|  | @@ -1,4121 +1,3700 @@
 | 
	
		
			
				|  |  |  define("amber_vm/parser", ["./smalltalk", "./nil"], function(smalltalk, nil) {
 | 
	
		
			
				|  |  | -smalltalk.parser = (function(){
 | 
	
		
			
				|  |  | +smalltalk.parser = (function() {
 | 
	
		
			
				|  |  |    /*
 | 
	
		
			
				|  |  | -   * Generated by PEG.js 0.7.0.
 | 
	
		
			
				|  |  | +   * Generated by PEG.js 0.8.0.
 | 
	
		
			
				|  |  |     *
 | 
	
		
			
				|  |  |     * http://pegjs.majda.cz/
 | 
	
		
			
				|  |  |     */
 | 
	
		
			
				|  |  | -  
 | 
	
		
			
				|  |  | -  function quote(s) {
 | 
	
		
			
				|  |  | -    /*
 | 
	
		
			
				|  |  | -     * ECMA-262, 5th ed., 7.8.4: All characters may appear literally in a
 | 
	
		
			
				|  |  | -     * string literal except for the closing quote character, backslash,
 | 
	
		
			
				|  |  | -     * carriage return, line separator, paragraph separator, and line feed.
 | 
	
		
			
				|  |  | -     * Any character may appear in the form of an escape sequence.
 | 
	
		
			
				|  |  | -     *
 | 
	
		
			
				|  |  | -     * For portability, we also escape escape all control and non-ASCII
 | 
	
		
			
				|  |  | -     * characters. Note that "\0" and "\v" escape sequences are not used
 | 
	
		
			
				|  |  | -     * because JSHint does not like the first and IE the second.
 | 
	
		
			
				|  |  | -     */
 | 
	
		
			
				|  |  | -     return '"' + s
 | 
	
		
			
				|  |  | -      .replace(/\\/g, '\\\\')  // backslash
 | 
	
		
			
				|  |  | -      .replace(/"/g, '\\"')    // closing quote character
 | 
	
		
			
				|  |  | -      .replace(/\x08/g, '\\b') // backspace
 | 
	
		
			
				|  |  | -      .replace(/\t/g, '\\t')   // horizontal tab
 | 
	
		
			
				|  |  | -      .replace(/\n/g, '\\n')   // line feed
 | 
	
		
			
				|  |  | -      .replace(/\f/g, '\\f')   // form feed
 | 
	
		
			
				|  |  | -      .replace(/\r/g, '\\r')   // carriage return
 | 
	
		
			
				|  |  | -      .replace(/[\x00-\x07\x0B\x0E-\x1F\x80-\uFFFF]/g, escape)
 | 
	
		
			
				|  |  | -      + '"';
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  function peg$subclass(child, parent) {
 | 
	
		
			
				|  |  | +    function ctor() { this.constructor = child; }
 | 
	
		
			
				|  |  | +    ctor.prototype = parent.prototype;
 | 
	
		
			
				|  |  | +    child.prototype = new ctor();
 | 
	
		
			
				|  |  |    }
 | 
	
		
			
				|  |  | -  
 | 
	
		
			
				|  |  | -  var result = {
 | 
	
		
			
				|  |  | -    /*
 | 
	
		
			
				|  |  | -     * Parses the input with a generated parser. If the parsing is successfull,
 | 
	
		
			
				|  |  | -     * returns a value explicitly or implicitly specified by the grammar from
 | 
	
		
			
				|  |  | -     * which the parser was generated (see |PEG.buildParser|). If the parsing is
 | 
	
		
			
				|  |  | -     * unsuccessful, throws |PEG.parser.SyntaxError| describing the error.
 | 
	
		
			
				|  |  | -     */
 | 
	
		
			
				|  |  | -    parse: function(input, startRule) {
 | 
	
		
			
				|  |  | -      var parseFunctions = {
 | 
	
		
			
				|  |  | -        "separator": parse_separator,
 | 
	
		
			
				|  |  | -        "comments": parse_comments,
 | 
	
		
			
				|  |  | -        "ws": parse_ws,
 | 
	
		
			
				|  |  | -        "identifier": parse_identifier,
 | 
	
		
			
				|  |  | -        "keyword": parse_keyword,
 | 
	
		
			
				|  |  | -        "selector": parse_selector,
 | 
	
		
			
				|  |  | -        "className": parse_className,
 | 
	
		
			
				|  |  | -        "string": parse_string,
 | 
	
		
			
				|  |  | -        "symbol": parse_symbol,
 | 
	
		
			
				|  |  | -        "bareSymbol": parse_bareSymbol,
 | 
	
		
			
				|  |  | -        "number": parse_number,
 | 
	
		
			
				|  |  | -        "numberExp": parse_numberExp,
 | 
	
		
			
				|  |  | -        "hex": parse_hex,
 | 
	
		
			
				|  |  | -        "float": parse_float,
 | 
	
		
			
				|  |  | -        "integer": parse_integer,
 | 
	
		
			
				|  |  | -        "literalArray": parse_literalArray,
 | 
	
		
			
				|  |  | -        "bareLiteralArray": parse_bareLiteralArray,
 | 
	
		
			
				|  |  | -        "literalArrayRest": parse_literalArrayRest,
 | 
	
		
			
				|  |  | -        "dynamicArray": parse_dynamicArray,
 | 
	
		
			
				|  |  | -        "dynamicDictionary": parse_dynamicDictionary,
 | 
	
		
			
				|  |  | -        "pseudoVariable": parse_pseudoVariable,
 | 
	
		
			
				|  |  | -        "parseTimeLiteral": parse_parseTimeLiteral,
 | 
	
		
			
				|  |  | -        "runtimeLiteral": parse_runtimeLiteral,
 | 
	
		
			
				|  |  | -        "literal": parse_literal,
 | 
	
		
			
				|  |  | -        "variable": parse_variable,
 | 
	
		
			
				|  |  | -        "keywordPair": parse_keywordPair,
 | 
	
		
			
				|  |  | -        "binarySelector": parse_binarySelector,
 | 
	
		
			
				|  |  | -        "keywordPattern": parse_keywordPattern,
 | 
	
		
			
				|  |  | -        "binaryPattern": parse_binaryPattern,
 | 
	
		
			
				|  |  | -        "unaryPattern": parse_unaryPattern,
 | 
	
		
			
				|  |  | -        "expression": parse_expression,
 | 
	
		
			
				|  |  | -        "expressionList": parse_expressionList,
 | 
	
		
			
				|  |  | -        "expressions": parse_expressions,
 | 
	
		
			
				|  |  | -        "assignment": parse_assignment,
 | 
	
		
			
				|  |  | -        "ret": parse_ret,
 | 
	
		
			
				|  |  | -        "temps": parse_temps,
 | 
	
		
			
				|  |  | -        "blockParamList": parse_blockParamList,
 | 
	
		
			
				|  |  | -        "subexpression": parse_subexpression,
 | 
	
		
			
				|  |  | -        "statements": parse_statements,
 | 
	
		
			
				|  |  | -        "sequence": parse_sequence,
 | 
	
		
			
				|  |  | -        "stSequence": parse_stSequence,
 | 
	
		
			
				|  |  | -        "block": parse_block,
 | 
	
		
			
				|  |  | -        "operand": parse_operand,
 | 
	
		
			
				|  |  | -        "unaryMessage": parse_unaryMessage,
 | 
	
		
			
				|  |  | -        "unaryTail": parse_unaryTail,
 | 
	
		
			
				|  |  | -        "unarySend": parse_unarySend,
 | 
	
		
			
				|  |  | -        "binaryMessage": parse_binaryMessage,
 | 
	
		
			
				|  |  | -        "binaryTail": parse_binaryTail,
 | 
	
		
			
				|  |  | -        "binarySend": parse_binarySend,
 | 
	
		
			
				|  |  | -        "keywordMessage": parse_keywordMessage,
 | 
	
		
			
				|  |  | -        "keywordSend": parse_keywordSend,
 | 
	
		
			
				|  |  | -        "message": parse_message,
 | 
	
		
			
				|  |  | -        "cascade": parse_cascade,
 | 
	
		
			
				|  |  | -        "jsStatement": parse_jsStatement,
 | 
	
		
			
				|  |  | -        "method": parse_method
 | 
	
		
			
				|  |  | -      };
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      if (startRule !== undefined) {
 | 
	
		
			
				|  |  | -        if (parseFunctions[startRule] === undefined) {
 | 
	
		
			
				|  |  | -          throw new Error("Invalid rule name: " + quote(startRule) + ".");
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -      } else {
 | 
	
		
			
				|  |  | -        startRule = "method";
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      var pos = { offset: 0, line: 1, column: 1, seenCR: false };
 | 
	
		
			
				|  |  | -      var reportFailures = 0;
 | 
	
		
			
				|  |  | -      var rightmostFailuresPos = { offset: 0, line: 1, column: 1, seenCR: false };
 | 
	
		
			
				|  |  | -      var rightmostFailuresExpected = [];
 | 
	
		
			
				|  |  | -      var cache = {};
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function padLeft(input, padding, length) {
 | 
	
		
			
				|  |  | -        var result = input;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var padLength = length - input.length;
 | 
	
		
			
				|  |  | -        for (var i = 0; i < padLength; i++) {
 | 
	
		
			
				|  |  | -          result = padding + result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        return result;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function escape(ch) {
 | 
	
		
			
				|  |  | -        var charCode = ch.charCodeAt(0);
 | 
	
		
			
				|  |  | -        var escapeChar;
 | 
	
		
			
				|  |  | -        var length;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        if (charCode <= 0xFF) {
 | 
	
		
			
				|  |  | -          escapeChar = 'x';
 | 
	
		
			
				|  |  | -          length = 2;
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          escapeChar = 'u';
 | 
	
		
			
				|  |  | -          length = 4;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        return '\\' + escapeChar + padLeft(charCode.toString(16).toUpperCase(), '0', length);
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function clone(object) {
 | 
	
		
			
				|  |  | -        var result = {};
 | 
	
		
			
				|  |  | -        for (var key in object) {
 | 
	
		
			
				|  |  | -          result[key] = object[key];
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        return result;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function advance(pos, n) {
 | 
	
		
			
				|  |  | -        var endOffset = pos.offset + n;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        for (var offset = pos.offset; offset < endOffset; offset++) {
 | 
	
		
			
				|  |  | -          var ch = input.charAt(offset);
 | 
	
		
			
				|  |  | -          if (ch === "\n") {
 | 
	
		
			
				|  |  | -            if (!pos.seenCR) { pos.line++; }
 | 
	
		
			
				|  |  | -            pos.column = 1;
 | 
	
		
			
				|  |  | -            pos.seenCR = false;
 | 
	
		
			
				|  |  | -          } else if (ch === "\r" || ch === "\u2028" || ch === "\u2029") {
 | 
	
		
			
				|  |  | -            pos.line++;
 | 
	
		
			
				|  |  | -            pos.column = 1;
 | 
	
		
			
				|  |  | -            pos.seenCR = true;
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            pos.column++;
 | 
	
		
			
				|  |  | -            pos.seenCR = false;
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos.offset += n;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function matchFailed(failure) {
 | 
	
		
			
				|  |  | -        if (pos.offset < rightmostFailuresPos.offset) {
 | 
	
		
			
				|  |  | -          return;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        if (pos.offset > rightmostFailuresPos.offset) {
 | 
	
		
			
				|  |  | -          rightmostFailuresPos = clone(pos);
 | 
	
		
			
				|  |  | -          rightmostFailuresExpected = [];
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        rightmostFailuresExpected.push(failure);
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_separator() {
 | 
	
		
			
				|  |  | -        var cacheKey = "separator@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        if (/^[ \t\x0B\f\xA0\uFEFF\n\r\u2028\u2029]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -          result1 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result1 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("[ \\t\\x0B\\f\\xA0\\uFEFF\\n\\r\\u2028\\u2029]");
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result1 !== null) {
 | 
	
		
			
				|  |  | -          result0 = [];
 | 
	
		
			
				|  |  | -          while (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0.push(result1);
 | 
	
		
			
				|  |  | -            if (/^[ \t\x0B\f\xA0\uFEFF\n\r\u2028\u2029]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -              result1 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result1 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("[ \\t\\x0B\\f\\xA0\\uFEFF\\n\\r\\u2028\\u2029]");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_comments() {
 | 
	
		
			
				|  |  | -        var cacheKey = "comments@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3;
 | 
	
		
			
				|  |  | -        var pos0;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        if (/^["]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -          result1 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result1 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("[\"]");
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result1 !== null) {
 | 
	
		
			
				|  |  | -          result2 = [];
 | 
	
		
			
				|  |  | -          if (/^[^"]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -            result3 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -            advance(pos, 1);
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result3 = null;
 | 
	
		
			
				|  |  | -            if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -              matchFailed("[^\"]");
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          while (result3 !== null) {
 | 
	
		
			
				|  |  | -            result2.push(result3);
 | 
	
		
			
				|  |  | -            if (/^[^"]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -              result3 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result3 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("[^\"]");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result2 !== null) {
 | 
	
		
			
				|  |  | -            if (/^["]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -              result3 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result3 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("[\"]");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result3 !== null) {
 | 
	
		
			
				|  |  | -              result1 = [result1, result2, result3];
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result1 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos0);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result1 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos0);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result1 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result1 !== null) {
 | 
	
		
			
				|  |  | -          result0 = [];
 | 
	
		
			
				|  |  | -          while (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0.push(result1);
 | 
	
		
			
				|  |  | -            pos0 = clone(pos);
 | 
	
		
			
				|  |  | -            if (/^["]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -              result1 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result1 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("[\"]");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result1 !== null) {
 | 
	
		
			
				|  |  | -              result2 = [];
 | 
	
		
			
				|  |  | -              if (/^[^"]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -                result3 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -                advance(pos, 1);
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result3 = null;
 | 
	
		
			
				|  |  | -                if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                  matchFailed("[^\"]");
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -              while (result3 !== null) {
 | 
	
		
			
				|  |  | -                result2.push(result3);
 | 
	
		
			
				|  |  | -                if (/^[^"]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -                  result3 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -                  advance(pos, 1);
 | 
	
		
			
				|  |  | -                } else {
 | 
	
		
			
				|  |  | -                  result3 = null;
 | 
	
		
			
				|  |  | -                  if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                    matchFailed("[^\"]");
 | 
	
		
			
				|  |  | -                  }
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -              if (result2 !== null) {
 | 
	
		
			
				|  |  | -                if (/^["]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -                  result3 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -                  advance(pos, 1);
 | 
	
		
			
				|  |  | -                } else {
 | 
	
		
			
				|  |  | -                  result3 = null;
 | 
	
		
			
				|  |  | -                  if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                    matchFailed("[\"]");
 | 
	
		
			
				|  |  | -                  }
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -                if (result3 !== null) {
 | 
	
		
			
				|  |  | -                  result1 = [result1, result2, result3];
 | 
	
		
			
				|  |  | -                } else {
 | 
	
		
			
				|  |  | -                  result1 = null;
 | 
	
		
			
				|  |  | -                  pos = clone(pos0);
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result1 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos0);
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result1 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos0);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_ws() {
 | 
	
		
			
				|  |  | -        var cacheKey = "ws@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        result0 = [];
 | 
	
		
			
				|  |  | -        result1 = parse_separator();
 | 
	
		
			
				|  |  | -        if (result1 === null) {
 | 
	
		
			
				|  |  | -          result1 = parse_comments();
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        while (result1 !== null) {
 | 
	
		
			
				|  |  | -          result0.push(result1);
 | 
	
		
			
				|  |  | -          result1 = parse_separator();
 | 
	
		
			
				|  |  | -          if (result1 === null) {
 | 
	
		
			
				|  |  | -            result1 = parse_comments();
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_identifier() {
 | 
	
		
			
				|  |  | -        var cacheKey = "identifier@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (/^[a-zA-Z]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -          result0 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("[a-zA-Z]");
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = [];
 | 
	
		
			
				|  |  | -          if (/^[a-zA-Z0-9]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -            result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -            advance(pos, 1);
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result2 = null;
 | 
	
		
			
				|  |  | -            if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -              matchFailed("[a-zA-Z0-9]");
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          while (result2 !== null) {
 | 
	
		
			
				|  |  | -            result1.push(result2);
 | 
	
		
			
				|  |  | -            if (/^[a-zA-Z0-9]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -              result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("[a-zA-Z0-9]");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0 = [result0, result1];
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, first, others) {return first + others.join("");})(pos0.offset, pos0.line, pos0.column, result0[0], result0[1]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_keyword() {
 | 
	
		
			
				|  |  | -        var cacheKey = "keyword@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_identifier();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          if (/^[:]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -            result1 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -            advance(pos, 1);
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result1 = null;
 | 
	
		
			
				|  |  | -            if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -              matchFailed("[:]");
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0 = [result0, result1];
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, first, last) {return first + last;})(pos0.offset, pos0.line, pos0.column, result0[0], result0[1]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_selector() {
 | 
	
		
			
				|  |  | -        var cacheKey = "selector@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (/^[a-zA-Z]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -          result0 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("[a-zA-Z]");
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = [];
 | 
	
		
			
				|  |  | -          if (/^[a-zA-Z0-9:]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -            result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -            advance(pos, 1);
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result2 = null;
 | 
	
		
			
				|  |  | -            if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -              matchFailed("[a-zA-Z0-9:]");
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          while (result2 !== null) {
 | 
	
		
			
				|  |  | -            result1.push(result2);
 | 
	
		
			
				|  |  | -            if (/^[a-zA-Z0-9:]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -              result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("[a-zA-Z0-9:]");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0 = [result0, result1];
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, first, others) {return first + others.join("");})(pos0.offset, pos0.line, pos0.column, result0[0], result0[1]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_className() {
 | 
	
		
			
				|  |  | -        var cacheKey = "className@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (/^[A-Z]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -          result0 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("[A-Z]");
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = [];
 | 
	
		
			
				|  |  | -          if (/^[a-zA-Z0-9]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -            result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -            advance(pos, 1);
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result2 = null;
 | 
	
		
			
				|  |  | -            if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -              matchFailed("[a-zA-Z0-9]");
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          while (result2 !== null) {
 | 
	
		
			
				|  |  | -            result1.push(result2);
 | 
	
		
			
				|  |  | -            if (/^[a-zA-Z0-9]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -              result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("[a-zA-Z0-9]");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0 = [result0, result1];
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, first, others) {return first + others.join("");})(pos0.offset, pos0.line, pos0.column, result0[0], result0[1]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_string() {
 | 
	
		
			
				|  |  | -        var cacheKey = "string@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2;
 | 
	
		
			
				|  |  | -        var pos0, pos1, pos2;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (/^[']/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -          result0 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("[']");
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = [];
 | 
	
		
			
				|  |  | -          pos2 = clone(pos);
 | 
	
		
			
				|  |  | -          if (input.substr(pos.offset, 2) === "''") {
 | 
	
		
			
				|  |  | -            result2 = "''";
 | 
	
		
			
				|  |  | -            advance(pos, 2);
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result2 = null;
 | 
	
		
			
				|  |  | -            if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -              matchFailed("\"''\"");
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result2 !== null) {
 | 
	
		
			
				|  |  | -            result2 = (function(offset, line, column) {return "'";})(pos2.offset, pos2.line, pos2.column);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result2 === null) {
 | 
	
		
			
				|  |  | -            pos = clone(pos2);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result2 === null) {
 | 
	
		
			
				|  |  | -            if (/^[^']/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -              result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("[^']");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          while (result2 !== null) {
 | 
	
		
			
				|  |  | -            result1.push(result2);
 | 
	
		
			
				|  |  | -            pos2 = clone(pos);
 | 
	
		
			
				|  |  | -            if (input.substr(pos.offset, 2) === "''") {
 | 
	
		
			
				|  |  | -              result2 = "''";
 | 
	
		
			
				|  |  | -              advance(pos, 2);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("\"''\"");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result2 = (function(offset, line, column) {return "'";})(pos2.offset, pos2.line, pos2.column);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 === null) {
 | 
	
		
			
				|  |  | -              pos = clone(pos2);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 === null) {
 | 
	
		
			
				|  |  | -              if (/^[^']/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -                result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -                advance(pos, 1);
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result2 = null;
 | 
	
		
			
				|  |  | -                if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                  matchFailed("[^']");
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            if (/^[']/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -              result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("[']");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result0 = [result0, result1, result2];
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, val) {
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  function SyntaxError(message, expected, found, offset, line, column) {
 | 
	
		
			
				|  |  | +    this.message  = message;
 | 
	
		
			
				|  |  | +    this.expected = expected;
 | 
	
		
			
				|  |  | +    this.found    = found;
 | 
	
		
			
				|  |  | +    this.offset   = offset;
 | 
	
		
			
				|  |  | +    this.line     = line;
 | 
	
		
			
				|  |  | +    this.column   = column;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    this.name     = "SyntaxError";
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  peg$subclass(SyntaxError, Error);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  function parse(input) {
 | 
	
		
			
				|  |  | +    var options = arguments.length > 1 ? arguments[1] : {},
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +        peg$FAILED = {},
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +        peg$startRuleFunctions = { start: peg$parsestart },
 | 
	
		
			
				|  |  | +        peg$startRuleFunction  = peg$parsestart,
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +        peg$c0 = [],
 | 
	
		
			
				|  |  | +        peg$c1 = peg$FAILED,
 | 
	
		
			
				|  |  | +        peg$c2 = /^[ \t\x0B\f\xA0\uFEFF\n\r\u2028\u2029]/,
 | 
	
		
			
				|  |  | +        peg$c3 = { type: "class", value: "[ \\t\\x0B\\f\\xA0\\uFEFF\\n\\r\\u2028\\u2029]", description: "[ \\t\\x0B\\f\\xA0\\uFEFF\\n\\r\\u2028\\u2029]" },
 | 
	
		
			
				|  |  | +        peg$c4 = /^["]/,
 | 
	
		
			
				|  |  | +        peg$c5 = { type: "class", value: "[\"]", description: "[\"]" },
 | 
	
		
			
				|  |  | +        peg$c6 = /^[^"]/,
 | 
	
		
			
				|  |  | +        peg$c7 = { type: "class", value: "[^\"]", description: "[^\"]" },
 | 
	
		
			
				|  |  | +        peg$c8 = /^[a-zA-Z]/,
 | 
	
		
			
				|  |  | +        peg$c9 = { type: "class", value: "[a-zA-Z]", description: "[a-zA-Z]" },
 | 
	
		
			
				|  |  | +        peg$c10 = /^[a-zA-Z0-9]/,
 | 
	
		
			
				|  |  | +        peg$c11 = { type: "class", value: "[a-zA-Z0-9]", description: "[a-zA-Z0-9]" },
 | 
	
		
			
				|  |  | +        peg$c12 = function(first, others) {return first + others.join("");},
 | 
	
		
			
				|  |  | +        peg$c13 = /^[:]/,
 | 
	
		
			
				|  |  | +        peg$c14 = { type: "class", value: "[:]", description: "[:]" },
 | 
	
		
			
				|  |  | +        peg$c15 = function(first, last) {return first + last;},
 | 
	
		
			
				|  |  | +        peg$c16 = /^[a-zA-Z0-9:]/,
 | 
	
		
			
				|  |  | +        peg$c17 = { type: "class", value: "[a-zA-Z0-9:]", description: "[a-zA-Z0-9:]" },
 | 
	
		
			
				|  |  | +        peg$c18 = /^[A-Z]/,
 | 
	
		
			
				|  |  | +        peg$c19 = { type: "class", value: "[A-Z]", description: "[A-Z]" },
 | 
	
		
			
				|  |  | +        peg$c20 = /^[']/,
 | 
	
		
			
				|  |  | +        peg$c21 = { type: "class", value: "[']", description: "[']" },
 | 
	
		
			
				|  |  | +        peg$c22 = "''",
 | 
	
		
			
				|  |  | +        peg$c23 = { type: "literal", value: "''", description: "\"''\"" },
 | 
	
		
			
				|  |  | +        peg$c24 = function() {return "'";},
 | 
	
		
			
				|  |  | +        peg$c25 = /^[^']/,
 | 
	
		
			
				|  |  | +        peg$c26 = { type: "class", value: "[^']", description: "[^']" },
 | 
	
		
			
				|  |  | +        peg$c27 = function(val) {
 | 
	
		
			
				|  |  |                               return smalltalk.ValueNode._new()
 | 
	
		
			
				|  |  | -                                    ._position_((line).__at(column))
 | 
	
		
			
				|  |  | +                                    ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  |                                      ._value_(val.join("").replace(/\"/ig, '"'));
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[1]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_symbol() {
 | 
	
		
			
				|  |  | -        var cacheKey = "symbol@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (input.charCodeAt(pos.offset) === 35) {
 | 
	
		
			
				|  |  | -          result0 = "#";
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("\"#\"");
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_bareSymbol();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0 = [result0, result1];
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, rest) {return rest;})(pos0.offset, pos0.line, pos0.column, result0[1]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_bareSymbol() {
 | 
	
		
			
				|  |  | -        var cacheKey = "bareSymbol@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_selector();
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          result0 = parse_binarySelector();
 | 
	
		
			
				|  |  | -          if (result0 === null) {
 | 
	
		
			
				|  |  | -            pos1 = clone(pos);
 | 
	
		
			
				|  |  | -            result0 = parse_string();
 | 
	
		
			
				|  |  | -            if (result0 !== null) {
 | 
	
		
			
				|  |  | -              result0 = (function(offset, line, column, node) {return node._value();})(pos1.offset, pos1.line, pos1.column, result0);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result0 === null) {
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, val) {
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c28 = "#",
 | 
	
		
			
				|  |  | +        peg$c29 = { type: "literal", value: "#", description: "\"#\"" },
 | 
	
		
			
				|  |  | +        peg$c30 = function(rest) {return rest;},
 | 
	
		
			
				|  |  | +        peg$c31 = function(node) {return node._value();},
 | 
	
		
			
				|  |  | +        peg$c32 = function(val) {
 | 
	
		
			
				|  |  |                                return smalltalk.ValueNode._new()
 | 
	
		
			
				|  |  | -                                     ._position_((line).__at(column))
 | 
	
		
			
				|  |  | +                                     ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  |                                       ._value_(val);
 | 
	
		
			
				|  |  | -                          })(pos0.offset, pos0.line, pos0.column, result0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_number() {
 | 
	
		
			
				|  |  | -        var cacheKey = "number@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0;
 | 
	
		
			
				|  |  | -        var pos0;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_numberExp();
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          result0 = parse_hex();
 | 
	
		
			
				|  |  | -          if (result0 === null) {
 | 
	
		
			
				|  |  | -            result0 = parse_float();
 | 
	
		
			
				|  |  | -            if (result0 === null) {
 | 
	
		
			
				|  |  | -              result0 = parse_integer();
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, n) {
 | 
	
		
			
				|  |  | +                          },
 | 
	
		
			
				|  |  | +        peg$c33 = function(n) {
 | 
	
		
			
				|  |  |                               return smalltalk.ValueNode._new()
 | 
	
		
			
				|  |  | -                                    ._position_((line).__at(column))
 | 
	
		
			
				|  |  | +                                    ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  |                                      ._value_(n);
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_numberExp() {
 | 
	
		
			
				|  |  | -        var cacheKey = "numberExp@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_float();
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          result0 = parse_integer();
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          if (input.charCodeAt(pos.offset) === 101) {
 | 
	
		
			
				|  |  | -            result1 = "e";
 | 
	
		
			
				|  |  | -            advance(pos, 1);
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result1 = null;
 | 
	
		
			
				|  |  | -            if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -              matchFailed("\"e\"");
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result2 = parse_integer();
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result0 = [result0, result1, result2];
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, n) {return parseFloat(n.join(""));})(pos0.offset, pos0.line, pos0.column, result0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_hex() {
 | 
	
		
			
				|  |  | -        var cacheKey = "hex@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (/^[\-]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -          result0 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("[\\-]");
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        result0 = result0 !== null ? result0 : "";
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          if (input.substr(pos.offset, 3) === "16r") {
 | 
	
		
			
				|  |  | -            result1 = "16r";
 | 
	
		
			
				|  |  | -            advance(pos, 3);
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result1 = null;
 | 
	
		
			
				|  |  | -            if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -              matchFailed("\"16r\"");
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            if (/^[0-9a-fA-F]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -              result3 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result3 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("[0-9a-fA-F]");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result3 !== null) {
 | 
	
		
			
				|  |  | -              result2 = [];
 | 
	
		
			
				|  |  | -              while (result3 !== null) {
 | 
	
		
			
				|  |  | -                result2.push(result3);
 | 
	
		
			
				|  |  | -                if (/^[0-9a-fA-F]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -                  result3 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -                  advance(pos, 1);
 | 
	
		
			
				|  |  | -                } else {
 | 
	
		
			
				|  |  | -                  result3 = null;
 | 
	
		
			
				|  |  | -                  if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                    matchFailed("[0-9a-fA-F]");
 | 
	
		
			
				|  |  | -                  }
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result0 = [result0, result1, result2];
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c34 = "e",
 | 
	
		
			
				|  |  | +        peg$c35 = { type: "literal", value: "e", description: "\"e\"" },
 | 
	
		
			
				|  |  | +        peg$c36 = function(n) {return parseFloat(n.join(""));},
 | 
	
		
			
				|  |  | +        peg$c37 = null,
 | 
	
		
			
				|  |  | +        peg$c38 = /^[\-]/,
 | 
	
		
			
				|  |  | +        peg$c39 = { type: "class", value: "[\\-]", description: "[\\-]" },
 | 
	
		
			
				|  |  | +        peg$c40 = "16r",
 | 
	
		
			
				|  |  | +        peg$c41 = { type: "literal", value: "16r", description: "\"16r\"" },
 | 
	
		
			
				|  |  | +        peg$c42 = /^[0-9a-fA-F]/,
 | 
	
		
			
				|  |  | +        peg$c43 = { type: "class", value: "[0-9a-fA-F]", description: "[0-9a-fA-F]" },
 | 
	
		
			
				|  |  | +        peg$c44 = function(neg, num) {return parseInt(((neg || '') + num.join("")), 16);},
 | 
	
		
			
				|  |  | +        peg$c45 = /^[0-9]/,
 | 
	
		
			
				|  |  | +        peg$c46 = { type: "class", value: "[0-9]", description: "[0-9]" },
 | 
	
		
			
				|  |  | +        peg$c47 = ".",
 | 
	
		
			
				|  |  | +        peg$c48 = { type: "literal", value: ".", description: "\".\"" },
 | 
	
		
			
				|  |  | +        peg$c49 = function(neg, digits, dec) {return parseFloat(((neg || '') + digits.join("") + "." + dec.join("")), 10);},
 | 
	
		
			
				|  |  | +        peg$c50 = function(neg, digits) {return (parseInt((neg || '') +digits.join(""), 10));},
 | 
	
		
			
				|  |  | +        peg$c51 = "#(",
 | 
	
		
			
				|  |  | +        peg$c52 = { type: "literal", value: "#(", description: "\"#(\"" },
 | 
	
		
			
				|  |  | +        peg$c53 = "(",
 | 
	
		
			
				|  |  | +        peg$c54 = { type: "literal", value: "(", description: "\"(\"" },
 | 
	
		
			
				|  |  | +        peg$c55 = function(lit) {return lit._value();},
 | 
	
		
			
				|  |  | +        peg$c56 = ")",
 | 
	
		
			
				|  |  | +        peg$c57 = { type: "literal", value: ")", description: "\")\"" },
 | 
	
		
			
				|  |  | +        peg$c58 = function(lits) {
 | 
	
		
			
				|  |  | +                             return smalltalk.ValueNode._new()
 | 
	
		
			
				|  |  | +                                    ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  | +                                    ._value_(lits);
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c59 = "{",
 | 
	
		
			
				|  |  | +        peg$c60 = { type: "literal", value: "{", description: "\"{\"" },
 | 
	
		
			
				|  |  | +        peg$c61 = "}",
 | 
	
		
			
				|  |  | +        peg$c62 = { type: "literal", value: "}", description: "\"}\"" },
 | 
	
		
			
				|  |  | +        peg$c63 = function(expressions) {
 | 
	
		
			
				|  |  | +                             return smalltalk.DynamicArrayNode._new()
 | 
	
		
			
				|  |  | +                                    ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  | +                                    ._nodes_(expressions || []);
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c64 = "#{",
 | 
	
		
			
				|  |  | +        peg$c65 = { type: "literal", value: "#{", description: "\"#{\"" },
 | 
	
		
			
				|  |  | +        peg$c66 = function(expressions) {
 | 
	
		
			
				|  |  | +                                return smalltalk.DynamicDictionaryNode._new()
 | 
	
		
			
				|  |  | +                                       ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  | +                                       ._nodes_(expressions || []);
 | 
	
		
			
				|  |  | +                            },
 | 
	
		
			
				|  |  | +        peg$c67 = "true",
 | 
	
		
			
				|  |  | +        peg$c68 = { type: "literal", value: "true", description: "\"true\"" },
 | 
	
		
			
				|  |  | +        peg$c69 = function() {return true;},
 | 
	
		
			
				|  |  | +        peg$c70 = "false",
 | 
	
		
			
				|  |  | +        peg$c71 = { type: "literal", value: "false", description: "\"false\"" },
 | 
	
		
			
				|  |  | +        peg$c72 = function() {return false;},
 | 
	
		
			
				|  |  | +        peg$c73 = "nil",
 | 
	
		
			
				|  |  | +        peg$c74 = { type: "literal", value: "nil", description: "\"nil\"" },
 | 
	
		
			
				|  |  | +        peg$c75 = function() {return nil;},
 | 
	
		
			
				|  |  | +        peg$c76 = function(val) {
 | 
	
		
			
				|  |  | +                               return smalltalk.ValueNode._new()
 | 
	
		
			
				|  |  | +                                      ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  | +                                      ._value_(val);
 | 
	
		
			
				|  |  | +                           },
 | 
	
		
			
				|  |  | +        peg$c77 = function(identifier) {
 | 
	
		
			
				|  |  | +                             return smalltalk.VariableNode._new()
 | 
	
		
			
				|  |  | +                                    ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  | +                                    ._value_(identifier);
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c78 = function(key, arg) {return {key:key, arg: arg};},
 | 
	
		
			
				|  |  | +        peg$c79 = /^[\\+*\/=><,@%~|&\-]/,
 | 
	
		
			
				|  |  | +        peg$c80 = { type: "class", value: "[\\\\+*\\/=><,@%~|&\\-]", description: "[\\\\+*\\/=><,@%~|&\\-]" },
 | 
	
		
			
				|  |  | +        peg$c81 = function(bin) {return bin.join("");},
 | 
	
		
			
				|  |  | +        peg$c82 = function(pairs) {
 | 
	
		
			
				|  |  | +                             var keywords = [];
 | 
	
		
			
				|  |  | +                             var params = [];
 | 
	
		
			
				|  |  | +                             var i = 0;
 | 
	
		
			
				|  |  | +                             for(i = 0; i < pairs.length; i++){
 | 
	
		
			
				|  |  | +                                 keywords.push(pairs[i].key);
 | 
	
		
			
				|  |  | +                             }
 | 
	
		
			
				|  |  | +                             for(i = 0; i < pairs.length; i++){
 | 
	
		
			
				|  |  | +                                 params.push(pairs[i].arg);
 | 
	
		
			
				|  |  | +                             }
 | 
	
		
			
				|  |  | +                             return [keywords.join(""), params];
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c83 = function(selector, arg) {return [selector, [arg]];},
 | 
	
		
			
				|  |  | +        peg$c84 = function(selector) {return [selector, []];},
 | 
	
		
			
				|  |  | +        peg$c85 = function(expression) {return expression;},
 | 
	
		
			
				|  |  | +        peg$c86 = function(first, others) {
 | 
	
		
			
				|  |  | +                             var result = [first];
 | 
	
		
			
				|  |  | +                             for(var i = 0; i < others.length; i++) {
 | 
	
		
			
				|  |  | +                                 result.push(others[i]);
 | 
	
		
			
				|  |  | +                             }
 | 
	
		
			
				|  |  | +                             return result;
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c87 = ":=",
 | 
	
		
			
				|  |  | +        peg$c88 = { type: "literal", value: ":=", description: "\":=\"" },
 | 
	
		
			
				|  |  | +        peg$c89 = function(variable, expression) {
 | 
	
		
			
				|  |  | +                             return smalltalk.AssignmentNode._new()
 | 
	
		
			
				|  |  | +                                    ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  | +                                    ._left_(variable)
 | 
	
		
			
				|  |  | +                                    ._right_(expression);
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c90 = "^",
 | 
	
		
			
				|  |  | +        peg$c91 = { type: "literal", value: "^", description: "\"^\"" },
 | 
	
		
			
				|  |  | +        peg$c92 = function(expression) {
 | 
	
		
			
				|  |  | +                             return smalltalk.ReturnNode._new()
 | 
	
		
			
				|  |  | +                                    ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  | +                                    ._nodes_([expression]);
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c93 = "|",
 | 
	
		
			
				|  |  | +        peg$c94 = { type: "literal", value: "|", description: "\"|\"" },
 | 
	
		
			
				|  |  | +        peg$c95 = function(variable) {return variable;},
 | 
	
		
			
				|  |  | +        peg$c96 = function(vars) {return vars;},
 | 
	
		
			
				|  |  | +        peg$c97 = ":",
 | 
	
		
			
				|  |  | +        peg$c98 = { type: "literal", value: ":", description: "\":\"" },
 | 
	
		
			
				|  |  | +        peg$c99 = function(param) {return param;},
 | 
	
		
			
				|  |  | +        peg$c100 = function(params) {return params;},
 | 
	
		
			
				|  |  | +        peg$c101 = /^[.]/,
 | 
	
		
			
				|  |  | +        peg$c102 = { type: "class", value: "[.]", description: "[.]" },
 | 
	
		
			
				|  |  | +        peg$c103 = function(ret) {return [ret];},
 | 
	
		
			
				|  |  | +        peg$c104 = function(exps, ret) {
 | 
	
		
			
				|  |  | +                               var expressions = exps;
 | 
	
		
			
				|  |  | +                               expressions.push(ret);
 | 
	
		
			
				|  |  | +                               return expressions;
 | 
	
		
			
				|  |  | +                           },
 | 
	
		
			
				|  |  | +        peg$c105 = function(expressions) {
 | 
	
		
			
				|  |  | +                               return expressions || [];
 | 
	
		
			
				|  |  | +                           },
 | 
	
		
			
				|  |  | +        peg$c106 = function(temps, statements) {
 | 
	
		
			
				|  |  | +                             return smalltalk.SequenceNode._new()
 | 
	
		
			
				|  |  | +                                    ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  | +                                    ._temps_(temps || [])
 | 
	
		
			
				|  |  | +                                    ._nodes_(statements || []);
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c107 = "[",
 | 
	
		
			
				|  |  | +        peg$c108 = { type: "literal", value: "[", description: "\"[\"" },
 | 
	
		
			
				|  |  | +        peg$c109 = "]",
 | 
	
		
			
				|  |  | +        peg$c110 = { type: "literal", value: "]", description: "\"]\"" },
 | 
	
		
			
				|  |  | +        peg$c111 = function(params, sequence) {
 | 
	
		
			
				|  |  | +                             return smalltalk.BlockNode._new()
 | 
	
		
			
				|  |  | +                                    ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  | +                                    ._parameters_(params || [])
 | 
	
		
			
				|  |  | +                                    ._nodes_([sequence._asBlockSequenceNode()]);
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c112 = void 0,
 | 
	
		
			
				|  |  | +        peg$c113 = function(selector) {
 | 
	
		
			
				|  |  | +                             return smalltalk.SendNode._new()
 | 
	
		
			
				|  |  | +                                    ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  | +                                    ._selector_(selector);
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c114 = function(message, tail) {
 | 
	
		
			
				|  |  | +                             if(tail) {
 | 
	
		
			
				|  |  | +                                 return tail._valueForReceiver_(message);
 | 
	
		
			
				|  |  | +                             }
 | 
	
		
			
				|  |  | +                             else {
 | 
	
		
			
				|  |  | +                                 return message;
 | 
	
		
			
				|  |  | +                             }
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c115 = function(receiver, tail) {
 | 
	
		
			
				|  |  | +                             if(tail) {
 | 
	
		
			
				|  |  | +                                 return tail._valueForReceiver_(receiver);
 | 
	
		
			
				|  |  | +                             }
 | 
	
		
			
				|  |  | +                             else {
 | 
	
		
			
				|  |  | +                                 return receiver;
 | 
	
		
			
				|  |  | +                             }
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c116 = function(selector, arg) {
 | 
	
		
			
				|  |  | +                             return smalltalk.SendNode._new()
 | 
	
		
			
				|  |  | +                                    ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  | +                                    ._selector_(selector)
 | 
	
		
			
				|  |  | +                                    ._arguments_([arg]);
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c117 = function(message, tail) {
 | 
	
		
			
				|  |  | +                             if(tail) {
 | 
	
		
			
				|  |  | +                                 return tail._valueForReceiver_(message);
 | 
	
		
			
				|  |  | +                              }
 | 
	
		
			
				|  |  | +                             else {
 | 
	
		
			
				|  |  | +                                 return message;
 | 
	
		
			
				|  |  | +                             }
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c118 = function(pair) {return pair;},
 | 
	
		
			
				|  |  | +        peg$c119 = function(pairs) {
 | 
	
		
			
				|  |  | +                             var selector = [];
 | 
	
		
			
				|  |  | +                             var args = [];
 | 
	
		
			
				|  |  | +                              for(var i = 0; i < pairs.length; i++) {
 | 
	
		
			
				|  |  | +                                  selector.push(pairs[i].key);
 | 
	
		
			
				|  |  | +                                  args.push(pairs[i].arg);
 | 
	
		
			
				|  |  | +                              }
 | 
	
		
			
				|  |  | +                              return smalltalk.SendNode._new()
 | 
	
		
			
				|  |  | +                                     ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  | +                                     ._selector_(selector.join(""))
 | 
	
		
			
				|  |  | +                                     ._arguments_(args);
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c120 = function(receiver, tail) {
 | 
	
		
			
				|  |  | +                             return tail._valueForReceiver_(receiver);
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c121 = ";",
 | 
	
		
			
				|  |  | +        peg$c122 = { type: "literal", value: ";", description: "\";\"" },
 | 
	
		
			
				|  |  | +        peg$c123 = function(mess) {return mess;},
 | 
	
		
			
				|  |  | +        peg$c124 = function(send, messages) {
 | 
	
		
			
				|  |  | +                             var cascade = [];
 | 
	
		
			
				|  |  | +                             cascade.push(send);
 | 
	
		
			
				|  |  | +                             for(var i = 0; i < messages.length; i++) {
 | 
	
		
			
				|  |  | +                                 cascade.push(messages[i]);
 | 
	
		
			
				|  |  | +                             }
 | 
	
		
			
				|  |  | +                             return smalltalk.CascadeNode._new()
 | 
	
		
			
				|  |  | +                                    ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  | +                                    ._receiver_(send._receiver())
 | 
	
		
			
				|  |  | +                                    ._nodes_(cascade);
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c125 = "<",
 | 
	
		
			
				|  |  | +        peg$c126 = { type: "literal", value: "<", description: "\"<\"" },
 | 
	
		
			
				|  |  | +        peg$c127 = ">>",
 | 
	
		
			
				|  |  | +        peg$c128 = { type: "literal", value: ">>", description: "\">>\"" },
 | 
	
		
			
				|  |  | +        peg$c129 = function() {return ">";},
 | 
	
		
			
				|  |  | +        peg$c130 = /^[^>]/,
 | 
	
		
			
				|  |  | +        peg$c131 = { type: "class", value: "[^>]", description: "[^>]" },
 | 
	
		
			
				|  |  | +        peg$c132 = ">",
 | 
	
		
			
				|  |  | +        peg$c133 = { type: "literal", value: ">", description: "\">\"" },
 | 
	
		
			
				|  |  | +        peg$c134 = function(val) {
 | 
	
		
			
				|  |  | +                             return smalltalk.JSStatementNode._new()
 | 
	
		
			
				|  |  | +                                    ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  | +                                    ._source_(val.join(""));
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +        peg$c135 = function(pattern, sequence) {
 | 
	
		
			
				|  |  | +                              return smalltalk.MethodNode._new()
 | 
	
		
			
				|  |  | +                                     ._position_((line()).__at(column()))
 | 
	
		
			
				|  |  | +                                     ._selector_(pattern[0])
 | 
	
		
			
				|  |  | +                                     ._arguments_(pattern[1])
 | 
	
		
			
				|  |  | +                                     ._nodes_([sequence]);
 | 
	
		
			
				|  |  | +                         },
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +        peg$currPos          = 0,
 | 
	
		
			
				|  |  | +        peg$reportedPos      = 0,
 | 
	
		
			
				|  |  | +        peg$cachedPos        = 0,
 | 
	
		
			
				|  |  | +        peg$cachedPosDetails = { line: 1, column: 1, seenCR: false },
 | 
	
		
			
				|  |  | +        peg$maxFailPos       = 0,
 | 
	
		
			
				|  |  | +        peg$maxFailExpected  = [],
 | 
	
		
			
				|  |  | +        peg$silentFails      = 0,
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +        peg$cache = {},
 | 
	
		
			
				|  |  | +        peg$result;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    if ("startRule" in options) {
 | 
	
		
			
				|  |  | +      if (!(options.startRule in peg$startRuleFunctions)) {
 | 
	
		
			
				|  |  | +        throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function text() {
 | 
	
		
			
				|  |  | +      return input.substring(peg$reportedPos, peg$currPos);
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function offset() {
 | 
	
		
			
				|  |  | +      return peg$reportedPos;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function line() {
 | 
	
		
			
				|  |  | +      return peg$computePosDetails(peg$reportedPos).line;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function column() {
 | 
	
		
			
				|  |  | +      return peg$computePosDetails(peg$reportedPos).column;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function expected(description) {
 | 
	
		
			
				|  |  | +      throw peg$buildException(
 | 
	
		
			
				|  |  | +        null,
 | 
	
		
			
				|  |  | +        [{ type: "other", description: description }],
 | 
	
		
			
				|  |  | +        peg$reportedPos
 | 
	
		
			
				|  |  | +      );
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function error(message) {
 | 
	
		
			
				|  |  | +      throw peg$buildException(message, null, peg$reportedPos);
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$computePosDetails(pos) {
 | 
	
		
			
				|  |  | +      function advance(details, startPos, endPos) {
 | 
	
		
			
				|  |  | +        var p, ch;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +        for (p = startPos; p < endPos; p++) {
 | 
	
		
			
				|  |  | +          ch = input.charAt(p);
 | 
	
		
			
				|  |  | +          if (ch === "\n") {
 | 
	
		
			
				|  |  | +            if (!details.seenCR) { details.line++; }
 | 
	
		
			
				|  |  | +            details.column = 1;
 | 
	
		
			
				|  |  | +            details.seenCR = false;
 | 
	
		
			
				|  |  | +          } else if (ch === "\r" || ch === "\u2028" || ch === "\u2029") {
 | 
	
		
			
				|  |  | +            details.line++;
 | 
	
		
			
				|  |  | +            details.column = 1;
 | 
	
		
			
				|  |  | +            details.seenCR = true;
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            details.column++;
 | 
	
		
			
				|  |  | +            details.seenCR = false;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, neg, num) {return parseInt((neg + num.join("")), 16);})(pos0.offset, pos0.line, pos0.column, result0[0], result0[2]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_float() {
 | 
	
		
			
				|  |  | -        var cacheKey = "float@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3, result4;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (/^[\-]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -          result0 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("[\\-]");
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (peg$cachedPos !== pos) {
 | 
	
		
			
				|  |  | +        if (peg$cachedPos > pos) {
 | 
	
		
			
				|  |  | +          peg$cachedPos = 0;
 | 
	
		
			
				|  |  | +          peg$cachedPosDetails = { line: 1, column: 1, seenCR: false };
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        result0 = result0 !== null ? result0 : "";
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          if (/^[0-9]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -            result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -            advance(pos, 1);
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result2 = null;
 | 
	
		
			
				|  |  | -            if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -              matchFailed("[0-9]");
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result2 !== null) {
 | 
	
		
			
				|  |  | -            result1 = [];
 | 
	
		
			
				|  |  | -            while (result2 !== null) {
 | 
	
		
			
				|  |  | -              result1.push(result2);
 | 
	
		
			
				|  |  | -              if (/^[0-9]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -                result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -                advance(pos, 1);
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result2 = null;
 | 
	
		
			
				|  |  | -                if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                  matchFailed("[0-9]");
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result1 = null;
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            if (input.charCodeAt(pos.offset) === 46) {
 | 
	
		
			
				|  |  | -              result2 = ".";
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("\".\"");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              if (/^[0-9]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -                result4 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -                advance(pos, 1);
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result4 = null;
 | 
	
		
			
				|  |  | -                if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                  matchFailed("[0-9]");
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -              if (result4 !== null) {
 | 
	
		
			
				|  |  | -                result3 = [];
 | 
	
		
			
				|  |  | -                while (result4 !== null) {
 | 
	
		
			
				|  |  | -                  result3.push(result4);
 | 
	
		
			
				|  |  | -                  if (/^[0-9]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -                    result4 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -                    advance(pos, 1);
 | 
	
		
			
				|  |  | -                  } else {
 | 
	
		
			
				|  |  | -                    result4 = null;
 | 
	
		
			
				|  |  | -                    if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                      matchFailed("[0-9]");
 | 
	
		
			
				|  |  | -                    }
 | 
	
		
			
				|  |  | -                  }
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result3 = null;
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                result0 = [result0, result1, result2, result3];
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result0 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos1);
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | +        advance(peg$cachedPosDetails, peg$cachedPos, pos);
 | 
	
		
			
				|  |  | +        peg$cachedPos = pos;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return peg$cachedPosDetails;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$fail(expected) {
 | 
	
		
			
				|  |  | +      if (peg$currPos < peg$maxFailPos) { return; }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (peg$currPos > peg$maxFailPos) {
 | 
	
		
			
				|  |  | +        peg$maxFailPos = peg$currPos;
 | 
	
		
			
				|  |  | +        peg$maxFailExpected = [];
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$maxFailExpected.push(expected);
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$buildException(message, expected, pos) {
 | 
	
		
			
				|  |  | +      function cleanupExpected(expected) {
 | 
	
		
			
				|  |  | +        var i = 1;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +        expected.sort(function(a, b) {
 | 
	
		
			
				|  |  | +          if (a.description < b.description) {
 | 
	
		
			
				|  |  | +            return -1;
 | 
	
		
			
				|  |  | +          } else if (a.description > b.description) {
 | 
	
		
			
				|  |  | +            return 1;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            return 0;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        });
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +        while (i < expected.length) {
 | 
	
		
			
				|  |  | +          if (expected[i - 1] === expected[i]) {
 | 
	
		
			
				|  |  | +            expected.splice(i, 1);
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            i++;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      function buildMessage(expected, found) {
 | 
	
		
			
				|  |  | +        function stringEscape(s) {
 | 
	
		
			
				|  |  | +          function hex(ch) { return ch.charCodeAt(0).toString(16).toUpperCase(); }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +          return s
 | 
	
		
			
				|  |  | +            .replace(/\\/g,   '\\\\')
 | 
	
		
			
				|  |  | +            .replace(/"/g,    '\\"')
 | 
	
		
			
				|  |  | +            .replace(/\x08/g, '\\b')
 | 
	
		
			
				|  |  | +            .replace(/\t/g,   '\\t')
 | 
	
		
			
				|  |  | +            .replace(/\n/g,   '\\n')
 | 
	
		
			
				|  |  | +            .replace(/\f/g,   '\\f')
 | 
	
		
			
				|  |  | +            .replace(/\r/g,   '\\r')
 | 
	
		
			
				|  |  | +            .replace(/[\x00-\x07\x0B\x0E\x0F]/g, function(ch) { return '\\x0' + hex(ch); })
 | 
	
		
			
				|  |  | +            .replace(/[\x10-\x1F\x80-\xFF]/g,    function(ch) { return '\\x'  + hex(ch); })
 | 
	
		
			
				|  |  | +            .replace(/[\u0180-\u0FFF]/g,         function(ch) { return '\\u0' + hex(ch); })
 | 
	
		
			
				|  |  | +            .replace(/[\u1080-\uFFFF]/g,         function(ch) { return '\\u'  + hex(ch); });
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +        var expectedDescs = new Array(expected.length),
 | 
	
		
			
				|  |  | +            expectedDesc, foundDesc, i;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +        for (i = 0; i < expected.length; i++) {
 | 
	
		
			
				|  |  | +          expectedDescs[i] = expected[i].description;
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +        expectedDesc = expected.length > 1
 | 
	
		
			
				|  |  | +          ? expectedDescs.slice(0, -1).join(", ")
 | 
	
		
			
				|  |  | +              + " or "
 | 
	
		
			
				|  |  | +              + expectedDescs[expected.length - 1]
 | 
	
		
			
				|  |  | +          : expectedDescs[0];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +        foundDesc = found ? "\"" + stringEscape(found) + "\"" : "end of input";
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +        return "Expected " + expectedDesc + " but " + foundDesc + " found.";
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var posDetails = peg$computePosDetails(pos),
 | 
	
		
			
				|  |  | +          found      = pos < input.length ? input.charAt(pos) : null;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (expected !== null) {
 | 
	
		
			
				|  |  | +        cleanupExpected(expected);
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return new SyntaxError(
 | 
	
		
			
				|  |  | +        message !== null ? message : buildMessage(expected, found),
 | 
	
		
			
				|  |  | +        expected,
 | 
	
		
			
				|  |  | +        found,
 | 
	
		
			
				|  |  | +        pos,
 | 
	
		
			
				|  |  | +        posDetails.line,
 | 
	
		
			
				|  |  | +        posDetails.column
 | 
	
		
			
				|  |  | +      );
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsestart() {
 | 
	
		
			
				|  |  | +      var s0;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 0,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$parsemethod();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseseparator() {
 | 
	
		
			
				|  |  | +      var s0, s1;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 1,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = [];
 | 
	
		
			
				|  |  | +      if (peg$c2.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +        s1 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c3); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        while (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s0.push(s1);
 | 
	
		
			
				|  |  | +          if (peg$c2.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +            s1 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c3); }
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, neg, digits, dec) {return parseFloat((neg + digits.join("") + "." + dec.join("")), 10);})(pos0.offset, pos0.line, pos0.column, result0[0], result0[1], result0[3]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_integer() {
 | 
	
		
			
				|  |  | -        var cacheKey = "integer@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (/^[\-]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -          result0 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsecomments() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 2,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = [];
 | 
	
		
			
				|  |  | +      s1 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (peg$c4.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +        s2 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s2 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c5); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s3 = [];
 | 
	
		
			
				|  |  | +        if (peg$c6.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +          s4 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +          peg$currPos++;
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("[\\-]");
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | +          s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +          if (peg$silentFails === 0) { peg$fail(peg$c7); }
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        result0 = result0 !== null ? result0 : "";
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          if (/^[0-9]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -            result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -            advance(pos, 1);
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result2 = null;
 | 
	
		
			
				|  |  | -            if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -              matchFailed("[0-9]");
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result2 !== null) {
 | 
	
		
			
				|  |  | -            result1 = [];
 | 
	
		
			
				|  |  | -            while (result2 !== null) {
 | 
	
		
			
				|  |  | -              result1.push(result2);
 | 
	
		
			
				|  |  | -              if (/^[0-9]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -                result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -                advance(pos, 1);
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result2 = null;
 | 
	
		
			
				|  |  | -                if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                  matchFailed("[0-9]");
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result1 = null;
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0 = [result0, result1];
 | 
	
		
			
				|  |  | +        while (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3.push(s4);
 | 
	
		
			
				|  |  | +          if (peg$c6.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +            s4 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, neg, digits) {return (parseInt(neg+digits.join(""), 10));})(pos0.offset, pos0.line, pos0.column, result0[0], result0[1]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_literalArray() {
 | 
	
		
			
				|  |  | -        var cacheKey = "literalArray@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (input.substr(pos.offset, 2) === "#(") {
 | 
	
		
			
				|  |  | -          result0 = "#(";
 | 
	
		
			
				|  |  | -          advance(pos, 2);
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("\"#(\"");
 | 
	
		
			
				|  |  | +            s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c7); }
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_literalArrayRest();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0 = [result0, result1];
 | 
	
		
			
				|  |  | +        if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          if (peg$c4.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +            s4 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, rest) {return rest;})(pos0.offset, pos0.line, pos0.column, result0[1]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_bareLiteralArray() {
 | 
	
		
			
				|  |  | -        var cacheKey = "bareLiteralArray@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (input.charCodeAt(pos.offset) === 40) {
 | 
	
		
			
				|  |  | -          result0 = "(";
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("\"(\"");
 | 
	
		
			
				|  |  | +            s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c5); }
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_literalArrayRest();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0 = [result0, result1];
 | 
	
		
			
				|  |  | +          if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s2 = [s2, s3, s4];
 | 
	
		
			
				|  |  | +            s1 = s2;
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s1;
 | 
	
		
			
				|  |  | +            s1 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, rest) {return rest;})(pos0.offset, pos0.line, pos0.column, result0[1]);
 | 
	
		
			
				|  |  | +          peg$currPos = s1;
 | 
	
		
			
				|  |  | +          s1 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_literalArrayRest() {
 | 
	
		
			
				|  |  | -        var cacheKey = "literalArrayRest@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3;
 | 
	
		
			
				|  |  | -        var pos0, pos1, pos2, pos3;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_ws();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = [];
 | 
	
		
			
				|  |  | -          pos2 = clone(pos);
 | 
	
		
			
				|  |  | -          pos3 = clone(pos);
 | 
	
		
			
				|  |  | -          result2 = parse_parseTimeLiteral();
 | 
	
		
			
				|  |  | -          if (result2 === null) {
 | 
	
		
			
				|  |  | -            result2 = parse_bareLiteralArray();
 | 
	
		
			
				|  |  | -            if (result2 === null) {
 | 
	
		
			
				|  |  | -              result2 = parse_bareSymbol();
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result2 !== null) {
 | 
	
		
			
				|  |  | -            result3 = parse_ws();
 | 
	
		
			
				|  |  | -            if (result3 !== null) {
 | 
	
		
			
				|  |  | -              result2 = [result2, result3];
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s1;
 | 
	
		
			
				|  |  | +        s1 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        while (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s0.push(s1);
 | 
	
		
			
				|  |  | +          s1 = peg$currPos;
 | 
	
		
			
				|  |  | +          if (peg$c4.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +            s2 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            s2 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c5); }
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s3 = [];
 | 
	
		
			
				|  |  | +            if (peg$c6.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +              s4 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +              peg$currPos++;
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos3);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result2 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos3);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result2 !== null) {
 | 
	
		
			
				|  |  | -            result2 = (function(offset, line, column, lit) {return lit._value();})(pos2.offset, pos2.line, pos2.column, result2[0]);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result2 === null) {
 | 
	
		
			
				|  |  | -            pos = clone(pos2);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          while (result2 !== null) {
 | 
	
		
			
				|  |  | -            result1.push(result2);
 | 
	
		
			
				|  |  | -            pos2 = clone(pos);
 | 
	
		
			
				|  |  | -            pos3 = clone(pos);
 | 
	
		
			
				|  |  | -            result2 = parse_parseTimeLiteral();
 | 
	
		
			
				|  |  | -            if (result2 === null) {
 | 
	
		
			
				|  |  | -              result2 = parse_bareLiteralArray();
 | 
	
		
			
				|  |  | -              if (result2 === null) {
 | 
	
		
			
				|  |  | -                result2 = parse_bareSymbol();
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result3 = parse_ws();
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                result2 = [result2, result3];
 | 
	
		
			
				|  |  | +              s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +              if (peg$silentFails === 0) { peg$fail(peg$c7); }
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  | +            while (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              s3.push(s4);
 | 
	
		
			
				|  |  | +              if (peg$c6.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +                s4 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +                peg$currPos++;
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result2 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos3);
 | 
	
		
			
				|  |  | +                s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +                if (peg$silentFails === 0) { peg$fail(peg$c7); }
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos3);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result2 = (function(offset, line, column, lit) {return lit._value();})(pos2.offset, pos2.line, pos2.column, result2[0]);
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  | -            if (result2 === null) {
 | 
	
		
			
				|  |  | -              pos = clone(pos2);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result2 = parse_ws();
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              if (input.charCodeAt(pos.offset) === 41) {
 | 
	
		
			
				|  |  | -                result3 = ")";
 | 
	
		
			
				|  |  | -                advance(pos, 1);
 | 
	
		
			
				|  |  | +            if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              if (peg$c4.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +                s4 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +                peg$currPos++;
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result3 = null;
 | 
	
		
			
				|  |  | -                if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                  matchFailed("\")\"");
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | +                s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +                if (peg$silentFails === 0) { peg$fail(peg$c5); }
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                result0 = [result0, result1, result2, result3];
 | 
	
		
			
				|  |  | +              if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                s2 = [s2, s3, s4];
 | 
	
		
			
				|  |  | +                s1 = s2;
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result0 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos1);
 | 
	
		
			
				|  |  | +                peg$currPos = s1;
 | 
	
		
			
				|  |  | +                s1 = peg$c1;
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | +              peg$currPos = s1;
 | 
	
		
			
				|  |  | +              s1 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s1;
 | 
	
		
			
				|  |  | +            s1 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, lits) {
 | 
	
		
			
				|  |  | -                             return smalltalk.ValueNode._new()
 | 
	
		
			
				|  |  | -                                    ._position_((line).__at(column))
 | 
	
		
			
				|  |  | -                                    ._value_(lits);
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[1]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_dynamicArray() {
 | 
	
		
			
				|  |  | -        var cacheKey = "dynamicArray@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3, result4, result5;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (input.charCodeAt(pos.offset) === 123) {
 | 
	
		
			
				|  |  | -          result0 = "{";
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsews() {
 | 
	
		
			
				|  |  | +      var s0, s1;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 3,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = [];
 | 
	
		
			
				|  |  | +      s1 = peg$parseseparator();
 | 
	
		
			
				|  |  | +      if (s1 === peg$FAILED) {
 | 
	
		
			
				|  |  | +        s1 = peg$parsecomments();
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      while (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s0.push(s1);
 | 
	
		
			
				|  |  | +        s1 = peg$parseseparator();
 | 
	
		
			
				|  |  | +        if (s1 === peg$FAILED) {
 | 
	
		
			
				|  |  | +          s1 = peg$parsecomments();
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseidentifier() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 4,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (peg$c8.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +        s1 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c9); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = [];
 | 
	
		
			
				|  |  | +        if (peg$c10.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +          s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +          peg$currPos++;
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("\"{\"");
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | +          s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +          if (peg$silentFails === 0) { peg$fail(peg$c11); }
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_ws();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result2 = parse_expressions();
 | 
	
		
			
				|  |  | -            result2 = result2 !== null ? result2 : "";
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result3 = parse_ws();
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                if (input.charCodeAt(pos.offset) === 46) {
 | 
	
		
			
				|  |  | -                  result4 = ".";
 | 
	
		
			
				|  |  | -                  advance(pos, 1);
 | 
	
		
			
				|  |  | -                } else {
 | 
	
		
			
				|  |  | -                  result4 = null;
 | 
	
		
			
				|  |  | -                  if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                    matchFailed("\".\"");
 | 
	
		
			
				|  |  | -                  }
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -                result4 = result4 !== null ? result4 : "";
 | 
	
		
			
				|  |  | -                if (result4 !== null) {
 | 
	
		
			
				|  |  | -                  if (input.charCodeAt(pos.offset) === 125) {
 | 
	
		
			
				|  |  | -                    result5 = "}";
 | 
	
		
			
				|  |  | -                    advance(pos, 1);
 | 
	
		
			
				|  |  | -                  } else {
 | 
	
		
			
				|  |  | -                    result5 = null;
 | 
	
		
			
				|  |  | -                    if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                      matchFailed("\"}\"");
 | 
	
		
			
				|  |  | -                    }
 | 
	
		
			
				|  |  | -                  }
 | 
	
		
			
				|  |  | -                  if (result5 !== null) {
 | 
	
		
			
				|  |  | -                    result0 = [result0, result1, result2, result3, result4, result5];
 | 
	
		
			
				|  |  | -                  } else {
 | 
	
		
			
				|  |  | -                    result0 = null;
 | 
	
		
			
				|  |  | -                    pos = clone(pos1);
 | 
	
		
			
				|  |  | -                  }
 | 
	
		
			
				|  |  | -                } else {
 | 
	
		
			
				|  |  | -                  result0 = null;
 | 
	
		
			
				|  |  | -                  pos = clone(pos1);
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result0 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos1);
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | +        while (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s2.push(s3);
 | 
	
		
			
				|  |  | +          if (peg$c10.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +            s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c11); }
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, expressions) {
 | 
	
		
			
				|  |  | -                             return smalltalk.DynamicArrayNode._new()
 | 
	
		
			
				|  |  | -                                    ._position_((line).__at(column))
 | 
	
		
			
				|  |  | -                                    ._nodes_(expressions);
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[2]);
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +          s1 = peg$c12(s1, s2);
 | 
	
		
			
				|  |  | +          s0 = s1;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_dynamicDictionary() {
 | 
	
		
			
				|  |  | -        var cacheKey = "dynamicDictionary@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsekeyword() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 5,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parseidentifier();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        if (peg$c13.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +          s2 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +          peg$currPos++;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          s2 = peg$FAILED;
 | 
	
		
			
				|  |  | +          if (peg$silentFails === 0) { peg$fail(peg$c14); }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +          s1 = peg$c15(s1, s2);
 | 
	
		
			
				|  |  | +          s0 = s1;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3, result4;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (input.substr(pos.offset, 2) === "#{") {
 | 
	
		
			
				|  |  | -          result0 = "#{";
 | 
	
		
			
				|  |  | -          advance(pos, 2);
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseselector() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 6,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (peg$c8.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +        s1 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c9); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = [];
 | 
	
		
			
				|  |  | +        if (peg$c16.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +          s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +          peg$currPos++;
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("\"#{\"");
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | +          s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +          if (peg$silentFails === 0) { peg$fail(peg$c17); }
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_ws();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result2 = parse_expressions();
 | 
	
		
			
				|  |  | -            result2 = result2 !== null ? result2 : "";
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result3 = parse_ws();
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                if (input.charCodeAt(pos.offset) === 125) {
 | 
	
		
			
				|  |  | -                  result4 = "}";
 | 
	
		
			
				|  |  | -                  advance(pos, 1);
 | 
	
		
			
				|  |  | -                } else {
 | 
	
		
			
				|  |  | -                  result4 = null;
 | 
	
		
			
				|  |  | -                  if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                    matchFailed("\"}\"");
 | 
	
		
			
				|  |  | -                  }
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -                if (result4 !== null) {
 | 
	
		
			
				|  |  | -                  result0 = [result0, result1, result2, result3, result4];
 | 
	
		
			
				|  |  | -                } else {
 | 
	
		
			
				|  |  | -                  result0 = null;
 | 
	
		
			
				|  |  | -                  pos = clone(pos1);
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result0 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos1);
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | +        while (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s2.push(s3);
 | 
	
		
			
				|  |  | +          if (peg$c16.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +            s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c17); }
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, expressions) {
 | 
	
		
			
				|  |  | -                                return smalltalk.DynamicDictionaryNode._new()
 | 
	
		
			
				|  |  | -                                       ._position_((line).__at(column))
 | 
	
		
			
				|  |  | -                                       ._nodes_(expressions);
 | 
	
		
			
				|  |  | -                            })(pos0.offset, pos0.line, pos0.column, result0[2]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_pseudoVariable() {
 | 
	
		
			
				|  |  | -        var cacheKey = "pseudoVariable@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (input.substr(pos.offset, 4) === "true") {
 | 
	
		
			
				|  |  | -          result0 = "true";
 | 
	
		
			
				|  |  | -          advance(pos, 4);
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +          s1 = peg$c12(s1, s2);
 | 
	
		
			
				|  |  | +          s0 = s1;
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("\"true\"");
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column) {return true;})(pos1.offset, pos1.line, pos1.column);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseclassName() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 7,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (peg$c18.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +        s1 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c19); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = [];
 | 
	
		
			
				|  |  | +        if (peg$c10.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +          s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +          peg$currPos++;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +          if (peg$silentFails === 0) { peg$fail(peg$c11); }
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos1 = clone(pos);
 | 
	
		
			
				|  |  | -          if (input.substr(pos.offset, 5) === "false") {
 | 
	
		
			
				|  |  | -            result0 = "false";
 | 
	
		
			
				|  |  | -            advance(pos, 5);
 | 
	
		
			
				|  |  | +        while (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s2.push(s3);
 | 
	
		
			
				|  |  | +          if (peg$c10.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +            s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -              matchFailed("\"false\"");
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result0 !== null) {
 | 
	
		
			
				|  |  | -            result0 = (function(offset, line, column) {return false;})(pos1.offset, pos1.line, pos1.column);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result0 === null) {
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result0 === null) {
 | 
	
		
			
				|  |  | -            pos1 = clone(pos);
 | 
	
		
			
				|  |  | -            if (input.substr(pos.offset, 3) === "nil") {
 | 
	
		
			
				|  |  | -              result0 = "nil";
 | 
	
		
			
				|  |  | -              advance(pos, 3);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("\"nil\"");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result0 !== null) {
 | 
	
		
			
				|  |  | -              result0 = (function(offset, line, column) {return nil;})(pos1.offset, pos1.line, pos1.column);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result0 === null) {
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | +            s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c11); }
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, val) {
 | 
	
		
			
				|  |  | -                               return smalltalk.ValueNode._new()
 | 
	
		
			
				|  |  | -                                      ._position_((line).__at(column))
 | 
	
		
			
				|  |  | -                                      ._value_(val);
 | 
	
		
			
				|  |  | -                           })(pos0.offset, pos0.line, pos0.column, result0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_parseTimeLiteral() {
 | 
	
		
			
				|  |  | -        var cacheKey = "parseTimeLiteral@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +          s1 = peg$c12(s1, s2);
 | 
	
		
			
				|  |  | +          s0 = s1;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        result0 = parse_pseudoVariable();
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          result0 = parse_number();
 | 
	
		
			
				|  |  | -          if (result0 === null) {
 | 
	
		
			
				|  |  | -            result0 = parse_literalArray();
 | 
	
		
			
				|  |  | -            if (result0 === null) {
 | 
	
		
			
				|  |  | -              result0 = parse_string();
 | 
	
		
			
				|  |  | -              if (result0 === null) {
 | 
	
		
			
				|  |  | -                result0 = parse_symbol();
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsestring() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 8,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (peg$c20.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +        s1 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c21); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = [];
 | 
	
		
			
				|  |  | +        s3 = peg$currPos;
 | 
	
		
			
				|  |  | +        if (input.substr(peg$currPos, 2) === peg$c22) {
 | 
	
		
			
				|  |  | +          s4 = peg$c22;
 | 
	
		
			
				|  |  | +          peg$currPos += 2;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +          if (peg$silentFails === 0) { peg$fail(peg$c23); }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s3;
 | 
	
		
			
				|  |  | +          s4 = peg$c24();
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        s3 = s4;
 | 
	
		
			
				|  |  | +        if (s3 === peg$FAILED) {
 | 
	
		
			
				|  |  | +          if (peg$c25.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +            s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c26); }
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        while (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s2.push(s3);
 | 
	
		
			
				|  |  | +          s3 = peg$currPos;
 | 
	
		
			
				|  |  | +          if (input.substr(peg$currPos, 2) === peg$c22) {
 | 
	
		
			
				|  |  | +            s4 = peg$c22;
 | 
	
		
			
				|  |  | +            peg$currPos += 2;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c23); }
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            peg$reportedPos = s3;
 | 
	
		
			
				|  |  | +            s4 = peg$c24();
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          s3 = s4;
 | 
	
		
			
				|  |  | +          if (s3 === peg$FAILED) {
 | 
	
		
			
				|  |  | +            if (peg$c25.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +              s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +              peg$currPos++;
 | 
	
		
			
				|  |  | +            } else {
 | 
	
		
			
				|  |  | +              s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +              if (peg$silentFails === 0) { peg$fail(peg$c26); }
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_runtimeLiteral() {
 | 
	
		
			
				|  |  | -        var cacheKey = "runtimeLiteral@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        result0 = parse_dynamicDictionary();
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          result0 = parse_dynamicArray();
 | 
	
		
			
				|  |  | -          if (result0 === null) {
 | 
	
		
			
				|  |  | -            result0 = parse_block();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          if (peg$c20.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +            s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c21); }
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_literal() {
 | 
	
		
			
				|  |  | -        var cacheKey = "literal@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        result0 = parse_runtimeLiteral();
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          result0 = parse_parseTimeLiteral();
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_variable() {
 | 
	
		
			
				|  |  | -        var cacheKey = "variable@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0;
 | 
	
		
			
				|  |  | -        var pos0;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_identifier();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, identifier) {
 | 
	
		
			
				|  |  | -                             return smalltalk.VariableNode._new()
 | 
	
		
			
				|  |  | -                                    ._position_((line).__at(column))
 | 
	
		
			
				|  |  | -                                    ._value_(identifier);
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_keywordPair() {
 | 
	
		
			
				|  |  | -        var cacheKey = "keywordPair@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_keyword();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_ws();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result2 = parse_binarySend();
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result3 = parse_ws();
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                result0 = [result0, result1, result2, result3];
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result0 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos1);
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +            s1 = peg$c27(s2);
 | 
	
		
			
				|  |  | +            s0 = s1;
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, key, arg) {return {key:key, arg: arg};})(pos0.offset, pos0.line, pos0.column, result0[0], result0[2]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_binarySelector() {
 | 
	
		
			
				|  |  | -        var cacheKey = "binarySelector@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1;
 | 
	
		
			
				|  |  | -        var pos0;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        if (/^[\\+*\/=><,@%~|&\-]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -          result1 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result1 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("[\\\\+*\\/=><,@%~|&\\-]");
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result1 !== null) {
 | 
	
		
			
				|  |  | -          result0 = [];
 | 
	
		
			
				|  |  | -          while (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0.push(result1);
 | 
	
		
			
				|  |  | -            if (/^[\\+*\/=><,@%~|&\-]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -              result1 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result1 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("[\\\\+*\\/=><,@%~|&\\-]");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsesymbol() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 9,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (input.charCodeAt(peg$currPos) === 35) {
 | 
	
		
			
				|  |  | +        s1 = peg$c28;
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c29); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsebareSymbol();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +          s1 = peg$c30(s2);
 | 
	
		
			
				|  |  | +          s0 = s1;
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, bin) {return bin.join("");})(pos0.offset, pos0.line, pos0.column, result0);
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_keywordPattern() {
 | 
	
		
			
				|  |  | -        var cacheKey = "keywordPattern@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsebareSymbol() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 10,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parseselector();
 | 
	
		
			
				|  |  | +      if (s1 === peg$FAILED) {
 | 
	
		
			
				|  |  | +        s1 = peg$parsebinarySelector();
 | 
	
		
			
				|  |  | +        if (s1 === peg$FAILED) {
 | 
	
		
			
				|  |  | +          s1 = peg$currPos;
 | 
	
		
			
				|  |  | +          s2 = peg$parsestring();
 | 
	
		
			
				|  |  | +          if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            peg$reportedPos = s1;
 | 
	
		
			
				|  |  | +            s2 = peg$c31(s2);
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          s1 = s2;
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +        s1 = peg$c32(s1);
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      s0 = s1;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsenumber() {
 | 
	
		
			
				|  |  | +      var s0, s1;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 11,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parsenumberExp();
 | 
	
		
			
				|  |  | +      if (s1 === peg$FAILED) {
 | 
	
		
			
				|  |  | +        s1 = peg$parsehex();
 | 
	
		
			
				|  |  | +        if (s1 === peg$FAILED) {
 | 
	
		
			
				|  |  | +          s1 = peg$parsefloat();
 | 
	
		
			
				|  |  | +          if (s1 === peg$FAILED) {
 | 
	
		
			
				|  |  | +            s1 = peg$parseinteger();
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +        s1 = peg$c33(s1);
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      s0 = s1;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsenumberExp() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 12,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$currPos;
 | 
	
		
			
				|  |  | +      s2 = peg$parsefloat();
 | 
	
		
			
				|  |  | +      if (s2 === peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parseinteger();
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        if (input.charCodeAt(peg$currPos) === 101) {
 | 
	
		
			
				|  |  | +          s3 = peg$c34;
 | 
	
		
			
				|  |  | +          peg$currPos++;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +          if (peg$silentFails === 0) { peg$fail(peg$c35); }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s4 = peg$parseinteger();
 | 
	
		
			
				|  |  | +          if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s2 = [s2, s3, s4];
 | 
	
		
			
				|  |  | +            s1 = s2;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            peg$currPos = s1;
 | 
	
		
			
				|  |  | +            s1 = peg$c1;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s1;
 | 
	
		
			
				|  |  | +          s1 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3, result4;
 | 
	
		
			
				|  |  | -        var pos0, pos1, pos2;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        pos2 = clone(pos);
 | 
	
		
			
				|  |  | -        result1 = parse_ws();
 | 
	
		
			
				|  |  | -        if (result1 !== null) {
 | 
	
		
			
				|  |  | -          result2 = parse_keyword();
 | 
	
		
			
				|  |  | -          if (result2 !== null) {
 | 
	
		
			
				|  |  | -            result3 = parse_ws();
 | 
	
		
			
				|  |  | -            if (result3 !== null) {
 | 
	
		
			
				|  |  | -              result4 = parse_identifier();
 | 
	
		
			
				|  |  | -              if (result4 !== null) {
 | 
	
		
			
				|  |  | -                result1 = [result1, result2, result3, result4];
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s1;
 | 
	
		
			
				|  |  | +        s1 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +        s1 = peg$c36(s1);
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      s0 = s1;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsehex() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 13,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (peg$c38.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +        s1 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c39); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 === peg$FAILED) {
 | 
	
		
			
				|  |  | +        s1 = peg$c37;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        if (input.substr(peg$currPos, 3) === peg$c40) {
 | 
	
		
			
				|  |  | +          s2 = peg$c40;
 | 
	
		
			
				|  |  | +          peg$currPos += 3;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          s2 = peg$FAILED;
 | 
	
		
			
				|  |  | +          if (peg$silentFails === 0) { peg$fail(peg$c41); }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3 = [];
 | 
	
		
			
				|  |  | +          if (peg$c42.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +            s4 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c43); }
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            while (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              s3.push(s4);
 | 
	
		
			
				|  |  | +              if (peg$c42.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +                s4 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +                peg$currPos++;
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result1 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos2);
 | 
	
		
			
				|  |  | +                s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +                if (peg$silentFails === 0) { peg$fail(peg$c43); }
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result1 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos2);
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result1 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos2);
 | 
	
		
			
				|  |  | +            s3 = peg$c1;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +            s1 = peg$c44(s1, s3);
 | 
	
		
			
				|  |  | +            s0 = s1;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result1 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos2);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result1 !== null) {
 | 
	
		
			
				|  |  | -          result1 = (function(offset, line, column, key, arg) {return {key:key, arg: arg};})(pos1.offset, pos1.line, pos1.column, result1[1], result1[3]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result1 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result1 !== null) {
 | 
	
		
			
				|  |  | -          result0 = [];
 | 
	
		
			
				|  |  | -          while (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0.push(result1);
 | 
	
		
			
				|  |  | -            pos1 = clone(pos);
 | 
	
		
			
				|  |  | -            pos2 = clone(pos);
 | 
	
		
			
				|  |  | -            result1 = parse_ws();
 | 
	
		
			
				|  |  | -            if (result1 !== null) {
 | 
	
		
			
				|  |  | -              result2 = parse_keyword();
 | 
	
		
			
				|  |  | -              if (result2 !== null) {
 | 
	
		
			
				|  |  | -                result3 = parse_ws();
 | 
	
		
			
				|  |  | -                if (result3 !== null) {
 | 
	
		
			
				|  |  | -                  result4 = parse_identifier();
 | 
	
		
			
				|  |  | -                  if (result4 !== null) {
 | 
	
		
			
				|  |  | -                    result1 = [result1, result2, result3, result4];
 | 
	
		
			
				|  |  | -                  } else {
 | 
	
		
			
				|  |  | -                    result1 = null;
 | 
	
		
			
				|  |  | -                    pos = clone(pos2);
 | 
	
		
			
				|  |  | -                  }
 | 
	
		
			
				|  |  | -                } else {
 | 
	
		
			
				|  |  | -                  result1 = null;
 | 
	
		
			
				|  |  | -                  pos = clone(pos2);
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result1 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos2);
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsefloat() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4, s5;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 14,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (peg$c38.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +        s1 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c39); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 === peg$FAILED) {
 | 
	
		
			
				|  |  | +        s1 = peg$c37;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = [];
 | 
	
		
			
				|  |  | +        if (peg$c45.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +          s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +          peg$currPos++;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +          if (peg$silentFails === 0) { peg$fail(peg$c46); }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          while (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s2.push(s3);
 | 
	
		
			
				|  |  | +            if (peg$c45.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +              s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +              peg$currPos++;
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result1 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos2);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result1 !== null) {
 | 
	
		
			
				|  |  | -              result1 = (function(offset, line, column, key, arg) {return {key:key, arg: arg};})(pos1.offset, pos1.line, pos1.column, result1[1], result1[3]);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result1 === null) {
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | +              s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +              if (peg$silentFails === 0) { peg$fail(peg$c46); }
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | +          s2 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, pairs) {
 | 
	
		
			
				|  |  | -                             var keywords = [];
 | 
	
		
			
				|  |  | -                             var params = [];
 | 
	
		
			
				|  |  | -                             var i = 0;
 | 
	
		
			
				|  |  | -                             for(i = 0; i < pairs.length; i++){
 | 
	
		
			
				|  |  | -                                 keywords.push(pairs[i].key);
 | 
	
		
			
				|  |  | -                             }
 | 
	
		
			
				|  |  | -                             for(i = 0; i < pairs.length; i++){
 | 
	
		
			
				|  |  | -                                 params.push(pairs[i].arg);
 | 
	
		
			
				|  |  | -                             }
 | 
	
		
			
				|  |  | -                             return [keywords.join(""), params];
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_binaryPattern() {
 | 
	
		
			
				|  |  | -        var cacheKey = "binaryPattern@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_ws();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_binarySelector();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result2 = parse_ws();
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result3 = parse_identifier();
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                result0 = [result0, result1, result2, result3];
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result0 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos1);
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          if (input.charCodeAt(peg$currPos) === 46) {
 | 
	
		
			
				|  |  | +            s3 = peg$c47;
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c48); }
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s4 = [];
 | 
	
		
			
				|  |  | +            if (peg$c45.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +              s5 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +              peg$currPos++;
 | 
	
		
			
				|  |  | +            } else {
 | 
	
		
			
				|  |  | +              s5 = peg$FAILED;
 | 
	
		
			
				|  |  | +              if (peg$silentFails === 0) { peg$fail(peg$c46); }
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  | +            if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              while (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                s4.push(s5);
 | 
	
		
			
				|  |  | +                if (peg$c45.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +                  s5 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +                  peg$currPos++;
 | 
	
		
			
				|  |  | +                } else {
 | 
	
		
			
				|  |  | +                  s5 = peg$FAILED;
 | 
	
		
			
				|  |  | +                  if (peg$silentFails === 0) { peg$fail(peg$c46); }
 | 
	
		
			
				|  |  | +                }
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | +              s4 = peg$c1;
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +              s1 = peg$c49(s1, s2, s4);
 | 
	
		
			
				|  |  | +              s0 = s1;
 | 
	
		
			
				|  |  | +            } else {
 | 
	
		
			
				|  |  | +              peg$currPos = s0;
 | 
	
		
			
				|  |  | +              s0 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, selector, arg) {return [selector, [arg]];})(pos0.offset, pos0.line, pos0.column, result0[1], result0[3]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_unaryPattern() {
 | 
	
		
			
				|  |  | -        var cacheKey = "unaryPattern@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_ws();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_identifier();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0 = [result0, result1];
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseinteger() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 15,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (peg$c38.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +        s1 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c39); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 === peg$FAILED) {
 | 
	
		
			
				|  |  | +        s1 = peg$c37;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = [];
 | 
	
		
			
				|  |  | +        if (peg$c45.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +          s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +          peg$currPos++;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +          if (peg$silentFails === 0) { peg$fail(peg$c46); }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          while (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s2.push(s3);
 | 
	
		
			
				|  |  | +            if (peg$c45.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +              s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +              peg$currPos++;
 | 
	
		
			
				|  |  | +            } else {
 | 
	
		
			
				|  |  | +              s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +              if (peg$silentFails === 0) { peg$fail(peg$c46); }
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | +          s2 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, selector) {return [selector, []];})(pos0.offset, pos0.line, pos0.column, result0[1]);
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +          s1 = peg$c50(s1, s2);
 | 
	
		
			
				|  |  | +          s0 = s1;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseliteralArray() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 16,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (input.substr(peg$currPos, 2) === peg$c51) {
 | 
	
		
			
				|  |  | +        s1 = peg$c51;
 | 
	
		
			
				|  |  | +        peg$currPos += 2;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c52); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parseliteralArrayRest();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +          s1 = peg$c30(s2);
 | 
	
		
			
				|  |  | +          s0 = s1;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_expression() {
 | 
	
		
			
				|  |  | -        var cacheKey = "expression@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsebareLiteralArray() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 17,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (input.charCodeAt(peg$currPos) === 40) {
 | 
	
		
			
				|  |  | +        s1 = peg$c53;
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c54); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parseliteralArrayRest();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +          s1 = peg$c30(s2);
 | 
	
		
			
				|  |  | +          s0 = s1;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        result0 = parse_assignment();
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          result0 = parse_cascade();
 | 
	
		
			
				|  |  | -          if (result0 === null) {
 | 
	
		
			
				|  |  | -            result0 = parse_keywordSend();
 | 
	
		
			
				|  |  | -            if (result0 === null) {
 | 
	
		
			
				|  |  | -              result0 = parse_binarySend();
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseliteralArrayRest() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4, s5;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 18,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parsews();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = [];
 | 
	
		
			
				|  |  | +        s3 = peg$currPos;
 | 
	
		
			
				|  |  | +        s4 = peg$parseparseTimeLiteral();
 | 
	
		
			
				|  |  | +        if (s4 === peg$FAILED) {
 | 
	
		
			
				|  |  | +          s4 = peg$parsebareLiteralArray();
 | 
	
		
			
				|  |  | +          if (s4 === peg$FAILED) {
 | 
	
		
			
				|  |  | +            s4 = peg$parsebareSymbol();
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s5 = peg$parsews();
 | 
	
		
			
				|  |  | +          if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            peg$reportedPos = s3;
 | 
	
		
			
				|  |  | +            s4 = peg$c55(s4);
 | 
	
		
			
				|  |  | +            s3 = s4;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            peg$currPos = s3;
 | 
	
		
			
				|  |  | +            s3 = peg$c1;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s3;
 | 
	
		
			
				|  |  | +          s3 = peg$c1;
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        while (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s2.push(s3);
 | 
	
		
			
				|  |  | +          s3 = peg$currPos;
 | 
	
		
			
				|  |  | +          s4 = peg$parseparseTimeLiteral();
 | 
	
		
			
				|  |  | +          if (s4 === peg$FAILED) {
 | 
	
		
			
				|  |  | +            s4 = peg$parsebareLiteralArray();
 | 
	
		
			
				|  |  | +            if (s4 === peg$FAILED) {
 | 
	
		
			
				|  |  | +              s4 = peg$parsebareSymbol();
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s5 = peg$parsews();
 | 
	
		
			
				|  |  | +            if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              peg$reportedPos = s3;
 | 
	
		
			
				|  |  | +              s4 = peg$c55(s4);
 | 
	
		
			
				|  |  | +              s3 = s4;
 | 
	
		
			
				|  |  | +            } else {
 | 
	
		
			
				|  |  | +              peg$currPos = s3;
 | 
	
		
			
				|  |  | +              s3 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            peg$currPos = s3;
 | 
	
		
			
				|  |  | +            s3 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_expressionList() {
 | 
	
		
			
				|  |  | -        var cacheKey = "expressionList@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_ws();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          if (input.charCodeAt(pos.offset) === 46) {
 | 
	
		
			
				|  |  | -            result1 = ".";
 | 
	
		
			
				|  |  | -            advance(pos, 1);
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result1 = null;
 | 
	
		
			
				|  |  | -            if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -              matchFailed("\".\"");
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3 = peg$parsews();
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            if (input.charCodeAt(peg$currPos) === 41) {
 | 
	
		
			
				|  |  | +              s4 = peg$c56;
 | 
	
		
			
				|  |  | +              peg$currPos++;
 | 
	
		
			
				|  |  | +            } else {
 | 
	
		
			
				|  |  | +              s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +              if (peg$silentFails === 0) { peg$fail(peg$c57); }
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result2 = parse_ws();
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result3 = parse_expression();
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                result0 = [result0, result1, result2, result3];
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result0 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos1);
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +              s1 = peg$c58(s2);
 | 
	
		
			
				|  |  | +              s0 = s1;
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | +              peg$currPos = s0;
 | 
	
		
			
				|  |  | +              s0 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, expression) {return expression;})(pos0.offset, pos0.line, pos0.column, result0[3]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_expressions() {
 | 
	
		
			
				|  |  | -        var cacheKey = "expressions@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_expression();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = [];
 | 
	
		
			
				|  |  | -          result2 = parse_expressionList();
 | 
	
		
			
				|  |  | -          while (result2 !== null) {
 | 
	
		
			
				|  |  | -            result1.push(result2);
 | 
	
		
			
				|  |  | -            result2 = parse_expressionList();
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0 = [result0, result1];
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, first, others) {
 | 
	
		
			
				|  |  | -                             var result = [first];
 | 
	
		
			
				|  |  | -                             for(var i = 0; i < others.length; i++) {
 | 
	
		
			
				|  |  | -                                 result.push(others[i]);
 | 
	
		
			
				|  |  | -                             }
 | 
	
		
			
				|  |  | -                             return result;
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[0], result0[1]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_assignment() {
 | 
	
		
			
				|  |  | -        var cacheKey = "assignment@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3, result4;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_variable();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_ws();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            if (input.substr(pos.offset, 2) === ":=") {
 | 
	
		
			
				|  |  | -              result2 = ":=";
 | 
	
		
			
				|  |  | -              advance(pos, 2);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("\":=\"");
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsedynamicArray() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4, s5, s6;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 19,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (input.charCodeAt(peg$currPos) === 123) {
 | 
	
		
			
				|  |  | +        s1 = peg$c59;
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c60); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsews();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3 = peg$parseexpressions();
 | 
	
		
			
				|  |  | +          if (s3 === peg$FAILED) {
 | 
	
		
			
				|  |  | +            s3 = peg$c37;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s4 = peg$parsews();
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              if (input.charCodeAt(peg$currPos) === 46) {
 | 
	
		
			
				|  |  | +                s5 = peg$c47;
 | 
	
		
			
				|  |  | +                peg$currPos++;
 | 
	
		
			
				|  |  | +              } else {
 | 
	
		
			
				|  |  | +                s5 = peg$FAILED;
 | 
	
		
			
				|  |  | +                if (peg$silentFails === 0) { peg$fail(peg$c48); }
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result3 = parse_ws();
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                result4 = parse_expression();
 | 
	
		
			
				|  |  | -                if (result4 !== null) {
 | 
	
		
			
				|  |  | -                  result0 = [result0, result1, result2, result3, result4];
 | 
	
		
			
				|  |  | +              if (s5 === peg$FAILED) {
 | 
	
		
			
				|  |  | +                s5 = peg$c37;
 | 
	
		
			
				|  |  | +              }
 | 
	
		
			
				|  |  | +              if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                if (input.charCodeAt(peg$currPos) === 125) {
 | 
	
		
			
				|  |  | +                  s6 = peg$c61;
 | 
	
		
			
				|  |  | +                  peg$currPos++;
 | 
	
		
			
				|  |  | +                } else {
 | 
	
		
			
				|  |  | +                  s6 = peg$FAILED;
 | 
	
		
			
				|  |  | +                  if (peg$silentFails === 0) { peg$fail(peg$c62); }
 | 
	
		
			
				|  |  | +                }
 | 
	
		
			
				|  |  | +                if (s6 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                  peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +                  s1 = peg$c63(s3);
 | 
	
		
			
				|  |  | +                  s0 = s1;
 | 
	
		
			
				|  |  |                  } else {
 | 
	
		
			
				|  |  | -                  result0 = null;
 | 
	
		
			
				|  |  | -                  pos = clone(pos1);
 | 
	
		
			
				|  |  | +                  peg$currPos = s0;
 | 
	
		
			
				|  |  | +                  s0 = peg$c1;
 | 
	
		
			
				|  |  |                  }
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result0 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos1);
 | 
	
		
			
				|  |  | +                peg$currPos = s0;
 | 
	
		
			
				|  |  | +                s0 = peg$c1;
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | +              peg$currPos = s0;
 | 
	
		
			
				|  |  | +              s0 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, variable, expression) {
 | 
	
		
			
				|  |  | -                             return smalltalk.AssignmentNode._new()
 | 
	
		
			
				|  |  | -                                    ._position_((line).__at(column))
 | 
	
		
			
				|  |  | -                                    ._left_(variable)
 | 
	
		
			
				|  |  | -                                    ._right_(expression);
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[0], result0[4]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_ret() {
 | 
	
		
			
				|  |  | -        var cacheKey = "ret@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3, result4;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (input.charCodeAt(pos.offset) === 94) {
 | 
	
		
			
				|  |  | -          result0 = "^";
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("\"^\"");
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_ws();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result2 = parse_expression();
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result3 = parse_ws();
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                if (input.charCodeAt(pos.offset) === 46) {
 | 
	
		
			
				|  |  | -                  result4 = ".";
 | 
	
		
			
				|  |  | -                  advance(pos, 1);
 | 
	
		
			
				|  |  | -                } else {
 | 
	
		
			
				|  |  | -                  result4 = null;
 | 
	
		
			
				|  |  | -                  if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                    matchFailed("\".\"");
 | 
	
		
			
				|  |  | -                  }
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -                result4 = result4 !== null ? result4 : "";
 | 
	
		
			
				|  |  | -                if (result4 !== null) {
 | 
	
		
			
				|  |  | -                  result0 = [result0, result1, result2, result3, result4];
 | 
	
		
			
				|  |  | -                } else {
 | 
	
		
			
				|  |  | -                  result0 = null;
 | 
	
		
			
				|  |  | -                  pos = clone(pos1);
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsedynamicDictionary() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4, s5;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 20,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (input.substr(peg$currPos, 2) === peg$c64) {
 | 
	
		
			
				|  |  | +        s1 = peg$c64;
 | 
	
		
			
				|  |  | +        peg$currPos += 2;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c65); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsews();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3 = peg$parseexpressions();
 | 
	
		
			
				|  |  | +          if (s3 === peg$FAILED) {
 | 
	
		
			
				|  |  | +            s3 = peg$c37;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s4 = peg$parsews();
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              if (input.charCodeAt(peg$currPos) === 125) {
 | 
	
		
			
				|  |  | +                s5 = peg$c61;
 | 
	
		
			
				|  |  | +                peg$currPos++;
 | 
	
		
			
				|  |  | +              } else {
 | 
	
		
			
				|  |  | +                s5 = peg$FAILED;
 | 
	
		
			
				|  |  | +                if (peg$silentFails === 0) { peg$fail(peg$c62); }
 | 
	
		
			
				|  |  | +              }
 | 
	
		
			
				|  |  | +              if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +                s1 = peg$c66(s3);
 | 
	
		
			
				|  |  | +                s0 = s1;
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result0 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos1);
 | 
	
		
			
				|  |  | +                peg$currPos = s0;
 | 
	
		
			
				|  |  | +                s0 = peg$c1;
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | +              peg$currPos = s0;
 | 
	
		
			
				|  |  | +              s0 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, expression) {
 | 
	
		
			
				|  |  | -                             return smalltalk.ReturnNode._new()
 | 
	
		
			
				|  |  | -                                    ._position_((line).__at(column))
 | 
	
		
			
				|  |  | -                                    ._nodes_([expression]);
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[2]);
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsepseudoVariable() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 21,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (input.substr(peg$currPos, 4) === peg$c67) {
 | 
	
		
			
				|  |  | +        s2 = peg$c67;
 | 
	
		
			
				|  |  | +        peg$currPos += 4;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s2 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c68); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        peg$reportedPos = s1;
 | 
	
		
			
				|  |  | +        s2 = peg$c69();
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      s1 = s2;
 | 
	
		
			
				|  |  | +      if (s1 === peg$FAILED) {
 | 
	
		
			
				|  |  | +        s1 = peg$currPos;
 | 
	
		
			
				|  |  | +        if (input.substr(peg$currPos, 5) === peg$c70) {
 | 
	
		
			
				|  |  | +          s2 = peg$c70;
 | 
	
		
			
				|  |  | +          peg$currPos += 5;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          s2 = peg$FAILED;
 | 
	
		
			
				|  |  | +          if (peg$silentFails === 0) { peg$fail(peg$c71); }
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_temps() {
 | 
	
		
			
				|  |  | -        var cacheKey = "temps@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s1;
 | 
	
		
			
				|  |  | +          s2 = peg$c72();
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3, result4;
 | 
	
		
			
				|  |  | -        var pos0, pos1, pos2, pos3;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (input.charCodeAt(pos.offset) === 124) {
 | 
	
		
			
				|  |  | -          result0 = "|";
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("\"|\"");
 | 
	
		
			
				|  |  | +        s1 = s2;
 | 
	
		
			
				|  |  | +        if (s1 === peg$FAILED) {
 | 
	
		
			
				|  |  | +          s1 = peg$currPos;
 | 
	
		
			
				|  |  | +          if (input.substr(peg$currPos, 3) === peg$c73) {
 | 
	
		
			
				|  |  | +            s2 = peg$c73;
 | 
	
		
			
				|  |  | +            peg$currPos += 3;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            s2 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c74); }
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            peg$reportedPos = s1;
 | 
	
		
			
				|  |  | +            s2 = peg$c75();
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | +          s1 = s2;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = [];
 | 
	
		
			
				|  |  | -          pos2 = clone(pos);
 | 
	
		
			
				|  |  | -          pos3 = clone(pos);
 | 
	
		
			
				|  |  | -          result2 = parse_ws();
 | 
	
		
			
				|  |  | -          if (result2 !== null) {
 | 
	
		
			
				|  |  | -            result3 = parse_identifier();
 | 
	
		
			
				|  |  | -            if (result3 !== null) {
 | 
	
		
			
				|  |  | -              result4 = parse_ws();
 | 
	
		
			
				|  |  | -              if (result4 !== null) {
 | 
	
		
			
				|  |  | -                result2 = [result2, result3, result4];
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result2 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos3);
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +        s1 = peg$c76(s1);
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      s0 = s1;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseparseTimeLiteral() {
 | 
	
		
			
				|  |  | +      var s0;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 22,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$parsepseudoVariable();
 | 
	
		
			
				|  |  | +      if (s0 === peg$FAILED) {
 | 
	
		
			
				|  |  | +        s0 = peg$parsenumber();
 | 
	
		
			
				|  |  | +        if (s0 === peg$FAILED) {
 | 
	
		
			
				|  |  | +          s0 = peg$parseliteralArray();
 | 
	
		
			
				|  |  | +          if (s0 === peg$FAILED) {
 | 
	
		
			
				|  |  | +            s0 = peg$parsestring();
 | 
	
		
			
				|  |  | +            if (s0 === peg$FAILED) {
 | 
	
		
			
				|  |  | +              s0 = peg$parsesymbol();
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseruntimeLiteral() {
 | 
	
		
			
				|  |  | +      var s0;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 23,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$parsedynamicDictionary();
 | 
	
		
			
				|  |  | +      if (s0 === peg$FAILED) {
 | 
	
		
			
				|  |  | +        s0 = peg$parsedynamicArray();
 | 
	
		
			
				|  |  | +        if (s0 === peg$FAILED) {
 | 
	
		
			
				|  |  | +          s0 = peg$parseblock();
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseliteral() {
 | 
	
		
			
				|  |  | +      var s0;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 24,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$parseruntimeLiteral();
 | 
	
		
			
				|  |  | +      if (s0 === peg$FAILED) {
 | 
	
		
			
				|  |  | +        s0 = peg$parseparseTimeLiteral();
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsevariable() {
 | 
	
		
			
				|  |  | +      var s0, s1;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 25,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parseidentifier();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +        s1 = peg$c77(s1);
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      s0 = s1;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsekeywordPair() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 26,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parsekeyword();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsews();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3 = peg$parsebinarySend();
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s4 = peg$parsews();
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +              s1 = peg$c78(s1, s3);
 | 
	
		
			
				|  |  | +              s0 = s1;
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos3);
 | 
	
		
			
				|  |  | +              peg$currPos = s0;
 | 
	
		
			
				|  |  | +              s0 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result2 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos3);
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -          if (result2 !== null) {
 | 
	
		
			
				|  |  | -            result2 = (function(offset, line, column, variable) {return variable;})(pos2.offset, pos2.line, pos2.column, result2[1]);
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsebinarySelector() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 27,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = [];
 | 
	
		
			
				|  |  | +      if (peg$c79.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +        s2 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s2 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c80); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        while (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s1.push(s2);
 | 
	
		
			
				|  |  | +          if (peg$c79.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +            s2 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            s2 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c80); }
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -          if (result2 === null) {
 | 
	
		
			
				|  |  | -            pos = clone(pos2);
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +        s1 = peg$c81(s1);
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      s0 = s1;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsekeywordPattern() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4, s5, s6;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 28,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = [];
 | 
	
		
			
				|  |  | +      s2 = peg$currPos;
 | 
	
		
			
				|  |  | +      s3 = peg$parsews();
 | 
	
		
			
				|  |  | +      if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s4 = peg$parsekeyword();
 | 
	
		
			
				|  |  | +        if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s5 = peg$parsews();
 | 
	
		
			
				|  |  | +          if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s6 = peg$parseidentifier();
 | 
	
		
			
				|  |  | +            if (s6 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              peg$reportedPos = s2;
 | 
	
		
			
				|  |  | +              s3 = peg$c78(s4, s6);
 | 
	
		
			
				|  |  | +              s2 = s3;
 | 
	
		
			
				|  |  | +            } else {
 | 
	
		
			
				|  |  | +              peg$currPos = s2;
 | 
	
		
			
				|  |  | +              s2 = peg$c1;
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            peg$currPos = s2;
 | 
	
		
			
				|  |  | +            s2 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -          while (result2 !== null) {
 | 
	
		
			
				|  |  | -            result1.push(result2);
 | 
	
		
			
				|  |  | -            pos2 = clone(pos);
 | 
	
		
			
				|  |  | -            pos3 = clone(pos);
 | 
	
		
			
				|  |  | -            result2 = parse_ws();
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result3 = parse_identifier();
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                result4 = parse_ws();
 | 
	
		
			
				|  |  | -                if (result4 !== null) {
 | 
	
		
			
				|  |  | -                  result2 = [result2, result3, result4];
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s2;
 | 
	
		
			
				|  |  | +          s2 = peg$c1;
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s2;
 | 
	
		
			
				|  |  | +        s2 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        while (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s1.push(s2);
 | 
	
		
			
				|  |  | +          s2 = peg$currPos;
 | 
	
		
			
				|  |  | +          s3 = peg$parsews();
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s4 = peg$parsekeyword();
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              s5 = peg$parsews();
 | 
	
		
			
				|  |  | +              if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                s6 = peg$parseidentifier();
 | 
	
		
			
				|  |  | +                if (s6 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                  peg$reportedPos = s2;
 | 
	
		
			
				|  |  | +                  s3 = peg$c78(s4, s6);
 | 
	
		
			
				|  |  | +                  s2 = s3;
 | 
	
		
			
				|  |  |                  } else {
 | 
	
		
			
				|  |  | -                  result2 = null;
 | 
	
		
			
				|  |  | -                  pos = clone(pos3);
 | 
	
		
			
				|  |  | +                  peg$currPos = s2;
 | 
	
		
			
				|  |  | +                  s2 = peg$c1;
 | 
	
		
			
				|  |  |                  }
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result2 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos3);
 | 
	
		
			
				|  |  | +                peg$currPos = s2;
 | 
	
		
			
				|  |  | +                s2 = peg$c1;
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos3);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result2 = (function(offset, line, column, variable) {return variable;})(pos2.offset, pos2.line, pos2.column, result2[1]);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 === null) {
 | 
	
		
			
				|  |  | -              pos = clone(pos2);
 | 
	
		
			
				|  |  | +              peg$currPos = s2;
 | 
	
		
			
				|  |  | +              s2 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            peg$currPos = s2;
 | 
	
		
			
				|  |  | +            s2 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            if (input.charCodeAt(pos.offset) === 124) {
 | 
	
		
			
				|  |  | -              result2 = "|";
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("\"|\"");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result0 = [result0, result1, result2];
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +        s1 = peg$c82(s1);
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      s0 = s1;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsebinaryPattern() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 29,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parsews();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsebinarySelector();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3 = peg$parsews();
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s4 = peg$parseidentifier();
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +              s1 = peg$c83(s2, s4);
 | 
	
		
			
				|  |  | +              s0 = s1;
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | +              peg$currPos = s0;
 | 
	
		
			
				|  |  | +              s0 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, vars) {return vars;})(pos0.offset, pos0.line, pos0.column, result0[1]);
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_blockParamList() {
 | 
	
		
			
				|  |  | -        var cacheKey = "blockParamList@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseunaryPattern() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 30,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parsews();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parseidentifier();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +          s1 = peg$c84(s2);
 | 
	
		
			
				|  |  | +          s0 = s1;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3, result4;
 | 
	
		
			
				|  |  | -        var pos0, pos1, pos2, pos3;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        pos2 = clone(pos);
 | 
	
		
			
				|  |  | -        pos3 = clone(pos);
 | 
	
		
			
				|  |  | -        result1 = parse_ws();
 | 
	
		
			
				|  |  | -        if (result1 !== null) {
 | 
	
		
			
				|  |  | -          if (input.charCodeAt(pos.offset) === 58) {
 | 
	
		
			
				|  |  | -            result2 = ":";
 | 
	
		
			
				|  |  | -            advance(pos, 1);
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result2 = null;
 | 
	
		
			
				|  |  | -            if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -              matchFailed("\":\"");
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseexpression() {
 | 
	
		
			
				|  |  | +      var s0;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 31,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$parseassignment();
 | 
	
		
			
				|  |  | +      if (s0 === peg$FAILED) {
 | 
	
		
			
				|  |  | +        s0 = peg$parsecascade();
 | 
	
		
			
				|  |  | +        if (s0 === peg$FAILED) {
 | 
	
		
			
				|  |  | +          s0 = peg$parsekeywordSend();
 | 
	
		
			
				|  |  | +          if (s0 === peg$FAILED) {
 | 
	
		
			
				|  |  | +            s0 = peg$parsebinarySend();
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseexpressionList() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 32,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parsews();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        if (input.charCodeAt(peg$currPos) === 46) {
 | 
	
		
			
				|  |  | +          s2 = peg$c47;
 | 
	
		
			
				|  |  | +          peg$currPos++;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          s2 = peg$FAILED;
 | 
	
		
			
				|  |  | +          if (peg$silentFails === 0) { peg$fail(peg$c48); }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3 = peg$parsews();
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s4 = peg$parseexpression();
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +              s1 = peg$c85(s4);
 | 
	
		
			
				|  |  | +              s0 = s1;
 | 
	
		
			
				|  |  | +            } else {
 | 
	
		
			
				|  |  | +              peg$currPos = s0;
 | 
	
		
			
				|  |  | +              s0 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -          if (result2 !== null) {
 | 
	
		
			
				|  |  | -            result3 = parse_ws();
 | 
	
		
			
				|  |  | -            if (result3 !== null) {
 | 
	
		
			
				|  |  | -              result4 = parse_identifier();
 | 
	
		
			
				|  |  | -              if (result4 !== null) {
 | 
	
		
			
				|  |  | -                result1 = [result1, result2, result3, result4];
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseexpressions() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 33,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parseexpression();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = [];
 | 
	
		
			
				|  |  | +        s3 = peg$parseexpressionList();
 | 
	
		
			
				|  |  | +        while (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s2.push(s3);
 | 
	
		
			
				|  |  | +          s3 = peg$parseexpressionList();
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +          s1 = peg$c86(s1, s2);
 | 
	
		
			
				|  |  | +          s0 = s1;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseassignment() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4, s5;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 34,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parsevariable();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsews();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          if (input.substr(peg$currPos, 2) === peg$c87) {
 | 
	
		
			
				|  |  | +            s3 = peg$c87;
 | 
	
		
			
				|  |  | +            peg$currPos += 2;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c88); }
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s4 = peg$parsews();
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              s5 = peg$parseexpression();
 | 
	
		
			
				|  |  | +              if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +                s1 = peg$c89(s1, s5);
 | 
	
		
			
				|  |  | +                s0 = s1;
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result1 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos3);
 | 
	
		
			
				|  |  | +                peg$currPos = s0;
 | 
	
		
			
				|  |  | +                s0 = peg$c1;
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result1 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos3);
 | 
	
		
			
				|  |  | +              peg$currPos = s0;
 | 
	
		
			
				|  |  | +              s0 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result1 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos3);
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result1 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos3);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result1 !== null) {
 | 
	
		
			
				|  |  | -          result1 = (function(offset, line, column, param) {return param;})(pos2.offset, pos2.line, pos2.column, result1[3]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result1 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos2);
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result1 !== null) {
 | 
	
		
			
				|  |  | -          result0 = [];
 | 
	
		
			
				|  |  | -          while (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0.push(result1);
 | 
	
		
			
				|  |  | -            pos2 = clone(pos);
 | 
	
		
			
				|  |  | -            pos3 = clone(pos);
 | 
	
		
			
				|  |  | -            result1 = parse_ws();
 | 
	
		
			
				|  |  | -            if (result1 !== null) {
 | 
	
		
			
				|  |  | -              if (input.charCodeAt(pos.offset) === 58) {
 | 
	
		
			
				|  |  | -                result2 = ":";
 | 
	
		
			
				|  |  | -                advance(pos, 1);
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseret() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4, s5;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 35,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (input.charCodeAt(peg$currPos) === 94) {
 | 
	
		
			
				|  |  | +        s1 = peg$c90;
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c91); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsews();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3 = peg$parseexpression();
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s4 = peg$parsews();
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              if (input.charCodeAt(peg$currPos) === 46) {
 | 
	
		
			
				|  |  | +                s5 = peg$c47;
 | 
	
		
			
				|  |  | +                peg$currPos++;
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result2 = null;
 | 
	
		
			
				|  |  | -                if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                  matchFailed("\":\"");
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | +                s5 = peg$FAILED;
 | 
	
		
			
				|  |  | +                if (peg$silentFails === 0) { peg$fail(peg$c48); }
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  | -              if (result2 !== null) {
 | 
	
		
			
				|  |  | -                result3 = parse_ws();
 | 
	
		
			
				|  |  | -                if (result3 !== null) {
 | 
	
		
			
				|  |  | -                  result4 = parse_identifier();
 | 
	
		
			
				|  |  | -                  if (result4 !== null) {
 | 
	
		
			
				|  |  | -                    result1 = [result1, result2, result3, result4];
 | 
	
		
			
				|  |  | -                  } else {
 | 
	
		
			
				|  |  | -                    result1 = null;
 | 
	
		
			
				|  |  | -                    pos = clone(pos3);
 | 
	
		
			
				|  |  | -                  }
 | 
	
		
			
				|  |  | -                } else {
 | 
	
		
			
				|  |  | -                  result1 = null;
 | 
	
		
			
				|  |  | -                  pos = clone(pos3);
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | +              if (s5 === peg$FAILED) {
 | 
	
		
			
				|  |  | +                s5 = peg$c37;
 | 
	
		
			
				|  |  | +              }
 | 
	
		
			
				|  |  | +              if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +                s1 = peg$c92(s3);
 | 
	
		
			
				|  |  | +                s0 = s1;
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result1 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos3);
 | 
	
		
			
				|  |  | +                peg$currPos = s0;
 | 
	
		
			
				|  |  | +                s0 = peg$c1;
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result1 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos3);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result1 !== null) {
 | 
	
		
			
				|  |  | -              result1 = (function(offset, line, column, param) {return param;})(pos2.offset, pos2.line, pos2.column, result1[3]);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result1 === null) {
 | 
	
		
			
				|  |  | -              pos = clone(pos2);
 | 
	
		
			
				|  |  | +              peg$currPos = s0;
 | 
	
		
			
				|  |  | +              s0 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_ws();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            if (input.charCodeAt(pos.offset) === 124) {
 | 
	
		
			
				|  |  | -              result2 = "|";
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("\"|\"");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result0 = [result0, result1, result2];
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsetemps() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4, s5, s6;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 36,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (input.charCodeAt(peg$currPos) === 124) {
 | 
	
		
			
				|  |  | +        s1 = peg$c93;
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c94); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = [];
 | 
	
		
			
				|  |  | +        s3 = peg$currPos;
 | 
	
		
			
				|  |  | +        s4 = peg$parsews();
 | 
	
		
			
				|  |  | +        if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s5 = peg$parseidentifier();
 | 
	
		
			
				|  |  | +          if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s6 = peg$parsews();
 | 
	
		
			
				|  |  | +            if (s6 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              peg$reportedPos = s3;
 | 
	
		
			
				|  |  | +              s4 = peg$c95(s5);
 | 
	
		
			
				|  |  | +              s3 = s4;
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | +              peg$currPos = s3;
 | 
	
		
			
				|  |  | +              s3 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s3;
 | 
	
		
			
				|  |  | +            s3 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, params) {return params;})(pos0.offset, pos0.line, pos0.column, result0[0]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_subexpression() {
 | 
	
		
			
				|  |  | -        var cacheKey = "subexpression@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3, result4;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (input.charCodeAt(pos.offset) === 40) {
 | 
	
		
			
				|  |  | -          result0 = "(";
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("\"(\"");
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | +          peg$currPos = s3;
 | 
	
		
			
				|  |  | +          s3 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_ws();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result2 = parse_expression();
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result3 = parse_ws();
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                if (input.charCodeAt(pos.offset) === 41) {
 | 
	
		
			
				|  |  | -                  result4 = ")";
 | 
	
		
			
				|  |  | -                  advance(pos, 1);
 | 
	
		
			
				|  |  | -                } else {
 | 
	
		
			
				|  |  | -                  result4 = null;
 | 
	
		
			
				|  |  | -                  if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                    matchFailed("\")\"");
 | 
	
		
			
				|  |  | -                  }
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -                if (result4 !== null) {
 | 
	
		
			
				|  |  | -                  result0 = [result0, result1, result2, result3, result4];
 | 
	
		
			
				|  |  | -                } else {
 | 
	
		
			
				|  |  | -                  result0 = null;
 | 
	
		
			
				|  |  | -                  pos = clone(pos1);
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | +        while (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s2.push(s3);
 | 
	
		
			
				|  |  | +          s3 = peg$currPos;
 | 
	
		
			
				|  |  | +          s4 = peg$parsews();
 | 
	
		
			
				|  |  | +          if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s5 = peg$parseidentifier();
 | 
	
		
			
				|  |  | +            if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              s6 = peg$parsews();
 | 
	
		
			
				|  |  | +              if (s6 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                peg$reportedPos = s3;
 | 
	
		
			
				|  |  | +                s4 = peg$c95(s5);
 | 
	
		
			
				|  |  | +                s3 = s4;
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result0 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos1);
 | 
	
		
			
				|  |  | +                peg$currPos = s3;
 | 
	
		
			
				|  |  | +                s3 = peg$c1;
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | +              peg$currPos = s3;
 | 
	
		
			
				|  |  | +              s3 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s3;
 | 
	
		
			
				|  |  | +            s3 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, expression) {return expression;})(pos0.offset, pos0.line, pos0.column, result0[2]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_statements() {
 | 
	
		
			
				|  |  | -        var cacheKey = "statements@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3, result4, result5, result6;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_ret();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = [];
 | 
	
		
			
				|  |  | -          if (/^[.]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -            result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -            advance(pos, 1);
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          if (input.charCodeAt(peg$currPos) === 124) {
 | 
	
		
			
				|  |  | +            s3 = peg$c93;
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result2 = null;
 | 
	
		
			
				|  |  | -            if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -              matchFailed("[.]");
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          while (result2 !== null) {
 | 
	
		
			
				|  |  | -            result1.push(result2);
 | 
	
		
			
				|  |  | -            if (/^[.]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -              result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("[.]");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | +            s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c94); }
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0 = [result0, result1];
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +            s1 = peg$c96(s2);
 | 
	
		
			
				|  |  | +            s0 = s1;
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, ret) {return [ret];})(pos0.offset, pos0.line, pos0.column, result0[0]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos0 = clone(pos);
 | 
	
		
			
				|  |  | -          pos1 = clone(pos);
 | 
	
		
			
				|  |  | -          result0 = parse_expressions();
 | 
	
		
			
				|  |  | -          if (result0 !== null) {
 | 
	
		
			
				|  |  | -            result1 = parse_ws();
 | 
	
		
			
				|  |  | -            if (result1 !== null) {
 | 
	
		
			
				|  |  | -              if (/^[.]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -                result3 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -                advance(pos, 1);
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result3 = null;
 | 
	
		
			
				|  |  | -                if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                  matchFailed("[.]");
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                result2 = [];
 | 
	
		
			
				|  |  | -                while (result3 !== null) {
 | 
	
		
			
				|  |  | -                  result2.push(result3);
 | 
	
		
			
				|  |  | -                  if (/^[.]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -                    result3 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -                    advance(pos, 1);
 | 
	
		
			
				|  |  | -                  } else {
 | 
	
		
			
				|  |  | -                    result3 = null;
 | 
	
		
			
				|  |  | -                    if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                      matchFailed("[.]");
 | 
	
		
			
				|  |  | -                    }
 | 
	
		
			
				|  |  | -                  }
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result2 = null;
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -              if (result2 !== null) {
 | 
	
		
			
				|  |  | -                result3 = parse_ws();
 | 
	
		
			
				|  |  | -                if (result3 !== null) {
 | 
	
		
			
				|  |  | -                  result4 = parse_ret();
 | 
	
		
			
				|  |  | -                  if (result4 !== null) {
 | 
	
		
			
				|  |  | -                    result5 = [];
 | 
	
		
			
				|  |  | -                    if (/^[.]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -                      result6 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -                      advance(pos, 1);
 | 
	
		
			
				|  |  | -                    } else {
 | 
	
		
			
				|  |  | -                      result6 = null;
 | 
	
		
			
				|  |  | -                      if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                        matchFailed("[.]");
 | 
	
		
			
				|  |  | -                      }
 | 
	
		
			
				|  |  | -                    }
 | 
	
		
			
				|  |  | -                    while (result6 !== null) {
 | 
	
		
			
				|  |  | -                      result5.push(result6);
 | 
	
		
			
				|  |  | -                      if (/^[.]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -                        result6 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -                        advance(pos, 1);
 | 
	
		
			
				|  |  | -                      } else {
 | 
	
		
			
				|  |  | -                        result6 = null;
 | 
	
		
			
				|  |  | -                        if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                          matchFailed("[.]");
 | 
	
		
			
				|  |  | -                        }
 | 
	
		
			
				|  |  | -                      }
 | 
	
		
			
				|  |  | -                    }
 | 
	
		
			
				|  |  | -                    if (result5 !== null) {
 | 
	
		
			
				|  |  | -                      result0 = [result0, result1, result2, result3, result4, result5];
 | 
	
		
			
				|  |  | -                    } else {
 | 
	
		
			
				|  |  | -                      result0 = null;
 | 
	
		
			
				|  |  | -                      pos = clone(pos1);
 | 
	
		
			
				|  |  | -                    }
 | 
	
		
			
				|  |  | -                  } else {
 | 
	
		
			
				|  |  | -                    result0 = null;
 | 
	
		
			
				|  |  | -                    pos = clone(pos1);
 | 
	
		
			
				|  |  | -                  }
 | 
	
		
			
				|  |  | -                } else {
 | 
	
		
			
				|  |  | -                  result0 = null;
 | 
	
		
			
				|  |  | -                  pos = clone(pos1);
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result0 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos1);
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseblockParamList() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4, s5, s6;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 37,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = [];
 | 
	
		
			
				|  |  | +      s2 = peg$currPos;
 | 
	
		
			
				|  |  | +      s3 = peg$parsews();
 | 
	
		
			
				|  |  | +      if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        if (input.charCodeAt(peg$currPos) === 58) {
 | 
	
		
			
				|  |  | +          s4 = peg$c97;
 | 
	
		
			
				|  |  | +          peg$currPos++;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +          if (peg$silentFails === 0) { peg$fail(peg$c98); }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s5 = peg$parsews();
 | 
	
		
			
				|  |  | +          if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s6 = peg$parseidentifier();
 | 
	
		
			
				|  |  | +            if (s6 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              peg$reportedPos = s2;
 | 
	
		
			
				|  |  | +              s3 = peg$c99(s6);
 | 
	
		
			
				|  |  | +              s2 = s3;
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | +              peg$currPos = s2;
 | 
	
		
			
				|  |  | +              s2 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s2;
 | 
	
		
			
				|  |  | +            s2 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -          if (result0 !== null) {
 | 
	
		
			
				|  |  | -            result0 = (function(offset, line, column, exps, ret) {
 | 
	
		
			
				|  |  | -                                 var expressions = exps;
 | 
	
		
			
				|  |  | -                                 expressions.push(ret);
 | 
	
		
			
				|  |  | -                                 return expressions;
 | 
	
		
			
				|  |  | -                             })(pos0.offset, pos0.line, pos0.column, result0[0], result0[4]);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result0 === null) {
 | 
	
		
			
				|  |  | -            pos = clone(pos0);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result0 === null) {
 | 
	
		
			
				|  |  | -            pos0 = clone(pos);
 | 
	
		
			
				|  |  | -            pos1 = clone(pos);
 | 
	
		
			
				|  |  | -            result0 = parse_expressions();
 | 
	
		
			
				|  |  | -            result0 = result0 !== null ? result0 : "";
 | 
	
		
			
				|  |  | -            if (result0 !== null) {
 | 
	
		
			
				|  |  | -              result1 = [];
 | 
	
		
			
				|  |  | -              if (/^[.]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -                result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -                advance(pos, 1);
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result2 = null;
 | 
	
		
			
				|  |  | -                if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                  matchFailed("[.]");
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -              while (result2 !== null) {
 | 
	
		
			
				|  |  | -                result1.push(result2);
 | 
	
		
			
				|  |  | -                if (/^[.]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -                  result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -                  advance(pos, 1);
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s2;
 | 
	
		
			
				|  |  | +          s2 = peg$c1;
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s2;
 | 
	
		
			
				|  |  | +        s2 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        while (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s1.push(s2);
 | 
	
		
			
				|  |  | +          s2 = peg$currPos;
 | 
	
		
			
				|  |  | +          s3 = peg$parsews();
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            if (input.charCodeAt(peg$currPos) === 58) {
 | 
	
		
			
				|  |  | +              s4 = peg$c97;
 | 
	
		
			
				|  |  | +              peg$currPos++;
 | 
	
		
			
				|  |  | +            } else {
 | 
	
		
			
				|  |  | +              s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +              if (peg$silentFails === 0) { peg$fail(peg$c98); }
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              s5 = peg$parsews();
 | 
	
		
			
				|  |  | +              if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                s6 = peg$parseidentifier();
 | 
	
		
			
				|  |  | +                if (s6 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                  peg$reportedPos = s2;
 | 
	
		
			
				|  |  | +                  s3 = peg$c99(s6);
 | 
	
		
			
				|  |  | +                  s2 = s3;
 | 
	
		
			
				|  |  |                  } else {
 | 
	
		
			
				|  |  | -                  result2 = null;
 | 
	
		
			
				|  |  | -                  if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                    matchFailed("[.]");
 | 
	
		
			
				|  |  | -                  }
 | 
	
		
			
				|  |  | +                  peg$currPos = s2;
 | 
	
		
			
				|  |  | +                  s2 = peg$c1;
 | 
	
		
			
				|  |  |                  }
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -              if (result1 !== null) {
 | 
	
		
			
				|  |  | -                result0 = [result0, result1];
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result0 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos1);
 | 
	
		
			
				|  |  | +                peg$currPos = s2;
 | 
	
		
			
				|  |  | +                s2 = peg$c1;
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result0 !== null) {
 | 
	
		
			
				|  |  | -              result0 = (function(offset, line, column, expressions) {
 | 
	
		
			
				|  |  | -                                   return expressions || [];
 | 
	
		
			
				|  |  | -                               })(pos0.offset, pos0.line, pos0.column, result0[0]);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result0 === null) {
 | 
	
		
			
				|  |  | -              pos = clone(pos0);
 | 
	
		
			
				|  |  | +              peg$currPos = s2;
 | 
	
		
			
				|  |  | +              s2 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            peg$currPos = s2;
 | 
	
		
			
				|  |  | +            s2 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_sequence() {
 | 
	
		
			
				|  |  | -        var cacheKey = "sequence@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        result0 = parse_jsStatement();
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          result0 = parse_stSequence();
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_stSequence() {
 | 
	
		
			
				|  |  | -        var cacheKey = "stSequence@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsews();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          if (input.charCodeAt(peg$currPos) === 124) {
 | 
	
		
			
				|  |  | +            s3 = peg$c93;
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c94); }
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +            s1 = peg$c100(s1);
 | 
	
		
			
				|  |  | +            s0 = s1;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_temps();
 | 
	
		
			
				|  |  | -        result0 = result0 !== null ? result0 : "";
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_ws();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result2 = parse_statements();
 | 
	
		
			
				|  |  | -            result2 = result2 !== null ? result2 : "";
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result3 = parse_ws();
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                result0 = [result0, result1, result2, result3];
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsesubexpression() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4, s5;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 38,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (input.charCodeAt(peg$currPos) === 40) {
 | 
	
		
			
				|  |  | +        s1 = peg$c53;
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c54); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsews();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3 = peg$parseexpression();
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s4 = peg$parsews();
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              if (input.charCodeAt(peg$currPos) === 41) {
 | 
	
		
			
				|  |  | +                s5 = peg$c56;
 | 
	
		
			
				|  |  | +                peg$currPos++;
 | 
	
		
			
				|  |  | +              } else {
 | 
	
		
			
				|  |  | +                s5 = peg$FAILED;
 | 
	
		
			
				|  |  | +                if (peg$silentFails === 0) { peg$fail(peg$c57); }
 | 
	
		
			
				|  |  | +              }
 | 
	
		
			
				|  |  | +              if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +                s1 = peg$c85(s3);
 | 
	
		
			
				|  |  | +                s0 = s1;
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result0 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos1);
 | 
	
		
			
				|  |  | +                peg$currPos = s0;
 | 
	
		
			
				|  |  | +                s0 = peg$c1;
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | +              peg$currPos = s0;
 | 
	
		
			
				|  |  | +              s0 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, temps, statements) {
 | 
	
		
			
				|  |  | -                             return smalltalk.SequenceNode._new()
 | 
	
		
			
				|  |  | -                                    ._position_((line).__at(column))
 | 
	
		
			
				|  |  | -                                    ._temps_(temps || [])
 | 
	
		
			
				|  |  | -                                    ._nodes_(statements || []);
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[0], result0[2]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_block() {
 | 
	
		
			
				|  |  | -        var cacheKey = "block@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3, result4, result5, result6;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (input.charCodeAt(pos.offset) === 91) {
 | 
	
		
			
				|  |  | -          result0 = "[";
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("\"[\"");
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsestatements() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4, s5, s6, s7;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 39,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parseret();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = [];
 | 
	
		
			
				|  |  | +        if (peg$c101.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +          s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +          peg$currPos++;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +          if (peg$silentFails === 0) { peg$fail(peg$c102); }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        while (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s2.push(s3);
 | 
	
		
			
				|  |  | +          if (peg$c101.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +            s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c102); }
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +          s1 = peg$c103(s1);
 | 
	
		
			
				|  |  | +          s0 = s1;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_ws();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result2 = parse_blockParamList();
 | 
	
		
			
				|  |  | -            result2 = result2 !== null ? result2 : "";
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result3 = parse_ws();
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                result4 = parse_sequence();
 | 
	
		
			
				|  |  | -                result4 = result4 !== null ? result4 : "";
 | 
	
		
			
				|  |  | -                if (result4 !== null) {
 | 
	
		
			
				|  |  | -                  result5 = parse_ws();
 | 
	
		
			
				|  |  | -                  if (result5 !== null) {
 | 
	
		
			
				|  |  | -                    if (input.charCodeAt(pos.offset) === 93) {
 | 
	
		
			
				|  |  | -                      result6 = "]";
 | 
	
		
			
				|  |  | -                      advance(pos, 1);
 | 
	
		
			
				|  |  | -                    } else {
 | 
	
		
			
				|  |  | -                      result6 = null;
 | 
	
		
			
				|  |  | -                      if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                        matchFailed("\"]\"");
 | 
	
		
			
				|  |  | -                      }
 | 
	
		
			
				|  |  | -                    }
 | 
	
		
			
				|  |  | -                    if (result6 !== null) {
 | 
	
		
			
				|  |  | -                      result0 = [result0, result1, result2, result3, result4, result5, result6];
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s0 === peg$FAILED) {
 | 
	
		
			
				|  |  | +        s0 = peg$currPos;
 | 
	
		
			
				|  |  | +        s1 = peg$parseexpressions();
 | 
	
		
			
				|  |  | +        if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s2 = peg$parsews();
 | 
	
		
			
				|  |  | +          if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s3 = [];
 | 
	
		
			
				|  |  | +            if (peg$c101.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +              s4 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +              peg$currPos++;
 | 
	
		
			
				|  |  | +            } else {
 | 
	
		
			
				|  |  | +              s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +              if (peg$silentFails === 0) { peg$fail(peg$c102); }
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              while (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                s3.push(s4);
 | 
	
		
			
				|  |  | +                if (peg$c101.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +                  s4 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +                  peg$currPos++;
 | 
	
		
			
				|  |  | +                } else {
 | 
	
		
			
				|  |  | +                  s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +                  if (peg$silentFails === 0) { peg$fail(peg$c102); }
 | 
	
		
			
				|  |  | +                }
 | 
	
		
			
				|  |  | +              }
 | 
	
		
			
				|  |  | +            } else {
 | 
	
		
			
				|  |  | +              s3 = peg$c1;
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  | +            if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              s4 = peg$parsews();
 | 
	
		
			
				|  |  | +              if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                s5 = peg$parseret();
 | 
	
		
			
				|  |  | +                if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                  s6 = [];
 | 
	
		
			
				|  |  | +                  if (peg$c101.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +                    s7 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +                    peg$currPos++;
 | 
	
		
			
				|  |  | +                  } else {
 | 
	
		
			
				|  |  | +                    s7 = peg$FAILED;
 | 
	
		
			
				|  |  | +                    if (peg$silentFails === 0) { peg$fail(peg$c102); }
 | 
	
		
			
				|  |  | +                  }
 | 
	
		
			
				|  |  | +                  while (s7 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                    s6.push(s7);
 | 
	
		
			
				|  |  | +                    if (peg$c101.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +                      s7 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +                      peg$currPos++;
 | 
	
		
			
				|  |  |                      } else {
 | 
	
		
			
				|  |  | -                      result0 = null;
 | 
	
		
			
				|  |  | -                      pos = clone(pos1);
 | 
	
		
			
				|  |  | +                      s7 = peg$FAILED;
 | 
	
		
			
				|  |  | +                      if (peg$silentFails === 0) { peg$fail(peg$c102); }
 | 
	
		
			
				|  |  |                      }
 | 
	
		
			
				|  |  | +                  }
 | 
	
		
			
				|  |  | +                  if (s6 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                    peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +                    s1 = peg$c104(s1, s5);
 | 
	
		
			
				|  |  | +                    s0 = s1;
 | 
	
		
			
				|  |  |                    } else {
 | 
	
		
			
				|  |  | -                    result0 = null;
 | 
	
		
			
				|  |  | -                    pos = clone(pos1);
 | 
	
		
			
				|  |  | +                    peg$currPos = s0;
 | 
	
		
			
				|  |  | +                    s0 = peg$c1;
 | 
	
		
			
				|  |  |                    }
 | 
	
		
			
				|  |  |                  } else {
 | 
	
		
			
				|  |  | -                  result0 = null;
 | 
	
		
			
				|  |  | -                  pos = clone(pos1);
 | 
	
		
			
				|  |  | +                  peg$currPos = s0;
 | 
	
		
			
				|  |  | +                  s0 = peg$c1;
 | 
	
		
			
				|  |  |                  }
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result0 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos1);
 | 
	
		
			
				|  |  | +                peg$currPos = s0;
 | 
	
		
			
				|  |  | +                s0 = peg$c1;
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | +              peg$currPos = s0;
 | 
	
		
			
				|  |  | +              s0 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, params, sequence) {
 | 
	
		
			
				|  |  | -                             return smalltalk.BlockNode._new()
 | 
	
		
			
				|  |  | -                                    ._position_((line).__at(column))
 | 
	
		
			
				|  |  | -                                    ._parameters_(params || [])
 | 
	
		
			
				|  |  | -                                    ._nodes_([sequence._asBlockSequenceNode()]);
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[2], result0[4]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_operand() {
 | 
	
		
			
				|  |  | -        var cacheKey = "operand@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        result0 = parse_literal();
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          result0 = parse_variable();
 | 
	
		
			
				|  |  | -          if (result0 === null) {
 | 
	
		
			
				|  |  | -            result0 = parse_subexpression();
 | 
	
		
			
				|  |  | +        if (s0 === peg$FAILED) {
 | 
	
		
			
				|  |  | +          s0 = peg$currPos;
 | 
	
		
			
				|  |  | +          s1 = peg$parseexpressions();
 | 
	
		
			
				|  |  | +          if (s1 === peg$FAILED) {
 | 
	
		
			
				|  |  | +            s1 = peg$c37;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_unaryMessage() {
 | 
	
		
			
				|  |  | -        var cacheKey = "unaryMessage@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2;
 | 
	
		
			
				|  |  | -        var pos0, pos1, pos2;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_ws();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_identifier();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            pos2 = clone(pos);
 | 
	
		
			
				|  |  | -            reportFailures++;
 | 
	
		
			
				|  |  | -            if (/^[:]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -              result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | +          if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s2 = [];
 | 
	
		
			
				|  |  | +            if (peg$c101.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +              s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +              peg$currPos++;
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("[:]");
 | 
	
		
			
				|  |  | +              s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +              if (peg$silentFails === 0) { peg$fail(peg$c102); }
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  | +            while (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              s2.push(s3);
 | 
	
		
			
				|  |  | +              if (peg$c101.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +                s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +                peg$currPos++;
 | 
	
		
			
				|  |  | +              } else {
 | 
	
		
			
				|  |  | +                s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +                if (peg$silentFails === 0) { peg$fail(peg$c102); }
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  | -            reportFailures--;
 | 
	
		
			
				|  |  | -            if (result2 === null) {
 | 
	
		
			
				|  |  | -              result2 = "";
 | 
	
		
			
				|  |  | +            if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +              s1 = peg$c105(s1);
 | 
	
		
			
				|  |  | +              s0 = s1;
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos2);
 | 
	
		
			
				|  |  | +              peg$currPos = s0;
 | 
	
		
			
				|  |  | +              s0 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result0 = [result0, result1, result2];
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsesequence() {
 | 
	
		
			
				|  |  | +      var s0;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 40,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$parsejsStatement();
 | 
	
		
			
				|  |  | +      if (s0 === peg$FAILED) {
 | 
	
		
			
				|  |  | +        s0 = peg$parsestSequence();
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsestSequence() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 41,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parsetemps();
 | 
	
		
			
				|  |  | +      if (s1 === peg$FAILED) {
 | 
	
		
			
				|  |  | +        s1 = peg$c37;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsews();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3 = peg$parsestatements();
 | 
	
		
			
				|  |  | +          if (s3 === peg$FAILED) {
 | 
	
		
			
				|  |  | +            s3 = peg$c37;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s4 = peg$parsews();
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +              s1 = peg$c106(s1, s3);
 | 
	
		
			
				|  |  | +              s0 = s1;
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | +              peg$currPos = s0;
 | 
	
		
			
				|  |  | +              s0 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, selector) {
 | 
	
		
			
				|  |  | -                             return smalltalk.SendNode._new()
 | 
	
		
			
				|  |  | -                                    ._position_((line).__at(column))
 | 
	
		
			
				|  |  | -                                    ._selector_(selector);
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[1]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_unaryTail() {
 | 
	
		
			
				|  |  | -        var cacheKey = "unaryTail@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_unaryMessage();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_ws();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result2 = parse_unaryTail();
 | 
	
		
			
				|  |  | -            result2 = result2 !== null ? result2 : "";
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result3 = parse_ws();
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                result0 = [result0, result1, result2, result3];
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseblock() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4, s5, s6, s7;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 42,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (input.charCodeAt(peg$currPos) === 91) {
 | 
	
		
			
				|  |  | +        s1 = peg$c107;
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c108); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsews();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3 = peg$parseblockParamList();
 | 
	
		
			
				|  |  | +          if (s3 === peg$FAILED) {
 | 
	
		
			
				|  |  | +            s3 = peg$c37;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s4 = peg$parsews();
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              s5 = peg$parsesequence();
 | 
	
		
			
				|  |  | +              if (s5 === peg$FAILED) {
 | 
	
		
			
				|  |  | +                s5 = peg$c37;
 | 
	
		
			
				|  |  | +              }
 | 
	
		
			
				|  |  | +              if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                s6 = peg$parsews();
 | 
	
		
			
				|  |  | +                if (s6 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                  if (input.charCodeAt(peg$currPos) === 93) {
 | 
	
		
			
				|  |  | +                    s7 = peg$c109;
 | 
	
		
			
				|  |  | +                    peg$currPos++;
 | 
	
		
			
				|  |  | +                  } else {
 | 
	
		
			
				|  |  | +                    s7 = peg$FAILED;
 | 
	
		
			
				|  |  | +                    if (peg$silentFails === 0) { peg$fail(peg$c110); }
 | 
	
		
			
				|  |  | +                  }
 | 
	
		
			
				|  |  | +                  if (s7 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                    peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +                    s1 = peg$c111(s3, s5);
 | 
	
		
			
				|  |  | +                    s0 = s1;
 | 
	
		
			
				|  |  | +                  } else {
 | 
	
		
			
				|  |  | +                    peg$currPos = s0;
 | 
	
		
			
				|  |  | +                    s0 = peg$c1;
 | 
	
		
			
				|  |  | +                  }
 | 
	
		
			
				|  |  | +                } else {
 | 
	
		
			
				|  |  | +                  peg$currPos = s0;
 | 
	
		
			
				|  |  | +                  s0 = peg$c1;
 | 
	
		
			
				|  |  | +                }
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result0 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos1);
 | 
	
		
			
				|  |  | +                peg$currPos = s0;
 | 
	
		
			
				|  |  | +                s0 = peg$c1;
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | +              peg$currPos = s0;
 | 
	
		
			
				|  |  | +              s0 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, message, tail) {
 | 
	
		
			
				|  |  | -                             if(tail) {
 | 
	
		
			
				|  |  | -                                 return tail._valueForReceiver_(message);
 | 
	
		
			
				|  |  | -                             }
 | 
	
		
			
				|  |  | -                             else {
 | 
	
		
			
				|  |  | -                                 return message;
 | 
	
		
			
				|  |  | -                             }
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[0], result0[2]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_unarySend() {
 | 
	
		
			
				|  |  | -        var cacheKey = "unarySend@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseoperand() {
 | 
	
		
			
				|  |  | +      var s0;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 43,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$parseliteral();
 | 
	
		
			
				|  |  | +      if (s0 === peg$FAILED) {
 | 
	
		
			
				|  |  | +        s0 = peg$parsevariable();
 | 
	
		
			
				|  |  | +        if (s0 === peg$FAILED) {
 | 
	
		
			
				|  |  | +          s0 = peg$parsesubexpression();
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseunaryMessage() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 44,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parsews();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parseidentifier();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3 = peg$currPos;
 | 
	
		
			
				|  |  | +          peg$silentFails++;
 | 
	
		
			
				|  |  | +          if (peg$c13.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +            s4 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c14); }
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          peg$silentFails--;
 | 
	
		
			
				|  |  | +          if (s4 === peg$FAILED) {
 | 
	
		
			
				|  |  | +            s3 = peg$c112;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            peg$currPos = s3;
 | 
	
		
			
				|  |  | +            s3 = peg$c1;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +            s1 = peg$c113(s2);
 | 
	
		
			
				|  |  | +            s0 = s1;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_operand();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_ws();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result2 = parse_unaryTail();
 | 
	
		
			
				|  |  | -            result2 = result2 !== null ? result2 : "";
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result0 = [result0, result1, result2];
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseunaryTail() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 45,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parseunaryMessage();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsews();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3 = peg$parseunaryTail();
 | 
	
		
			
				|  |  | +          if (s3 === peg$FAILED) {
 | 
	
		
			
				|  |  | +            s3 = peg$c37;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s4 = peg$parsews();
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +              s1 = peg$c114(s1, s3);
 | 
	
		
			
				|  |  | +              s0 = s1;
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | +              peg$currPos = s0;
 | 
	
		
			
				|  |  | +              s0 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, receiver, tail) {
 | 
	
		
			
				|  |  | -                             if(tail) {
 | 
	
		
			
				|  |  | -                                 return tail._valueForReceiver_(receiver);
 | 
	
		
			
				|  |  | -                             }
 | 
	
		
			
				|  |  | -                             else {
 | 
	
		
			
				|  |  | -                                 return receiver;
 | 
	
		
			
				|  |  | -                             }
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[0], result0[2]);
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_binaryMessage() {
 | 
	
		
			
				|  |  | -        var cacheKey = "binaryMessage@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parseunarySend() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 46,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parseoperand();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsews();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3 = peg$parseunaryTail();
 | 
	
		
			
				|  |  | +          if (s3 === peg$FAILED) {
 | 
	
		
			
				|  |  | +            s3 = peg$c37;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +            s1 = peg$c115(s1, s3);
 | 
	
		
			
				|  |  | +            s0 = s1;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_ws();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_binarySelector();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result2 = parse_ws();
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result3 = parse_unarySend();
 | 
	
		
			
				|  |  | -              if (result3 === null) {
 | 
	
		
			
				|  |  | -                result3 = parse_operand();
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                result0 = [result0, result1, result2, result3];
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result0 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos1);
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsebinaryMessage() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 47,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parsews();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsebinarySelector();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3 = peg$parsews();
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s4 = peg$parseunarySend();
 | 
	
		
			
				|  |  | +            if (s4 === peg$FAILED) {
 | 
	
		
			
				|  |  | +              s4 = peg$parseoperand();
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +              s1 = peg$c116(s2, s4);
 | 
	
		
			
				|  |  | +              s0 = s1;
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | +              peg$currPos = s0;
 | 
	
		
			
				|  |  | +              s0 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, selector, arg) {
 | 
	
		
			
				|  |  | -                             return smalltalk.SendNode._new()
 | 
	
		
			
				|  |  | -                                    ._position_((line).__at(column))
 | 
	
		
			
				|  |  | -                                    ._selector_(selector)
 | 
	
		
			
				|  |  | -                                    ._arguments_([arg]);
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[1], result0[3]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_binaryTail() {
 | 
	
		
			
				|  |  | -        var cacheKey = "binaryTail@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_binaryMessage();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_binaryTail();
 | 
	
		
			
				|  |  | -          result1 = result1 !== null ? result1 : "";
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0 = [result0, result1];
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, message, tail) {
 | 
	
		
			
				|  |  | -                             if(tail) {
 | 
	
		
			
				|  |  | -                                 return tail._valueForReceiver_(message);
 | 
	
		
			
				|  |  | -                              }
 | 
	
		
			
				|  |  | -                             else {
 | 
	
		
			
				|  |  | -                                 return message;
 | 
	
		
			
				|  |  | -                             }
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[0], result0[1]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_binarySend() {
 | 
	
		
			
				|  |  | -        var cacheKey = "binarySend@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_unarySend();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_binaryTail();
 | 
	
		
			
				|  |  | -          result1 = result1 !== null ? result1 : "";
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0 = [result0, result1];
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, receiver, tail) {
 | 
	
		
			
				|  |  | -                             if(tail) {
 | 
	
		
			
				|  |  | -                                 return tail._valueForReceiver_(receiver);
 | 
	
		
			
				|  |  | -                             }
 | 
	
		
			
				|  |  | -                             else {
 | 
	
		
			
				|  |  | -                                 return receiver;
 | 
	
		
			
				|  |  | -                             }
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[0], result0[1]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsebinaryTail() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 48,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parsebinaryMessage();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsebinaryTail();
 | 
	
		
			
				|  |  | +        if (s2 === peg$FAILED) {
 | 
	
		
			
				|  |  | +          s2 = peg$c37;
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +          s1 = peg$c117(s1, s2);
 | 
	
		
			
				|  |  | +          s0 = s1;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_keywordMessage() {
 | 
	
		
			
				|  |  | -        var cacheKey = "keywordMessage@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsebinarySend() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 49,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parseunarySend();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsebinaryTail();
 | 
	
		
			
				|  |  | +        if (s2 === peg$FAILED) {
 | 
	
		
			
				|  |  | +          s2 = peg$c37;
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +          s1 = peg$c115(s1, s2);
 | 
	
		
			
				|  |  | +          s0 = s1;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3;
 | 
	
		
			
				|  |  | -        var pos0, pos1, pos2, pos3;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_ws();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          pos2 = clone(pos);
 | 
	
		
			
				|  |  | -          pos3 = clone(pos);
 | 
	
		
			
				|  |  | -          result2 = parse_keywordPair();
 | 
	
		
			
				|  |  | -          if (result2 !== null) {
 | 
	
		
			
				|  |  | -            result3 = parse_ws();
 | 
	
		
			
				|  |  | -            if (result3 !== null) {
 | 
	
		
			
				|  |  | -              result2 = [result2, result3];
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos3);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result2 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos3);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result2 !== null) {
 | 
	
		
			
				|  |  | -            result2 = (function(offset, line, column, pair) {return pair;})(pos2.offset, pos2.line, pos2.column, result2[0]);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result2 === null) {
 | 
	
		
			
				|  |  | -            pos = clone(pos2);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result2 !== null) {
 | 
	
		
			
				|  |  | -            result1 = [];
 | 
	
		
			
				|  |  | -            while (result2 !== null) {
 | 
	
		
			
				|  |  | -              result1.push(result2);
 | 
	
		
			
				|  |  | -              pos2 = clone(pos);
 | 
	
		
			
				|  |  | -              pos3 = clone(pos);
 | 
	
		
			
				|  |  | -              result2 = parse_keywordPair();
 | 
	
		
			
				|  |  | -              if (result2 !== null) {
 | 
	
		
			
				|  |  | -                result3 = parse_ws();
 | 
	
		
			
				|  |  | -                if (result3 !== null) {
 | 
	
		
			
				|  |  | -                  result2 = [result2, result3];
 | 
	
		
			
				|  |  | -                } else {
 | 
	
		
			
				|  |  | -                  result2 = null;
 | 
	
		
			
				|  |  | -                  pos = clone(pos3);
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsekeywordMessage() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4, s5;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 50,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parsews();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = [];
 | 
	
		
			
				|  |  | +        s3 = peg$currPos;
 | 
	
		
			
				|  |  | +        s4 = peg$parsekeywordPair();
 | 
	
		
			
				|  |  | +        if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s5 = peg$parsews();
 | 
	
		
			
				|  |  | +          if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            peg$reportedPos = s3;
 | 
	
		
			
				|  |  | +            s4 = peg$c118(s4);
 | 
	
		
			
				|  |  | +            s3 = s4;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            peg$currPos = s3;
 | 
	
		
			
				|  |  | +            s3 = peg$c1;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s3;
 | 
	
		
			
				|  |  | +          s3 = peg$c1;
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          while (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s2.push(s3);
 | 
	
		
			
				|  |  | +            s3 = peg$currPos;
 | 
	
		
			
				|  |  | +            s4 = peg$parsekeywordPair();
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              s5 = peg$parsews();
 | 
	
		
			
				|  |  | +              if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                peg$reportedPos = s3;
 | 
	
		
			
				|  |  | +                s4 = peg$c118(s4);
 | 
	
		
			
				|  |  | +                s3 = s4;
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result2 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos3);
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -              if (result2 !== null) {
 | 
	
		
			
				|  |  | -                result2 = (function(offset, line, column, pair) {return pair;})(pos2.offset, pos2.line, pos2.column, result2[0]);
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -              if (result2 === null) {
 | 
	
		
			
				|  |  | -                pos = clone(pos2);
 | 
	
		
			
				|  |  | +                peg$currPos = s3;
 | 
	
		
			
				|  |  | +                s3 = peg$c1;
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  | +            } else {
 | 
	
		
			
				|  |  | +              peg$currPos = s3;
 | 
	
		
			
				|  |  | +              s3 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result1 = null;
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0 = [result0, result1];
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, pairs) {
 | 
	
		
			
				|  |  | -                             var selector = [];
 | 
	
		
			
				|  |  | -                             var args = [];
 | 
	
		
			
				|  |  | -                              for(var i = 0; i < pairs.length; i++) {
 | 
	
		
			
				|  |  | -                                  selector.push(pairs[i].key);
 | 
	
		
			
				|  |  | -                                  args.push(pairs[i].arg);
 | 
	
		
			
				|  |  | -                              }
 | 
	
		
			
				|  |  | -                              return smalltalk.SendNode._new()
 | 
	
		
			
				|  |  | -                                     ._position_((line).__at(column))
 | 
	
		
			
				|  |  | -                                     ._selector_(selector.join(""))
 | 
	
		
			
				|  |  | -                                     ._arguments_(args);
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[1]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | +          s2 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_keywordSend() {
 | 
	
		
			
				|  |  | -        var cacheKey = "keywordSend@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_binarySend();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_keywordMessage();
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result0 = [result0, result1];
 | 
	
		
			
				|  |  | -          } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +          s1 = peg$c119(s2);
 | 
	
		
			
				|  |  | +          s0 = s1;
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, receiver, tail) {
 | 
	
		
			
				|  |  | -                             return tail._valueForReceiver_(receiver);
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[0], result0[1]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_message() {
 | 
	
		
			
				|  |  | -        var cacheKey = "message@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        result0 = parse_binaryMessage();
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          result0 = parse_unaryMessage();
 | 
	
		
			
				|  |  | -          if (result0 === null) {
 | 
	
		
			
				|  |  | -            result0 = parse_keywordMessage();
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_cascade() {
 | 
	
		
			
				|  |  | -        var cacheKey = "cascade@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsekeywordSend() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 51,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parsebinarySend();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsekeywordMessage();
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +          s1 = peg$c120(s1, s2);
 | 
	
		
			
				|  |  | +          s0 = s1;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3, result4, result5, result6, result7;
 | 
	
		
			
				|  |  | -        var pos0, pos1, pos2, pos3;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_ws();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_keywordSend();
 | 
	
		
			
				|  |  | -          if (result1 === null) {
 | 
	
		
			
				|  |  | -            result1 = parse_binarySend();
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            pos2 = clone(pos);
 | 
	
		
			
				|  |  | -            pos3 = clone(pos);
 | 
	
		
			
				|  |  | -            result3 = parse_ws();
 | 
	
		
			
				|  |  | -            if (result3 !== null) {
 | 
	
		
			
				|  |  | -              if (input.charCodeAt(pos.offset) === 59) {
 | 
	
		
			
				|  |  | -                result4 = ";";
 | 
	
		
			
				|  |  | -                advance(pos, 1);
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result4 = null;
 | 
	
		
			
				|  |  | -                if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                  matchFailed("\";\"");
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -              if (result4 !== null) {
 | 
	
		
			
				|  |  | -                result5 = parse_ws();
 | 
	
		
			
				|  |  | -                if (result5 !== null) {
 | 
	
		
			
				|  |  | -                  result6 = parse_message();
 | 
	
		
			
				|  |  | -                  if (result6 !== null) {
 | 
	
		
			
				|  |  | -                    result7 = parse_ws();
 | 
	
		
			
				|  |  | -                    if (result7 !== null) {
 | 
	
		
			
				|  |  | -                      result3 = [result3, result4, result5, result6, result7];
 | 
	
		
			
				|  |  | -                    } else {
 | 
	
		
			
				|  |  | -                      result3 = null;
 | 
	
		
			
				|  |  | -                      pos = clone(pos3);
 | 
	
		
			
				|  |  | -                    }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsemessage() {
 | 
	
		
			
				|  |  | +      var s0;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 52,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$parsebinaryMessage();
 | 
	
		
			
				|  |  | +      if (s0 === peg$FAILED) {
 | 
	
		
			
				|  |  | +        s0 = peg$parseunaryMessage();
 | 
	
		
			
				|  |  | +        if (s0 === peg$FAILED) {
 | 
	
		
			
				|  |  | +          s0 = peg$parsekeywordMessage();
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsecascade() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 53,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parsews();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsekeywordSend();
 | 
	
		
			
				|  |  | +        if (s2 === peg$FAILED) {
 | 
	
		
			
				|  |  | +          s2 = peg$parsebinarySend();
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3 = [];
 | 
	
		
			
				|  |  | +          s4 = peg$currPos;
 | 
	
		
			
				|  |  | +          s5 = peg$parsews();
 | 
	
		
			
				|  |  | +          if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            if (input.charCodeAt(peg$currPos) === 59) {
 | 
	
		
			
				|  |  | +              s6 = peg$c121;
 | 
	
		
			
				|  |  | +              peg$currPos++;
 | 
	
		
			
				|  |  | +            } else {
 | 
	
		
			
				|  |  | +              s6 = peg$FAILED;
 | 
	
		
			
				|  |  | +              if (peg$silentFails === 0) { peg$fail(peg$c122); }
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  | +            if (s6 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              s7 = peg$parsews();
 | 
	
		
			
				|  |  | +              if (s7 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                s8 = peg$parsemessage();
 | 
	
		
			
				|  |  | +                if (s8 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                  s9 = peg$parsews();
 | 
	
		
			
				|  |  | +                  if (s9 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                    peg$reportedPos = s4;
 | 
	
		
			
				|  |  | +                    s5 = peg$c123(s8);
 | 
	
		
			
				|  |  | +                    s4 = s5;
 | 
	
		
			
				|  |  |                    } else {
 | 
	
		
			
				|  |  | -                    result3 = null;
 | 
	
		
			
				|  |  | -                    pos = clone(pos3);
 | 
	
		
			
				|  |  | +                    peg$currPos = s4;
 | 
	
		
			
				|  |  | +                    s4 = peg$c1;
 | 
	
		
			
				|  |  |                    }
 | 
	
		
			
				|  |  |                  } else {
 | 
	
		
			
				|  |  | -                  result3 = null;
 | 
	
		
			
				|  |  | -                  pos = clone(pos3);
 | 
	
		
			
				|  |  | +                  peg$currPos = s4;
 | 
	
		
			
				|  |  | +                  s4 = peg$c1;
 | 
	
		
			
				|  |  |                  }
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result3 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos3);
 | 
	
		
			
				|  |  | +                peg$currPos = s4;
 | 
	
		
			
				|  |  | +                s4 = peg$c1;
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result3 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos3);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result3 !== null) {
 | 
	
		
			
				|  |  | -              result3 = (function(offset, line, column, mess) {return mess;})(pos2.offset, pos2.line, pos2.column, result3[3]);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result3 === null) {
 | 
	
		
			
				|  |  | -              pos = clone(pos2);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result3 !== null) {
 | 
	
		
			
				|  |  | -              result2 = [];
 | 
	
		
			
				|  |  | -              while (result3 !== null) {
 | 
	
		
			
				|  |  | -                result2.push(result3);
 | 
	
		
			
				|  |  | -                pos2 = clone(pos);
 | 
	
		
			
				|  |  | -                pos3 = clone(pos);
 | 
	
		
			
				|  |  | -                result3 = parse_ws();
 | 
	
		
			
				|  |  | -                if (result3 !== null) {
 | 
	
		
			
				|  |  | -                  if (input.charCodeAt(pos.offset) === 59) {
 | 
	
		
			
				|  |  | -                    result4 = ";";
 | 
	
		
			
				|  |  | -                    advance(pos, 1);
 | 
	
		
			
				|  |  | -                  } else {
 | 
	
		
			
				|  |  | -                    result4 = null;
 | 
	
		
			
				|  |  | -                    if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                      matchFailed("\";\"");
 | 
	
		
			
				|  |  | -                    }
 | 
	
		
			
				|  |  | -                  }
 | 
	
		
			
				|  |  | -                  if (result4 !== null) {
 | 
	
		
			
				|  |  | -                    result5 = parse_ws();
 | 
	
		
			
				|  |  | -                    if (result5 !== null) {
 | 
	
		
			
				|  |  | -                      result6 = parse_message();
 | 
	
		
			
				|  |  | -                      if (result6 !== null) {
 | 
	
		
			
				|  |  | -                        result7 = parse_ws();
 | 
	
		
			
				|  |  | -                        if (result7 !== null) {
 | 
	
		
			
				|  |  | -                          result3 = [result3, result4, result5, result6, result7];
 | 
	
		
			
				|  |  | -                        } else {
 | 
	
		
			
				|  |  | -                          result3 = null;
 | 
	
		
			
				|  |  | -                          pos = clone(pos3);
 | 
	
		
			
				|  |  | -                        }
 | 
	
		
			
				|  |  | +              peg$currPos = s4;
 | 
	
		
			
				|  |  | +              s4 = peg$c1;
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            peg$currPos = s4;
 | 
	
		
			
				|  |  | +            s4 = peg$c1;
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            while (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              s3.push(s4);
 | 
	
		
			
				|  |  | +              s4 = peg$currPos;
 | 
	
		
			
				|  |  | +              s5 = peg$parsews();
 | 
	
		
			
				|  |  | +              if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                if (input.charCodeAt(peg$currPos) === 59) {
 | 
	
		
			
				|  |  | +                  s6 = peg$c121;
 | 
	
		
			
				|  |  | +                  peg$currPos++;
 | 
	
		
			
				|  |  | +                } else {
 | 
	
		
			
				|  |  | +                  s6 = peg$FAILED;
 | 
	
		
			
				|  |  | +                  if (peg$silentFails === 0) { peg$fail(peg$c122); }
 | 
	
		
			
				|  |  | +                }
 | 
	
		
			
				|  |  | +                if (s6 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                  s7 = peg$parsews();
 | 
	
		
			
				|  |  | +                  if (s7 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                    s8 = peg$parsemessage();
 | 
	
		
			
				|  |  | +                    if (s8 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                      s9 = peg$parsews();
 | 
	
		
			
				|  |  | +                      if (s9 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                        peg$reportedPos = s4;
 | 
	
		
			
				|  |  | +                        s5 = peg$c123(s8);
 | 
	
		
			
				|  |  | +                        s4 = s5;
 | 
	
		
			
				|  |  |                        } else {
 | 
	
		
			
				|  |  | -                        result3 = null;
 | 
	
		
			
				|  |  | -                        pos = clone(pos3);
 | 
	
		
			
				|  |  | +                        peg$currPos = s4;
 | 
	
		
			
				|  |  | +                        s4 = peg$c1;
 | 
	
		
			
				|  |  |                        }
 | 
	
		
			
				|  |  |                      } else {
 | 
	
		
			
				|  |  | -                      result3 = null;
 | 
	
		
			
				|  |  | -                      pos = clone(pos3);
 | 
	
		
			
				|  |  | +                      peg$currPos = s4;
 | 
	
		
			
				|  |  | +                      s4 = peg$c1;
 | 
	
		
			
				|  |  |                      }
 | 
	
		
			
				|  |  |                    } else {
 | 
	
		
			
				|  |  | -                    result3 = null;
 | 
	
		
			
				|  |  | -                    pos = clone(pos3);
 | 
	
		
			
				|  |  | +                    peg$currPos = s4;
 | 
	
		
			
				|  |  | +                    s4 = peg$c1;
 | 
	
		
			
				|  |  |                    }
 | 
	
		
			
				|  |  |                  } else {
 | 
	
		
			
				|  |  | -                  result3 = null;
 | 
	
		
			
				|  |  | -                  pos = clone(pos3);
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -                if (result3 !== null) {
 | 
	
		
			
				|  |  | -                  result3 = (function(offset, line, column, mess) {return mess;})(pos2.offset, pos2.line, pos2.column, result3[3]);
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -                if (result3 === null) {
 | 
	
		
			
				|  |  | -                  pos = clone(pos2);
 | 
	
		
			
				|  |  | +                  peg$currPos = s4;
 | 
	
		
			
				|  |  | +                  s4 = peg$c1;
 | 
	
		
			
				|  |  |                  }
 | 
	
		
			
				|  |  | +              } else {
 | 
	
		
			
				|  |  | +                peg$currPos = s4;
 | 
	
		
			
				|  |  | +                s4 = peg$c1;
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result0 = [result0, result1, result2];
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, send, messages) {
 | 
	
		
			
				|  |  | -                             var cascade = [];
 | 
	
		
			
				|  |  | -                             cascade.push(send);
 | 
	
		
			
				|  |  | -                             for(var i = 0; i < messages.length; i++) {
 | 
	
		
			
				|  |  | -                                 cascade.push(messages[i]);
 | 
	
		
			
				|  |  | -                             }
 | 
	
		
			
				|  |  | -                             return smalltalk.CascadeNode._new()
 | 
	
		
			
				|  |  | -                                    ._position_((line).__at(column))
 | 
	
		
			
				|  |  | -                                    ._receiver_(send._receiver())
 | 
	
		
			
				|  |  | -                                    ._nodes_(cascade);
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[1], result0[2]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_jsStatement() {
 | 
	
		
			
				|  |  | -        var cacheKey = "jsStatement@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2;
 | 
	
		
			
				|  |  | -        var pos0, pos1, pos2;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        if (input.charCodeAt(pos.offset) === 60) {
 | 
	
		
			
				|  |  | -          result0 = "<";
 | 
	
		
			
				|  |  | -          advance(pos, 1);
 | 
	
		
			
				|  |  | -        } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -            matchFailed("\"<\"");
 | 
	
		
			
				|  |  | +            s3 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = [];
 | 
	
		
			
				|  |  | -          pos2 = clone(pos);
 | 
	
		
			
				|  |  | -          if (input.substr(pos.offset, 2) === ">>") {
 | 
	
		
			
				|  |  | -            result2 = ">>";
 | 
	
		
			
				|  |  | -            advance(pos, 2);
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +            s1 = peg$c124(s2, s3);
 | 
	
		
			
				|  |  | +            s0 = s1;
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result2 = null;
 | 
	
		
			
				|  |  | -            if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -              matchFailed("\">>\"");
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -          if (result2 !== null) {
 | 
	
		
			
				|  |  | -            result2 = (function(offset, line, column) {return ">";})(pos2.offset, pos2.line, pos2.column);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result2 === null) {
 | 
	
		
			
				|  |  | -            pos = clone(pos2);
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result2 === null) {
 | 
	
		
			
				|  |  | -            if (/^[^>]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -              result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsejsStatement() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 54,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      if (input.charCodeAt(peg$currPos) === 60) {
 | 
	
		
			
				|  |  | +        s1 = peg$c125;
 | 
	
		
			
				|  |  | +        peg$currPos++;
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        s1 = peg$FAILED;
 | 
	
		
			
				|  |  | +        if (peg$silentFails === 0) { peg$fail(peg$c126); }
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = [];
 | 
	
		
			
				|  |  | +        s3 = peg$currPos;
 | 
	
		
			
				|  |  | +        if (input.substr(peg$currPos, 2) === peg$c127) {
 | 
	
		
			
				|  |  | +          s4 = peg$c127;
 | 
	
		
			
				|  |  | +          peg$currPos += 2;
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +          if (peg$silentFails === 0) { peg$fail(peg$c128); }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          peg$reportedPos = s3;
 | 
	
		
			
				|  |  | +          s4 = peg$c129();
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        s3 = s4;
 | 
	
		
			
				|  |  | +        if (s3 === peg$FAILED) {
 | 
	
		
			
				|  |  | +          if (peg$c130.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +            s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c131); }
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        while (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s2.push(s3);
 | 
	
		
			
				|  |  | +          s3 = peg$currPos;
 | 
	
		
			
				|  |  | +          if (input.substr(peg$currPos, 2) === peg$c127) {
 | 
	
		
			
				|  |  | +            s4 = peg$c127;
 | 
	
		
			
				|  |  | +            peg$currPos += 2;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            s4 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c128); }
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            peg$reportedPos = s3;
 | 
	
		
			
				|  |  | +            s4 = peg$c129();
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +          s3 = s4;
 | 
	
		
			
				|  |  | +          if (s3 === peg$FAILED) {
 | 
	
		
			
				|  |  | +            if (peg$c130.test(input.charAt(peg$currPos))) {
 | 
	
		
			
				|  |  | +              s3 = input.charAt(peg$currPos);
 | 
	
		
			
				|  |  | +              peg$currPos++;
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("[^>]");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | +              s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +              if (peg$silentFails === 0) { peg$fail(peg$c131); }
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -          while (result2 !== null) {
 | 
	
		
			
				|  |  | -            result1.push(result2);
 | 
	
		
			
				|  |  | -            pos2 = clone(pos);
 | 
	
		
			
				|  |  | -            if (input.substr(pos.offset, 2) === ">>") {
 | 
	
		
			
				|  |  | -              result2 = ">>";
 | 
	
		
			
				|  |  | -              advance(pos, 2);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("\">>\"");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result2 = (function(offset, line, column) {return ">";})(pos2.offset, pos2.line, pos2.column);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 === null) {
 | 
	
		
			
				|  |  | -              pos = clone(pos2);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 === null) {
 | 
	
		
			
				|  |  | -              if (/^[^>]/.test(input.charAt(pos.offset))) {
 | 
	
		
			
				|  |  | -                result2 = input.charAt(pos.offset);
 | 
	
		
			
				|  |  | -                advance(pos, 1);
 | 
	
		
			
				|  |  | -              } else {
 | 
	
		
			
				|  |  | -                result2 = null;
 | 
	
		
			
				|  |  | -                if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                  matchFailed("[^>]");
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          if (input.charCodeAt(peg$currPos) === 62) {
 | 
	
		
			
				|  |  | +            s3 = peg$c132;
 | 
	
		
			
				|  |  | +            peg$currPos++;
 | 
	
		
			
				|  |  | +          } else {
 | 
	
		
			
				|  |  | +            s3 = peg$FAILED;
 | 
	
		
			
				|  |  | +            if (peg$silentFails === 0) { peg$fail(peg$c133); }
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            if (input.charCodeAt(pos.offset) === 62) {
 | 
	
		
			
				|  |  | -              result2 = ">";
 | 
	
		
			
				|  |  | -              advance(pos, 1);
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result2 = null;
 | 
	
		
			
				|  |  | -              if (reportFailures === 0) {
 | 
	
		
			
				|  |  | -                matchFailed("\">\"");
 | 
	
		
			
				|  |  | -              }
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result0 = [result0, result1, result2];
 | 
	
		
			
				|  |  | -            } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +            s1 = peg$c134(s2);
 | 
	
		
			
				|  |  | +            s0 = s1;
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, val) {
 | 
	
		
			
				|  |  | -                             return smalltalk.JSStatementNode._new()
 | 
	
		
			
				|  |  | -                                    ._position_((line).__at(column))
 | 
	
		
			
				|  |  | -                                    ._source_(val.join(""));
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[1]);
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function parse_method() {
 | 
	
		
			
				|  |  | -        var cacheKey = "method@" + pos.offset;
 | 
	
		
			
				|  |  | -        var cachedResult = cache[cacheKey];
 | 
	
		
			
				|  |  | -        if (cachedResult) {
 | 
	
		
			
				|  |  | -          pos = clone(cachedResult.nextPos);
 | 
	
		
			
				|  |  | -          return cachedResult.result;
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var result0, result1, result2, result3, result4;
 | 
	
		
			
				|  |  | -        var pos0, pos1;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        pos0 = clone(pos);
 | 
	
		
			
				|  |  | -        pos1 = clone(pos);
 | 
	
		
			
				|  |  | -        result0 = parse_ws();
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result1 = parse_keywordPattern();
 | 
	
		
			
				|  |  | -          if (result1 === null) {
 | 
	
		
			
				|  |  | -            result1 = parse_binaryPattern();
 | 
	
		
			
				|  |  | -            if (result1 === null) {
 | 
	
		
			
				|  |  | -              result1 = parse_unaryPattern();
 | 
	
		
			
				|  |  | -            }
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | -          if (result1 !== null) {
 | 
	
		
			
				|  |  | -            result2 = parse_ws();
 | 
	
		
			
				|  |  | -            if (result2 !== null) {
 | 
	
		
			
				|  |  | -              result3 = parse_sequence();
 | 
	
		
			
				|  |  | -              result3 = result3 !== null ? result3 : "";
 | 
	
		
			
				|  |  | -              if (result3 !== null) {
 | 
	
		
			
				|  |  | -                result4 = parse_ws();
 | 
	
		
			
				|  |  | -                if (result4 !== null) {
 | 
	
		
			
				|  |  | -                  result0 = [result0, result1, result2, result3, result4];
 | 
	
		
			
				|  |  | -                } else {
 | 
	
		
			
				|  |  | -                  result0 = null;
 | 
	
		
			
				|  |  | -                  pos = clone(pos1);
 | 
	
		
			
				|  |  | -                }
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    function peg$parsemethod() {
 | 
	
		
			
				|  |  | +      var s0, s1, s2, s3, s4, s5;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      var key    = peg$currPos * 56 + 55,
 | 
	
		
			
				|  |  | +          cached = peg$cache[key];
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      if (cached) {
 | 
	
		
			
				|  |  | +        peg$currPos = cached.nextPos;
 | 
	
		
			
				|  |  | +        return cached.result;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      s0 = peg$currPos;
 | 
	
		
			
				|  |  | +      s1 = peg$parsews();
 | 
	
		
			
				|  |  | +      if (s1 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +        s2 = peg$parsekeywordPattern();
 | 
	
		
			
				|  |  | +        if (s2 === peg$FAILED) {
 | 
	
		
			
				|  |  | +          s2 = peg$parsebinaryPattern();
 | 
	
		
			
				|  |  | +          if (s2 === peg$FAILED) {
 | 
	
		
			
				|  |  | +            s2 = peg$parseunaryPattern();
 | 
	
		
			
				|  |  | +          }
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  | +        if (s2 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +          s3 = peg$parsews();
 | 
	
		
			
				|  |  | +          if (s3 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +            s4 = peg$parsesequence();
 | 
	
		
			
				|  |  | +            if (s4 === peg$FAILED) {
 | 
	
		
			
				|  |  | +              s4 = peg$c37;
 | 
	
		
			
				|  |  | +            }
 | 
	
		
			
				|  |  | +            if (s4 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +              s5 = peg$parsews();
 | 
	
		
			
				|  |  | +              if (s5 !== peg$FAILED) {
 | 
	
		
			
				|  |  | +                peg$reportedPos = s0;
 | 
	
		
			
				|  |  | +                s1 = peg$c135(s2, s4);
 | 
	
		
			
				|  |  | +                s0 = s1;
 | 
	
		
			
				|  |  |                } else {
 | 
	
		
			
				|  |  | -                result0 = null;
 | 
	
		
			
				|  |  | -                pos = clone(pos1);
 | 
	
		
			
				|  |  | +                peg$currPos = s0;
 | 
	
		
			
				|  |  | +                s0 = peg$c1;
 | 
	
		
			
				|  |  |                }
 | 
	
		
			
				|  |  |              } else {
 | 
	
		
			
				|  |  | -              result0 = null;
 | 
	
		
			
				|  |  | -              pos = clone(pos1);
 | 
	
		
			
				|  |  | +              peg$currPos = s0;
 | 
	
		
			
				|  |  | +              s0 = peg$c1;
 | 
	
		
			
				|  |  |              }
 | 
	
		
			
				|  |  |            } else {
 | 
	
		
			
				|  |  | -            result0 = null;
 | 
	
		
			
				|  |  | -            pos = clone(pos1);
 | 
	
		
			
				|  |  | +            peg$currPos = s0;
 | 
	
		
			
				|  |  | +            s0 = peg$c1;
 | 
	
		
			
				|  |  |            }
 | 
	
		
			
				|  |  |          } else {
 | 
	
		
			
				|  |  | -          result0 = null;
 | 
	
		
			
				|  |  | -          pos = clone(pos1);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 !== null) {
 | 
	
		
			
				|  |  | -          result0 = (function(offset, line, column, pattern, sequence) {
 | 
	
		
			
				|  |  | -                              return smalltalk.MethodNode._new()
 | 
	
		
			
				|  |  | -                                     ._position_((line).__at(column))
 | 
	
		
			
				|  |  | -                                     ._selector_(pattern[0])
 | 
	
		
			
				|  |  | -                                     ._arguments_(pattern[1])
 | 
	
		
			
				|  |  | -                                     ._nodes_([sequence]);
 | 
	
		
			
				|  |  | -                         })(pos0.offset, pos0.line, pos0.column, result0[1], result0[3]);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        if (result0 === null) {
 | 
	
		
			
				|  |  | -          pos = clone(pos0);
 | 
	
		
			
				|  |  | -        }
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        cache[cacheKey] = {
 | 
	
		
			
				|  |  | -          nextPos: clone(pos),
 | 
	
		
			
				|  |  | -          result:  result0
 | 
	
		
			
				|  |  | -        };
 | 
	
		
			
				|  |  | -        return result0;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      function cleanupExpected(expected) {
 | 
	
		
			
				|  |  | -        expected.sort();
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        var lastExpected = null;
 | 
	
		
			
				|  |  | -        var cleanExpected = [];
 | 
	
		
			
				|  |  | -        for (var i = 0; i < expected.length; i++) {
 | 
	
		
			
				|  |  | -          if (expected[i] !== lastExpected) {
 | 
	
		
			
				|  |  | -            cleanExpected.push(expected[i]);
 | 
	
		
			
				|  |  | -            lastExpected = expected[i];
 | 
	
		
			
				|  |  | -          }
 | 
	
		
			
				|  |  | +          peg$currPos = s0;
 | 
	
		
			
				|  |  | +          s0 = peg$c1;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  | -        return cleanExpected;
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      var result = parseFunctions[startRule]();
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      /*
 | 
	
		
			
				|  |  | -       * The parser is now in one of the following three states:
 | 
	
		
			
				|  |  | -       *
 | 
	
		
			
				|  |  | -       * 1. The parser successfully parsed the whole input.
 | 
	
		
			
				|  |  | -       *
 | 
	
		
			
				|  |  | -       *    - |result !== null|
 | 
	
		
			
				|  |  | -       *    - |pos.offset === input.length|
 | 
	
		
			
				|  |  | -       *    - |rightmostFailuresExpected| may or may not contain something
 | 
	
		
			
				|  |  | -       *
 | 
	
		
			
				|  |  | -       * 2. The parser successfully parsed only a part of the input.
 | 
	
		
			
				|  |  | -       *
 | 
	
		
			
				|  |  | -       *    - |result !== null|
 | 
	
		
			
				|  |  | -       *    - |pos.offset < input.length|
 | 
	
		
			
				|  |  | -       *    - |rightmostFailuresExpected| may or may not contain something
 | 
	
		
			
				|  |  | -       *
 | 
	
		
			
				|  |  | -       * 3. The parser did not successfully parse any part of the input.
 | 
	
		
			
				|  |  | -       *
 | 
	
		
			
				|  |  | -       *   - |result === null|
 | 
	
		
			
				|  |  | -       *   - |pos.offset === 0|
 | 
	
		
			
				|  |  | -       *   - |rightmostFailuresExpected| contains at least one failure
 | 
	
		
			
				|  |  | -       *
 | 
	
		
			
				|  |  | -       * All code following this comment (including called functions) must
 | 
	
		
			
				|  |  | -       * handle these states.
 | 
	
		
			
				|  |  | -       */
 | 
	
		
			
				|  |  | -      if (result === null || pos.offset !== input.length) {
 | 
	
		
			
				|  |  | -        var offset = Math.max(pos.offset, rightmostFailuresPos.offset);
 | 
	
		
			
				|  |  | -        var found = offset < input.length ? input.charAt(offset) : null;
 | 
	
		
			
				|  |  | -        var errorPosition = pos.offset > rightmostFailuresPos.offset ? pos : rightmostFailuresPos;
 | 
	
		
			
				|  |  | -        
 | 
	
		
			
				|  |  | -        throw new this.SyntaxError(
 | 
	
		
			
				|  |  | -          cleanupExpected(rightmostFailuresExpected),
 | 
	
		
			
				|  |  | -          found,
 | 
	
		
			
				|  |  | -          offset,
 | 
	
		
			
				|  |  | -          errorPosition.line,
 | 
	
		
			
				|  |  | -          errorPosition.column
 | 
	
		
			
				|  |  | -        );
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      return result;
 | 
	
		
			
				|  |  | -    },
 | 
	
		
			
				|  |  | -    
 | 
	
		
			
				|  |  | -    /* Returns the parser source code. */
 | 
	
		
			
				|  |  | -    toSource: function() { return this._source; }
 | 
	
		
			
				|  |  | -  };
 | 
	
		
			
				|  |  | -  
 | 
	
		
			
				|  |  | -  /* Thrown when a parser encounters a syntax error. */
 | 
	
		
			
				|  |  | -  
 | 
	
		
			
				|  |  | -  result.SyntaxError = function(expected, found, offset, line, column) {
 | 
	
		
			
				|  |  | -    function buildMessage(expected, found) {
 | 
	
		
			
				|  |  | -      var expectedHumanized, foundHumanized;
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      switch (expected.length) {
 | 
	
		
			
				|  |  | -        case 0:
 | 
	
		
			
				|  |  | -          expectedHumanized = "end of input";
 | 
	
		
			
				|  |  | -          break;
 | 
	
		
			
				|  |  | -        case 1:
 | 
	
		
			
				|  |  | -          expectedHumanized = expected[0];
 | 
	
		
			
				|  |  | -          break;
 | 
	
		
			
				|  |  | -        default:
 | 
	
		
			
				|  |  | -          expectedHumanized = expected.slice(0, expected.length - 1).join(", ")
 | 
	
		
			
				|  |  | -            + " or "
 | 
	
		
			
				|  |  | -            + expected[expected.length - 1];
 | 
	
		
			
				|  |  | -      }
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      foundHumanized = found ? quote(found) : "end of input";
 | 
	
		
			
				|  |  | -      
 | 
	
		
			
				|  |  | -      return "Expected " + expectedHumanized + " but " + foundHumanized + " found.";
 | 
	
		
			
				|  |  | +      } else {
 | 
	
		
			
				|  |  | +        peg$currPos = s0;
 | 
	
		
			
				|  |  | +        s0 = peg$c1;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      peg$cache[key] = { nextPos: peg$currPos, result: s0 };
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      return s0;
 | 
	
		
			
				|  |  |      }
 | 
	
		
			
				|  |  | -    
 | 
	
		
			
				|  |  | -    this.name = "SyntaxError";
 | 
	
		
			
				|  |  | -    this.expected = expected;
 | 
	
		
			
				|  |  | -    this.found = found;
 | 
	
		
			
				|  |  | -    this.message = buildMessage(expected, found);
 | 
	
		
			
				|  |  | -    this.offset = offset;
 | 
	
		
			
				|  |  | -    this.line = line;
 | 
	
		
			
				|  |  | -    this.column = column;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    peg$result = peg$startRuleFunction();
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +    if (peg$result !== peg$FAILED && peg$currPos === input.length) {
 | 
	
		
			
				|  |  | +      return peg$result;
 | 
	
		
			
				|  |  | +    } else {
 | 
	
		
			
				|  |  | +      if (peg$result !== peg$FAILED && peg$currPos < input.length) {
 | 
	
		
			
				|  |  | +        peg$fail({ type: "end", description: "end of input" });
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +      throw peg$buildException(null, peg$maxFailExpected, peg$maxFailPos);
 | 
	
		
			
				|  |  | +    }
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +  return {
 | 
	
		
			
				|  |  | +    SyntaxError: SyntaxError,
 | 
	
		
			
				|  |  | +    parse:       parse
 | 
	
		
			
				|  |  |    };
 | 
	
		
			
				|  |  | -  
 | 
	
		
			
				|  |  | -  result.SyntaxError.prototype = Error.prototype;
 | 
	
		
			
				|  |  | -  
 | 
	
		
			
				|  |  | -  return result;
 | 
	
		
			
				|  |  |  })();
 | 
	
		
			
				|  |  |  });
 |