@makano/rew 1.0.1

package/lib/coffeescript/grammar.js

@@ -0,0 +1,2496 @@
+// 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.
+
+  // 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;
+
+  ({Parser} = require('jison'));
+
+  // 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*\}/;
+
+  // 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];
+  };
+
+  // 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:
+
+  //     '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);
+      })
+    ]
+  };
+
+  // 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:
+
+  //     2 + (3 * 4)
+
+  // 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']];
+
+  // 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 = [];
+
+  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);