@makano/rew 1.1.81 → 1.2.1

package/lib/coffeescript/grammar.js

@@ -1,2496 +1,1930 @@
 // Generated by CoffeeScript 2.7.0
-(function() {
-  // The CoffeeScript parser is generated by [Jison](https://github.com/zaach/jison)
-  // from this grammar file. Jison is a bottom-up parser generator, similar in
-  // style to [Bison](http://www.gnu.org/software/bison), implemented in JavaScript.
-  // It can recognize [LALR(1), LR(0), SLR(1), and LR(1)](https://en.wikipedia.org/wiki/LR_grammar)
-  // type grammars. To create the Jison parser, we list the pattern to match
-  // on the left-hand side, and the action to take (usually the creation of syntax
-  // tree nodes) on the right. As the parser runs, it
-  // shifts tokens from our token stream, from left to right, and
-  // [attempts to match](https://en.wikipedia.org/wiki/Bottom-up_parsing)
-  // the token sequence against the rules below. When a match can be made, it
-  // reduces into the [nonterminal](https://en.wikipedia.org/wiki/Terminal_and_nonterminal_symbols)
-  // (the enclosing name at the top), and we proceed from there.
+(function () {
+	// The CoffeeScript parser is generated by [Jison](https://github.com/zaach/jison)
+	// from this grammar file. Jison is a bottom-up parser generator, similar in
+	// style to [Bison](http://www.gnu.org/software/bison), implemented in JavaScript.
+	// It can recognize [LALR(1), LR(0), SLR(1), and LR(1)](https://en.wikipedia.org/wiki/LR_grammar)
+	// type grammars. To create the Jison parser, we list the pattern to match
+	// on the left-hand side, and the action to take (usually the creation of syntax
+	// tree nodes) on the right. As the parser runs, it
+	// shifts tokens from our token stream, from left to right, and
+	// [attempts to match](https://en.wikipedia.org/wiki/Bottom-up_parsing)
+	// the token sequence against the rules below. When a match can be made, it
+	// reduces into the [nonterminal](https://en.wikipedia.org/wiki/Terminal_and_nonterminal_symbols)
+	// (the enclosing name at the top), and we proceed from there.
 
-  // If you run the `cake build:parser` command, Jison constructs a parse table
-  // from our rules and saves it into `lib/parser.js`.
+	// If you run the `cake build:parser` command, Jison constructs a parse table
+	// from our rules and saves it into `lib/parser.js`.
 
-  // The only dependency is on the **Jison.Parser**.
-  var Parser, alt, alternatives, grammar, name, o, operators, token, tokens, unwrap;
+	// The only dependency is on the **Jison.Parser**.
+	var Parser, alt, alternatives, grammar, name, o, operators, token, tokens, unwrap;
 
-  ({Parser} = require('jison'));
+	({ Parser } = require('jison'));
 
-  // Jison DSL
-  // ---------
+	// Jison DSL
+	// ---------
 
-  // Since we're going to be wrapped in a function by Jison in any case, if our
-  // action immediately returns a value, we can optimize by removing the function
-  // wrapper and just returning the value directly.
-  unwrap = /^function\s*\(\)\s*\{\s*return\s*([\s\S]*);\s*\}/;
+	// Since we're going to be wrapped in a function by Jison in any case, if our
+	// action immediately returns a value, we can optimize by removing the function
+	// wrapper and just returning the value directly.
+	unwrap = /^function\s*\(\)\s*\{\s*return\s*([\s\S]*);\s*\}/;
 
-  // Our handy DSL for Jison grammar generation, thanks to
-  // [Tim Caswell](https://github.com/creationix). For every rule in the grammar,
-  // we pass the pattern-defining string, the action to run, and extra options,
-  // optionally. If no action is specified, we simply pass the value of the
-  // previous nonterminal.
-  o = function(patternString, action, options) {
-    var getAddDataToNodeFunctionString, match, patternCount, performActionFunctionString, returnsLoc;
-    patternString = patternString.replace(/\s{2,}/g, ' ');
-    patternCount = patternString.split(' ').length;
-    if (action) {
-      // This code block does string replacements in the generated `parser.js`
-      // file, replacing the calls to the `LOC` function and other strings as
-      // listed below.
-      action = (match = unwrap.exec(action)) ? match[1] : `(${action}())`;
-      // All runtime functions we need are defined on `yy`
-      action = action.replace(/\bnew /g, '$&yy.');
-      action = action.replace(/\b(?:Block\.wrap|extend)\b/g, 'yy.$&');
-      // Returns strings of functions to add to `parser.js` which add extra data
-      // that nodes may have, such as comments or location data. Location data
-      // is added to the first parameter passed in, and the parameter is returned.
-      // If the parameter is not a node, it will just be passed through unaffected.
-      getAddDataToNodeFunctionString = function(first, last, forceUpdateLocation = true) {
-        return `yy.addDataToNode(yy, @${first}, ${first[0] === '$' ? '$$' : '$'}${first}, ${last ? `@${last}, ${last[0] === '$' ? '$$' : '$'}${last}` : 'null, null'}, ${forceUpdateLocation ? 'true' : 'false'})`;
-      };
-      // This code replaces the calls to `LOC` with the `yy.addDataToNode` string
-      // defined above. The `LOC` function, when used below in the grammar rules,
-      // is used to make sure that newly created node class objects get correct
-      // location data assigned to them. By default, the grammar will assign the
-      // location data spanned by *all* of the tokens on the left (e.g. a string
-      // such as `'Body TERMINATOR Line'`) to the “top-level” node returned by
-      // the grammar rule (the function on the right). But for “inner” node class
-      // objects created by grammar rules, they won’t get correct location data
-      // assigned to them without adding `LOC`.
+	// Our handy DSL for Jison grammar generation, thanks to
+	// [Tim Caswell](https://github.com/creationix). For every rule in the grammar,
+	// we pass the pattern-defining string, the action to run, and extra options,
+	// optionally. If no action is specified, we simply pass the value of the
+	// previous nonterminal.
+	o = function (patternString, action, options) {
+		var getAddDataToNodeFunctionString, match, patternCount, performActionFunctionString, returnsLoc;
+		patternString = patternString.replace(/\s{2,}/g, ' ');
+		patternCount = patternString.split(' ').length;
+		if (action) {
+			// This code block does string replacements in the generated `parser.js`
+			// file, replacing the calls to the `LOC` function and other strings as
+			// listed below.
+			action = (match = unwrap.exec(action)) ? match[1] : `(${action}())`;
+			// All runtime functions we need are defined on `yy`
+			action = action.replace(/\bnew /g, '$&yy.');
+			action = action.replace(/\b(?:Block\.wrap|extend)\b/g, 'yy.$&');
+			// Returns strings of functions to add to `parser.js` which add extra data
+			// that nodes may have, such as comments or location data. Location data
+			// is added to the first parameter passed in, and the parameter is returned.
+			// If the parameter is not a node, it will just be passed through unaffected.
+			getAddDataToNodeFunctionString = function (first, last, forceUpdateLocation = true) {
+				return `yy.addDataToNode(yy, @${first}, ${first[0] === '$' ? '$$' : '$'}${first}, ${last ? `@${last}, ${last[0] === '$' ? '$$' : '$'}${last}` : 'null, null'}, ${forceUpdateLocation ? 'true' : 'false'})`;
+			};
+			// This code replaces the calls to `LOC` with the `yy.addDataToNode` string
+			// defined above. The `LOC` function, when used below in the grammar rules,
+			// is used to make sure that newly created node class objects get correct
+			// location data assigned to them. By default, the grammar will assign the
+			// location data spanned by *all* of the tokens on the left (e.g. a string
+			// such as `'Body TERMINATOR Line'`) to the “top-level” node returned by
+			// the grammar rule (the function on the right). But for “inner” node class
+			// objects created by grammar rules, they won’t get correct location data
+			// assigned to them without adding `LOC`.
 
-      // For example, consider the grammar rule `'NEW_TARGET . Property'`, which
-      // is handled by a function that returns
-      // `new MetaProperty LOC(1)(new IdentifierLiteral $1), LOC(3)(new Access $3)`.
-      // The `1` in `LOC(1)` refers to the first token (`NEW_TARGET`) and the `3`
-      // in `LOC(3)` refers to the third token (`Property`). In order for the
-      // `new IdentifierLiteral` to get assigned the location data corresponding
-      // to `new` in the source code, we use
-      // `LOC(1)(new IdentifierLiteral ...)` to mean “assign the location data of
-      // the *first* token of this grammar rule (`NEW_TARGET`) to this
-      // `new IdentifierLiteral`”. The `LOC(3)` means “assign the location data of
-      // the *third* token of this grammar rule (`Property`) to this
-      // `new Access`”.
-      returnsLoc = /^LOC/.test(action);
-      action = action.replace(/LOC\(([0-9]*)\)/g, getAddDataToNodeFunctionString('$1'));
-      // A call to `LOC` with two arguments, e.g. `LOC(2,4)`, sets the location
-      // data for the generated node on both of the referenced tokens  (the second
-      // and fourth in this example).
-      action = action.replace(/LOC\(([0-9]*),\s*([0-9]*)\)/g, getAddDataToNodeFunctionString('$1', '$2'));
-      performActionFunctionString = `$$ = ${getAddDataToNodeFunctionString(1, patternCount, !returnsLoc)}(${action});`;
-    } else {
-      performActionFunctionString = '$$ = $1;';
-    }
-    return [patternString, performActionFunctionString, options];
-  };
+			// For example, consider the grammar rule `'NEW_TARGET . Property'`, which
+			// is handled by a function that returns
+			// `new MetaProperty LOC(1)(new IdentifierLiteral $1), LOC(3)(new Access $3)`.
+			// The `1` in `LOC(1)` refers to the first token (`NEW_TARGET`) and the `3`
+			// in `LOC(3)` refers to the third token (`Property`). In order for the
+			// `new IdentifierLiteral` to get assigned the location data corresponding
+			// to `new` in the source code, we use
+			// `LOC(1)(new IdentifierLiteral ...)` to mean “assign the location data of
+			// the *first* token of this grammar rule (`NEW_TARGET`) to this
+			// `new IdentifierLiteral`”. The `LOC(3)` means “assign the location data of
+			// the *third* token of this grammar rule (`Property`) to this
+			// `new Access`”.
+			returnsLoc = /^LOC/.test(action);
+			action = action.replace(/LOC\(([0-9]*)\)/g, getAddDataToNodeFunctionString('$1'));
+			// A call to `LOC` with two arguments, e.g. `LOC(2,4)`, sets the location
+			// data for the generated node on both of the referenced tokens  (the second
+			// and fourth in this example).
+			action = action.replace(/LOC\(([0-9]*),\s*([0-9]*)\)/g, getAddDataToNodeFunctionString('$1', '$2'));
+			performActionFunctionString = `$$ = ${getAddDataToNodeFunctionString(1, patternCount, !returnsLoc)}(${action});`;
+		} else {
+			performActionFunctionString = '$$ = $1;';
+		}
+		return [patternString, performActionFunctionString, options];
+	};
 
-  // Grammatical Rules
-  // -----------------
+	// Grammatical Rules
+	// -----------------
 
-  // In all of the rules that follow, you'll see the name of the nonterminal as
-  // the key to a list of alternative matches. With each match's action, the
-  // dollar-sign variables are provided by Jison as references to the value of
-  // their numeric position, so in this rule:
+	// In all of the rules that follow, you'll see the name of the nonterminal as
+	// the key to a list of alternative matches. With each match's action, the
+	// dollar-sign variables are provided by Jison as references to the value of
+	// their numeric position, so in this rule:
 
-  //     'Expression UNLESS Expression'
+	//     'Expression UNLESS Expression'
 
-  // `$1` would be the value of the first `Expression`, `$2` would be the token
-  // for the `UNLESS` terminal, and `$3` would be the value of the second
-  // `Expression`.
-  grammar = {
-    // The **Root** is the top-level node in the syntax tree. Since we parse bottom-up,
-    // all parsing must end here.
-    Root: [
-      o('',
-      function() {
-        return new Root(new Block());
-      }),
-      o('Body',
-      function() {
-        return new Root($1);
-      })
-    ],
-    // Any list of statements and expressions, separated by line breaks or semicolons.
-    Body: [
-      o('Line',
-      function() {
-        return Block.wrap([$1]);
-      }),
-      o('Body TERMINATOR Line',
-      function() {
-        return $1.push($3);
-      }),
-      o('Body TERMINATOR')
-    ],
-    // Block and statements, which make up a line in a body. FuncDirective is a
-    // statement, but not included in Statement because that results in an ambiguous
-    // grammar.
-    Line: [o('Expression'), o('ExpressionLine'), o('Statement'), o('FuncDirective')],
-    FuncDirective: [o('YieldReturn'), o('AwaitReturn')],
-    // Pure statements which cannot be expressions.
-    Statement: [
-      o('Return'),
-      o('STATEMENT',
-      function() {
-        return new StatementLiteral($1);
-      }),
-      o('Import'),
-      o('Export')
-    ],
-    // All the different types of expressions in our language. The basic unit of
-    // CoffeeScript is the **Expression** -- everything that can be an expression
-    // is one. Blocks serve as the building blocks of many other rules, making
-    // them somewhat circular.
-    Expression: [o('Value'), o('Code'), o('Operation'), o('Assign'), o('If'), o('Try'), o('While'), o('For'), o('Switch'), o('Class'), o('Throw'), o('Yield')],
-    // Expressions which are written in single line and would otherwise require being
-    // wrapped in braces: E.g `a = b if do -> f a is 1`, `if f (a) -> a*2 then ...`,
-    // `for x in do (obj) -> f obj when x > 8 then f x`
-    ExpressionLine: [o('CodeLine'), o('IfLine'), o('OperationLine')],
-    Yield: [
-      o('YIELD',
-      function() {
-        return new Op($1,
-      new Value(new Literal('')));
-      }),
-      o('YIELD Expression',
-      function() {
-        return new Op($1,
-      $2);
-      }),
-      o('YIELD INDENT Object OUTDENT',
-      function() {
-        return new Op($1,
-      $3);
-      }),
-      o('YIELD FROM Expression',
-      function() {
-        return new Op($1.concat($2),
-      $3);
-      })
-    ],
-    // An indented block of expressions. Note that the [Rewriter](rewriter.html)
-    // will convert some postfix forms into blocks for us, by adjusting the
-    // token stream.
-    Block: [
-      o('INDENT OUTDENT',
-      function() {
-        return new Block();
-      }),
-      o('INDENT Body OUTDENT',
-      function() {
-        return $2;
-      })
-    ],
-    Identifier: [
-      o('IDENTIFIER',
-      function() {
-        return new IdentifierLiteral($1);
-      }),
-      o('JSX_TAG',
-      function() {
-        var ref,
-      ref1,
-      ref2,
-      ref3;
-        return new JSXTag($1.toString(),
-      {
-          tagNameLocationData: $1.tagNameToken[2],
-          closingTagOpeningBracketLocationData: (ref = $1.closingTagOpeningBracketToken) != null ? ref[2] : void 0,
-          closingTagSlashLocationData: (ref1 = $1.closingTagSlashToken) != null ? ref1[2] : void 0,
-          closingTagNameLocationData: (ref2 = $1.closingTagNameToken) != null ? ref2[2] : void 0,
-          closingTagClosingBracketLocationData: (ref3 = $1.closingTagClosingBracketToken) != null ? ref3[2] : void 0
-        });
-      })
-    ],
-    Property: [
-      o('PROPERTY',
-      function() {
-        return new PropertyName($1.toString());
-      })
-    ],
-    // Alphanumerics are separated from the other **Literal** matchers because
-    // they can also serve as keys in object literals.
-    AlphaNumeric: [
-      o('NUMBER',
-      function() {
-        return new NumberLiteral($1.toString(),
-      {
-          parsedValue: $1.parsedValue
-        });
-      }),
-      o('String')
-    ],
-    String: [
-      o('STRING',
-      function() {
-        return new StringLiteral($1.slice(1,
-      -1), // strip artificial quotes and unwrap to primitive string
-      {
-          quote: $1.quote,
-          initialChunk: $1.initialChunk,
-          finalChunk: $1.finalChunk,
-          indent: $1.indent,
-          double: $1.double,
-          heregex: $1.heregex
-        });
-      }),
-      o('STRING_START Interpolations STRING_END',
-      function() {
-        return new StringWithInterpolations(Block.wrap($2),
-      {
-          quote: $1.quote,
-          startQuote: LOC(1)(new Literal($1.toString()))
-        });
-      })
-    ],
-    Interpolations: [
-      o('InterpolationChunk',
-      function() {
-        return [$1];
-      }),
-      o('Interpolations InterpolationChunk',
-      function() {
-        return $1.concat($2);
-      })
-    ],
-    InterpolationChunk: [
-      o('INTERPOLATION_START Body INTERPOLATION_END',
-      function() {
-        return new Interpolation($2);
-      }),
-      o('INTERPOLATION_START INDENT Body OUTDENT INTERPOLATION_END',
-      function() {
-        return new Interpolation($3);
-      }),
-      o('INTERPOLATION_START INTERPOLATION_END',
-      function() {
-        return new Interpolation();
-      }),
-      o('String',
-      function() {
-        return $1;
-      })
-    ],
-    // The .toString() calls here and elsewhere are to convert `String` objects
-    // back to primitive strings now that we've retrieved stowaway extra properties
-    Regex: [
-      o('REGEX',
-      function() {
-        return new RegexLiteral($1.toString(),
-      {
-          delimiter: $1.delimiter,
-          heregexCommentTokens: $1.heregexCommentTokens
-        });
-      }),
-      o('REGEX_START Invocation REGEX_END',
-      function() {
-        return new RegexWithInterpolations($2,
-      {
-          heregexCommentTokens: $3.heregexCommentTokens
-        });
-      })
-    ],
-    // All of our immediate values. Generally these can be passed straight
-    // through and printed to JavaScript.
-    Literal: [
-      o('AlphaNumeric'),
-      o('JS',
-      function() {
-        return new PassthroughLiteral($1.toString(),
-      {
-          here: $1.here,
-          generated: $1.generated
-        });
-      }),
-      o('Regex'),
-      o('UNDEFINED',
-      function() {
-        return new UndefinedLiteral($1);
-      }),
-      o('NULL',
-      function() {
-        return new NullLiteral($1);
-      }),
-      o('BOOL',
-      function() {
-        return new BooleanLiteral($1.toString(),
-      {
-          originalValue: $1.original
-        });
-      }),
-      o('INFINITY',
-      function() {
-        return new InfinityLiteral($1.toString(),
-      {
-          originalValue: $1.original
-        });
-      }),
-      o('NAN',
-      function() {
-        return new NaNLiteral($1);
-      })
-    ],
-    // Assignment of a variable, property, or index to a value.
-    Assign: [
-      o('Assignable = Expression',
-      function() {
-        return new Assign($1,
-      $3);
-      }),
-      o('Assignable = TERMINATOR Expression',
-      function() {
-        return new Assign($1,
-      $4);
-      }),
-      o('Assignable = INDENT Expression OUTDENT',
-      function() {
-        return new Assign($1,
-      $4);
-      })
-    ],
-    // Assignment when it happens within an object literal. The difference from
-    // the ordinary **Assign** is that these allow numbers and strings as keys.
-    AssignObj: [
-      o('ObjAssignable',
-      function() {
-        return new Value($1);
-      }),
-      o('ObjRestValue'),
-      o('ObjAssignable : Expression',
-      function() {
-        return new Assign(LOC(1)(new Value($1)),
-      $3,
-      'object',
-      {
-          operatorToken: LOC(2)(new Literal($2))
-        });
-      }),
-      o('ObjAssignable : INDENT Expression OUTDENT',
-      function() {
-        return new Assign(LOC(1)(new Value($1)),
-      $4,
-      'object',
-      {
-          operatorToken: LOC(2)(new Literal($2))
-        });
-      }),
-      o('SimpleObjAssignable = Expression',
-      function() {
-        return new Assign(LOC(1)(new Value($1)),
-      $3,
-      null,
-      {
-          operatorToken: LOC(2)(new Literal($2))
-        });
-      }),
-      o('SimpleObjAssignable = INDENT Expression OUTDENT',
-      function() {
-        return new Assign(LOC(1)(new Value($1)),
-      $4,
-      null,
-      {
-          operatorToken: LOC(2)(new Literal($2))
-        });
-      })
-    ],
-    SimpleObjAssignable: [o('Identifier'), o('Property'), o('ThisProperty')],
-    ObjAssignable: [
-      o('SimpleObjAssignable'),
-      o('[ Expression ]',
-      function() {
-        return new Value(new ComputedPropertyName($2));
-      }),
-      o('@ [ Expression ]',
-      function() {
-        return new Value(LOC(1)(new ThisLiteral($1)),
-      [LOC(3)(new ComputedPropertyName($3))],
-      'this');
-      }),
-      o('AlphaNumeric')
-    ],
-    // Object literal spread properties.
-    ObjRestValue: [
-      o('SimpleObjAssignable ...',
-      function() {
-        return new Splat(new Value($1));
-      }),
-      o('... SimpleObjAssignable',
-      function() {
-        return new Splat(new Value($2),
-      {
-          postfix: false
-        });
-      }),
-      o('ObjSpreadExpr ...',
-      function() {
-        return new Splat($1);
-      }),
-      o('... ObjSpreadExpr',
-      function() {
-        return new Splat($2,
-      {
-          postfix: false
-        });
-      })
-    ],
-    ObjSpreadExpr: [
-      o('ObjSpreadIdentifier'),
-      o('Object'),
-      o('Parenthetical'),
-      o('Super'),
-      o('This'),
-      o('SUPER OptFuncExist Arguments',
-      function() {
-        return new SuperCall(LOC(1)(new Super()),
-      $3,
-      $2.soak,
-      $1);
-      }),
-      o('DYNAMIC_IMPORT Arguments',
-      function() {
-        return new DynamicImportCall(LOC(1)(new DynamicImport()),
-      $2);
-      }),
-      o('SimpleObjAssignable OptFuncExist Arguments',
-      function() {
-        return new Call(new Value($1),
-      $3,
-      $2.soak);
-      }),
-      o('ObjSpreadExpr OptFuncExist Arguments',
-      function() {
-        return new Call($1,
-      $3,
-      $2.soak);
-      })
-    ],
-    ObjSpreadIdentifier: [
-      o('SimpleObjAssignable Accessor',
-      function() {
-        return (new Value($1)).add($2);
-      }),
-      o('ObjSpreadExpr Accessor',
-      function() {
-        return (new Value($1)).add($2);
-      })
-    ],
-    // A return statement from a function body.
-    Return: [
-      o('RETURN Expression',
-      function() {
-        return new Return($2);
-      }),
-      o('RETURN INDENT Object OUTDENT',
-      function() {
-        return new Return(new Value($3));
-      }),
-      o('RETURN',
-      function() {
-        return new Return();
-      })
-    ],
-    YieldReturn: [
-      o('YIELD RETURN Expression',
-      function() {
-        return new YieldReturn($3,
-      {
-          returnKeyword: LOC(2)(new Literal($2))
-        });
-      }),
-      o('YIELD RETURN',
-      function() {
-        return new YieldReturn(null,
-      {
-          returnKeyword: LOC(2)(new Literal($2))
-        });
-      })
-    ],
-    AwaitReturn: [
-      o('AWAIT RETURN Expression',
-      function() {
-        return new AwaitReturn($3,
-      {
-          returnKeyword: LOC(2)(new Literal($2))
-        });
-      }),
-      o('AWAIT RETURN',
-      function() {
-        return new AwaitReturn(null,
-      {
-          returnKeyword: LOC(2)(new Literal($2))
-        });
-      })
-    ],
-    // The **Code** node is the function literal. It’s defined by an indented block
-    // of **Block** preceded by a function arrow, with an optional parameter list.
-    Code: [
-      o('PARAM_START ParamList PARAM_END FuncGlyph Block',
-      function() {
-        return new Code($2,
-      $5,
-      $4,
-      LOC(1)(new Literal($1)));
-      }),
-      o('FuncGlyph Block',
-      function() {
-        return new Code([],
-      $2,
-      $1);
-      })
-    ],
-    // The Codeline is the **Code** node with **Line** instead of indented **Block**.
-    CodeLine: [
-      o('PARAM_START ParamList PARAM_END FuncGlyph Line',
-      function() {
-        return new Code($2,
-      LOC(5)(Block.wrap([$5])),
-      $4,
-      LOC(1)(new Literal($1)));
-      }),
-      o('FuncGlyph Line',
-      function() {
-        return new Code([],
-      LOC(2)(Block.wrap([$2])),
-      $1);
-      })
-    ],
-    // CoffeeScript has two different symbols for functions. `->` is for ordinary
-    // functions, and `=>` is for functions bound to the current value of *this*.
-    FuncGlyph: [
-      o('->',
-      function() {
-        return new FuncGlyph($1);
-      }),
-      o('=>',
-      function() {
-        return new FuncGlyph($1);
-      })
-    ],
-    // An optional, trailing comma.
-    OptComma: [o(''), o(',')],
-    // The list of parameters that a function accepts can be of any length.
-    ParamList: [
-      o('',
-      function() {
-        return [];
-      }),
-      o('Param',
-      function() {
-        return [$1];
-      }),
-      o('ParamList , Param',
-      function() {
-        return $1.concat($3);
-      }),
-      o('ParamList OptComma TERMINATOR Param',
-      function() {
-        return $1.concat($4);
-      }),
-      o('ParamList OptComma INDENT ParamList OptComma OUTDENT',
-      function() {
-        return $1.concat($4);
-      })
-    ],
-    // A single parameter in a function definition can be ordinary, or a splat
-    // that hoovers up the remaining arguments.
-    Param: [
-      o('ParamVar',
-      function() {
-        return new Param($1);
-      }),
-      o('ParamVar ...',
-      function() {
-        return new Param($1,
-      null,
-      true);
-      }),
-      o('... ParamVar',
-      function() {
-        return new Param($2,
-      null,
-      {
-          postfix: false
-        });
-      }),
-      o('ParamVar = Expression',
-      function() {
-        return new Param($1,
-      $3);
-      }),
-      o('...',
-      function() {
-        return new Expansion();
-      })
-    ],
-    // Function Parameters
-    ParamVar: [o('Identifier'), o('ThisProperty'), o('Array'), o('Object')],
-    // A splat that occurs outside of a parameter list.
-    Splat: [
-      o('Expression ...',
-      function() {
-        return new Splat($1);
-      }),
-      o('... Expression',
-      function() {
-        return new Splat($2,
-      {
-          postfix: false
-        });
-      })
-    ],
-    // Variables and properties that can be assigned to.
-    SimpleAssignable: [
-      o('Identifier',
-      function() {
-        return new Value($1);
-      }),
-      o('Value Accessor',
-      function() {
-        return $1.add($2);
-      }),
-      o('Code Accessor',
-      function() {
-        return new Value($1).add($2);
-      }),
-      o('ThisProperty')
-    ],
-    // Everything that can be assigned to.
-    Assignable: [
-      o('SimpleAssignable'),
-      o('Array',
-      function() {
-        return new Value($1);
-      }),
-      o('Object',
-      function() {
-        return new Value($1);
-      })
-    ],
-    // The types of things that can be treated as values -- assigned to, invoked
-    // as functions, indexed into, named as a class, etc.
-    Value: [
-      o('Assignable'),
-      o('Literal',
-      function() {
-        return new Value($1);
-      }),
-      o('Parenthetical',
-      function() {
-        return new Value($1);
-      }),
-      o('Range',
-      function() {
-        return new Value($1);
-      }),
-      o('Invocation',
-      function() {
-        return new Value($1);
-      }),
-      o('DoIife',
-      function() {
-        return new Value($1);
-      }),
-      o('This'),
-      o('Super',
-      function() {
-        return new Value($1);
-      }),
-      o('MetaProperty',
-      function() {
-        return new Value($1);
-      })
-    ],
-    // A `super`-based expression that can be used as a value.
-    Super: [
-      o('SUPER . Property',
-      function() {
-        return new Super(LOC(3)(new Access($3)),
-      LOC(1)(new Literal($1)));
-      }),
-      o('SUPER INDEX_START Expression INDEX_END',
-      function() {
-        return new Super(LOC(3)(new Index($3)),
-      LOC(1)(new Literal($1)));
-      }),
-      o('SUPER INDEX_START INDENT Expression OUTDENT INDEX_END',
-      function() {
-        return new Super(LOC(4)(new Index($4)),
-      LOC(1)(new Literal($1)));
-      })
-    ],
-    // A “meta-property” access e.g. `new.target` or `import.meta`, where
-    // something that looks like a property is referenced on a keyword.
-    MetaProperty: [
-      o('NEW_TARGET . Property',
-      function() {
-        return new MetaProperty(LOC(1)(new IdentifierLiteral($1)),
-      LOC(3)(new Access($3)));
-      }),
-      o('IMPORT_META . Property',
-      function() {
-        return new MetaProperty(LOC(1)(new IdentifierLiteral($1)),
-      LOC(3)(new Access($3)));
-      })
-    ],
-    // The general group of accessors into an object, by property, by prototype
-    // or by array index or slice.
-    Accessor: [
-      o('.  Property',
-      function() {
-        return new Access($2);
-      }),
-      o('?. Property',
-      function() {
-        return new Access($2,
-      {
-          soak: true
-        });
-      }),
-      o(':: Property',
-      function() {
-        return [
-          LOC(1)(new Access(new PropertyName('prototype'),
-          {
-            shorthand: true
-          })),
-          LOC(2)(new Access($2))
-        ];
-      }),
-      o('?:: Property',
-      function() {
-        return [
-          LOC(1)(new Access(new PropertyName('prototype'),
-          {
-            shorthand: true,
-            soak: true
-          })),
-          LOC(2)(new Access($2))
-        ];
-      }),
-      o('::',
-      function() {
-        return new Access(new PropertyName('prototype'),
-      {
-          shorthand: true
-        });
-      }),
-      o('?::',
-      function() {
-        return new Access(new PropertyName('prototype'),
-      {
-          shorthand: true,
-          soak: true
-        });
-      }),
-      o('Index')
-    ],
-    // Indexing into an object or array using bracket notation.
-    Index: [
-      o('INDEX_START IndexValue INDEX_END',
-      function() {
-        return $2;
-      }),
-      o('INDEX_START INDENT IndexValue OUTDENT INDEX_END',
-      function() {
-        return $3;
-      }),
-      o('INDEX_SOAK  Index',
-      function() {
-        return extend($2,
-      {
-          soak: true
-        });
-      })
-    ],
-    IndexValue: [
-      o('Expression',
-      function() {
-        return new Index($1);
-      }),
-      o('Slice',
-      function() {
-        return new Slice($1);
-      })
-    ],
-    // In CoffeeScript, an object literal is simply a list of assignments.
-    Object: [
-      o('{ AssignList OptComma }',
-      function() {
-        return new Obj($2,
-      $1.generated);
-      })
-    ],
-    // Assignment of properties within an object literal can be separated by
-    // comma, as in JavaScript, or simply by newline.
-    AssignList: [
-      o('',
-      function() {
-        return [];
-      }),
-      o('AssignObj',
-      function() {
-        return [$1];
-      }),
-      o('AssignList , AssignObj',
-      function() {
-        return $1.concat($3);
-      }),
-      o('AssignList OptComma TERMINATOR AssignObj',
-      function() {
-        return $1.concat($4);
-      }),
-      o('AssignList OptComma INDENT AssignList OptComma OUTDENT',
-      function() {
-        return $1.concat($4);
-      })
-    ],
-    // Class definitions have optional bodies of prototype property assignments,
-    // and optional references to the superclass.
-    Class: [
-      o('CLASS',
-      function() {
-        return new Class();
-      }),
-      o('CLASS Block',
-      function() {
-        return new Class(null,
-      null,
-      $2);
-      }),
-      o('CLASS EXTENDS Expression',
-      function() {
-        return new Class(null,
-      $3);
-      }),
-      o('CLASS EXTENDS Expression Block',
-      function() {
-        return new Class(null,
-      $3,
-      $4);
-      }),
-      o('CLASS SimpleAssignable',
-      function() {
-        return new Class($2);
-      }),
-      o('CLASS SimpleAssignable Block',
-      function() {
-        return new Class($2,
-      null,
-      $3);
-      }),
-      o('CLASS SimpleAssignable EXTENDS Expression',
-      function() {
-        return new Class($2,
-      $4);
-      }),
-      o('CLASS SimpleAssignable EXTENDS Expression Block',
-      function() {
-        return new Class($2,
-      $4,
-      $5);
-      })
-    ],
-    Import: [
-      o('IMPORT String',
-      function() {
-        return new ImportDeclaration(null,
-      $2);
-      }),
-      o('IMPORT String ASSERT Object',
-      function() {
-        return new ImportDeclaration(null,
-      $2,
-      $4);
-      }),
-      o('IMPORT ImportDefaultSpecifier FROM String',
-      function() {
-        return new ImportDeclaration(new ImportClause($2,
-      null),
-      $4);
-      }),
-      o('IMPORT ImportDefaultSpecifier FROM String ASSERT Object',
-      function() {
-        return new ImportDeclaration(new ImportClause($2,
-      null),
-      $4,
-      $6);
-      }),
-      o('IMPORT ImportNamespaceSpecifier FROM String',
-      function() {
-        return new ImportDeclaration(new ImportClause(null,
-      $2),
-      $4);
-      }),
-      o('IMPORT ImportNamespaceSpecifier FROM String ASSERT Object',
-      function() {
-        return new ImportDeclaration(new ImportClause(null,
-      $2),
-      $4,
-      $6);
-      }),
-      o('IMPORT { } FROM String',
-      function() {
-        return new ImportDeclaration(new ImportClause(null,
-      new ImportSpecifierList([])),
-      $5);
-      }),
-      o('IMPORT { } FROM String ASSERT Object',
-      function() {
-        return new ImportDeclaration(new ImportClause(null,
-      new ImportSpecifierList([])),
-      $5,
-      $7);
-      }),
-      o('IMPORT { ImportSpecifierList OptComma } FROM String',
-      function() {
-        return new ImportDeclaration(new ImportClause(null,
-      new ImportSpecifierList($3)),
-      $7);
-      }),
-      o('IMPORT { ImportSpecifierList OptComma } FROM String ASSERT Object',
-      function() {
-        return new ImportDeclaration(new ImportClause(null,
-      new ImportSpecifierList($3)),
-      $7,
-      $9);
-      }),
-      o('IMPORT ImportDefaultSpecifier , ImportNamespaceSpecifier FROM String',
-      function() {
-        return new ImportDeclaration(new ImportClause($2,
-      $4),
-      $6);
-      }),
-      o('IMPORT ImportDefaultSpecifier , ImportNamespaceSpecifier FROM String ASSERT Object',
-      function() {
-        return new ImportDeclaration(new ImportClause($2,
-      $4),
-      $6,
-      $8);
-      }),
-      o('IMPORT ImportDefaultSpecifier , { ImportSpecifierList OptComma } FROM String',
-      function() {
-        return new ImportDeclaration(new ImportClause($2,
-      new ImportSpecifierList($5)),
-      $9);
-      }),
-      o('IMPORT ImportDefaultSpecifier , { ImportSpecifierList OptComma } FROM String ASSERT Object',
-      function() {
-        return new ImportDeclaration(new ImportClause($2,
-      new ImportSpecifierList($5)),
-      $9,
-      $11);
-      })
-    ],
-    ImportSpecifierList: [
-      o('ImportSpecifier',
-      function() {
-        return [$1];
-      }),
-      o('ImportSpecifierList , ImportSpecifier',
-      function() {
-        return $1.concat($3);
-      }),
-      o('ImportSpecifierList OptComma TERMINATOR ImportSpecifier',
-      function() {
-        return $1.concat($4);
-      }),
-      o('INDENT ImportSpecifierList OptComma OUTDENT',
-      function() {
-        return $2;
-      }),
-      o('ImportSpecifierList OptComma INDENT ImportSpecifierList OptComma OUTDENT',
-      function() {
-        return $1.concat($4);
-      })
-    ],
-    ImportSpecifier: [
-      o('Identifier',
-      function() {
-        return new ImportSpecifier($1);
-      }),
-      o('Identifier AS Identifier',
-      function() {
-        return new ImportSpecifier($1,
-      $3);
-      }),
-      o('DEFAULT',
-      function() {
-        return new ImportSpecifier(LOC(1)(new DefaultLiteral($1)));
-      }),
-      o('DEFAULT AS Identifier',
-      function() {
-        return new ImportSpecifier(LOC(1)(new DefaultLiteral($1)),
-      $3);
-      })
-    ],
-    ImportDefaultSpecifier: [
-      o('Identifier',
-      function() {
-        return new ImportDefaultSpecifier($1);
-      })
-    ],
-    ImportNamespaceSpecifier: [
-      o('IMPORT_ALL AS Identifier',
-      function() {
-        return new ImportNamespaceSpecifier(new Literal($1),
-      $3);
-      })
-    ],
-    Export: [
-      o('EXPORT { }',
-      function() {
-        return new ExportNamedDeclaration(new ExportSpecifierList([]));
-      }),
-      o('EXPORT { ExportSpecifierList OptComma }',
-      function() {
-        return new ExportNamedDeclaration(new ExportSpecifierList($3));
-      }),
-      o('EXPORT Class',
-      function() {
-        return new ExportNamedDeclaration($2);
-      }),
-      o('EXPORT Identifier = Expression',
-      function() {
-        return new ExportNamedDeclaration(LOC(2,
-      4)(new Assign($2,
-      $4,
-      null,
-      {
-          moduleDeclaration: 'export'
-        })));
-      }),
-      o('EXPORT Identifier = TERMINATOR Expression',
-      function() {
-        return new ExportNamedDeclaration(LOC(2,
-      5)(new Assign($2,
-      $5,
-      null,
-      {
-          moduleDeclaration: 'export'
-        })));
-      }),
-      o('EXPORT Identifier = INDENT Expression OUTDENT',
-      function() {
-        return new ExportNamedDeclaration(LOC(2,
-      6)(new Assign($2,
-      $5,
-      null,
-      {
-          moduleDeclaration: 'export'
-        })));
-      }),
-      o('EXPORT DEFAULT Expression',
-      function() {
-        return new ExportDefaultDeclaration($3);
-      }),
-      o('EXPORT DEFAULT INDENT Object OUTDENT',
-      function() {
-        return new ExportDefaultDeclaration(new Value($4));
-      }),
-      o('EXPORT EXPORT_ALL FROM String',
-      function() {
-        return new ExportAllDeclaration(new Literal($2),
-      $4);
-      }),
-      o('EXPORT EXPORT_ALL FROM String ASSERT Object',
-      function() {
-        return new ExportAllDeclaration(new Literal($2),
-      $4,
-      $6);
-      }),
-      o('EXPORT { } FROM String',
-      function() {
-        return new ExportNamedDeclaration(new ExportSpecifierList([]),
-      $5);
-      }),
-      o('EXPORT { } FROM String ASSERT Object',
-      function() {
-        return new ExportNamedDeclaration(new ExportSpecifierList([]),
-      $5,
-      $7);
-      }),
-      o('EXPORT { ExportSpecifierList OptComma } FROM String',
-      function() {
-        return new ExportNamedDeclaration(new ExportSpecifierList($3),
-      $7);
-      }),
-      o('EXPORT { ExportSpecifierList OptComma } FROM String ASSERT Object',
-      function() {
-        return new ExportNamedDeclaration(new ExportSpecifierList($3),
-      $7,
-      $9);
-      })
-    ],
-    ExportSpecifierList: [
-      o('ExportSpecifier',
-      function() {
-        return [$1];
-      }),
-      o('ExportSpecifierList , ExportSpecifier',
-      function() {
-        return $1.concat($3);
-      }),
-      o('ExportSpecifierList OptComma TERMINATOR ExportSpecifier',
-      function() {
-        return $1.concat($4);
-      }),
-      o('INDENT ExportSpecifierList OptComma OUTDENT',
-      function() {
-        return $2;
-      }),
-      o('ExportSpecifierList OptComma INDENT ExportSpecifierList OptComma OUTDENT',
-      function() {
-        return $1.concat($4);
-      })
-    ],
-    ExportSpecifier: [
-      o('Identifier',
-      function() {
-        return new ExportSpecifier($1);
-      }),
-      o('Identifier AS Identifier',
-      function() {
-        return new ExportSpecifier($1,
-      $3);
-      }),
-      o('Identifier AS DEFAULT',
-      function() {
-        return new ExportSpecifier($1,
-      LOC(3)(new DefaultLiteral($3)));
-      }),
-      o('DEFAULT',
-      function() {
-        return new ExportSpecifier(LOC(1)(new DefaultLiteral($1)));
-      }),
-      o('DEFAULT AS Identifier',
-      function() {
-        return new ExportSpecifier(LOC(1)(new DefaultLiteral($1)),
-      $3);
-      })
-    ],
-    // Ordinary function invocation, or a chained series of calls.
-    Invocation: [
-      o('Value OptFuncExist String',
-      function() {
-        return new TaggedTemplateCall($1,
-      $3,
-      $2.soak);
-      }),
-      o('Value OptFuncExist Arguments',
-      function() {
-        return new Call($1,
-      $3,
-      $2.soak);
-      }),
-      o('SUPER OptFuncExist Arguments',
-      function() {
-        return new SuperCall(LOC(1)(new Super()),
-      $3,
-      $2.soak,
-      $1);
-      }),
-      o('DYNAMIC_IMPORT Arguments',
-      function() {
-        return new DynamicImportCall(LOC(1)(new DynamicImport()),
-      $2);
-      })
-    ],
-    // An optional existence check on a function.
-    OptFuncExist: [
-      o('',
-      function() {
-        return {
-          soak: false
-        };
-      }),
-      o('FUNC_EXIST',
-      function() {
-        return {
-          soak: true
-        };
-      })
-    ],
-    // The list of arguments to a function call.
-    Arguments: [
-      o('CALL_START CALL_END',
-      function() {
-        return [];
-      }),
-      o('CALL_START ArgList OptComma CALL_END',
-      function() {
-        $2.implicit = $1.generated;
-        return $2;
-      })
-    ],
-    // A reference to the *this* current object.
-    This: [
-      o('THIS',
-      function() {
-        return new Value(new ThisLiteral($1));
-      }),
-      o('@',
-      function() {
-        return new Value(new ThisLiteral($1));
-      })
-    ],
-    // A reference to a property on *this*.
-    ThisProperty: [
-      o('@ Property',
-      function() {
-        return new Value(LOC(1)(new ThisLiteral($1)),
-      [LOC(2)(new Access($2))],
-      'this');
-      })
-    ],
-    // The array literal.
-    Array: [
-      o('[ ]',
-      function() {
-        return new Arr([]);
-      }),
-      o('[ Elisions ]',
-      function() {
-        return new Arr($2);
-      }),
-      o('[ ArgElisionList OptElisions ]',
-      function() {
-        return new Arr([].concat($2,
-      $3));
-      })
-    ],
-    // Inclusive and exclusive range dots.
-    RangeDots: [
-      o('..',
-      function() {
-        return {
-          exclusive: false
-        };
-      }),
-      o('...',
-      function() {
-        return {
-          exclusive: true
-        };
-      })
-    ],
-    // The CoffeeScript range literal.
-    Range: [
-      o('[ Expression RangeDots Expression ]',
-      function() {
-        return new Range($2,
-      $4,
-      $3.exclusive ? 'exclusive' : 'inclusive');
-      }),
-      o('[ ExpressionLine RangeDots Expression ]',
-      function() {
-        return new Range($2,
-      $4,
-      $3.exclusive ? 'exclusive' : 'inclusive');
-      })
-    ],
-    // Array slice literals.
-    Slice: [
-      o('Expression RangeDots Expression',
-      function() {
-        return new Range($1,
-      $3,
-      $2.exclusive ? 'exclusive' : 'inclusive');
-      }),
-      o('Expression RangeDots',
-      function() {
-        return new Range($1,
-      null,
-      $2.exclusive ? 'exclusive' : 'inclusive');
-      }),
-      o('ExpressionLine RangeDots Expression',
-      function() {
-        return new Range($1,
-      $3,
-      $2.exclusive ? 'exclusive' : 'inclusive');
-      }),
-      o('ExpressionLine RangeDots',
-      function() {
-        return new Range($1,
-      null,
-      $2.exclusive ? 'exclusive' : 'inclusive');
-      }),
-      o('RangeDots Expression',
-      function() {
-        return new Range(null,
-      $2,
-      $1.exclusive ? 'exclusive' : 'inclusive');
-      }),
-      o('RangeDots',
-      function() {
-        return new Range(null,
-      null,
-      $1.exclusive ? 'exclusive' : 'inclusive');
-      })
-    ],
-    // The **ArgList** is the list of objects passed into a function call
-    // (i.e. comma-separated expressions). Newlines work as well.
-    ArgList: [
-      o('Arg',
-      function() {
-        return [$1];
-      }),
-      o('ArgList , Arg',
-      function() {
-        return $1.concat($3);
-      }),
-      o('ArgList OptComma TERMINATOR Arg',
-      function() {
-        return $1.concat($4);
-      }),
-      o('INDENT ArgList OptComma OUTDENT',
-      function() {
-        return $2;
-      }),
-      o('ArgList OptComma INDENT ArgList OptComma OUTDENT',
-      function() {
-        return $1.concat($4);
-      })
-    ],
-    // Valid arguments are Blocks or Splats.
-    Arg: [
-      o('Expression'),
-      o('ExpressionLine'),
-      o('Splat'),
-      o('...',
-      function() {
-        return new Expansion();
-      })
-    ],
-    // The **ArgElisionList** is the list of objects, contents of an array literal
-    // (i.e. comma-separated expressions and elisions). Newlines work as well.
-    ArgElisionList: [
-      o('ArgElision'),
-      o('ArgElisionList , ArgElision',
-      function() {
-        return $1.concat($3);
-      }),
-      o('ArgElisionList OptComma TERMINATOR ArgElision',
-      function() {
-        return $1.concat($4);
-      }),
-      o('INDENT ArgElisionList OptElisions OUTDENT',
-      function() {
-        return $2.concat($3);
-      }),
-      o('ArgElisionList OptElisions INDENT ArgElisionList OptElisions OUTDENT',
-      function() {
-        return $1.concat($2,
-      $4,
-      $5);
-      })
-    ],
-    ArgElision: [
-      o('Arg',
-      function() {
-        return [$1];
-      }),
-      o('Elisions Arg',
-      function() {
-        return $1.concat($2);
-      })
-    ],
-    OptElisions: [
-      o('OptComma',
-      function() {
-        return [];
-      }),
-      o(', Elisions',
-      function() {
-        return [].concat($2);
-      })
-    ],
-    Elisions: [
-      o('Elision',
-      function() {
-        return [$1];
-      }),
-      o('Elisions Elision',
-      function() {
-        return $1.concat($2);
-      })
-    ],
-    Elision: [
-      o(',',
-      function() {
-        return new Elision();
-      }),
-      o('Elision TERMINATOR',
-      function() {
-        return $1;
-      })
-    ],
-    // Just simple, comma-separated, required arguments (no fancy syntax). We need
-    // this to be separate from the **ArgList** for use in **Switch** blocks, where
-    // having the newlines wouldn't make sense.
-    SimpleArgs: [
-      o('Expression'),
-      o('ExpressionLine'),
-      o('SimpleArgs , Expression',
-      function() {
-        return [].concat($1,
-      $3);
-      }),
-      o('SimpleArgs , ExpressionLine',
-      function() {
-        return [].concat($1,
-      $3);
-      })
-    ],
-    // The variants of *try/catch/finally* exception handling blocks.
-    Try: [
-      o('TRY Block',
-      function() {
-        return new Try($2);
-      }),
-      o('TRY Block Catch',
-      function() {
-        return new Try($2,
-      $3);
-      }),
-      o('TRY Block FINALLY Block',
-      function() {
-        return new Try($2,
-      null,
-      $4,
-      LOC(3)(new Literal($3)));
-      }),
-      o('TRY Block Catch FINALLY Block',
-      function() {
-        return new Try($2,
-      $3,
-      $5,
-      LOC(4)(new Literal($4)));
-      })
-    ],
-    // A catch clause names its error and runs a block of code.
-    Catch: [
-      o('CATCH Identifier Block',
-      function() {
-        return new Catch($3,
-      $2);
-      }),
-      o('CATCH Object Block',
-      function() {
-        return new Catch($3,
-      LOC(2)(new Value($2)));
-      }),
-      o('CATCH Block',
-      function() {
-        return new Catch($2);
-      })
-    ],
-    // Throw an exception object.
-    Throw: [
-      o('THROW Expression',
-      function() {
-        return new Throw($2);
-      }),
-      o('THROW INDENT Object OUTDENT',
-      function() {
-        return new Throw(new Value($3));
-      })
-    ],
-    // Parenthetical expressions. Note that the **Parenthetical** is a **Value**,
-    // not an **Expression**, so if you need to use an expression in a place
-    // where only values are accepted, wrapping it in parentheses will always do
-    // the trick.
-    Parenthetical: [
-      o('( Body )',
-      function() {
-        return new Parens($2);
-      }),
-      o('( INDENT Body OUTDENT )',
-      function() {
-        return new Parens($3);
-      })
-    ],
-    // The condition portion of a while loop.
-    WhileLineSource: [
-      o('WHILE ExpressionLine',
-      function() {
-        return new While($2);
-      }),
-      o('WHILE ExpressionLine WHEN ExpressionLine',
-      function() {
-        return new While($2,
-      {
-          guard: $4
-        });
-      }),
-      o('UNTIL ExpressionLine',
-      function() {
-        return new While($2,
-      {
-          invert: true
-        });
-      }),
-      o('UNTIL ExpressionLine WHEN ExpressionLine',
-      function() {
-        return new While($2,
-      {
-          invert: true,
-          guard: $4
-        });
-      })
-    ],
-    WhileSource: [
-      o('WHILE Expression',
-      function() {
-        return new While($2);
-      }),
-      o('WHILE Expression WHEN Expression',
-      function() {
-        return new While($2,
-      {
-          guard: $4
-        });
-      }),
-      o('WHILE ExpressionLine WHEN Expression',
-      function() {
-        return new While($2,
-      {
-          guard: $4
-        });
-      }),
-      o('UNTIL Expression',
-      function() {
-        return new While($2,
-      {
-          invert: true
-        });
-      }),
-      o('UNTIL Expression WHEN Expression',
-      function() {
-        return new While($2,
-      {
-          invert: true,
-          guard: $4
-        });
-      }),
-      o('UNTIL ExpressionLine WHEN Expression',
-      function() {
-        return new While($2,
-      {
-          invert: true,
-          guard: $4
-        });
-      })
-    ],
-    // The while loop can either be normal, with a block of expressions to execute,
-    // or postfix, with a single expression. There is no do..while.
-    While: [
-      o('WhileSource Block',
-      function() {
-        return $1.addBody($2);
-      }),
-      o('WhileLineSource Block',
-      function() {
-        return $1.addBody($2);
-      }),
-      o('Statement  WhileSource',
-      function() {
-        return (Object.assign($2,
-      {
-          postfix: true
-        })).addBody(LOC(1)(Block.wrap([$1])));
-      }),
-      o('Expression WhileSource',
-      function() {
-        return (Object.assign($2,
-      {
-          postfix: true
-        })).addBody(LOC(1)(Block.wrap([$1])));
-      }),
-      o('Loop',
-      function() {
-        return $1;
-      })
-    ],
-    Loop: [
-      o('LOOP Block',
-      function() {
-        return new While(LOC(1)(new BooleanLiteral('true')),
-      {
-          isLoop: true
-        }).addBody($2);
-      }),
-      o('LOOP Expression',
-      function() {
-        return new While(LOC(1)(new BooleanLiteral('true')),
-      {
-          isLoop: true
-        }).addBody(LOC(2)(Block.wrap([$2])));
-      })
-    ],
-    // Array, object, and range comprehensions, at the most generic level.
-    // Comprehensions can either be normal, with a block of expressions to execute,
-    // or postfix, with a single expression.
-    For: [
-      o('Statement    ForBody',
-      function() {
-        $2.postfix = true;
-        return $2.addBody($1);
-      }),
-      o('Expression   ForBody',
-      function() {
-        $2.postfix = true;
-        return $2.addBody($1);
-      }),
-      o('ForBody      Block',
-      function() {
-        return $1.addBody($2);
-      }),
-      o('ForLineBody  Block',
-      function() {
-        return $1.addBody($2);
-      })
-    ],
-    ForBody: [
-      o('FOR Range',
-      function() {
-        return new For([],
-      {
-          source: LOC(2)(new Value($2))
-        });
-      }),
-      o('FOR Range BY Expression',
-      function() {
-        return new For([],
-      {
-          source: LOC(2)(new Value($2)),
-          step: $4
-        });
-      }),
-      o('ForStart ForSource',
-      function() {
-        return $1.addSource($2);
-      })
-    ],
-    ForLineBody: [
-      o('FOR Range BY ExpressionLine',
-      function() {
-        return new For([],
-      {
-          source: LOC(2)(new Value($2)),
-          step: $4
-        });
-      }),
-      o('ForStart ForLineSource',
-      function() {
-        return $1.addSource($2);
-      })
-    ],
-    ForStart: [
-      o('FOR ForVariables',
-      function() {
-        return new For([],
-      {
-          name: $2[0],
-          index: $2[1]
-        });
-      }),
-      o('FOR AWAIT ForVariables',
-      function() {
-        var index,
-      name;
-        [name,
-      index] = $3;
-        return new For([],
-      {
-          name,
-          index,
-          await: true,
-          awaitTag: LOC(2)(new Literal($2))
-        });
-      }),
-      o('FOR OWN ForVariables',
-      function() {
-        var index,
-      name;
-        [name,
-      index] = $3;
-        return new For([],
-      {
-          name,
-          index,
-          own: true,
-          ownTag: LOC(2)(new Literal($2))
-        });
-      })
-    ],
-    // An array of all accepted values for a variable inside the loop.
-    // This enables support for pattern matching.
-    ForValue: [
-      o('Identifier'),
-      o('ThisProperty'),
-      o('Array',
-      function() {
-        return new Value($1);
-      }),
-      o('Object',
-      function() {
-        return new Value($1);
-      })
-    ],
-    // An array or range comprehension has variables for the current element
-    // and (optional) reference to the current index. Or, *key, value*, in the case
-    // of object comprehensions.
-    ForVariables: [
-      o('ForValue',
-      function() {
-        return [$1];
-      }),
-      o('ForValue , ForValue',
-      function() {
-        return [$1,
-      $3];
-      })
-    ],
-    // The source of a comprehension is an array or object with an optional guard
-    // clause. If it’s an array comprehension, you can also choose to step through
-    // in fixed-size increments.
-    ForSource: [
-      o('FORIN Expression',
-      function() {
-        return {
-          source: $2
-        };
-      }),
-      o('FOROF Expression',
-      function() {
-        return {
-          source: $2,
-          object: true
-        };
-      }),
-      o('FORIN Expression WHEN Expression',
-      function() {
-        return {
-          source: $2,
-          guard: $4
-        };
-      }),
-      o('FORIN ExpressionLine WHEN Expression',
-      function() {
-        return {
-          source: $2,
-          guard: $4
-        };
-      }),
-      o('FOROF Expression WHEN Expression',
-      function() {
-        return {
-          source: $2,
-          guard: $4,
-          object: true
-        };
-      }),
-      o('FOROF ExpressionLine WHEN Expression',
-      function() {
-        return {
-          source: $2,
-          guard: $4,
-          object: true
-        };
-      }),
-      o('FORIN Expression BY Expression',
-      function() {
-        return {
-          source: $2,
-          step: $4
-        };
-      }),
-      o('FORIN ExpressionLine BY Expression',
-      function() {
-        return {
-          source: $2,
-          step: $4
-        };
-      }),
-      o('FORIN Expression WHEN Expression BY Expression',
-      function() {
-        return {
-          source: $2,
-          guard: $4,
-          step: $6
-        };
-      }),
-      o('FORIN ExpressionLine WHEN Expression BY Expression',
-      function() {
-        return {
-          source: $2,
-          guard: $4,
-          step: $6
-        };
-      }),
-      o('FORIN Expression WHEN ExpressionLine BY Expression',
-      function() {
-        return {
-          source: $2,
-          guard: $4,
-          step: $6
-        };
-      }),
-      o('FORIN ExpressionLine WHEN ExpressionLine BY Expression',
-      function() {
-        return {
-          source: $2,
-          guard: $4,
-          step: $6
-        };
-      }),
-      o('FORIN Expression BY Expression WHEN Expression',
-      function() {
-        return {
-          source: $2,
-          step: $4,
-          guard: $6
-        };
-      }),
-      o('FORIN ExpressionLine BY Expression WHEN Expression',
-      function() {
-        return {
-          source: $2,
-          step: $4,
-          guard: $6
-        };
-      }),
-      o('FORIN Expression BY ExpressionLine WHEN Expression',
-      function() {
-        return {
-          source: $2,
-          step: $4,
-          guard: $6
-        };
-      }),
-      o('FORIN ExpressionLine BY ExpressionLine WHEN Expression',
-      function() {
-        return {
-          source: $2,
-          step: $4,
-          guard: $6
-        };
-      }),
-      o('FORFROM Expression',
-      function() {
-        return {
-          source: $2,
-          from: true
-        };
-      }),
-      o('FORFROM Expression WHEN Expression',
-      function() {
-        return {
-          source: $2,
-          guard: $4,
-          from: true
-        };
-      }),
-      o('FORFROM ExpressionLine WHEN Expression',
-      function() {
-        return {
-          source: $2,
-          guard: $4,
-          from: true
-        };
-      })
-    ],
-    ForLineSource: [
-      o('FORIN ExpressionLine',
-      function() {
-        return {
-          source: $2
-        };
-      }),
-      o('FOROF ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          object: true
-        };
-      }),
-      o('FORIN Expression WHEN ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          guard: $4
-        };
-      }),
-      o('FORIN ExpressionLine WHEN ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          guard: $4
-        };
-      }),
-      o('FOROF Expression WHEN ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          guard: $4,
-          object: true
-        };
-      }),
-      o('FOROF ExpressionLine WHEN ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          guard: $4,
-          object: true
-        };
-      }),
-      o('FORIN Expression BY ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          step: $4
-        };
-      }),
-      o('FORIN ExpressionLine BY ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          step: $4
-        };
-      }),
-      o('FORIN Expression WHEN Expression BY ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          guard: $4,
-          step: $6
-        };
-      }),
-      o('FORIN ExpressionLine WHEN Expression BY ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          guard: $4,
-          step: $6
-        };
-      }),
-      o('FORIN Expression WHEN ExpressionLine BY ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          guard: $4,
-          step: $6
-        };
-      }),
-      o('FORIN ExpressionLine WHEN ExpressionLine BY ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          guard: $4,
-          step: $6
-        };
-      }),
-      o('FORIN Expression BY Expression WHEN ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          step: $4,
-          guard: $6
-        };
-      }),
-      o('FORIN ExpressionLine BY Expression WHEN ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          step: $4,
-          guard: $6
-        };
-      }),
-      o('FORIN Expression BY ExpressionLine WHEN ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          step: $4,
-          guard: $6
-        };
-      }),
-      o('FORIN ExpressionLine BY ExpressionLine WHEN ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          step: $4,
-          guard: $6
-        };
-      }),
-      o('FORFROM ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          from: true
-        };
-      }),
-      o('FORFROM Expression WHEN ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          guard: $4,
-          from: true
-        };
-      }),
-      o('FORFROM ExpressionLine WHEN ExpressionLine',
-      function() {
-        return {
-          source: $2,
-          guard: $4,
-          from: true
-        };
-      })
-    ],
-    Switch: [
-      o('SWITCH Expression INDENT Whens OUTDENT',
-      function() {
-        return new Switch($2,
-      $4);
-      }),
-      o('SWITCH ExpressionLine INDENT Whens OUTDENT',
-      function() {
-        return new Switch($2,
-      $4);
-      }),
-      o('SWITCH Expression INDENT Whens ELSE Block OUTDENT',
-      function() {
-        return new Switch($2,
-      $4,
-      LOC(5,
-      6)($6));
-      }),
-      o('SWITCH ExpressionLine INDENT Whens ELSE Block OUTDENT',
-      function() {
-        return new Switch($2,
-      $4,
-      LOC(5,
-      6)($6));
-      }),
-      o('SWITCH INDENT Whens OUTDENT',
-      function() {
-        return new Switch(null,
-      $3);
-      }),
-      o('SWITCH INDENT Whens ELSE Block OUTDENT',
-      function() {
-        return new Switch(null,
-      $3,
-      LOC(4,
-      5)($5));
-      })
-    ],
-    Whens: [
-      o('When',
-      function() {
-        return [$1];
-      }),
-      o('Whens When',
-      function() {
-        return $1.concat($2);
-      })
-    ],
-    // An individual **When** clause, with action.
-    When: [
-      o('LEADING_WHEN SimpleArgs Block',
-      function() {
-        return new SwitchWhen($2,
-      $3);
-      }),
-      o('LEADING_WHEN SimpleArgs Block TERMINATOR',
-      function() {
-        return LOC(1,
-      3)(new SwitchWhen($2,
-      $3));
-      })
-    ],
-    // The most basic form of *if* is a condition and an action. The following
-    // if-related rules are broken up along these lines in order to avoid
-    // ambiguity.
-    IfBlock: [
-      o('IF Expression Block',
-      function() {
-        return new If($2,
-      $3,
-      {
-          type: $1
-        });
-      }),
-      o('IfBlock ELSE IF Expression Block',
-      function() {
-        return $1.addElse(LOC(3,
-      5)(new If($4,
-      $5,
-      {
-          type: $3
-        })));
-      })
-    ],
-    // The full complement of *if* expressions, including postfix one-liner
-    // *if* and *unless*.
-    If: [
-      o('IfBlock'),
-      o('IfBlock ELSE Block',
-      function() {
-        return $1.addElse($3);
-      }),
-      o('Statement  POST_IF Expression',
-      function() {
-        return new If($3,
-      LOC(1)(Block.wrap([$1])),
-      {
-          type: $2,
-          postfix: true
-        });
-      }),
-      o('Expression POST_IF Expression',
-      function() {
-        return new If($3,
-      LOC(1)(Block.wrap([$1])),
-      {
-          type: $2,
-          postfix: true
-        });
-      })
-    ],
-    IfBlockLine: [
-      o('IF ExpressionLine Block',
-      function() {
-        return new If($2,
-      $3,
-      {
-          type: $1
-        });
-      }),
-      o('IfBlockLine ELSE IF ExpressionLine Block',
-      function() {
-        return $1.addElse(LOC(3,
-      5)(new If($4,
-      $5,
-      {
-          type: $3
-        })));
-      })
-    ],
-    IfLine: [
-      o('IfBlockLine'),
-      o('IfBlockLine ELSE Block',
-      function() {
-        return $1.addElse($3);
-      }),
-      o('Statement  POST_IF ExpressionLine',
-      function() {
-        return new If($3,
-      LOC(1)(Block.wrap([$1])),
-      {
-          type: $2,
-          postfix: true
-        });
-      }),
-      o('Expression POST_IF ExpressionLine',
-      function() {
-        return new If($3,
-      LOC(1)(Block.wrap([$1])),
-      {
-          type: $2,
-          postfix: true
-        });
-      })
-    ],
-    // Arithmetic and logical operators, working on one or more operands.
-    // Here they are grouped by order of precedence. The actual precedence rules
-    // are defined at the bottom of the page. It would be shorter if we could
-    // combine most of these rules into a single generic *Operand OpSymbol Operand*
-    // -type rule, but in order to make the precedence binding possible, separate
-    // rules are necessary.
-    OperationLine: [
-      o('UNARY ExpressionLine',
-      function() {
-        return new Op($1,
-      $2);
-      }),
-      o('DO ExpressionLine',
-      function() {
-        return new Op($1,
-      $2);
-      }),
-      o('DO_IIFE CodeLine',
-      function() {
-        return new Op($1,
-      $2);
-      })
-    ],
-    Operation: [
-      o('UNARY Expression',
-      function() {
-        return new Op($1.toString(),
-      $2,
-      void 0,
-      void 0,
-      {
-          originalOperator: $1.original
-        });
-      }),
-      o('DO Expression',
-      function() {
-        return new Op($1,
-      $2);
-      }),
-      o('UNARY_MATH Expression',
-      function() {
-        return new Op($1,
-      $2);
-      }),
-      o('-     Expression',
-      (function() {
-        return new Op('-',
-      $2);
-      }),
-      {
-        prec: 'UNARY_MATH'
-      }),
-      o('+     Expression',
-      (function() {
-        return new Op('+',
-      $2);
-      }),
-      {
-        prec: 'UNARY_MATH'
-      }),
-      o('AWAIT Expression',
-      function() {
-        return new Op($1,
-      $2);
-      }),
-      o('AWAIT INDENT Object OUTDENT',
-      function() {
-        return new Op($1,
-      $3);
-      }),
-      o('-- SimpleAssignable',
-      function() {
-        return new Op('--',
-      $2);
-      }),
-      o('++ SimpleAssignable',
-      function() {
-        return new Op('++',
-      $2);
-      }),
-      o('SimpleAssignable --',
-      function() {
-        return new Op('--',
-      $1,
-      null,
-      true);
-      }),
-      o('SimpleAssignable ++',
-      function() {
-        return new Op('++',
-      $1,
-      null,
-      true);
-      }),
-      // [The existential operator](https://coffeescript.org/#existential-operator).
-      o('Expression ?',
-      function() {
-        return new Existence($1);
-      }),
-      o('Expression +  Expression',
-      function() {
-        return new Op('+',
-      $1,
-      $3);
-      }),
-      o('Expression -  Expression',
-      function() {
-        return new Op('-',
-      $1,
-      $3);
-      }),
-      o('Expression MATH     Expression',
-      function() {
-        return new Op($2,
-      $1,
-      $3);
-      }),
-      o('Expression **       Expression',
-      function() {
-        return new Op($2,
-      $1,
-      $3);
-      }),
-      o('Expression SHIFT    Expression',
-      function() {
-        return new Op($2,
-      $1,
-      $3);
-      }),
-      o('Expression COMPARE  Expression',
-      function() {
-        return new Op($2.toString(),
-      $1,
-      $3,
-      void 0,
-      {
-          originalOperator: $2.original
-        });
-      }),
-      o('Expression &        Expression',
-      function() {
-        return new Op($2,
-      $1,
-      $3);
-      }),
-      o('Expression ^        Expression',
-      function() {
-        return new Op($2,
-      $1,
-      $3);
-      }),
-      o('Expression |        Expression',
-      function() {
-        return new Op($2,
-      $1,
-      $3);
-      }),
-      o('Expression &&       Expression',
-      function() {
-        return new Op($2.toString(),
-      $1,
-      $3,
-      void 0,
-      {
-          originalOperator: $2.original
-        });
-      }),
-      o('Expression ||       Expression',
-      function() {
-        return new Op($2.toString(),
-      $1,
-      $3,
-      void 0,
-      {
-          originalOperator: $2.original
-        });
-      }),
-      o('Expression BIN?     Expression',
-      function() {
-        return new Op($2,
-      $1,
-      $3);
-      }),
-      o('Expression RELATION Expression',
-      function() {
-        var ref,
-      ref1;
-        return new Op($2.toString(),
-      $1,
-      $3,
-      void 0,
-      {
-          invertOperator: (ref = (ref1 = $2.invert) != null ? ref1.original : void 0) != null ? ref : $2.invert
-        });
-      }),
-      o('SimpleAssignable COMPOUND_ASSIGN Expression',
-      function() {
-        return new Assign($1,
-      $3,
-      $2.toString(),
-      {
-          originalContext: $2.original
-        });
-      }),
-      o('SimpleAssignable COMPOUND_ASSIGN INDENT Expression OUTDENT',
-      function() {
-        return new Assign($1,
-      $4,
-      $2.toString(),
-      {
-          originalContext: $2.original
-        });
-      }),
-      o('SimpleAssignable COMPOUND_ASSIGN TERMINATOR Expression',
-      function() {
-        return new Assign($1,
-      $4,
-      $2.toString(),
-      {
-          originalContext: $2.original
-        });
-      })
-    ],
-    DoIife: [
-      o('DO_IIFE Code',
-      function() {
-        return new Op($1,
-      $2);
-      })
-    ]
-  };
+	// `$1` would be the value of the first `Expression`, `$2` would be the token
+	// for the `UNLESS` terminal, and `$3` would be the value of the second
+	// `Expression`.
+	grammar = {
+		// The **Root** is the top-level node in the syntax tree. Since we parse bottom-up,
+		// all parsing must end here.
+		Root: [
+			o('', function () {
+				return new Root(new Block());
+			}),
+			o('Body', function () {
+				return new Root($1);
+			}),
+		],
+		// Any list of statements and expressions, separated by line breaks or semicolons.
+		Body: [
+			o('Line', function () {
+				return Block.wrap([$1]);
+			}),
+			o('Body TERMINATOR Line', function () {
+				return $1.push($3);
+			}),
+			o('Body TERMINATOR'),
+		],
+		// Block and statements, which make up a line in a body. FuncDirective is a
+		// statement, but not included in Statement because that results in an ambiguous
+		// grammar.
+		Line: [o('Expression'), o('ExpressionLine'), o('Statement'), o('FuncDirective')],
+		FuncDirective: [o('YieldReturn'), o('AwaitReturn')],
+		// Pure statements which cannot be expressions.
+		Statement: [
+			o('Return'),
+			o('STATEMENT', function () {
+				return new StatementLiteral($1);
+			}),
+			o('Import'),
+			o('Export'),
+		],
+		// All the different types of expressions in our language. The basic unit of
+		// CoffeeScript is the **Expression** -- everything that can be an expression
+		// is one. Blocks serve as the building blocks of many other rules, making
+		// them somewhat circular.
+		Expression: [
+			o('Value'),
+			o('Code'),
+			o('Operation'),
+			o('Assign'),
+			o('If'),
+			o('Try'),
+			o('While'),
+			o('For'),
+			o('Switch'),
+			o('Class'),
+			o('Throw'),
+			o('Yield'),
+		],
+		// Expressions which are written in single line and would otherwise require being
+		// wrapped in braces: E.g `a = b if do -> f a is 1`, `if f (a) -> a*2 then ...`,
+		// `for x in do (obj) -> f obj when x > 8 then f x`
+		ExpressionLine: [o('CodeLine'), o('IfLine'), o('OperationLine')],
+		Yield: [
+			o('YIELD', function () {
+				return new Op($1, new Value(new Literal('')));
+			}),
+			o('YIELD Expression', function () {
+				return new Op($1, $2);
+			}),
+			o('YIELD INDENT Object OUTDENT', function () {
+				return new Op($1, $3);
+			}),
+			o('YIELD FROM Expression', function () {
+				return new Op($1.concat($2), $3);
+			}),
+		],
+		// An indented block of expressions. Note that the [Rewriter](rewriter.html)
+		// will convert some postfix forms into blocks for us, by adjusting the
+		// token stream.
+		Block: [
+			o('INDENT OUTDENT', function () {
+				return new Block();
+			}),
+			o('INDENT Body OUTDENT', function () {
+				return $2;
+			}),
+		],
+		Identifier: [
+			o('IDENTIFIER', function () {
+				return new IdentifierLiteral($1);
+			}),
+			o('JSX_TAG', function () {
+				var ref, ref1, ref2, ref3;
+				return new JSXTag($1.toString(), {
+					tagNameLocationData: $1.tagNameToken[2],
+					closingTagOpeningBracketLocationData: (ref = $1.closingTagOpeningBracketToken) != null ? ref[2] : void 0,
+					closingTagSlashLocationData: (ref1 = $1.closingTagSlashToken) != null ? ref1[2] : void 0,
+					closingTagNameLocationData: (ref2 = $1.closingTagNameToken) != null ? ref2[2] : void 0,
+					closingTagClosingBracketLocationData: (ref3 = $1.closingTagClosingBracketToken) != null ? ref3[2] : void 0,
+				});
+			}),
+		],
+		Property: [
+			o('PROPERTY', function () {
+				return new PropertyName($1.toString());
+			}),
+		],
+		// Alphanumerics are separated from the other **Literal** matchers because
+		// they can also serve as keys in object literals.
+		AlphaNumeric: [
+			o('NUMBER', function () {
+				return new NumberLiteral($1.toString(), {
+					parsedValue: $1.parsedValue,
+				});
+			}),
+			o('String'),
+		],
+		String: [
+			o('STRING', function () {
+				return new StringLiteral(
+					$1.slice(1, -1), // strip artificial quotes and unwrap to primitive string
+					{
+						quote: $1.quote,
+						initialChunk: $1.initialChunk,
+						finalChunk: $1.finalChunk,
+						indent: $1.indent,
+						double: $1.double,
+						heregex: $1.heregex,
+					},
+				);
+			}),
+			o('STRING_START Interpolations STRING_END', function () {
+				return new StringWithInterpolations(Block.wrap($2), {
+					quote: $1.quote,
+					startQuote: LOC(1)(new Literal($1.toString())),
+				});
+			}),
+		],
+		Interpolations: [
+			o('InterpolationChunk', function () {
+				return [$1];
+			}),
+			o('Interpolations InterpolationChunk', function () {
+				return $1.concat($2);
+			}),
+		],
+		InterpolationChunk: [
+			o('INTERPOLATION_START Body INTERPOLATION_END', function () {
+				return new Interpolation($2);
+			}),
+			o('INTERPOLATION_START INDENT Body OUTDENT INTERPOLATION_END', function () {
+				return new Interpolation($3);
+			}),
+			o('INTERPOLATION_START INTERPOLATION_END', function () {
+				return new Interpolation();
+			}),
+			o('String', function () {
+				return $1;
+			}),
+		],
+		// The .toString() calls here and elsewhere are to convert `String` objects
+		// back to primitive strings now that we've retrieved stowaway extra properties
+		Regex: [
+			o('REGEX', function () {
+				return new RegexLiteral($1.toString(), {
+					delimiter: $1.delimiter,
+					heregexCommentTokens: $1.heregexCommentTokens,
+				});
+			}),
+			o('REGEX_START Invocation REGEX_END', function () {
+				return new RegexWithInterpolations($2, {
+					heregexCommentTokens: $3.heregexCommentTokens,
+				});
+			}),
+		],
+		// All of our immediate values. Generally these can be passed straight
+		// through and printed to JavaScript.
+		Literal: [
+			o('AlphaNumeric'),
+			o('JS', function () {
+				return new PassthroughLiteral($1.toString(), {
+					here: $1.here,
+					generated: $1.generated,
+				});
+			}),
+			o('Regex'),
+			o('UNDEFINED', function () {
+				return new UndefinedLiteral($1);
+			}),
+			o('NULL', function () {
+				return new NullLiteral($1);
+			}),
+			o('BOOL', function () {
+				return new BooleanLiteral($1.toString(), {
+					originalValue: $1.original,
+				});
+			}),
+			o('INFINITY', function () {
+				return new InfinityLiteral($1.toString(), {
+					originalValue: $1.original,
+				});
+			}),
+			o('NAN', function () {
+				return new NaNLiteral($1);
+			}),
+		],
+		// Assignment of a variable, property, or index to a value.
+		Assign: [
+			o('Assignable = Expression', function () {
+				return new Assign($1, $3);
+			}),
+			o('Assignable = TERMINATOR Expression', function () {
+				return new Assign($1, $4);
+			}),
+			o('Assignable = INDENT Expression OUTDENT', function () {
+				return new Assign($1, $4);
+			}),
+		],
+		// Assignment when it happens within an object literal. The difference from
+		// the ordinary **Assign** is that these allow numbers and strings as keys.
+		AssignObj: [
+			o('ObjAssignable', function () {
+				return new Value($1);
+			}),
+			o('ObjRestValue'),
+			o('ObjAssignable : Expression', function () {
+				return new Assign(LOC(1)(new Value($1)), $3, 'object', {
+					operatorToken: LOC(2)(new Literal($2)),
+				});
+			}),
+			o('ObjAssignable : INDENT Expression OUTDENT', function () {
+				return new Assign(LOC(1)(new Value($1)), $4, 'object', {
+					operatorToken: LOC(2)(new Literal($2)),
+				});
+			}),
+			o('SimpleObjAssignable = Expression', function () {
+				return new Assign(LOC(1)(new Value($1)), $3, null, {
+					operatorToken: LOC(2)(new Literal($2)),
+				});
+			}),
+			o('SimpleObjAssignable = INDENT Expression OUTDENT', function () {
+				return new Assign(LOC(1)(new Value($1)), $4, null, {
+					operatorToken: LOC(2)(new Literal($2)),
+				});
+			}),
+		],
+		SimpleObjAssignable: [o('Identifier'), o('Property'), o('ThisProperty')],
+		ObjAssignable: [
+			o('SimpleObjAssignable'),
+			o('[ Expression ]', function () {
+				return new Value(new ComputedPropertyName($2));
+			}),
+			o('@ [ Expression ]', function () {
+				return new Value(LOC(1)(new ThisLiteral($1)), [LOC(3)(new ComputedPropertyName($3))], 'this');
+			}),
+			o('AlphaNumeric'),
+		],
+		// Object literal spread properties.
+		ObjRestValue: [
+			o('SimpleObjAssignable ...', function () {
+				return new Splat(new Value($1));
+			}),
+			o('... SimpleObjAssignable', function () {
+				return new Splat(new Value($2), {
+					postfix: false,
+				});
+			}),
+			o('ObjSpreadExpr ...', function () {
+				return new Splat($1);
+			}),
+			o('... ObjSpreadExpr', function () {
+				return new Splat($2, {
+					postfix: false,
+				});
+			}),
+		],
+		ObjSpreadExpr: [
+			o('ObjSpreadIdentifier'),
+			o('Object'),
+			o('Parenthetical'),
+			o('Super'),
+			o('This'),
+			o('SUPER OptFuncExist Arguments', function () {
+				return new SuperCall(LOC(1)(new Super()), $3, $2.soak, $1);
+			}),
+			o('DYNAMIC_IMPORT Arguments', function () {
+				return new DynamicImportCall(LOC(1)(new DynamicImport()), $2);
+			}),
+			o('SimpleObjAssignable OptFuncExist Arguments', function () {
+				return new Call(new Value($1), $3, $2.soak);
+			}),
+			o('ObjSpreadExpr OptFuncExist Arguments', function () {
+				return new Call($1, $3, $2.soak);
+			}),
+		],
+		ObjSpreadIdentifier: [
+			o('SimpleObjAssignable Accessor', function () {
+				return new Value($1).add($2);
+			}),
+			o('ObjSpreadExpr Accessor', function () {
+				return new Value($1).add($2);
+			}),
+		],
+		// A return statement from a function body.
+		Return: [
+			o('RETURN Expression', function () {
+				return new Return($2);
+			}),
+			o('RETURN INDENT Object OUTDENT', function () {
+				return new Return(new Value($3));
+			}),
+			o('RETURN', function () {
+				return new Return();
+			}),
+		],
+		YieldReturn: [
+			o('YIELD RETURN Expression', function () {
+				return new YieldReturn($3, {
+					returnKeyword: LOC(2)(new Literal($2)),
+				});
+			}),
+			o('YIELD RETURN', function () {
+				return new YieldReturn(null, {
+					returnKeyword: LOC(2)(new Literal($2)),
+				});
+			}),
+		],
+		AwaitReturn: [
+			o('AWAIT RETURN Expression', function () {
+				return new AwaitReturn($3, {
+					returnKeyword: LOC(2)(new Literal($2)),
+				});
+			}),
+			o('AWAIT RETURN', function () {
+				return new AwaitReturn(null, {
+					returnKeyword: LOC(2)(new Literal($2)),
+				});
+			}),
+		],
+		// The **Code** node is the function literal. It’s defined by an indented block
+		// of **Block** preceded by a function arrow, with an optional parameter list.
+		Code: [
+			o('PARAM_START ParamList PARAM_END FuncGlyph Block', function () {
+				return new Code($2, $5, $4, LOC(1)(new Literal($1)));
+			}),
+			o('FuncGlyph Block', function () {
+				return new Code([], $2, $1);
+			}),
+		],
+		// The Codeline is the **Code** node with **Line** instead of indented **Block**.
+		CodeLine: [
+			o('PARAM_START ParamList PARAM_END FuncGlyph Line', function () {
+				return new Code($2, LOC(5)(Block.wrap([$5])), $4, LOC(1)(new Literal($1)));
+			}),
+			o('FuncGlyph Line', function () {
+				return new Code([], LOC(2)(Block.wrap([$2])), $1);
+			}),
+		],
+		// CoffeeScript has two different symbols for functions. `->` is for ordinary
+		// functions, and `=>` is for functions bound to the current value of *this*.
+		FuncGlyph: [
+			o('->', function () {
+				return new FuncGlyph($1);
+			}),
+			o('=>', function () {
+				return new FuncGlyph($1);
+			}),
+		],
+		// An optional, trailing comma.
+		OptComma: [o(''), o(',')],
+		// The list of parameters that a function accepts can be of any length.
+		ParamList: [
+			o('', function () {
+				return [];
+			}),
+			o('Param', function () {
+				return [$1];
+			}),
+			o('ParamList , Param', function () {
+				return $1.concat($3);
+			}),
+			o('ParamList OptComma TERMINATOR Param', function () {
+				return $1.concat($4);
+			}),
+			o('ParamList OptComma INDENT ParamList OptComma OUTDENT', function () {
+				return $1.concat($4);
+			}),
+		],
+		// A single parameter in a function definition can be ordinary, or a splat
+		// that hoovers up the remaining arguments.
+		Param: [
+			o('ParamVar', function () {
+				return new Param($1);
+			}),
+			o('ParamVar ...', function () {
+				return new Param($1, null, true);
+			}),
+			o('... ParamVar', function () {
+				return new Param($2, null, {
+					postfix: false,
+				});
+			}),
+			o('ParamVar = Expression', function () {
+				return new Param($1, $3);
+			}),
+			o('...', function () {
+				return new Expansion();
+			}),
+		],
+		// Function Parameters
+		ParamVar: [o('Identifier'), o('ThisProperty'), o('Array'), o('Object')],
+		// A splat that occurs outside of a parameter list.
+		Splat: [
+			o('Expression ...', function () {
+				return new Splat($1);
+			}),
+			o('... Expression', function () {
+				return new Splat($2, {
+					postfix: false,
+				});
+			}),
+		],
+		// Variables and properties that can be assigned to.
+		SimpleAssignable: [
+			o('Identifier', function () {
+				return new Value($1);
+			}),
+			o('Value Accessor', function () {
+				return $1.add($2);
+			}),
+			o('Code Accessor', function () {
+				return new Value($1).add($2);
+			}),
+			o('ThisProperty'),
+		],
+		// Everything that can be assigned to.
+		Assignable: [
+			o('SimpleAssignable'),
+			o('Array', function () {
+				return new Value($1);
+			}),
+			o('Object', function () {
+				return new Value($1);
+			}),
+		],
+		// The types of things that can be treated as values -- assigned to, invoked
+		// as functions, indexed into, named as a class, etc.
+		Value: [
+			o('Assignable'),
+			o('Literal', function () {
+				return new Value($1);
+			}),
+			o('Parenthetical', function () {
+				return new Value($1);
+			}),
+			o('Range', function () {
+				return new Value($1);
+			}),
+			o('Invocation', function () {
+				return new Value($1);
+			}),
+			o('DoIife', function () {
+				return new Value($1);
+			}),
+			o('This'),
+			o('Super', function () {
+				return new Value($1);
+			}),
+			o('MetaProperty', function () {
+				return new Value($1);
+			}),
+		],
+		// A `super`-based expression that can be used as a value.
+		Super: [
+			o('SUPER . Property', function () {
+				return new Super(LOC(3)(new Access($3)), LOC(1)(new Literal($1)));
+			}),
+			o('SUPER INDEX_START Expression INDEX_END', function () {
+				return new Super(LOC(3)(new Index($3)), LOC(1)(new Literal($1)));
+			}),
+			o('SUPER INDEX_START INDENT Expression OUTDENT INDEX_END', function () {
+				return new Super(LOC(4)(new Index($4)), LOC(1)(new Literal($1)));
+			}),
+		],
+		// A “meta-property” access e.g. `new.target` or `import.meta`, where
+		// something that looks like a property is referenced on a keyword.
+		MetaProperty: [
+			o('NEW_TARGET . Property', function () {
+				return new MetaProperty(LOC(1)(new IdentifierLiteral($1)), LOC(3)(new Access($3)));
+			}),
+			o('IMPORT_META . Property', function () {
+				return new MetaProperty(LOC(1)(new IdentifierLiteral($1)), LOC(3)(new Access($3)));
+			}),
+		],
+		// The general group of accessors into an object, by property, by prototype
+		// or by array index or slice.
+		Accessor: [
+			o('.  Property', function () {
+				return new Access($2);
+			}),
+			o('?. Property', function () {
+				return new Access($2, {
+					soak: true,
+				});
+			}),
+			o(':: Property', function () {
+				return [
+					LOC(1)(
+						new Access(new PropertyName('prototype'), {
+							shorthand: true,
+						}),
+					),
+					LOC(2)(new Access($2)),
+				];
+			}),
+			o('?:: Property', function () {
+				return [
+					LOC(1)(
+						new Access(new PropertyName('prototype'), {
+							shorthand: true,
+							soak: true,
+						}),
+					),
+					LOC(2)(new Access($2)),
+				];
+			}),
+			o('::', function () {
+				return new Access(new PropertyName('prototype'), {
+					shorthand: true,
+				});
+			}),
+			o('?::', function () {
+				return new Access(new PropertyName('prototype'), {
+					shorthand: true,
+					soak: true,
+				});
+			}),
+			o('Index'),
+		],
+		// Indexing into an object or array using bracket notation.
+		Index: [
+			o('INDEX_START IndexValue INDEX_END', function () {
+				return $2;
+			}),
+			o('INDEX_START INDENT IndexValue OUTDENT INDEX_END', function () {
+				return $3;
+			}),
+			o('INDEX_SOAK  Index', function () {
+				return extend($2, {
+					soak: true,
+				});
+			}),
+		],
+		IndexValue: [
+			o('Expression', function () {
+				return new Index($1);
+			}),
+			o('Slice', function () {
+				return new Slice($1);
+			}),
+		],
+		// In CoffeeScript, an object literal is simply a list of assignments.
+		Object: [
+			o('{ AssignList OptComma }', function () {
+				return new Obj($2, $1.generated);
+			}),
+		],
+		// Assignment of properties within an object literal can be separated by
+		// comma, as in JavaScript, or simply by newline.
+		AssignList: [
+			o('', function () {
+				return [];
+			}),
+			o('AssignObj', function () {
+				return [$1];
+			}),
+			o('AssignList , AssignObj', function () {
+				return $1.concat($3);
+			}),
+			o('AssignList OptComma TERMINATOR AssignObj', function () {
+				return $1.concat($4);
+			}),
+			o('AssignList OptComma INDENT AssignList OptComma OUTDENT', function () {
+				return $1.concat($4);
+			}),
+		],
+		// Class definitions have optional bodies of prototype property assignments,
+		// and optional references to the superclass.
+		Class: [
+			o('CLASS', function () {
+				return new Class();
+			}),
+			o('CLASS Block', function () {
+				return new Class(null, null, $2);
+			}),
+			o('CLASS EXTENDS Expression', function () {
+				return new Class(null, $3);
+			}),
+			o('CLASS EXTENDS Expression Block', function () {
+				return new Class(null, $3, $4);
+			}),
+			o('CLASS SimpleAssignable', function () {
+				return new Class($2);
+			}),
+			o('CLASS SimpleAssignable Block', function () {
+				return new Class($2, null, $3);
+			}),
+			o('CLASS SimpleAssignable EXTENDS Expression', function () {
+				return new Class($2, $4);
+			}),
+			o('CLASS SimpleAssignable EXTENDS Expression Block', function () {
+				return new Class($2, $4, $5);
+			}),
+		],
+		Import: [
+			o('IMPORT String', function () {
+				return new ImportDeclaration(null, $2);
+			}),
+			o('IMPORT String ASSERT Object', function () {
+				return new ImportDeclaration(null, $2, $4);
+			}),
+			o('IMPORT ImportDefaultSpecifier FROM String', function () {
+				return new ImportDeclaration(new ImportClause($2, null), $4);
+			}),
+			o('IMPORT ImportDefaultSpecifier FROM String ASSERT Object', function () {
+				return new ImportDeclaration(new ImportClause($2, null), $4, $6);
+			}),
+			o('IMPORT ImportNamespaceSpecifier FROM String', function () {
+				return new ImportDeclaration(new ImportClause(null, $2), $4);
+			}),
+			o('IMPORT ImportNamespaceSpecifier FROM String ASSERT Object', function () {
+				return new ImportDeclaration(new ImportClause(null, $2), $4, $6);
+			}),
+			o('IMPORT { } FROM String', function () {
+				return new ImportDeclaration(new ImportClause(null, new ImportSpecifierList([])), $5);
+			}),
+			o('IMPORT { } FROM String ASSERT Object', function () {
+				return new ImportDeclaration(new ImportClause(null, new ImportSpecifierList([])), $5, $7);
+			}),
+			o('IMPORT { ImportSpecifierList OptComma } FROM String', function () {
+				return new ImportDeclaration(new ImportClause(null, new ImportSpecifierList($3)), $7);
+			}),
+			o('IMPORT { ImportSpecifierList OptComma } FROM String ASSERT Object', function () {
+				return new ImportDeclaration(new ImportClause(null, new ImportSpecifierList($3)), $7, $9);
+			}),
+			o('IMPORT ImportDefaultSpecifier , ImportNamespaceSpecifier FROM String', function () {
+				return new ImportDeclaration(new ImportClause($2, $4), $6);
+			}),
+			o('IMPORT ImportDefaultSpecifier , ImportNamespaceSpecifier FROM String ASSERT Object', function () {
+				return new ImportDeclaration(new ImportClause($2, $4), $6, $8);
+			}),
+			o('IMPORT ImportDefaultSpecifier , { ImportSpecifierList OptComma } FROM String', function () {
+				return new ImportDeclaration(new ImportClause($2, new ImportSpecifierList($5)), $9);
+			}),
+			o('IMPORT ImportDefaultSpecifier , { ImportSpecifierList OptComma } FROM String ASSERT Object', function () {
+				return new ImportDeclaration(new ImportClause($2, new ImportSpecifierList($5)), $9, $11);
+			}),
+		],
+		ImportSpecifierList: [
+			o('ImportSpecifier', function () {
+				return [$1];
+			}),
+			o('ImportSpecifierList , ImportSpecifier', function () {
+				return $1.concat($3);
+			}),
+			o('ImportSpecifierList OptComma TERMINATOR ImportSpecifier', function () {
+				return $1.concat($4);
+			}),
+			o('INDENT ImportSpecifierList OptComma OUTDENT', function () {
+				return $2;
+			}),
+			o('ImportSpecifierList OptComma INDENT ImportSpecifierList OptComma OUTDENT', function () {
+				return $1.concat($4);
+			}),
+		],
+		ImportSpecifier: [
+			o('Identifier', function () {
+				return new ImportSpecifier($1);
+			}),
+			o('Identifier AS Identifier', function () {
+				return new ImportSpecifier($1, $3);
+			}),
+			o('DEFAULT', function () {
+				return new ImportSpecifier(LOC(1)(new DefaultLiteral($1)));
+			}),
+			o('DEFAULT AS Identifier', function () {
+				return new ImportSpecifier(LOC(1)(new DefaultLiteral($1)), $3);
+			}),
+		],
+		ImportDefaultSpecifier: [
+			o('Identifier', function () {
+				return new ImportDefaultSpecifier($1);
+			}),
+		],
+		ImportNamespaceSpecifier: [
+			o('IMPORT_ALL AS Identifier', function () {
+				return new ImportNamespaceSpecifier(new Literal($1), $3);
+			}),
+		],
+		Export: [
+			o('EXPORT { }', function () {
+				return new ExportNamedDeclaration(new ExportSpecifierList([]));
+			}),
+			o('EXPORT { ExportSpecifierList OptComma }', function () {
+				return new ExportNamedDeclaration(new ExportSpecifierList($3));
+			}),
+			o('EXPORT Class', function () {
+				return new ExportNamedDeclaration($2);
+			}),
+			o('EXPORT Identifier = Expression', function () {
+				return new ExportNamedDeclaration(
+					LOC(
+						2,
+						4,
+					)(
+						new Assign($2, $4, null, {
+							moduleDeclaration: 'export',
+						}),
+					),
+				);
+			}),
+			o('EXPORT Identifier = TERMINATOR Expression', function () {
+				return new ExportNamedDeclaration(
+					LOC(
+						2,
+						5,
+					)(
+						new Assign($2, $5, null, {
+							moduleDeclaration: 'export',
+						}),
+					),
+				);
+			}),
+			o('EXPORT Identifier = INDENT Expression OUTDENT', function () {
+				return new ExportNamedDeclaration(
+					LOC(
+						2,
+						6,
+					)(
+						new Assign($2, $5, null, {
+							moduleDeclaration: 'export',
+						}),
+					),
+				);
+			}),
+			o('EXPORT DEFAULT Expression', function () {
+				return new ExportDefaultDeclaration($3);
+			}),
+			o('EXPORT DEFAULT INDENT Object OUTDENT', function () {
+				return new ExportDefaultDeclaration(new Value($4));
+			}),
+			o('EXPORT EXPORT_ALL FROM String', function () {
+				return new ExportAllDeclaration(new Literal($2), $4);
+			}),
+			o('EXPORT EXPORT_ALL FROM String ASSERT Object', function () {
+				return new ExportAllDeclaration(new Literal($2), $4, $6);
+			}),
+			o('EXPORT { } FROM String', function () {
+				return new ExportNamedDeclaration(new ExportSpecifierList([]), $5);
+			}),
+			o('EXPORT { } FROM String ASSERT Object', function () {
+				return new ExportNamedDeclaration(new ExportSpecifierList([]), $5, $7);
+			}),
+			o('EXPORT { ExportSpecifierList OptComma } FROM String', function () {
+				return new ExportNamedDeclaration(new ExportSpecifierList($3), $7);
+			}),
+			o('EXPORT { ExportSpecifierList OptComma } FROM String ASSERT Object', function () {
+				return new ExportNamedDeclaration(new ExportSpecifierList($3), $7, $9);
+			}),
+		],
+		ExportSpecifierList: [
+			o('ExportSpecifier', function () {
+				return [$1];
+			}),
+			o('ExportSpecifierList , ExportSpecifier', function () {
+				return $1.concat($3);
+			}),
+			o('ExportSpecifierList OptComma TERMINATOR ExportSpecifier', function () {
+				return $1.concat($4);
+			}),
+			o('INDENT ExportSpecifierList OptComma OUTDENT', function () {
+				return $2;
+			}),
+			o('ExportSpecifierList OptComma INDENT ExportSpecifierList OptComma OUTDENT', function () {
+				return $1.concat($4);
+			}),
+		],
+		ExportSpecifier: [
+			o('Identifier', function () {
+				return new ExportSpecifier($1);
+			}),
+			o('Identifier AS Identifier', function () {
+				return new ExportSpecifier($1, $3);
+			}),
+			o('Identifier AS DEFAULT', function () {
+				return new ExportSpecifier($1, LOC(3)(new DefaultLiteral($3)));
+			}),
+			o('DEFAULT', function () {
+				return new ExportSpecifier(LOC(1)(new DefaultLiteral($1)));
+			}),
+			o('DEFAULT AS Identifier', function () {
+				return new ExportSpecifier(LOC(1)(new DefaultLiteral($1)), $3);
+			}),
+		],
+		// Ordinary function invocation, or a chained series of calls.
+		Invocation: [
+			o('Value OptFuncExist String', function () {
+				return new TaggedTemplateCall($1, $3, $2.soak);
+			}),
+			o('Value OptFuncExist Arguments', function () {
+				return new Call($1, $3, $2.soak);
+			}),
+			o('SUPER OptFuncExist Arguments', function () {
+				return new SuperCall(LOC(1)(new Super()), $3, $2.soak, $1);
+			}),
+			o('DYNAMIC_IMPORT Arguments', function () {
+				return new DynamicImportCall(LOC(1)(new DynamicImport()), $2);
+			}),
+		],
+		// An optional existence check on a function.
+		OptFuncExist: [
+			o('', function () {
+				return {
+					soak: false,
+				};
+			}),
+			o('FUNC_EXIST', function () {
+				return {
+					soak: true,
+				};
+			}),
+		],
+		// The list of arguments to a function call.
+		Arguments: [
+			o('CALL_START CALL_END', function () {
+				return [];
+			}),
+			o('CALL_START ArgList OptComma CALL_END', function () {
+				$2.implicit = $1.generated;
+				return $2;
+			}),
+		],
+		// A reference to the *this* current object.
+		This: [
+			o('THIS', function () {
+				return new Value(new ThisLiteral($1));
+			}),
+			o('@', function () {
+				return new Value(new ThisLiteral($1));
+			}),
+		],
+		// A reference to a property on *this*.
+		ThisProperty: [
+			o('@ Property', function () {
+				return new Value(LOC(1)(new ThisLiteral($1)), [LOC(2)(new Access($2))], 'this');
+			}),
+		],
+		// The array literal.
+		Array: [
+			o('[ ]', function () {
+				return new Arr([]);
+			}),
+			o('[ Elisions ]', function () {
+				return new Arr($2);
+			}),
+			o('[ ArgElisionList OptElisions ]', function () {
+				return new Arr([].concat($2, $3));
+			}),
+		],
+		// Inclusive and exclusive range dots.
+		RangeDots: [
+			o('..', function () {
+				return {
+					exclusive: false,
+				};
+			}),
+			o('...', function () {
+				return {
+					exclusive: true,
+				};
+			}),
+		],
+		// The CoffeeScript range literal.
+		Range: [
+			o('[ Expression RangeDots Expression ]', function () {
+				return new Range($2, $4, $3.exclusive ? 'exclusive' : 'inclusive');
+			}),
+			o('[ ExpressionLine RangeDots Expression ]', function () {
+				return new Range($2, $4, $3.exclusive ? 'exclusive' : 'inclusive');
+			}),
+		],
+		// Array slice literals.
+		Slice: [
+			o('Expression RangeDots Expression', function () {
+				return new Range($1, $3, $2.exclusive ? 'exclusive' : 'inclusive');
+			}),
+			o('Expression RangeDots', function () {
+				return new Range($1, null, $2.exclusive ? 'exclusive' : 'inclusive');
+			}),
+			o('ExpressionLine RangeDots Expression', function () {
+				return new Range($1, $3, $2.exclusive ? 'exclusive' : 'inclusive');
+			}),
+			o('ExpressionLine RangeDots', function () {
+				return new Range($1, null, $2.exclusive ? 'exclusive' : 'inclusive');
+			}),
+			o('RangeDots Expression', function () {
+				return new Range(null, $2, $1.exclusive ? 'exclusive' : 'inclusive');
+			}),
+			o('RangeDots', function () {
+				return new Range(null, null, $1.exclusive ? 'exclusive' : 'inclusive');
+			}),
+		],
+		// The **ArgList** is the list of objects passed into a function call
+		// (i.e. comma-separated expressions). Newlines work as well.
+		ArgList: [
+			o('Arg', function () {
+				return [$1];
+			}),
+			o('ArgList , Arg', function () {
+				return $1.concat($3);
+			}),
+			o('ArgList OptComma TERMINATOR Arg', function () {
+				return $1.concat($4);
+			}),
+			o('INDENT ArgList OptComma OUTDENT', function () {
+				return $2;
+			}),
+			o('ArgList OptComma INDENT ArgList OptComma OUTDENT', function () {
+				return $1.concat($4);
+			}),
+		],
+		// Valid arguments are Blocks or Splats.
+		Arg: [
+			o('Expression'),
+			o('ExpressionLine'),
+			o('Splat'),
+			o('...', function () {
+				return new Expansion();
+			}),
+		],
+		// The **ArgElisionList** is the list of objects, contents of an array literal
+		// (i.e. comma-separated expressions and elisions). Newlines work as well.
+		ArgElisionList: [
+			o('ArgElision'),
+			o('ArgElisionList , ArgElision', function () {
+				return $1.concat($3);
+			}),
+			o('ArgElisionList OptComma TERMINATOR ArgElision', function () {
+				return $1.concat($4);
+			}),
+			o('INDENT ArgElisionList OptElisions OUTDENT', function () {
+				return $2.concat($3);
+			}),
+			o('ArgElisionList OptElisions INDENT ArgElisionList OptElisions OUTDENT', function () {
+				return $1.concat($2, $4, $5);
+			}),
+		],
+		ArgElision: [
+			o('Arg', function () {
+				return [$1];
+			}),
+			o('Elisions Arg', function () {
+				return $1.concat($2);
+			}),
+		],
+		OptElisions: [
+			o('OptComma', function () {
+				return [];
+			}),
+			o(', Elisions', function () {
+				return [].concat($2);
+			}),
+		],
+		Elisions: [
+			o('Elision', function () {
+				return [$1];
+			}),
+			o('Elisions Elision', function () {
+				return $1.concat($2);
+			}),
+		],
+		Elision: [
+			o(',', function () {
+				return new Elision();
+			}),
+			o('Elision TERMINATOR', function () {
+				return $1;
+			}),
+		],
+		// Just simple, comma-separated, required arguments (no fancy syntax). We need
+		// this to be separate from the **ArgList** for use in **Switch** blocks, where
+		// having the newlines wouldn't make sense.
+		SimpleArgs: [
+			o('Expression'),
+			o('ExpressionLine'),
+			o('SimpleArgs , Expression', function () {
+				return [].concat($1, $3);
+			}),
+			o('SimpleArgs , ExpressionLine', function () {
+				return [].concat($1, $3);
+			}),
+		],
+		// The variants of *try/catch/finally* exception handling blocks.
+		Try: [
+			o('TRY Block', function () {
+				return new Try($2);
+			}),
+			o('TRY Block Catch', function () {
+				return new Try($2, $3);
+			}),
+			o('TRY Block FINALLY Block', function () {
+				return new Try($2, null, $4, LOC(3)(new Literal($3)));
+			}),
+			o('TRY Block Catch FINALLY Block', function () {
+				return new Try($2, $3, $5, LOC(4)(new Literal($4)));
+			}),
+		],
+		// A catch clause names its error and runs a block of code.
+		Catch: [
+			o('CATCH Identifier Block', function () {
+				return new Catch($3, $2);
+			}),
+			o('CATCH Object Block', function () {
+				return new Catch($3, LOC(2)(new Value($2)));
+			}),
+			o('CATCH Block', function () {
+				return new Catch($2);
+			}),
+		],
+		// Throw an exception object.
+		Throw: [
+			o('THROW Expression', function () {
+				return new Throw($2);
+			}),
+			o('THROW INDENT Object OUTDENT', function () {
+				return new Throw(new Value($3));
+			}),
+		],
+		// Parenthetical expressions. Note that the **Parenthetical** is a **Value**,
+		// not an **Expression**, so if you need to use an expression in a place
+		// where only values are accepted, wrapping it in parentheses will always do
+		// the trick.
+		Parenthetical: [
+			o('( Body )', function () {
+				return new Parens($2);
+			}),
+			o('( INDENT Body OUTDENT )', function () {
+				return new Parens($3);
+			}),
+		],
+		// The condition portion of a while loop.
+		WhileLineSource: [
+			o('WHILE ExpressionLine', function () {
+				return new While($2);
+			}),
+			o('WHILE ExpressionLine WHEN ExpressionLine', function () {
+				return new While($2, {
+					guard: $4,
+				});
+			}),
+			o('UNTIL ExpressionLine', function () {
+				return new While($2, {
+					invert: true,
+				});
+			}),
+			o('UNTIL ExpressionLine WHEN ExpressionLine', function () {
+				return new While($2, {
+					invert: true,
+					guard: $4,
+				});
+			}),
+		],
+		WhileSource: [
+			o('WHILE Expression', function () {
+				return new While($2);
+			}),
+			o('WHILE Expression WHEN Expression', function () {
+				return new While($2, {
+					guard: $4,
+				});
+			}),
+			o('WHILE ExpressionLine WHEN Expression', function () {
+				return new While($2, {
+					guard: $4,
+				});
+			}),
+			o('UNTIL Expression', function () {
+				return new While($2, {
+					invert: true,
+				});
+			}),
+			o('UNTIL Expression WHEN Expression', function () {
+				return new While($2, {
+					invert: true,
+					guard: $4,
+				});
+			}),
+			o('UNTIL ExpressionLine WHEN Expression', function () {
+				return new While($2, {
+					invert: true,
+					guard: $4,
+				});
+			}),
+		],
+		// The while loop can either be normal, with a block of expressions to execute,
+		// or postfix, with a single expression. There is no do..while.
+		While: [
+			o('WhileSource Block', function () {
+				return $1.addBody($2);
+			}),
+			o('WhileLineSource Block', function () {
+				return $1.addBody($2);
+			}),
+			o('Statement  WhileSource', function () {
+				return Object.assign($2, {
+					postfix: true,
+				}).addBody(LOC(1)(Block.wrap([$1])));
+			}),
+			o('Expression WhileSource', function () {
+				return Object.assign($2, {
+					postfix: true,
+				}).addBody(LOC(1)(Block.wrap([$1])));
+			}),
+			o('Loop', function () {
+				return $1;
+			}),
+		],
+		Loop: [
+			o('LOOP Block', function () {
+				return new While(LOC(1)(new BooleanLiteral('true')), {
+					isLoop: true,
+				}).addBody($2);
+			}),
+			o('LOOP Expression', function () {
+				return new While(LOC(1)(new BooleanLiteral('true')), {
+					isLoop: true,
+				}).addBody(LOC(2)(Block.wrap([$2])));
+			}),
+		],
+		// Array, object, and range comprehensions, at the most generic level.
+		// Comprehensions can either be normal, with a block of expressions to execute,
+		// or postfix, with a single expression.
+		For: [
+			o('Statement    ForBody', function () {
+				$2.postfix = true;
+				return $2.addBody($1);
+			}),
+			o('Expression   ForBody', function () {
+				$2.postfix = true;
+				return $2.addBody($1);
+			}),
+			o('ForBody      Block', function () {
+				return $1.addBody($2);
+			}),
+			o('ForLineBody  Block', function () {
+				return $1.addBody($2);
+			}),
+		],
+		ForBody: [
+			o('FOR Range', function () {
+				return new For([], {
+					source: LOC(2)(new Value($2)),
+				});
+			}),
+			o('FOR Range BY Expression', function () {
+				return new For([], {
+					source: LOC(2)(new Value($2)),
+					step: $4,
+				});
+			}),
+			o('ForStart ForSource', function () {
+				return $1.addSource($2);
+			}),
+		],
+		ForLineBody: [
+			o('FOR Range BY ExpressionLine', function () {
+				return new For([], {
+					source: LOC(2)(new Value($2)),
+					step: $4,
+				});
+			}),
+			o('ForStart ForLineSource', function () {
+				return $1.addSource($2);
+			}),
+		],
+		ForStart: [
+			o('FOR ForVariables', function () {
+				return new For([], {
+					name: $2[0],
+					index: $2[1],
+				});
+			}),
+			o('FOR AWAIT ForVariables', function () {
+				var index, name;
+				[name, index] = $3;
+				return new For([], {
+					name,
+					index,
+					await: true,
+					awaitTag: LOC(2)(new Literal($2)),
+				});
+			}),
+			o('FOR OWN ForVariables', function () {
+				var index, name;
+				[name, index] = $3;
+				return new For([], {
+					name,
+					index,
+					own: true,
+					ownTag: LOC(2)(new Literal($2)),
+				});
+			}),
+		],
+		// An array of all accepted values for a variable inside the loop.
+		// This enables support for pattern matching.
+		ForValue: [
+			o('Identifier'),
+			o('ThisProperty'),
+			o('Array', function () {
+				return new Value($1);
+			}),
+			o('Object', function () {
+				return new Value($1);
+			}),
+		],
+		// An array or range comprehension has variables for the current element
+		// and (optional) reference to the current index. Or, *key, value*, in the case
+		// of object comprehensions.
+		ForVariables: [
+			o('ForValue', function () {
+				return [$1];
+			}),
+			o('ForValue , ForValue', function () {
+				return [$1, $3];
+			}),
+		],
+		// The source of a comprehension is an array or object with an optional guard
+		// clause. If it’s an array comprehension, you can also choose to step through
+		// in fixed-size increments.
+		ForSource: [
+			o('FORIN Expression', function () {
+				return {
+					source: $2,
+				};
+			}),
+			o('FOROF Expression', function () {
+				return {
+					source: $2,
+					object: true,
+				};
+			}),
+			o('FORIN Expression WHEN Expression', function () {
+				return {
+					source: $2,
+					guard: $4,
+				};
+			}),
+			o('FORIN ExpressionLine WHEN Expression', function () {
+				return {
+					source: $2,
+					guard: $4,
+				};
+			}),
+			o('FOROF Expression WHEN Expression', function () {
+				return {
+					source: $2,
+					guard: $4,
+					object: true,
+				};
+			}),
+			o('FOROF ExpressionLine WHEN Expression', function () {
+				return {
+					source: $2,
+					guard: $4,
+					object: true,
+				};
+			}),
+			o('FORIN Expression BY Expression', function () {
+				return {
+					source: $2,
+					step: $4,
+				};
+			}),
+			o('FORIN ExpressionLine BY Expression', function () {
+				return {
+					source: $2,
+					step: $4,
+				};
+			}),
+			o('FORIN Expression WHEN Expression BY Expression', function () {
+				return {
+					source: $2,
+					guard: $4,
+					step: $6,
+				};
+			}),
+			o('FORIN ExpressionLine WHEN Expression BY Expression', function () {
+				return {
+					source: $2,
+					guard: $4,
+					step: $6,
+				};
+			}),
+			o('FORIN Expression WHEN ExpressionLine BY Expression', function () {
+				return {
+					source: $2,
+					guard: $4,
+					step: $6,
+				};
+			}),
+			o('FORIN ExpressionLine WHEN ExpressionLine BY Expression', function () {
+				return {
+					source: $2,
+					guard: $4,
+					step: $6,
+				};
+			}),
+			o('FORIN Expression BY Expression WHEN Expression', function () {
+				return {
+					source: $2,
+					step: $4,
+					guard: $6,
+				};
+			}),
+			o('FORIN ExpressionLine BY Expression WHEN Expression', function () {
+				return {
+					source: $2,
+					step: $4,
+					guard: $6,
+				};
+			}),
+			o('FORIN Expression BY ExpressionLine WHEN Expression', function () {
+				return {
+					source: $2,
+					step: $4,
+					guard: $6,
+				};
+			}),
+			o('FORIN ExpressionLine BY ExpressionLine WHEN Expression', function () {
+				return {
+					source: $2,
+					step: $4,
+					guard: $6,
+				};
+			}),
+			o('FORFROM Expression', function () {
+				return {
+					source: $2,
+					from: true,
+				};
+			}),
+			o('FORFROM Expression WHEN Expression', function () {
+				return {
+					source: $2,
+					guard: $4,
+					from: true,
+				};
+			}),
+			o('FORFROM ExpressionLine WHEN Expression', function () {
+				return {
+					source: $2,
+					guard: $4,
+					from: true,
+				};
+			}),
+		],
+		ForLineSource: [
+			o('FORIN ExpressionLine', function () {
+				return {
+					source: $2,
+				};
+			}),
+			o('FOROF ExpressionLine', function () {
+				return {
+					source: $2,
+					object: true,
+				};
+			}),
+			o('FORIN Expression WHEN ExpressionLine', function () {
+				return {
+					source: $2,
+					guard: $4,
+				};
+			}),
+			o('FORIN ExpressionLine WHEN ExpressionLine', function () {
+				return {
+					source: $2,
+					guard: $4,
+				};
+			}),
+			o('FOROF Expression WHEN ExpressionLine', function () {
+				return {
+					source: $2,
+					guard: $4,
+					object: true,
+				};
+			}),
+			o('FOROF ExpressionLine WHEN ExpressionLine', function () {
+				return {
+					source: $2,
+					guard: $4,
+					object: true,
+				};
+			}),
+			o('FORIN Expression BY ExpressionLine', function () {
+				return {
+					source: $2,
+					step: $4,
+				};
+			}),
+			o('FORIN ExpressionLine BY ExpressionLine', function () {
+				return {
+					source: $2,
+					step: $4,
+				};
+			}),
+			o('FORIN Expression WHEN Expression BY ExpressionLine', function () {
+				return {
+					source: $2,
+					guard: $4,
+					step: $6,
+				};
+			}),
+			o('FORIN ExpressionLine WHEN Expression BY ExpressionLine', function () {
+				return {
+					source: $2,
+					guard: $4,
+					step: $6,
+				};
+			}),
+			o('FORIN Expression WHEN ExpressionLine BY ExpressionLine', function () {
+				return {
+					source: $2,
+					guard: $4,
+					step: $6,
+				};
+			}),
+			o('FORIN ExpressionLine WHEN ExpressionLine BY ExpressionLine', function () {
+				return {
+					source: $2,
+					guard: $4,
+					step: $6,
+				};
+			}),
+			o('FORIN Expression BY Expression WHEN ExpressionLine', function () {
+				return {
+					source: $2,
+					step: $4,
+					guard: $6,
+				};
+			}),
+			o('FORIN ExpressionLine BY Expression WHEN ExpressionLine', function () {
+				return {
+					source: $2,
+					step: $4,
+					guard: $6,
+				};
+			}),
+			o('FORIN Expression BY ExpressionLine WHEN ExpressionLine', function () {
+				return {
+					source: $2,
+					step: $4,
+					guard: $6,
+				};
+			}),
+			o('FORIN ExpressionLine BY ExpressionLine WHEN ExpressionLine', function () {
+				return {
+					source: $2,
+					step: $4,
+					guard: $6,
+				};
+			}),
+			o('FORFROM ExpressionLine', function () {
+				return {
+					source: $2,
+					from: true,
+				};
+			}),
+			o('FORFROM Expression WHEN ExpressionLine', function () {
+				return {
+					source: $2,
+					guard: $4,
+					from: true,
+				};
+			}),
+			o('FORFROM ExpressionLine WHEN ExpressionLine', function () {
+				return {
+					source: $2,
+					guard: $4,
+					from: true,
+				};
+			}),
+		],
+		Switch: [
+			o('SWITCH Expression INDENT Whens OUTDENT', function () {
+				return new Switch($2, $4);
+			}),
+			o('SWITCH ExpressionLine INDENT Whens OUTDENT', function () {
+				return new Switch($2, $4);
+			}),
+			o('SWITCH Expression INDENT Whens ELSE Block OUTDENT', function () {
+				return new Switch($2, $4, LOC(5, 6)($6));
+			}),
+			o('SWITCH ExpressionLine INDENT Whens ELSE Block OUTDENT', function () {
+				return new Switch($2, $4, LOC(5, 6)($6));
+			}),
+			o('SWITCH INDENT Whens OUTDENT', function () {
+				return new Switch(null, $3);
+			}),
+			o('SWITCH INDENT Whens ELSE Block OUTDENT', function () {
+				return new Switch(null, $3, LOC(4, 5)($5));
+			}),
+		],
+		Whens: [
+			o('When', function () {
+				return [$1];
+			}),
+			o('Whens When', function () {
+				return $1.concat($2);
+			}),
+		],
+		// An individual **When** clause, with action.
+		When: [
+			o('LEADING_WHEN SimpleArgs Block', function () {
+				return new SwitchWhen($2, $3);
+			}),
+			o('LEADING_WHEN SimpleArgs Block TERMINATOR', function () {
+				return LOC(1, 3)(new SwitchWhen($2, $3));
+			}),
+		],
+		// The most basic form of *if* is a condition and an action. The following
+		// if-related rules are broken up along these lines in order to avoid
+		// ambiguity.
+		IfBlock: [
+			o('IF Expression Block', function () {
+				return new If($2, $3, {
+					type: $1,
+				});
+			}),
+			o('IfBlock ELSE IF Expression Block', function () {
+				return $1.addElse(
+					LOC(
+						3,
+						5,
+					)(
+						new If($4, $5, {
+							type: $3,
+						}),
+					),
+				);
+			}),
+		],
+		// The full complement of *if* expressions, including postfix one-liner
+		// *if* and *unless*.
+		If: [
+			o('IfBlock'),
+			o('IfBlock ELSE Block', function () {
+				return $1.addElse($3);
+			}),
+			o('Statement  POST_IF Expression', function () {
+				return new If($3, LOC(1)(Block.wrap([$1])), {
+					type: $2,
+					postfix: true,
+				});
+			}),
+			o('Expression POST_IF Expression', function () {
+				return new If($3, LOC(1)(Block.wrap([$1])), {
+					type: $2,
+					postfix: true,
+				});
+			}),
+		],
+		IfBlockLine: [
+			o('IF ExpressionLine Block', function () {
+				return new If($2, $3, {
+					type: $1,
+				});
+			}),
+			o('IfBlockLine ELSE IF ExpressionLine Block', function () {
+				return $1.addElse(
+					LOC(
+						3,
+						5,
+					)(
+						new If($4, $5, {
+							type: $3,
+						}),
+					),
+				);
+			}),
+		],
+		IfLine: [
+			o('IfBlockLine'),
+			o('IfBlockLine ELSE Block', function () {
+				return $1.addElse($3);
+			}),
+			o('Statement  POST_IF ExpressionLine', function () {
+				return new If($3, LOC(1)(Block.wrap([$1])), {
+					type: $2,
+					postfix: true,
+				});
+			}),
+			o('Expression POST_IF ExpressionLine', function () {
+				return new If($3, LOC(1)(Block.wrap([$1])), {
+					type: $2,
+					postfix: true,
+				});
+			}),
+		],
+		// Arithmetic and logical operators, working on one or more operands.
+		// Here they are grouped by order of precedence. The actual precedence rules
+		// are defined at the bottom of the page. It would be shorter if we could
+		// combine most of these rules into a single generic *Operand OpSymbol Operand*
+		// -type rule, but in order to make the precedence binding possible, separate
+		// rules are necessary.
+		OperationLine: [
+			o('UNARY ExpressionLine', function () {
+				return new Op($1, $2);
+			}),
+			o('DO ExpressionLine', function () {
+				return new Op($1, $2);
+			}),
+			o('DO_IIFE CodeLine', function () {
+				return new Op($1, $2);
+			}),
+		],
+		Operation: [
+			o('UNARY Expression', function () {
+				return new Op($1.toString(), $2, void 0, void 0, {
+					originalOperator: $1.original,
+				});
+			}),
+			o('DO Expression', function () {
+				return new Op($1, $2);
+			}),
+			o('UNARY_MATH Expression', function () {
+				return new Op($1, $2);
+			}),
+			o(
+				'-     Expression',
+				function () {
+					return new Op('-', $2);
+				},
+				{
+					prec: 'UNARY_MATH',
+				},
+			),
+			o(
+				'+     Expression',
+				function () {
+					return new Op('+', $2);
+				},
+				{
+					prec: 'UNARY_MATH',
+				},
+			),
+			o('AWAIT Expression', function () {
+				return new Op($1, $2);
+			}),
+			o('AWAIT INDENT Object OUTDENT', function () {
+				return new Op($1, $3);
+			}),
+			o('-- SimpleAssignable', function () {
+				return new Op('--', $2);
+			}),
+			o('++ SimpleAssignable', function () {
+				return new Op('++', $2);
+			}),
+			o('SimpleAssignable --', function () {
+				return new Op('--', $1, null, true);
+			}),
+			o('SimpleAssignable ++', function () {
+				return new Op('++', $1, null, true);
+			}),
+			// [The existential operator](https://coffeescript.org/#existential-operator).
+			o('Expression ?', function () {
+				return new Existence($1);
+			}),
+			o('Expression +  Expression', function () {
+				return new Op('+', $1, $3);
+			}),
+			o('Expression -  Expression', function () {
+				return new Op('-', $1, $3);
+			}),
+			o('Expression MATH     Expression', function () {
+				return new Op($2, $1, $3);
+			}),
+			o('Expression **       Expression', function () {
+				return new Op($2, $1, $3);
+			}),
+			o('Expression SHIFT    Expression', function () {
+				return new Op($2, $1, $3);
+			}),
+			o('Expression COMPARE  Expression', function () {
+				return new Op($2.toString(), $1, $3, void 0, {
+					originalOperator: $2.original,
+				});
+			}),
+			o('Expression &        Expression', function () {
+				return new Op($2, $1, $3);
+			}),
+			o('Expression ^        Expression', function () {
+				return new Op($2, $1, $3);
+			}),
+			o('Expression |        Expression', function () {
+				return new Op($2, $1, $3);
+			}),
+			o('Expression &&       Expression', function () {
+				return new Op($2.toString(), $1, $3, void 0, {
+					originalOperator: $2.original,
+				});
+			}),
+			o('Expression ||       Expression', function () {
+				return new Op($2.toString(), $1, $3, void 0, {
+					originalOperator: $2.original,
+				});
+			}),
+			o('Expression BIN?     Expression', function () {
+				return new Op($2, $1, $3);
+			}),
+			o('Expression RELATION Expression', function () {
+				var ref, ref1;
+				return new Op($2.toString(), $1, $3, void 0, {
+					invertOperator: (ref = (ref1 = $2.invert) != null ? ref1.original : void 0) != null ? ref : $2.invert,
+				});
+			}),
+			o('SimpleAssignable COMPOUND_ASSIGN Expression', function () {
+				return new Assign($1, $3, $2.toString(), {
+					originalContext: $2.original,
+				});
+			}),
+			o('SimpleAssignable COMPOUND_ASSIGN INDENT Expression OUTDENT', function () {
+				return new Assign($1, $4, $2.toString(), {
+					originalContext: $2.original,
+				});
+			}),
+			o('SimpleAssignable COMPOUND_ASSIGN TERMINATOR Expression', function () {
+				return new Assign($1, $4, $2.toString(), {
+					originalContext: $2.original,
+				});
+			}),
+		],
+		DoIife: [
+			o('DO_IIFE Code', function () {
+				return new Op($1, $2);
+			}),
+		],
+	};
 
-  // Precedence
-  // ----------
+	// Precedence
+	// ----------
 
-  // Operators at the top of this list have higher precedence than the ones lower
-  // down. Following these rules is what makes `2 + 3 * 4` parse as:
+	// Operators at the top of this list have higher precedence than the ones lower
+	// down. Following these rules is what makes `2 + 3 * 4` parse as:
 
-  //     2 + (3 * 4)
+	//     2 + (3 * 4)
 
-  // And not:
+	// And not:
 
-  //     (2 + 3) * 4
-  operators = [['right', 'DO_IIFE'], ['left', '.', '?.', '::', '?::'], ['left', 'CALL_START', 'CALL_END'], ['nonassoc', '++', '--'], ['left', '?'], ['right', 'UNARY', 'DO'], ['right', 'AWAIT'], ['right', '**'], ['right', 'UNARY_MATH'], ['left', 'MATH'], ['left', '+', '-'], ['left', 'SHIFT'], ['left', 'RELATION'], ['left', 'COMPARE'], ['left', '&'], ['left', '^'], ['left', '|'], ['left', '&&'], ['left', '||'], ['left', 'BIN?'], ['nonassoc', 'INDENT', 'OUTDENT'], ['right', 'YIELD'], ['right', '=', ':', 'COMPOUND_ASSIGN', 'RETURN', 'THROW', 'EXTENDS'], ['right', 'FORIN', 'FOROF', 'FORFROM', 'BY', 'WHEN'], ['right', 'IF', 'ELSE', 'FOR', 'WHILE', 'UNTIL', 'LOOP', 'SUPER', 'CLASS', 'IMPORT', 'EXPORT', 'DYNAMIC_IMPORT'], ['left', 'POST_IF']];
+	//     (2 + 3) * 4
+	operators = [
+		['right', 'DO_IIFE'],
+		['left', '.', '?.', '::', '?::'],
+		['left', 'CALL_START', 'CALL_END'],
+		['nonassoc', '++', '--'],
+		['left', '?'],
+		['right', 'UNARY', 'DO'],
+		['right', 'AWAIT'],
+		['right', '**'],
+		['right', 'UNARY_MATH'],
+		['left', 'MATH'],
+		['left', '+', '-'],
+		['left', 'SHIFT'],
+		['left', 'RELATION'],
+		['left', 'COMPARE'],
+		['left', '&'],
+		['left', '^'],
+		['left', '|'],
+		['left', '&&'],
+		['left', '||'],
+		['left', 'BIN?'],
+		['nonassoc', 'INDENT', 'OUTDENT'],
+		['right', 'YIELD'],
+		['right', '=', ':', 'COMPOUND_ASSIGN', 'RETURN', 'THROW', 'EXTENDS'],
+		['right', 'FORIN', 'FOROF', 'FORFROM', 'BY', 'WHEN'],
+		['right', 'IF', 'ELSE', 'FOR', 'WHILE', 'UNTIL', 'LOOP', 'SUPER', 'CLASS', 'IMPORT', 'EXPORT', 'DYNAMIC_IMPORT'],
+		['left', 'POST_IF'],
+	];
 
-  // Wrapping Up
-  // -----------
+	// Wrapping Up
+	// -----------
 
-  // Finally, now that we have our **grammar** and our **operators**, we can create
-  // our **Jison.Parser**. We do this by processing all of our rules, recording all
-  // terminals (every symbol which does not appear as the name of a rule above)
-  // as "tokens".
-  tokens = [];
+	// Finally, now that we have our **grammar** and our **operators**, we can create
+	// our **Jison.Parser**. We do this by processing all of our rules, recording all
+	// terminals (every symbol which does not appear as the name of a rule above)
+	// as "tokens".
+	tokens = [];
 
-  for (name in grammar) {
-    alternatives = grammar[name];
-    grammar[name] = (function() {
-      var i, j, len, len1, ref, results;
-      results = [];
-      for (i = 0, len = alternatives.length; i < len; i++) {
-        alt = alternatives[i];
-        ref = alt[0].split(' ');
-        for (j = 0, len1 = ref.length; j < len1; j++) {
-          token = ref[j];
-          if (!grammar[token]) {
-            tokens.push(token);
-          }
-        }
-        if (name === 'Root') {
-          alt[1] = `return ${alt[1]}`;
-        }
-        results.push(alt);
-      }
-      return results;
-    })();
-  }
-
-  // Initialize the **Parser** with our list of terminal **tokens**, our **grammar**
-  // rules, and the name of the root. Reverse the operators because Jison orders
-  // precedence from low to high, and we have it high to low
-  // (as in [Yacc](http://dinosaur.compilertools.net/yacc/index.html)).
-  exports.parser = new Parser({
-    tokens: tokens.join(' '),
-    bnf: grammar,
-    operators: operators.reverse(),
-    startSymbol: 'Root'
-  });
+	for (name in grammar) {
+		alternatives = grammar[name];
+		grammar[name] = (function () {
+			var i, j, len, len1, ref, results;
+			results = [];
+			for (i = 0, len = alternatives.length; i < len; i++) {
+				alt = alternatives[i];
+				ref = alt[0].split(' ');
+				for (j = 0, len1 = ref.length; j < len1; j++) {
+					token = ref[j];
+					if (!grammar[token]) {
+						tokens.push(token);
+					}
+				}
+				if (name === 'Root') {
+					alt[1] = `return ${alt[1]}`;
+				}
+				results.push(alt);
+			}
+			return results;
+		})();
+	}
 
+	// Initialize the **Parser** with our list of terminal **tokens**, our **grammar**
+	// rules, and the name of the root. Reverse the operators because Jison orders
+	// precedence from low to high, and we have it high to low
+	// (as in [Yacc](http://dinosaur.compilertools.net/yacc/index.html)).
+	exports.parser = new Parser({
+		tokens: tokens.join(' '),
+		bnf: grammar,
+		operators: operators.reverse(),
+		startSymbol: 'Root',
+	});
 }).call(this);