ohm-js 16.3.0-dev.unicode-code-point-escape → 16.3.2

package/dist/ohm.esm.js

@@ -143,7 +143,7 @@ exports.abstract = function(optMethodName) {
 
 exports.assert = function(cond, message) {
   if (!cond) {
-    throw new Error(message);
+    throw new Error(message || 'Assertion failed');
   }
 };
 
@@ -237,24 +237,9 @@ exports.StringBuffer.prototype.contents = function() {
   return this.strings.join('');
 };
 
-// Character escaping and unescaping
-
-exports.escapeChar = function(c, optDelim) {
-  const charCode = c.charCodeAt(0);
-  if ((c === '"' || c === "'") && optDelim && c !== optDelim) {
-    return c;
-  } else if (charCode < 128) {
-    return escapeStringFor[charCode];
-  } else if (128 <= charCode && charCode < 256) {
-    return '\\x' + exports.padLeft(charCode.toString(16), 2, '0');
-  } else {
-    return '\\u' + exports.padLeft(charCode.toString(16), 4, '0');
-  }
-};
-
 const escapeUnicode = str => String.fromCodePoint(parseInt(str, 16));
 
-exports.unescapeChar = function(s) {
+exports.unescapeCodePoint = function(s) {
   if (s.charAt(0) === '\\') {
     switch (s.charAt(1)) {
       case 'b':
@@ -308,20 +293,19 @@ exports.unexpectedObjToString = function(obj) {
 
 const common$k = common$l;
 
-// Ensures that the deprecation warning for `primitiveValue` only appears once.
-let didWarnForPrimitiveValue = false;
-
 // --------------------------------------------------------------------
 // Private stuff
 // --------------------------------------------------------------------
 
 class Node {
-  constructor(grammar, ctorName, matchLength) {
-    this.grammar = grammar;
-    this.ctorName = ctorName;
+  constructor(matchLength) {
     this.matchLength = matchLength;
   }
 
+  get ctorName() {
+    throw new Error('subclass responsibility');
+  }
+
   numChildren() {
     return this.children ? this.children.length : 0;
   }
@@ -415,52 +399,38 @@ class Node {
   isOptional() {
     return false;
   }
-
-  toJSON() {
-    return {[this.ctorName]: this.children};
-  }
 }
 
 // Terminals
 
 class TerminalNode$2 extends Node {
-  constructor(grammar, value) {
-    const matchLength = value ? value.length : 0;
-    super(grammar, '_terminal', matchLength);
-    this._value = value;
+  get ctorName() {
+    return '_terminal';
   }
 
   isTerminal() {
     return true;
   }
 
-  toJSON() {
-    return {[this.ctorName]: this._value};
-  }
-
   get primitiveValue() {
-    if (!didWarnForPrimitiveValue) {
-      // eslint-disable-next-line no-console
-      console.warn(
-          'Warning: primitiveValue is deprecated and will be removed in a future version of Ohm. ' +
-          'Use sourceString instead.'
-      );
-      didWarnForPrimitiveValue = true;
-    }
-
-    return this._value;
+    throw new Error('The `primitiveValue` property was removed in Ohm v17.');
   }
 }
 
 // Nonterminals
 
 class NonterminalNode$1 extends Node {
-  constructor(grammar, ruleName, children, childOffsets, matchLength) {
-    super(grammar, ruleName, matchLength);
+  constructor(ruleName, children, childOffsets, matchLength) {
+    super(matchLength);
+    this.ruleName = ruleName;
     this.children = children;
     this.childOffsets = childOffsets;
   }
 
+  get ctorName() {
+    return this.ruleName;
+  }
+
   isNonterminal() {
     return true;
   }
@@ -477,13 +447,17 @@ class NonterminalNode$1 extends Node {
 // Iterations
 
 class IterationNode$2 extends Node {
-  constructor(grammar, children, childOffsets, matchLength, isOptional) {
-    super(grammar, '_iter', matchLength);
+  constructor(children, childOffsets, matchLength, isOptional) {
+    super(matchLength);
     this.children = children;
     this.childOffsets = childOffsets;
     this.optional = isOptional;
   }
 
+  get ctorName() {
+    return '_iter';
+  }
+
   isIteration() {
     return true;
   }
@@ -591,6 +565,9 @@ class Range extends PExpr$1 {
     super();
     this.from = from;
     this.to = to;
+    // If either `from` or `to` is made up of multiple code units, then
+    // the range should consume a full code point, not a single code unit.
+    this.matchCodePoint = from.length > 1 || to.length > 1;
   }
 }
 
@@ -757,7 +734,7 @@ pexprsMain.UnicodeChar = UnicodeChar;
 // --------------------------------------------------------------------
 
 const common$i = common$l;
-const pexprs$m = pexprsMain;
+const pexprs$l = pexprsMain;
 
 // --------------------------------------------------------------------
 // Operations
@@ -766,7 +743,7 @@ const pexprs$m = pexprsMain;
 /*
   Return true if we should skip spaces preceding this expression in a syntactic context.
 */
-pexprs$m.PExpr.prototype.allowsSkippingPrecedingSpace = common$i.abstract(
+pexprs$l.PExpr.prototype.allowsSkippingPrecedingSpace = common$i.abstract(
     'allowsSkippingPrecedingSpace'
 );
 
@@ -774,12 +751,12 @@ pexprs$m.PExpr.prototype.allowsSkippingPrecedingSpace = common$i.abstract(
   Generally, these are all first-order expressions and (with the exception of Apply)
   directly read from the input stream.
 */
-pexprs$m.any.allowsSkippingPrecedingSpace =
-  pexprs$m.end.allowsSkippingPrecedingSpace =
-  pexprs$m.Apply.prototype.allowsSkippingPrecedingSpace =
-  pexprs$m.Terminal.prototype.allowsSkippingPrecedingSpace =
-  pexprs$m.Range.prototype.allowsSkippingPrecedingSpace =
-  pexprs$m.UnicodeChar.prototype.allowsSkippingPrecedingSpace =
+pexprs$l.any.allowsSkippingPrecedingSpace =
+  pexprs$l.end.allowsSkippingPrecedingSpace =
+  pexprs$l.Apply.prototype.allowsSkippingPrecedingSpace =
+  pexprs$l.Terminal.prototype.allowsSkippingPrecedingSpace =
+  pexprs$l.Range.prototype.allowsSkippingPrecedingSpace =
+  pexprs$l.UnicodeChar.prototype.allowsSkippingPrecedingSpace =
     function() {
       return true;
     };
@@ -787,13 +764,13 @@ pexprs$m.any.allowsSkippingPrecedingSpace =
 /*
   Higher-order expressions that don't directly consume input.
 */
-pexprs$m.Alt.prototype.allowsSkippingPrecedingSpace =
-  pexprs$m.Iter.prototype.allowsSkippingPrecedingSpace =
-  pexprs$m.Lex.prototype.allowsSkippingPrecedingSpace =
-  pexprs$m.Lookahead.prototype.allowsSkippingPrecedingSpace =
-  pexprs$m.Not.prototype.allowsSkippingPrecedingSpace =
-  pexprs$m.Param.prototype.allowsSkippingPrecedingSpace =
-  pexprs$m.Seq.prototype.allowsSkippingPrecedingSpace =
+pexprs$l.Alt.prototype.allowsSkippingPrecedingSpace =
+  pexprs$l.Iter.prototype.allowsSkippingPrecedingSpace =
+  pexprs$l.Lex.prototype.allowsSkippingPrecedingSpace =
+  pexprs$l.Lookahead.prototype.allowsSkippingPrecedingSpace =
+  pexprs$l.Not.prototype.allowsSkippingPrecedingSpace =
+  pexprs$l.Param.prototype.allowsSkippingPrecedingSpace =
+  pexprs$l.Seq.prototype.allowsSkippingPrecedingSpace =
     function() {
       return false;
     };
@@ -850,9 +827,9 @@ var Namespace_1 = Namespace$2;
 // Imports
 // --------------------------------------------------------------------
 
-const pexprs$l = pexprsMain;
-
+const {assert: assert$3} = common$l;
 const Namespace$1 = Namespace_1;
+const pexprs$k = pexprsMain;
 
 // --------------------------------------------------------------------
 // Private stuff
@@ -982,7 +959,7 @@ function wrongNumberOfArguments(ruleName, expected, actual, expr) {
       ', got ' +
       actual +
       ')',
-      expr.source
+      expr
   );
 }
 
@@ -1055,6 +1032,21 @@ function multipleSuperSplices(expr) {
   return createError("'...' can appear at most once in a rule body", expr.source);
 }
 
+// Unicode code point escapes
+
+function invalidCodePoint(applyWrapper) {
+  const node = applyWrapper._node;
+  assert$3(node && node.isNonterminal() && node.ctorName === 'escapeChar_unicodeCodePoint');
+
+  // Get an interval that covers all of the hex digits.
+  const digitIntervals = applyWrapper.children.slice(1, -1).map(d => d.source);
+  const fullInterval = digitIntervals[0].coverageWith(...digitIntervals.slice(1));
+  return createError(
+      `U+${fullInterval.contents} is not a valid Unicode code point`,
+      fullInterval
+  );
+}
+
 // ----------------- Kleene operators -----------------
 
 function kleeneExprHasNullableOperand(kleeneExpr, applicationStack) {
@@ -1069,7 +1061,7 @@ function kleeneExprHasNullableOperand(kleeneExpr, applicationStack) {
     "' (possible infinite loop)";
   if (applicationStack.length > 0) {
     const stackTrace = applicationStack
-        .map(app => new pexprs$l.Apply(app.ruleName, app.args))
+        .map(app => new pexprs$k.Apply(app.ruleName, app.args))
         .join('\n');
     message += '\nApplication stack (most recent application last):\n' + stackTrace;
   }
@@ -1160,6 +1152,7 @@ var errors$9 = {
   inconsistentArity,
   incorrectArgumentType,
   intervalSourcesDontMatch,
+  invalidCodePoint,
   invalidConstructorCall,
   invalidParameter,
   grammarSyntaxError,
@@ -1371,7 +1364,7 @@ exports.uniqueId = (() => {
 
 const {abstract, isSyntactic} = common$l;
 const errors$8 = errors$9;
-const pexprs$k = pexprsMain;
+const pexprs$j = pexprsMain;
 const util$6 = util$7;
 
 let BuiltInRules;
@@ -1386,51 +1379,51 @@ util$6.awaitBuiltInRules(g => {
 
 let lexifyCount;
 
-pexprs$k.PExpr.prototype.assertAllApplicationsAreValid = function(ruleName, grammar) {
+pexprs$j.PExpr.prototype.assertAllApplicationsAreValid = function(ruleName, grammar) {
   lexifyCount = 0;
   this._assertAllApplicationsAreValid(ruleName, grammar);
 };
 
-pexprs$k.PExpr.prototype._assertAllApplicationsAreValid = abstract(
+pexprs$j.PExpr.prototype._assertAllApplicationsAreValid = abstract(
     '_assertAllApplicationsAreValid'
 );
 
-pexprs$k.any._assertAllApplicationsAreValid =
-  pexprs$k.end._assertAllApplicationsAreValid =
-  pexprs$k.Terminal.prototype._assertAllApplicationsAreValid =
-  pexprs$k.Range.prototype._assertAllApplicationsAreValid =
-  pexprs$k.Param.prototype._assertAllApplicationsAreValid =
-  pexprs$k.UnicodeChar.prototype._assertAllApplicationsAreValid =
+pexprs$j.any._assertAllApplicationsAreValid =
+  pexprs$j.end._assertAllApplicationsAreValid =
+  pexprs$j.Terminal.prototype._assertAllApplicationsAreValid =
+  pexprs$j.Range.prototype._assertAllApplicationsAreValid =
+  pexprs$j.Param.prototype._assertAllApplicationsAreValid =
+  pexprs$j.UnicodeChar.prototype._assertAllApplicationsAreValid =
     function(ruleName, grammar) {
       // no-op
     };
 
-pexprs$k.Lex.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) {
+pexprs$j.Lex.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) {
   lexifyCount++;
   this.expr._assertAllApplicationsAreValid(ruleName, grammar);
   lexifyCount--;
 };
 
-pexprs$k.Alt.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) {
+pexprs$j.Alt.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) {
   for (let idx = 0; idx < this.terms.length; idx++) {
     this.terms[idx]._assertAllApplicationsAreValid(ruleName, grammar);
   }
 };
 
-pexprs$k.Seq.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) {
+pexprs$j.Seq.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) {
   for (let idx = 0; idx < this.factors.length; idx++) {
     this.factors[idx]._assertAllApplicationsAreValid(ruleName, grammar);
   }
 };
 
-pexprs$k.Iter.prototype._assertAllApplicationsAreValid =
-  pexprs$k.Not.prototype._assertAllApplicationsAreValid =
-  pexprs$k.Lookahead.prototype._assertAllApplicationsAreValid =
+pexprs$j.Iter.prototype._assertAllApplicationsAreValid =
+  pexprs$j.Not.prototype._assertAllApplicationsAreValid =
+  pexprs$j.Lookahead.prototype._assertAllApplicationsAreValid =
     function(ruleName, grammar) {
       this.expr._assertAllApplicationsAreValid(ruleName, grammar);
     };
 
-pexprs$k.Apply.prototype._assertAllApplicationsAreValid = function(
+pexprs$j.Apply.prototype._assertAllApplicationsAreValid = function(
     ruleName,
     grammar,
     skipSyntacticCheck = false
@@ -1462,14 +1455,14 @@ pexprs$k.Apply.prototype._assertAllApplicationsAreValid = function(
 
   // If it's an application of 'caseInsensitive', ensure that the argument is a Terminal.
   if (isBuiltInCaseInsensitive) {
-    if (!(this.args[0] instanceof pexprs$k.Terminal)) {
+    if (!(this.args[0] instanceof pexprs$j.Terminal)) {
       throw errors$8.incorrectArgumentType('a Terminal (e.g. "abc")', this.args[0]);
     }
   }
 
   if (isBuiltInApplySyntactic) {
     const arg = this.args[0];
-    if (!(arg instanceof pexprs$k.Apply)) {
+    if (!(arg instanceof pexprs$j.Apply)) {
       throw errors$8.incorrectArgumentType('a syntactic rule application', arg);
     }
     if (!isSyntactic(arg.ruleName)) {
@@ -1497,28 +1490,28 @@ pexprs$k.Apply.prototype._assertAllApplicationsAreValid = function(
 
 const common$h = common$l;
 const errors$7 = errors$9;
-const pexprs$j = pexprsMain;
+const pexprs$i = pexprsMain;
 
 // --------------------------------------------------------------------
 // Operations
 // --------------------------------------------------------------------
 
-pexprs$j.PExpr.prototype.assertChoicesHaveUniformArity = common$h.abstract(
+pexprs$i.PExpr.prototype.assertChoicesHaveUniformArity = common$h.abstract(
     'assertChoicesHaveUniformArity'
 );
 
-pexprs$j.any.assertChoicesHaveUniformArity =
-  pexprs$j.end.assertChoicesHaveUniformArity =
-  pexprs$j.Terminal.prototype.assertChoicesHaveUniformArity =
-  pexprs$j.Range.prototype.assertChoicesHaveUniformArity =
-  pexprs$j.Param.prototype.assertChoicesHaveUniformArity =
-  pexprs$j.Lex.prototype.assertChoicesHaveUniformArity =
-  pexprs$j.UnicodeChar.prototype.assertChoicesHaveUniformArity =
+pexprs$i.any.assertChoicesHaveUniformArity =
+  pexprs$i.end.assertChoicesHaveUniformArity =
+  pexprs$i.Terminal.prototype.assertChoicesHaveUniformArity =
+  pexprs$i.Range.prototype.assertChoicesHaveUniformArity =
+  pexprs$i.Param.prototype.assertChoicesHaveUniformArity =
+  pexprs$i.Lex.prototype.assertChoicesHaveUniformArity =
+  pexprs$i.UnicodeChar.prototype.assertChoicesHaveUniformArity =
     function(ruleName) {
       // no-op
     };
 
-pexprs$j.Alt.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+pexprs$i.Alt.prototype.assertChoicesHaveUniformArity = function(ruleName) {
   if (this.terms.length === 0) {
     return;
   }
@@ -1533,7 +1526,7 @@ pexprs$j.Alt.prototype.assertChoicesHaveUniformArity = function(ruleName) {
   }
 };
 
-pexprs$j.Extend.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+pexprs$i.Extend.prototype.assertChoicesHaveUniformArity = function(ruleName) {
   // Extend is a special case of Alt that's guaranteed to have exactly two
   // cases: [extensions, origBody].
   const actualArity = this.terms[0].getArity();
@@ -1543,25 +1536,25 @@ pexprs$j.Extend.prototype.assertChoicesHaveUniformArity = function(ruleName) {
   }
 };
 
-pexprs$j.Seq.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+pexprs$i.Seq.prototype.assertChoicesHaveUniformArity = function(ruleName) {
   for (let idx = 0; idx < this.factors.length; idx++) {
     this.factors[idx].assertChoicesHaveUniformArity(ruleName);
   }
 };
 
-pexprs$j.Iter.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+pexprs$i.Iter.prototype.assertChoicesHaveUniformArity = function(ruleName) {
   this.expr.assertChoicesHaveUniformArity(ruleName);
 };
 
-pexprs$j.Not.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+pexprs$i.Not.prototype.assertChoicesHaveUniformArity = function(ruleName) {
   // no-op (not required b/c the nested expr doesn't show up in the CST)
 };
 
-pexprs$j.Lookahead.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+pexprs$i.Lookahead.prototype.assertChoicesHaveUniformArity = function(ruleName) {
   this.expr.assertChoicesHaveUniformArity(ruleName);
 };
 
-pexprs$j.Apply.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+pexprs$i.Apply.prototype.assertChoicesHaveUniformArity = function(ruleName) {
   // The arities of the parameter expressions is required to be 1 by
   // `assertAllApplicationsAreValid()`.
 };
@@ -1572,39 +1565,39 @@ pexprs$j.Apply.prototype.assertChoicesHaveUniformArity = function(ruleName) {
 
 const common$g = common$l;
 const errors$6 = errors$9;
-const pexprs$i = pexprsMain;
+const pexprs$h = pexprsMain;
 
 // --------------------------------------------------------------------
 // Operations
 // --------------------------------------------------------------------
 
-pexprs$i.PExpr.prototype.assertIteratedExprsAreNotNullable = common$g.abstract(
+pexprs$h.PExpr.prototype.assertIteratedExprsAreNotNullable = common$g.abstract(
     'assertIteratedExprsAreNotNullable'
 );
 
-pexprs$i.any.assertIteratedExprsAreNotNullable =
-  pexprs$i.end.assertIteratedExprsAreNotNullable =
-  pexprs$i.Terminal.prototype.assertIteratedExprsAreNotNullable =
-  pexprs$i.Range.prototype.assertIteratedExprsAreNotNullable =
-  pexprs$i.Param.prototype.assertIteratedExprsAreNotNullable =
-  pexprs$i.UnicodeChar.prototype.assertIteratedExprsAreNotNullable =
+pexprs$h.any.assertIteratedExprsAreNotNullable =
+  pexprs$h.end.assertIteratedExprsAreNotNullable =
+  pexprs$h.Terminal.prototype.assertIteratedExprsAreNotNullable =
+  pexprs$h.Range.prototype.assertIteratedExprsAreNotNullable =
+  pexprs$h.Param.prototype.assertIteratedExprsAreNotNullable =
+  pexprs$h.UnicodeChar.prototype.assertIteratedExprsAreNotNullable =
     function(grammar) {
       // no-op
     };
 
-pexprs$i.Alt.prototype.assertIteratedExprsAreNotNullable = function(grammar) {
+pexprs$h.Alt.prototype.assertIteratedExprsAreNotNullable = function(grammar) {
   for (let idx = 0; idx < this.terms.length; idx++) {
     this.terms[idx].assertIteratedExprsAreNotNullable(grammar);
   }
 };
 
-pexprs$i.Seq.prototype.assertIteratedExprsAreNotNullable = function(grammar) {
+pexprs$h.Seq.prototype.assertIteratedExprsAreNotNullable = function(grammar) {
   for (let idx = 0; idx < this.factors.length; idx++) {
     this.factors[idx].assertIteratedExprsAreNotNullable(grammar);
   }
 };
 
-pexprs$i.Iter.prototype.assertIteratedExprsAreNotNullable = function(grammar) {
+pexprs$h.Iter.prototype.assertIteratedExprsAreNotNullable = function(grammar) {
   // Note: this is the implementation of this method for `Star` and `Plus` expressions.
   // It is overridden for `Opt` below.
   this.expr.assertIteratedExprsAreNotNullable(grammar);
@@ -1613,15 +1606,15 @@ pexprs$i.Iter.prototype.assertIteratedExprsAreNotNullable = function(grammar) {
   }
 };
 
-pexprs$i.Opt.prototype.assertIteratedExprsAreNotNullable =
-  pexprs$i.Not.prototype.assertIteratedExprsAreNotNullable =
-  pexprs$i.Lookahead.prototype.assertIteratedExprsAreNotNullable =
-  pexprs$i.Lex.prototype.assertIteratedExprsAreNotNullable =
+pexprs$h.Opt.prototype.assertIteratedExprsAreNotNullable =
+  pexprs$h.Not.prototype.assertIteratedExprsAreNotNullable =
+  pexprs$h.Lookahead.prototype.assertIteratedExprsAreNotNullable =
+  pexprs$h.Lex.prototype.assertIteratedExprsAreNotNullable =
     function(grammar) {
       this.expr.assertIteratedExprsAreNotNullable(grammar);
     };
 
-pexprs$i.Apply.prototype.assertIteratedExprsAreNotNullable = function(grammar) {
+pexprs$h.Apply.prototype.assertIteratedExprsAreNotNullable = function(grammar) {
   this.args.forEach(arg => {
     arg.assertIteratedExprsAreNotNullable(grammar);
   });
@@ -1986,7 +1979,7 @@ const Trace$1 = Trace_1;
 const common$e = common$l;
 const errors$4 = errors$9;
 const nodes = nodes$1;
-const pexprs$h = pexprsMain;
+const pexprs$g = pexprsMain;
 
 const {TerminalNode: TerminalNode$1} = nodes;
 const {NonterminalNode} = nodes;
@@ -2012,14 +2005,14 @@ const {IterationNode: IterationNode$1} = nodes;
   Note that `State.prototype.eval(expr)`, unlike this method, guarantees that neither the state
   object's bindings nor its input stream's position will change if the expression fails to match.
 */
-pexprs$h.PExpr.prototype.eval = common$e.abstract('eval'); // function(state) { ... }
+pexprs$g.PExpr.prototype.eval = common$e.abstract('eval'); // function(state) { ... }
 
-pexprs$h.any.eval = function(state) {
+pexprs$g.any.eval = function(state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   const ch = inputStream.next();
   if (ch) {
-    state.pushBinding(new TerminalNode$1(state.grammar, ch), origPos);
+    state.pushBinding(new TerminalNode$1(ch.length), origPos);
     return true;
   } else {
     state.processFailure(origPos, this);
@@ -2027,11 +2020,11 @@ pexprs$h.any.eval = function(state) {
   }
 };
 
-pexprs$h.end.eval = function(state) {
+pexprs$g.end.eval = function(state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   if (inputStream.atEnd()) {
-    state.pushBinding(new TerminalNode$1(state.grammar, undefined), origPos);
+    state.pushBinding(new TerminalNode$1(0), origPos);
     return true;
   } else {
     state.processFailure(origPos, this);
@@ -2039,31 +2032,30 @@ pexprs$h.end.eval = function(state) {
   }
 };
 
-pexprs$h.Terminal.prototype.eval = function(state) {
+pexprs$g.Terminal.prototype.eval = function(state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   if (!inputStream.matchString(this.obj)) {
     state.processFailure(origPos, this);
     return false;
   } else {
-    state.pushBinding(new TerminalNode$1(state.grammar, this.obj), origPos);
+    state.pushBinding(new TerminalNode$1(this.obj.length), origPos);
     return true;
   }
 };
 
-pexprs$h.Range.prototype.eval = function(state) {
+pexprs$g.Range.prototype.eval = function(state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
 
-  let cp;
-  if (this.from.length > 1 || this.to.length > 1) {
-    cp = inputStream.nextCodePoint();
-  } else {
-    cp = inputStream.atEnd() ? undefined : inputStream.next().codePointAt(0);
-  }
+  // A range can operate in one of two modes: matching a single, 16-bit _code unit_,
+  // or matching a _code point_. (Code points over 0xFFFF take up two 16-bit code units.)
+  const cp = this.matchCodePoint ? inputStream.nextCodePoint() : inputStream.nextCharCode();
 
+  // Always compare by code point value to get the correct result in all scenarios.
+  // Note that for strings of length 1, codePointAt(0) and charPointAt(0) are equivalent.
   if (cp !== undefined && this.from.codePointAt(0) <= cp && cp <= this.to.codePointAt(0)) {
-    state.pushBinding(new TerminalNode$1(state.grammar, String.fromCodePoint(cp)), origPos);
+    state.pushBinding(new TerminalNode$1(String.fromCodePoint(cp).length), origPos);
     return true;
   } else {
     state.processFailure(origPos, this);
@@ -2071,18 +2063,18 @@ pexprs$h.Range.prototype.eval = function(state) {
   }
 };
 
-pexprs$h.Param.prototype.eval = function(state) {
+pexprs$g.Param.prototype.eval = function(state) {
   return state.eval(state.currentApplication().args[this.index]);
 };
 
-pexprs$h.Lex.prototype.eval = function(state) {
+pexprs$g.Lex.prototype.eval = function(state) {
   state.enterLexifiedContext();
   const ans = state.eval(this.expr);
   state.exitLexifiedContext();
   return ans;
 };
 
-pexprs$h.Alt.prototype.eval = function(state) {
+pexprs$g.Alt.prototype.eval = function(state) {
   for (let idx = 0; idx < this.terms.length; idx++) {
     if (state.eval(this.terms[idx])) {
       return true;
@@ -2091,7 +2083,7 @@ pexprs$h.Alt.prototype.eval = function(state) {
   return false;
 };
 
-pexprs$h.Seq.prototype.eval = function(state) {
+pexprs$g.Seq.prototype.eval = function(state) {
   for (let idx = 0; idx < this.factors.length; idx++) {
     const factor = this.factors[idx];
     if (!state.eval(factor)) {
@@ -2101,7 +2093,7 @@ pexprs$h.Seq.prototype.eval = function(state) {
   return true;
 };
 
-pexprs$h.Iter.prototype.eval = function(state) {
+pexprs$g.Iter.prototype.eval = function(state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   const arity = this.getArity();
@@ -2145,17 +2137,17 @@ pexprs$h.Iter.prototype.eval = function(state) {
     offset = colOffsets[0][0];
     matchLength = endOffset - offset;
   }
-  const isOptional = this instanceof pexprs$h.Opt;
+  const isOptional = this instanceof pexprs$g.Opt;
   for (idx = 0; idx < cols.length; idx++) {
     state._bindings.push(
-        new IterationNode$1(state.grammar, cols[idx], colOffsets[idx], matchLength, isOptional)
+        new IterationNode$1(cols[idx], colOffsets[idx], matchLength, isOptional)
     );
     state._bindingOffsets.push(offset);
   }
   return true;
 };
 
-pexprs$h.Not.prototype.eval = function(state) {
+pexprs$g.Not.prototype.eval = function(state) {
   /*
     TODO:
     - Right now we're just throwing away all of the failures that happen inside a `not`, and
@@ -2181,7 +2173,7 @@ pexprs$h.Not.prototype.eval = function(state) {
   return true;
 };
 
-pexprs$h.Lookahead.prototype.eval = function(state) {
+pexprs$g.Lookahead.prototype.eval = function(state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   if (state.eval(this.expr)) {
@@ -2192,7 +2184,7 @@ pexprs$h.Lookahead.prototype.eval = function(state) {
   }
 };
 
-pexprs$h.Apply.prototype.eval = function(state) {
+pexprs$g.Apply.prototype.eval = function(state) {
   const caller = state.currentApplication();
   const actuals = caller ? caller.args : [];
   const app = this.substituteParams(actuals);
@@ -2215,7 +2207,7 @@ pexprs$h.Apply.prototype.eval = function(state) {
   return app.reallyEval(state);
 };
 
-pexprs$h.Apply.prototype.handleCycle = function(state) {
+pexprs$g.Apply.prototype.handleCycle = function(state) {
   const posInfo = state.getCurrentPosInfo();
   const {currentLeftRecursion} = posInfo;
   const memoKey = this.toMemoKey();
@@ -2238,7 +2230,7 @@ pexprs$h.Apply.prototype.handleCycle = function(state) {
   return state.useMemoizedResult(state.inputStream.pos, memoRec);
 };
 
-pexprs$h.Apply.prototype.reallyEval = function(state) {
+pexprs$g.Apply.prototype.reallyEval = function(state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   const origPosInfo = state.getCurrentPosInfo();
@@ -2315,7 +2307,7 @@ pexprs$h.Apply.prototype.reallyEval = function(state) {
   return succeeded;
 };
 
-pexprs$h.Apply.prototype.evalOnce = function(expr, state) {
+pexprs$g.Apply.prototype.evalOnce = function(expr, state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
 
@@ -2323,19 +2315,14 @@ pexprs$h.Apply.prototype.evalOnce = function(expr, state) {
     const arity = expr.getArity();
     const bindings = state._bindings.splice(state._bindings.length - arity, arity);
     const offsets = state._bindingOffsets.splice(state._bindingOffsets.length - arity, arity);
-    return new NonterminalNode(
-        state.grammar,
-        this.ruleName,
-        bindings,
-        offsets,
-        inputStream.pos - origPos
-    );
+    const matchLength = inputStream.pos - origPos;
+    return new NonterminalNode(this.ruleName, bindings, offsets, matchLength);
   } else {
     return false;
   }
 };
 
-pexprs$h.Apply.prototype.growSeedResult = function(body, state, origPos, lrMemoRec, newValue) {
+pexprs$g.Apply.prototype.growSeedResult = function(body, state, origPos, lrMemoRec, newValue) {
   if (!newValue) {
     return false;
   }
@@ -2379,12 +2366,12 @@ pexprs$h.Apply.prototype.growSeedResult = function(body, state, origPos, lrMemoR
   return lrMemoRec.value;
 };
 
-pexprs$h.UnicodeChar.prototype.eval = function(state) {
+pexprs$g.UnicodeChar.prototype.eval = function(state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   const ch = inputStream.next();
   if (ch && this.pattern.test(ch)) {
-    state.pushBinding(new TerminalNode$1(state.grammar, ch), origPos);
+    state.pushBinding(new TerminalNode$1(ch.length), origPos);
     return true;
   } else {
     state.processFailure(origPos, this);
@@ -2397,32 +2384,32 @@ pexprs$h.UnicodeChar.prototype.eval = function(state) {
 // --------------------------------------------------------------------
 
 const common$d = common$l;
-const pexprs$g = pexprsMain;
+const pexprs$f = pexprsMain;
 
 // --------------------------------------------------------------------
 // Operations
 // --------------------------------------------------------------------
 
-pexprs$g.PExpr.prototype.getArity = common$d.abstract('getArity');
+pexprs$f.PExpr.prototype.getArity = common$d.abstract('getArity');
 
-pexprs$g.any.getArity =
-  pexprs$g.end.getArity =
-  pexprs$g.Terminal.prototype.getArity =
-  pexprs$g.Range.prototype.getArity =
-  pexprs$g.Param.prototype.getArity =
-  pexprs$g.Apply.prototype.getArity =
-  pexprs$g.UnicodeChar.prototype.getArity =
+pexprs$f.any.getArity =
+  pexprs$f.end.getArity =
+  pexprs$f.Terminal.prototype.getArity =
+  pexprs$f.Range.prototype.getArity =
+  pexprs$f.Param.prototype.getArity =
+  pexprs$f.Apply.prototype.getArity =
+  pexprs$f.UnicodeChar.prototype.getArity =
     function() {
       return 1;
     };
 
-pexprs$g.Alt.prototype.getArity = function() {
+pexprs$f.Alt.prototype.getArity = function() {
   // This is ok b/c all terms must have the same arity -- this property is
   // checked by the Grammar constructor.
   return this.terms.length === 0 ? 0 : this.terms[0].getArity();
 };
 
-pexprs$g.Seq.prototype.getArity = function() {
+pexprs$f.Seq.prototype.getArity = function() {
   let arity = 0;
   for (let idx = 0; idx < this.factors.length; idx++) {
     arity += this.factors[idx].getArity();
@@ -2430,15 +2417,15 @@ pexprs$g.Seq.prototype.getArity = function() {
   return arity;
 };
 
-pexprs$g.Iter.prototype.getArity = function() {
+pexprs$f.Iter.prototype.getArity = function() {
   return this.expr.getArity();
 };
 
-pexprs$g.Not.prototype.getArity = function() {
+pexprs$f.Not.prototype.getArity = function() {
   return 0;
 };
 
-pexprs$g.Lookahead.prototype.getArity = pexprs$g.Lex.prototype.getArity = function() {
+pexprs$f.Lookahead.prototype.getArity = pexprs$f.Lex.prototype.getArity = function() {
   return this.expr.getArity();
 };
 
@@ -2447,7 +2434,7 @@ pexprs$g.Lookahead.prototype.getArity = pexprs$g.Lex.prototype.getArity = functi
 // --------------------------------------------------------------------
 
 const common$c = common$l;
-const pexprs$f = pexprsMain;
+const pexprs$e = pexprsMain;
 
 // --------------------------------------------------------------------
 // Private stuff
@@ -2466,40 +2453,40 @@ function getMetaInfo(expr, grammarInterval) {
 // Operations
 // --------------------------------------------------------------------
 
-pexprs$f.PExpr.prototype.outputRecipe = common$c.abstract('outputRecipe');
+pexprs$e.PExpr.prototype.outputRecipe = common$c.abstract('outputRecipe');
 
-pexprs$f.any.outputRecipe = function(formals, grammarInterval) {
+pexprs$e.any.outputRecipe = function(formals, grammarInterval) {
   return ['any', getMetaInfo(this, grammarInterval)];
 };
 
-pexprs$f.end.outputRecipe = function(formals, grammarInterval) {
+pexprs$e.end.outputRecipe = function(formals, grammarInterval) {
   return ['end', getMetaInfo(this, grammarInterval)];
 };
 
-pexprs$f.Terminal.prototype.outputRecipe = function(formals, grammarInterval) {
+pexprs$e.Terminal.prototype.outputRecipe = function(formals, grammarInterval) {
   return ['terminal', getMetaInfo(this, grammarInterval), this.obj];
 };
 
-pexprs$f.Range.prototype.outputRecipe = function(formals, grammarInterval) {
+pexprs$e.Range.prototype.outputRecipe = function(formals, grammarInterval) {
   return ['range', getMetaInfo(this, grammarInterval), this.from, this.to];
 };
 
-pexprs$f.Param.prototype.outputRecipe = function(formals, grammarInterval) {
+pexprs$e.Param.prototype.outputRecipe = function(formals, grammarInterval) {
   return ['param', getMetaInfo(this, grammarInterval), this.index];
 };
 
-pexprs$f.Alt.prototype.outputRecipe = function(formals, grammarInterval) {
+pexprs$e.Alt.prototype.outputRecipe = function(formals, grammarInterval) {
   return ['alt', getMetaInfo(this, grammarInterval)].concat(
       this.terms.map(term => term.outputRecipe(formals, grammarInterval))
   );
 };
 
-pexprs$f.Extend.prototype.outputRecipe = function(formals, grammarInterval) {
+pexprs$e.Extend.prototype.outputRecipe = function(formals, grammarInterval) {
   const extension = this.terms[0]; // [extension, original]
   return extension.outputRecipe(formals, grammarInterval);
 };
 
-pexprs$f.Splice.prototype.outputRecipe = function(formals, grammarInterval) {
+pexprs$e.Splice.prototype.outputRecipe = function(formals, grammarInterval) {
   const beforeTerms = this.terms.slice(0, this.expansionPos);
   const afterTerms = this.terms.slice(this.expansionPos + 1);
   return [
@@ -2510,18 +2497,18 @@ pexprs$f.Splice.prototype.outputRecipe = function(formals, grammarInterval) {
   ];
 };
 
-pexprs$f.Seq.prototype.outputRecipe = function(formals, grammarInterval) {
+pexprs$e.Seq.prototype.outputRecipe = function(formals, grammarInterval) {
   return ['seq', getMetaInfo(this, grammarInterval)].concat(
       this.factors.map(factor => factor.outputRecipe(formals, grammarInterval))
   );
 };
 
-pexprs$f.Star.prototype.outputRecipe =
-  pexprs$f.Plus.prototype.outputRecipe =
-  pexprs$f.Opt.prototype.outputRecipe =
-  pexprs$f.Not.prototype.outputRecipe =
-  pexprs$f.Lookahead.prototype.outputRecipe =
-  pexprs$f.Lex.prototype.outputRecipe =
+pexprs$e.Star.prototype.outputRecipe =
+  pexprs$e.Plus.prototype.outputRecipe =
+  pexprs$e.Opt.prototype.outputRecipe =
+  pexprs$e.Not.prototype.outputRecipe =
+  pexprs$e.Lookahead.prototype.outputRecipe =
+  pexprs$e.Lex.prototype.outputRecipe =
     function(formals, grammarInterval) {
       return [
         this.constructor.name.toLowerCase(),
@@ -2530,7 +2517,7 @@ pexprs$f.Star.prototype.outputRecipe =
       ];
     };
 
-pexprs$f.Apply.prototype.outputRecipe = function(formals, grammarInterval) {
+pexprs$e.Apply.prototype.outputRecipe = function(formals, grammarInterval) {
   return [
     'app',
     getMetaInfo(this, grammarInterval),
@@ -2539,7 +2526,7 @@ pexprs$f.Apply.prototype.outputRecipe = function(formals, grammarInterval) {
   ];
 };
 
-pexprs$f.UnicodeChar.prototype.outputRecipe = function(formals, grammarInterval) {
+pexprs$e.UnicodeChar.prototype.outputRecipe = function(formals, grammarInterval) {
   return ['unicodeChar', getMetaInfo(this, grammarInterval), this.category];
 };
 
@@ -2548,7 +2535,7 @@ pexprs$f.UnicodeChar.prototype.outputRecipe = function(formals, grammarInterval)
 // --------------------------------------------------------------------
 
 const common$b = common$l;
-const pexprs$e = pexprsMain;
+const pexprs$d = pexprsMain;
 
 // --------------------------------------------------------------------
 // Operations
@@ -2559,49 +2546,49 @@ const pexprs$e = pexprsMain;
   parameter with a `Param` node. Returns a PExpr -- either a new one, or the original one if
   it was modified in place.
 */
-pexprs$e.PExpr.prototype.introduceParams = common$b.abstract('introduceParams');
-
-pexprs$e.any.introduceParams =
-  pexprs$e.end.introduceParams =
-  pexprs$e.Terminal.prototype.introduceParams =
-  pexprs$e.Range.prototype.introduceParams =
-  pexprs$e.Param.prototype.introduceParams =
-  pexprs$e.UnicodeChar.prototype.introduceParams =
+pexprs$d.PExpr.prototype.introduceParams = common$b.abstract('introduceParams');
+
+pexprs$d.any.introduceParams =
+  pexprs$d.end.introduceParams =
+  pexprs$d.Terminal.prototype.introduceParams =
+  pexprs$d.Range.prototype.introduceParams =
+  pexprs$d.Param.prototype.introduceParams =
+  pexprs$d.UnicodeChar.prototype.introduceParams =
     function(formals) {
       return this;
     };
 
-pexprs$e.Alt.prototype.introduceParams = function(formals) {
+pexprs$d.Alt.prototype.introduceParams = function(formals) {
   this.terms.forEach((term, idx, terms) => {
     terms[idx] = term.introduceParams(formals);
   });
   return this;
 };
 
-pexprs$e.Seq.prototype.introduceParams = function(formals) {
+pexprs$d.Seq.prototype.introduceParams = function(formals) {
   this.factors.forEach((factor, idx, factors) => {
     factors[idx] = factor.introduceParams(formals);
   });
   return this;
 };
 
-pexprs$e.Iter.prototype.introduceParams =
-  pexprs$e.Not.prototype.introduceParams =
-  pexprs$e.Lookahead.prototype.introduceParams =
-  pexprs$e.Lex.prototype.introduceParams =
+pexprs$d.Iter.prototype.introduceParams =
+  pexprs$d.Not.prototype.introduceParams =
+  pexprs$d.Lookahead.prototype.introduceParams =
+  pexprs$d.Lex.prototype.introduceParams =
     function(formals) {
       this.expr = this.expr.introduceParams(formals);
       return this;
     };
 
-pexprs$e.Apply.prototype.introduceParams = function(formals) {
+pexprs$d.Apply.prototype.introduceParams = function(formals) {
   const index = formals.indexOf(this.ruleName);
   if (index >= 0) {
     if (this.args.length > 0) {
       // TODO: Should this be supported? See issue #64.
       throw new Error('Parameterized rules cannot be passed as arguments to another rule.');
     }
-    return new pexprs$e.Param(index).withSource(this.source);
+    return new pexprs$d.Param(index).withSource(this.source);
   } else {
     this.args.forEach((arg, idx, args) => {
       args[idx] = arg.introduceParams(formals);
@@ -2615,33 +2602,33 @@ pexprs$e.Apply.prototype.introduceParams = function(formals) {
 // --------------------------------------------------------------------
 
 const common$a = common$l;
-const pexprs$d = pexprsMain;
+const pexprs$c = pexprsMain;
 
 // --------------------------------------------------------------------
 // Operations
 // --------------------------------------------------------------------
 
 // Returns `true` if this parsing expression may accept without consuming any input.
-pexprs$d.PExpr.prototype.isNullable = function(grammar) {
+pexprs$c.PExpr.prototype.isNullable = function(grammar) {
   return this._isNullable(grammar, Object.create(null));
 };
 
-pexprs$d.PExpr.prototype._isNullable = common$a.abstract('_isNullable');
+pexprs$c.PExpr.prototype._isNullable = common$a.abstract('_isNullable');
 
-pexprs$d.any._isNullable =
-  pexprs$d.Range.prototype._isNullable =
-  pexprs$d.Param.prototype._isNullable =
-  pexprs$d.Plus.prototype._isNullable =
-  pexprs$d.UnicodeChar.prototype._isNullable =
+pexprs$c.any._isNullable =
+  pexprs$c.Range.prototype._isNullable =
+  pexprs$c.Param.prototype._isNullable =
+  pexprs$c.Plus.prototype._isNullable =
+  pexprs$c.UnicodeChar.prototype._isNullable =
     function(grammar, memo) {
       return false;
     };
 
-pexprs$d.end._isNullable = function(grammar, memo) {
+pexprs$c.end._isNullable = function(grammar, memo) {
   return true;
 };
 
-pexprs$d.Terminal.prototype._isNullable = function(grammar, memo) {
+pexprs$c.Terminal.prototype._isNullable = function(grammar, memo) {
   if (typeof this.obj === 'string') {
     // This is an over-simplification: it's only correct if the input is a string. If it's an array
     // or an object, then the empty string parsing expression is not nullable.
@@ -2651,27 +2638,27 @@ pexprs$d.Terminal.prototype._isNullable = function(grammar, memo) {
   }
 };
 
-pexprs$d.Alt.prototype._isNullable = function(grammar, memo) {
+pexprs$c.Alt.prototype._isNullable = function(grammar, memo) {
   return this.terms.length === 0 || this.terms.some(term => term._isNullable(grammar, memo));
 };
 
-pexprs$d.Seq.prototype._isNullable = function(grammar, memo) {
+pexprs$c.Seq.prototype._isNullable = function(grammar, memo) {
   return this.factors.every(factor => factor._isNullable(grammar, memo));
 };
 
-pexprs$d.Star.prototype._isNullable =
-  pexprs$d.Opt.prototype._isNullable =
-  pexprs$d.Not.prototype._isNullable =
-  pexprs$d.Lookahead.prototype._isNullable =
+pexprs$c.Star.prototype._isNullable =
+  pexprs$c.Opt.prototype._isNullable =
+  pexprs$c.Not.prototype._isNullable =
+  pexprs$c.Lookahead.prototype._isNullable =
     function(grammar, memo) {
       return true;
     };
 
-pexprs$d.Lex.prototype._isNullable = function(grammar, memo) {
+pexprs$c.Lex.prototype._isNullable = function(grammar, memo) {
   return this.expr._isNullable(grammar, memo);
 };
 
-pexprs$d.Apply.prototype._isNullable = function(grammar, memo) {
+pexprs$c.Apply.prototype._isNullable = function(grammar, memo) {
   const key = this.toMemoKey();
   if (!Object.prototype.hasOwnProperty.call(memo, key)) {
     const {body} = grammar.rules[this.ruleName];
@@ -2687,7 +2674,7 @@ pexprs$d.Apply.prototype._isNullable = function(grammar, memo) {
 // --------------------------------------------------------------------
 
 const common$9 = common$l;
-const pexprs$c = pexprsMain;
+const pexprs$b = pexprsMain;
 
 // --------------------------------------------------------------------
 // Operations
@@ -2700,44 +2687,44 @@ const pexprs$c = pexprsMain;
   The receiver must not be modified; a new PExpr must be returned if any replacement is necessary.
 */
 // function(actuals) { ... }
-pexprs$c.PExpr.prototype.substituteParams = common$9.abstract('substituteParams');
+pexprs$b.PExpr.prototype.substituteParams = common$9.abstract('substituteParams');
 
-pexprs$c.any.substituteParams =
-  pexprs$c.end.substituteParams =
-  pexprs$c.Terminal.prototype.substituteParams =
-  pexprs$c.Range.prototype.substituteParams =
-  pexprs$c.UnicodeChar.prototype.substituteParams =
+pexprs$b.any.substituteParams =
+  pexprs$b.end.substituteParams =
+  pexprs$b.Terminal.prototype.substituteParams =
+  pexprs$b.Range.prototype.substituteParams =
+  pexprs$b.UnicodeChar.prototype.substituteParams =
     function(actuals) {
       return this;
     };
 
-pexprs$c.Param.prototype.substituteParams = function(actuals) {
+pexprs$b.Param.prototype.substituteParams = function(actuals) {
   return actuals[this.index];
 };
 
-pexprs$c.Alt.prototype.substituteParams = function(actuals) {
-  return new pexprs$c.Alt(this.terms.map(term => term.substituteParams(actuals)));
+pexprs$b.Alt.prototype.substituteParams = function(actuals) {
+  return new pexprs$b.Alt(this.terms.map(term => term.substituteParams(actuals)));
 };
 
-pexprs$c.Seq.prototype.substituteParams = function(actuals) {
-  return new pexprs$c.Seq(this.factors.map(factor => factor.substituteParams(actuals)));
+pexprs$b.Seq.prototype.substituteParams = function(actuals) {
+  return new pexprs$b.Seq(this.factors.map(factor => factor.substituteParams(actuals)));
 };
 
-pexprs$c.Iter.prototype.substituteParams =
-  pexprs$c.Not.prototype.substituteParams =
-  pexprs$c.Lookahead.prototype.substituteParams =
-  pexprs$c.Lex.prototype.substituteParams =
+pexprs$b.Iter.prototype.substituteParams =
+  pexprs$b.Not.prototype.substituteParams =
+  pexprs$b.Lookahead.prototype.substituteParams =
+  pexprs$b.Lex.prototype.substituteParams =
     function(actuals) {
       return new this.constructor(this.expr.substituteParams(actuals));
     };
 
-pexprs$c.Apply.prototype.substituteParams = function(actuals) {
+pexprs$b.Apply.prototype.substituteParams = function(actuals) {
   if (this.args.length === 0) {
     // Avoid making a copy of this application, as an optimization
     return this;
   } else {
     const args = this.args.map(arg => arg.substituteParams(actuals));
-    return new pexprs$c.Apply(this.ruleName, args);
+    return new pexprs$b.Apply(this.ruleName, args);
   }
 };
 
@@ -2746,7 +2733,7 @@ pexprs$c.Apply.prototype.substituteParams = function(actuals) {
 // --------------------------------------------------------------------
 
 const common$8 = common$l;
-const pexprs$b = pexprsMain;
+const pexprs$a = pexprsMain;
 
 const {copyWithoutDuplicates} = common$8;
 
@@ -2812,17 +2799,17 @@ function resolveDuplicatedNames(argumentNameList) {
   * e.getArity() === e.toArgumentNameList(1).length
 */
 // function(firstArgIndex, noDupCheck) { ... }
-pexprs$b.PExpr.prototype.toArgumentNameList = common$8.abstract('toArgumentNameList');
+pexprs$a.PExpr.prototype.toArgumentNameList = common$8.abstract('toArgumentNameList');
 
-pexprs$b.any.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs$a.any.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   return ['any'];
 };
 
-pexprs$b.end.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs$a.end.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   return ['end'];
 };
 
-pexprs$b.Terminal.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs$a.Terminal.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   if (typeof this.obj === 'string' && /^[_a-zA-Z0-9]+$/.test(this.obj)) {
     // If this terminal is a valid suffix for a JS identifier, just prepend it with '_'
     return ['_' + this.obj];
@@ -2832,7 +2819,7 @@ pexprs$b.Terminal.prototype.toArgumentNameList = function(firstArgIndex, noDupCh
   }
 };
 
-pexprs$b.Range.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs$a.Range.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   let argName = this.from + '_to_' + this.to;
   // If the `argName` is not valid then try to prepend a `_`.
   if (!isRestrictedJSIdentifier(argName)) {
@@ -2845,7 +2832,7 @@ pexprs$b.Range.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck
   return [argName];
 };
 
-pexprs$b.Alt.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs$a.Alt.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   // `termArgNameLists` is an array of arrays where each row is the
   // argument name list that corresponds to a term in this alternation.
   const termArgNameLists = this.terms.map(term =>
@@ -2869,7 +2856,7 @@ pexprs$b.Alt.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck)
   return argumentNameList;
 };
 
-pexprs$b.Seq.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs$a.Seq.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   // Generate the argument name list, without worrying about duplicates.
   let argumentNameList = [];
   this.factors.forEach(factor => {
@@ -2885,7 +2872,7 @@ pexprs$b.Seq.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck)
   return argumentNameList;
 };
 
-pexprs$b.Iter.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs$a.Iter.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   const argumentNameList = this.expr
       .toArgumentNameList(firstArgIndex, noDupCheck)
       .map(exprArgumentString =>
@@ -2899,30 +2886,30 @@ pexprs$b.Iter.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck)
   return argumentNameList;
 };
 
-pexprs$b.Opt.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs$a.Opt.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   return this.expr.toArgumentNameList(firstArgIndex, noDupCheck).map(argName => {
     return 'opt' + argName[0].toUpperCase() + argName.slice(1);
   });
 };
 
-pexprs$b.Not.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs$a.Not.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   return [];
 };
 
-pexprs$b.Lookahead.prototype.toArgumentNameList = pexprs$b.Lex.prototype.toArgumentNameList =
+pexprs$a.Lookahead.prototype.toArgumentNameList = pexprs$a.Lex.prototype.toArgumentNameList =
   function(firstArgIndex, noDupCheck) {
     return this.expr.toArgumentNameList(firstArgIndex, noDupCheck);
   };
 
-pexprs$b.Apply.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs$a.Apply.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   return [this.ruleName];
 };
 
-pexprs$b.UnicodeChar.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs$a.UnicodeChar.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   return ['$' + firstArgIndex];
 };
 
-pexprs$b.Param.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs$a.Param.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   return ['param' + this.index];
 };
 
@@ -2931,36 +2918,36 @@ pexprs$b.Param.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck
 // --------------------------------------------------------------------
 
 const common$7 = common$l;
-const pexprs$a = pexprsMain;
+const pexprs$9 = pexprsMain;
 
 // --------------------------------------------------------------------
 // Operations
 // --------------------------------------------------------------------
 
 // Returns a string representing the PExpr, for use as a UI label, etc.
-pexprs$a.PExpr.prototype.toDisplayString = common$7.abstract('toDisplayString');
+pexprs$9.PExpr.prototype.toDisplayString = common$7.abstract('toDisplayString');
 
-pexprs$a.Alt.prototype.toDisplayString = pexprs$a.Seq.prototype.toDisplayString = function() {
+pexprs$9.Alt.prototype.toDisplayString = pexprs$9.Seq.prototype.toDisplayString = function() {
   if (this.source) {
     return this.source.trimmed().contents;
   }
   return '[' + this.constructor.name + ']';
 };
 
-pexprs$a.any.toDisplayString =
-  pexprs$a.end.toDisplayString =
-  pexprs$a.Iter.prototype.toDisplayString =
-  pexprs$a.Not.prototype.toDisplayString =
-  pexprs$a.Lookahead.prototype.toDisplayString =
-  pexprs$a.Lex.prototype.toDisplayString =
-  pexprs$a.Terminal.prototype.toDisplayString =
-  pexprs$a.Range.prototype.toDisplayString =
-  pexprs$a.Param.prototype.toDisplayString =
+pexprs$9.any.toDisplayString =
+  pexprs$9.end.toDisplayString =
+  pexprs$9.Iter.prototype.toDisplayString =
+  pexprs$9.Not.prototype.toDisplayString =
+  pexprs$9.Lookahead.prototype.toDisplayString =
+  pexprs$9.Lex.prototype.toDisplayString =
+  pexprs$9.Terminal.prototype.toDisplayString =
+  pexprs$9.Range.prototype.toDisplayString =
+  pexprs$9.Param.prototype.toDisplayString =
     function() {
       return this.toString();
     };
 
-pexprs$a.Apply.prototype.toDisplayString = function() {
+pexprs$9.Apply.prototype.toDisplayString = function() {
   if (this.args.length > 0) {
     const ps = this.args.map(arg => arg.toDisplayString());
     return this.ruleName + '<' + ps.join(',') + '>';
@@ -2969,7 +2956,7 @@ pexprs$a.Apply.prototype.toDisplayString = function() {
   }
 };
 
-pexprs$a.UnicodeChar.prototype.toDisplayString = function() {
+pexprs$9.UnicodeChar.prototype.toDisplayString = function() {
   return 'Unicode [' + this.category + '] character';
 };
 
@@ -2979,42 +2966,42 @@ pexprs$a.UnicodeChar.prototype.toDisplayString = function() {
 
 const Failure$1 = Failure_1;
 const common$6 = common$l;
-const pexprs$9 = pexprsMain;
+const pexprs$8 = pexprsMain;
 
 // --------------------------------------------------------------------
 // Operations
 // --------------------------------------------------------------------
 
-pexprs$9.PExpr.prototype.toFailure = common$6.abstract('toFailure');
+pexprs$8.PExpr.prototype.toFailure = common$6.abstract('toFailure');
 
-pexprs$9.any.toFailure = function(grammar) {
+pexprs$8.any.toFailure = function(grammar) {
   return new Failure$1(this, 'any object', 'description');
 };
 
-pexprs$9.end.toFailure = function(grammar) {
+pexprs$8.end.toFailure = function(grammar) {
   return new Failure$1(this, 'end of input', 'description');
 };
 
-pexprs$9.Terminal.prototype.toFailure = function(grammar) {
+pexprs$8.Terminal.prototype.toFailure = function(grammar) {
   return new Failure$1(this, this.obj, 'string');
 };
 
-pexprs$9.Range.prototype.toFailure = function(grammar) {
+pexprs$8.Range.prototype.toFailure = function(grammar) {
   // TODO: come up with something better
   return new Failure$1(this, JSON.stringify(this.from) + '..' + JSON.stringify(this.to), 'code');
 };
 
-pexprs$9.Not.prototype.toFailure = function(grammar) {
+pexprs$8.Not.prototype.toFailure = function(grammar) {
   const description =
-    this.expr === pexprs$9.any ? 'nothing' : 'not ' + this.expr.toFailure(grammar);
+    this.expr === pexprs$8.any ? 'nothing' : 'not ' + this.expr.toFailure(grammar);
   return new Failure$1(this, description, 'description');
 };
 
-pexprs$9.Lookahead.prototype.toFailure = function(grammar) {
+pexprs$8.Lookahead.prototype.toFailure = function(grammar) {
   return this.expr.toFailure(grammar);
 };
 
-pexprs$9.Apply.prototype.toFailure = function(grammar) {
+pexprs$8.Apply.prototype.toFailure = function(grammar) {
   let {description} = grammar.rules[this.ruleName];
   if (!description) {
     const article = /^[aeiouAEIOU]/.test(this.ruleName) ? 'an' : 'a';
@@ -3023,23 +3010,23 @@ pexprs$9.Apply.prototype.toFailure = function(grammar) {
   return new Failure$1(this, description, 'description');
 };
 
-pexprs$9.UnicodeChar.prototype.toFailure = function(grammar) {
+pexprs$8.UnicodeChar.prototype.toFailure = function(grammar) {
   return new Failure$1(this, 'a Unicode [' + this.category + '] character', 'description');
 };
 
-pexprs$9.Alt.prototype.toFailure = function(grammar) {
+pexprs$8.Alt.prototype.toFailure = function(grammar) {
   const fs = this.terms.map(t => t.toFailure(grammar));
   const description = '(' + fs.join(' or ') + ')';
   return new Failure$1(this, description, 'description');
 };
 
-pexprs$9.Seq.prototype.toFailure = function(grammar) {
+pexprs$8.Seq.prototype.toFailure = function(grammar) {
   const fs = this.factors.map(f => f.toFailure(grammar));
   const description = '(' + fs.join(' ') + ')';
   return new Failure$1(this, description, 'description');
 };
 
-pexprs$9.Iter.prototype.toFailure = function(grammar) {
+pexprs$8.Iter.prototype.toFailure = function(grammar) {
   const description = '(' + this.expr.toFailure(grammar) + this.operator + ')';
   return new Failure$1(this, description, 'description');
 };
@@ -3049,7 +3036,7 @@ pexprs$9.Iter.prototype.toFailure = function(grammar) {
 // --------------------------------------------------------------------
 
 const common$5 = common$l;
-const pexprs$8 = pexprsMain;
+const pexprs$7 = pexprsMain;
 
 // --------------------------------------------------------------------
 // Operations
@@ -3062,57 +3049,57 @@ const pexprs$8 = pexprsMain;
   ~"b" "a" and "a" are interchangeable in any grammar,
   both in terms of the languages they accept and their arities.
 */
-pexprs$8.PExpr.prototype.toString = common$5.abstract('toString');
+pexprs$7.PExpr.prototype.toString = common$5.abstract('toString');
 
-pexprs$8.any.toString = function() {
+pexprs$7.any.toString = function() {
   return 'any';
 };
 
-pexprs$8.end.toString = function() {
+pexprs$7.end.toString = function() {
   return 'end';
 };
 
-pexprs$8.Terminal.prototype.toString = function() {
+pexprs$7.Terminal.prototype.toString = function() {
   return JSON.stringify(this.obj);
 };
 
-pexprs$8.Range.prototype.toString = function() {
+pexprs$7.Range.prototype.toString = function() {
   return JSON.stringify(this.from) + '..' + JSON.stringify(this.to);
 };
 
-pexprs$8.Param.prototype.toString = function() {
+pexprs$7.Param.prototype.toString = function() {
   return '$' + this.index;
 };
 
-pexprs$8.Lex.prototype.toString = function() {
+pexprs$7.Lex.prototype.toString = function() {
   return '#(' + this.expr.toString() + ')';
 };
 
-pexprs$8.Alt.prototype.toString = function() {
+pexprs$7.Alt.prototype.toString = function() {
   return this.terms.length === 1 ?
     this.terms[0].toString() :
     '(' + this.terms.map(term => term.toString()).join(' | ') + ')';
 };
 
-pexprs$8.Seq.prototype.toString = function() {
+pexprs$7.Seq.prototype.toString = function() {
   return this.factors.length === 1 ?
     this.factors[0].toString() :
     '(' + this.factors.map(factor => factor.toString()).join(' ') + ')';
 };
 
-pexprs$8.Iter.prototype.toString = function() {
+pexprs$7.Iter.prototype.toString = function() {
   return this.expr + this.operator;
 };
 
-pexprs$8.Not.prototype.toString = function() {
+pexprs$7.Not.prototype.toString = function() {
   return '~' + this.expr;
 };
 
-pexprs$8.Lookahead.prototype.toString = function() {
+pexprs$7.Lookahead.prototype.toString = function() {
   return '&' + this.expr;
 };
 
-pexprs$8.Apply.prototype.toString = function() {
+pexprs$7.Apply.prototype.toString = function() {
   if (this.args.length > 0) {
     const ps = this.args.map(arg => arg.toString());
     return this.ruleName + '<' + ps.join(',') + '>';
@@ -3121,7 +3108,7 @@ pexprs$8.Apply.prototype.toString = function() {
   }
 };
 
-pexprs$8.UnicodeChar.prototype.toString = function() {
+pexprs$7.UnicodeChar.prototype.toString = function() {
   return '\\p{' + this.category + '}';
 };
 
@@ -3129,7 +3116,7 @@ pexprs$8.UnicodeChar.prototype.toString = function() {
 // Re-export classes
 // --------------------------------------------------------------------
 
-var pexprs$7 = pexprsMain;
+var pexprs$6 = pexprsMain;
 
 // --------------------------------------------------------------------
 // Imports
@@ -3138,7 +3125,7 @@ var pexprs$7 = pexprsMain;
 const Failure = Failure_1;
 const {TerminalNode} = nodes$1;
 const {assert: assert$1} = common$l;
-const {PExpr, Terminal} = pexprs$7;
+const {PExpr, Terminal} = pexprs$6;
 
 class CaseInsensitiveTerminal$1 extends PExpr {
   constructor(param) {
@@ -3166,7 +3153,7 @@ class CaseInsensitiveTerminal$1 extends PExpr {
       state.processFailure(origPos, this);
       return false;
     } else {
-      state.pushBinding(new TerminalNode(state.grammar, matchStr), origPos);
+      state.pushBinding(new TerminalNode(matchStr.length), origPos);
       return true;
     }
   }
@@ -3227,7 +3214,12 @@ InputStream$3.prototype = {
     return ans;
   },
 
-  nextCodePoint(dbg = false) {
+  nextCharCode() {
+    const nextChar = this.next();
+    return nextChar && nextChar.charCodeAt(0);
+  },
+
+  nextCodePoint() {
     const cp = this.source.slice(this.pos++).codePointAt(0);
     // If the code point is beyond plane 0, it takes up two characters.
     if (cp > 0xffff) {
@@ -3293,7 +3285,7 @@ const Interval = Interval_1;
 // Private stuff
 // --------------------------------------------------------------------
 
-function MatchResult$3(
+function MatchResult$2(
     matcher,
     input,
     startExpr,
@@ -3327,19 +3319,19 @@ function MatchResult$3(
   }
 }
 
-MatchResult$3.prototype.succeeded = function() {
+MatchResult$2.prototype.succeeded = function() {
   return !!this._cst;
 };
 
-MatchResult$3.prototype.failed = function() {
+MatchResult$2.prototype.failed = function() {
   return !this.succeeded();
 };
 
-MatchResult$3.prototype.getRightmostFailurePosition = function() {
+MatchResult$2.prototype.getRightmostFailurePosition = function() {
   return this._rightmostFailurePosition;
 };
 
-MatchResult$3.prototype.getRightmostFailures = function() {
+MatchResult$2.prototype.getRightmostFailures = function() {
   if (!this._rightmostFailures) {
     this.matcher.setInput(this.input);
     const matchResultWithFailures = this.matcher._match(
@@ -3352,7 +3344,7 @@ MatchResult$3.prototype.getRightmostFailures = function() {
   return this._rightmostFailures;
 };
 
-MatchResult$3.prototype.toString = function() {
+MatchResult$2.prototype.toString = function() {
   return this.succeeded() ?
     '[match succeeded]' :
     '[match failed at position ' + this.getRightmostFailurePosition() + ']';
@@ -3360,7 +3352,7 @@ MatchResult$3.prototype.toString = function() {
 
 // Return a string summarizing the expected contents of the input stream when
 // the match failure occurred.
-MatchResult$3.prototype.getExpectedText = function() {
+MatchResult$2.prototype.getExpectedText = function() {
   if (this.succeeded()) {
     throw new Error('cannot get expected text of a successful MatchResult');
   }
@@ -3384,7 +3376,7 @@ MatchResult$3.prototype.getExpectedText = function() {
   return sb.contents();
 };
 
-MatchResult$3.prototype.getInterval = function() {
+MatchResult$2.prototype.getInterval = function() {
   const pos = this.getRightmostFailurePosition();
   return new Interval(this.input, pos, pos);
 };
@@ -3393,7 +3385,7 @@ MatchResult$3.prototype.getInterval = function() {
 // Exports
 // --------------------------------------------------------------------
 
-var MatchResult_1 = MatchResult$3;
+var MatchResult_1 = MatchResult$2;
 
 // --------------------------------------------------------------------
 // Private stuff
@@ -3513,10 +3505,10 @@ var PosInfo_1 = PosInfo$1;
 // --------------------------------------------------------------------
 
 const InputStream$2 = InputStream_1;
-const MatchResult$2 = MatchResult_1;
+const MatchResult$1 = MatchResult_1;
 const PosInfo = PosInfo_1;
 const Trace = Trace_1;
-const pexprs$6 = pexprs$7;
+const pexprs$5 = pexprs$6;
 const util$3 = util$7;
 
 // --------------------------------------------------------------------
@@ -3529,7 +3521,7 @@ util$3.awaitBuiltInRules(builtInRules => {
   builtInApplySyntacticBody = builtInRules.rules.applySyntactic.body;
 });
 
-const applySpaces = new pexprs$6.Apply('spaces');
+const applySpaces = new pexprs$5.Apply('spaces');
 
 function MatchState$1(matcher, startExpr, optPositionToRecordFailures) {
   this.matcher = matcher;
@@ -3722,7 +3714,7 @@ MatchState$1.prototype = {
   // Returns the memoized trace entry for `expr` at `pos`, if one exists, `null` otherwise.
   getMemoizedTraceEntry(pos, expr) {
     const posInfo = this.memoTable[pos];
-    if (posInfo && expr.ruleName) {
+    if (posInfo && expr instanceof pexprs$5.Apply) {
       const memoRec = posInfo.memo[expr.toMemoKey()];
       if (memoRec && memoRec.traceEntry) {
         const entry = memoRec.traceEntry.cloneWithExpr(expr);
@@ -3735,7 +3727,7 @@ MatchState$1.prototype = {
 
   // Returns a new trace entry, with the currently active trace array as its children.
   getTraceEntry(pos, expr, succeeded, bindings) {
-    if (expr instanceof pexprs$6.Apply) {
+    if (expr instanceof pexprs$5.Apply) {
       const app = this.currentApplication();
       const actuals = app ? app.args : [];
       expr = expr.substituteParams(actuals);
@@ -3864,11 +3856,15 @@ MatchState$1.prototype = {
           key => this.recordedFailures[key]
       );
     }
-    return new MatchResult$2(
+    const cst = this._bindings[0];
+    if (cst) {
+      cst.grammar = this.grammar;
+    }
+    return new MatchResult$1(
         this.matcher,
         this.input,
         this.startExpr,
-        this._bindings[0],
+        cst,
         this._bindingOffsets[0],
         this.rightmostFailurePosition,
         rightmostFailures
@@ -3911,7 +3907,7 @@ var MatchState_1 = MatchState$1;
 
 const MatchState = MatchState_1;
 
-const pexprs$5 = pexprs$7;
+const pexprs$4 = pexprs$6;
 
 // --------------------------------------------------------------------
 // Private stuff
@@ -3995,7 +3991,7 @@ Matcher$1.prototype._getStartExpr = function(optStartApplicationStr) {
   }
 
   const startApp = this.grammar.parseApplication(applicationStr);
-  return new pexprs$5.Seq([startApp, pexprs$5.end]);
+  return new pexprs$4.Seq([startApp, pexprs$4.end]);
 };
 
 // --------------------------------------------------------------------
@@ -4010,7 +4006,7 @@ var Matcher_1 = Matcher$1;
 
 const InputStream$1 = InputStream_1;
 const {IterationNode} = nodes$1;
-const MatchResult$1 = MatchResult_1;
+const MatchResult = MatchResult_1;
 const common$3 = common$l;
 const errors$3 = errors$9;
 const util$2 = util$7;
@@ -4051,11 +4047,6 @@ class Wrapper {
     return '[semantics wrapper for ' + this._node.grammar.name + ']';
   }
 
-  // This is used by ohm editor to display a node wrapper appropriately.
-  toJSON() {
-    return this.toString();
-  }
-
   _forgetMemoizedResultFor(attributeName) {
     // Remove the memoized attribute from the cstNode and all its children.
     delete this._node[this._semantics.attributeKeys[attributeName]];
@@ -4135,7 +4126,7 @@ class Wrapper {
     const childWrappers = optChildWrappers || [];
 
     const childNodes = childWrappers.map(c => c._node);
-    const iter = new IterationNode(this._node.grammar, childNodes, [], -1, false);
+    const iter = new IterationNode(childNodes, [], -1, false);
 
     const wrapper = this._semantics.wrap(iter, null, null);
     wrapper._childWrappers = childWrappers;
@@ -4162,18 +4153,6 @@ class Wrapper {
     return this._node.numChildren();
   }
 
-  // Returns the primitive value of this CST node, if it's a terminal node. Otherwise,
-  // throws an exception.
-  // DEPRECATED: Use `sourceString` instead.
-  get primitiveValue() {
-    if (this.isTerminal()) {
-      return this._node.primitiveValue;
-    }
-    throw new TypeError(
-        "tried to access the 'primitiveValue' attribute of a non-terminal CST node"
-    );
-  }
-
   // Returns the contents of the input stream consumed by this CST node.
   get sourceString() {
     return this.source.contents;
@@ -4539,7 +4518,7 @@ Semantics$2.createSemantics = function(grammar, optSuperSemantics) {
   // To enable clients to invoke a semantics like a function, return a function that acts as a proxy
   // for `s`, which is the real `Semantics` instance.
   const proxy = function ASemantics(matchResult) {
-    if (!(matchResult instanceof MatchResult$1)) {
+    if (!(matchResult instanceof MatchResult)) {
       throw new TypeError(
           'Semantics expected a MatchResult, but got ' +
           common$3.unexpectedObjToString(matchResult)
@@ -4723,7 +4702,7 @@ const Matcher = Matcher_1;
 const Semantics$1 = Semantics_1;
 const common$2 = common$l;
 const errors$2 = errors$9;
-const pexprs$4 = pexprs$7;
+const pexprs$3 = pexprs$6;
 
 // --------------------------------------------------------------------
 // Private stuff
@@ -4744,7 +4723,7 @@ function getSortedRuleValues(grammar) {
 // See https://v8.dev/features/subsume-json for more details.
 const jsonToJS = str => str.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 
-function Grammar$5(name, superGrammar, rules, optDefaultStartRule) {
+function Grammar$4(name, superGrammar, rules, optDefaultStartRule) {
   this.name = name;
   this.superGrammar = superGrammar;
   this.rules = rules;
@@ -4766,12 +4745,12 @@ let ohmGrammar$2;
 let buildGrammar$1;
 
 // This method is called from main.js once Ohm has loaded.
-Grammar$5.initApplicationParser = function(grammar, builderFn) {
+Grammar$4.initApplicationParser = function(grammar, builderFn) {
   ohmGrammar$2 = grammar;
   buildGrammar$1 = builderFn;
 };
 
-Grammar$5.prototype = {
+Grammar$4.prototype = {
   matcher() {
     return new Matcher(this);
   },
@@ -4779,7 +4758,7 @@ Grammar$5.prototype = {
   // Return true if the grammar is a built-in grammar, otherwise false.
   // NOTE: This might give an unexpected result if called before BuiltInRules is defined!
   isBuiltIn() {
-    return this === Grammar$5.ProtoBuiltInRules || this === Grammar$5.BuiltInRules;
+    return this === Grammar$4.ProtoBuiltInRules || this === Grammar$4.BuiltInRules;
   },
 
   equals(g) {
@@ -4918,7 +4897,7 @@ Grammar$5.prototype = {
       if (isDefinition) {
         operation = 'define';
       } else {
-        operation = body instanceof pexprs$4.Extend ? 'extend' : 'override';
+        operation = body instanceof pexprs$3.Extend ? 'extend' : 'override';
       }
 
       const metaInfo = {};
@@ -5005,7 +4984,7 @@ Grammar$5.prototype = {
     let app;
     if (str.indexOf('<') === -1) {
       // simple application
-      app = new pexprs$4.Apply(str);
+      app = new pexprs$3.Apply(str);
     } else {
       // parameterized application
       const cst = ohmGrammar$2.match(str, 'Base_application');
@@ -5035,43 +5014,43 @@ Grammar$5.prototype = {
 // `BuiltInRules`. That grammar contains several convenience rules, e.g., `letter` and
 // `digit`, and is implicitly the super-grammar of any grammar whose super-grammar
 // isn't specified.
-Grammar$5.ProtoBuiltInRules = new Grammar$5(
+Grammar$4.ProtoBuiltInRules = new Grammar$4(
     'ProtoBuiltInRules', // name
     undefined, // supergrammar
     {
       any: {
-        body: pexprs$4.any,
+        body: pexprs$3.any,
         formals: [],
         description: 'any character',
         primitive: true,
       },
       end: {
-        body: pexprs$4.end,
+        body: pexprs$3.end,
         formals: [],
         description: 'end of input',
         primitive: true,
       },
 
       caseInsensitive: {
-        body: new CaseInsensitiveTerminal(new pexprs$4.Param(0)),
+        body: new CaseInsensitiveTerminal(new pexprs$3.Param(0)),
         formals: ['str'],
         primitive: true,
       },
       lower: {
-        body: new pexprs$4.UnicodeChar('Ll'),
+        body: new pexprs$3.UnicodeChar('Ll'),
         formals: [],
         description: 'a lowercase letter',
         primitive: true,
       },
       upper: {
-        body: new pexprs$4.UnicodeChar('Lu'),
+        body: new pexprs$3.UnicodeChar('Lu'),
         formals: [],
         description: 'an uppercase letter',
         primitive: true,
       },
       // Union of Lt (titlecase), Lm (modifier), and Lo (other), i.e. any letter not in Ll or Lu.
       unicodeLtmo: {
-        body: new pexprs$4.UnicodeChar('Ltmo'),
+        body: new pexprs$3.UnicodeChar('Ltmo'),
         formals: [],
         description: 'a Unicode character in Lt, Lm, or Lo',
         primitive: true,
@@ -5080,11 +5059,11 @@ Grammar$5.ProtoBuiltInRules = new Grammar$5(
       // These rules are not truly primitive (they could be written in userland) but are defined
       // here for bootstrapping purposes.
       spaces: {
-        body: new pexprs$4.Star(new pexprs$4.Apply('space')),
+        body: new pexprs$3.Star(new pexprs$3.Apply('space')),
         formals: [],
       },
       space: {
-        body: new pexprs$4.Range('\x00', ' '),
+        body: new pexprs$3.Range('\x00', ' '),
         formals: [],
         description: 'a space',
       },
@@ -5095,17 +5074,17 @@ Grammar$5.ProtoBuiltInRules = new Grammar$5(
 // Exports
 // --------------------------------------------------------------------
 
-var Grammar_1 = Grammar$5;
+var Grammar_1 = Grammar$4;
 
 // --------------------------------------------------------------------
 // Imports
 // --------------------------------------------------------------------
 
-const Grammar$4 = Grammar_1;
+const Grammar$3 = Grammar_1;
 const InputStream = InputStream_1;
 const common$1 = common$l;
 const errors$1 = errors$9;
-const pexprs$3 = pexprs$7;
+const pexprs$2 = pexprs$6;
 
 // --------------------------------------------------------------------
 // Private Stuff
@@ -5129,7 +5108,7 @@ GrammarDecl$1.prototype.ensureSuperGrammar = function() {
       // TODO: The conditional expression below is an ugly hack. It's kind of ok because
       // I doubt anyone will ever try to declare a grammar called `BuiltInRules`. Still,
       // we should try to find a better way to do this.
-      this.name === 'BuiltInRules' ? Grammar$4.ProtoBuiltInRules : Grammar$4.BuiltInRules
+      this.name === 'BuiltInRules' ? Grammar$3.ProtoBuiltInRules : Grammar$3.BuiltInRules
     );
   }
   return this.superGrammar;
@@ -5200,7 +5179,7 @@ GrammarDecl$1.prototype.withSource = function(source) {
 
 // Creates a Grammar instance, and if it passes the sanity checks, returns it.
 GrammarDecl$1.prototype.build = function() {
-  const grammar = new Grammar$4(
+  const grammar = new Grammar$3(
       this.name,
       this.ensureSuperGrammar(),
       this.rules,
@@ -5276,7 +5255,7 @@ GrammarDecl$1.prototype.extend = function(name, formals, fragment, descIgnored,
   if (!ruleInfo) {
     throw errors$1.cannotExtendUndeclaredRule(name, this.superGrammar.name, source);
   }
-  const body = new pexprs$3.Extend(this.superGrammar, name, fragment);
+  const body = new pexprs$2.Extend(this.superGrammar, name, fragment);
   body.source = fragment.source;
   this.installOverriddenOrExtendedRule(name, formals, body, source);
   return this;
@@ -5292,9 +5271,9 @@ var GrammarDecl_1 = GrammarDecl$1;
 // Imports
 // --------------------------------------------------------------------
 
-const Grammar$3 = Grammar_1;
+const Grammar$2 = Grammar_1;
 const GrammarDecl = GrammarDecl_1;
-const pexprs$2 = pexprs$7;
+const pexprs$1 = pexprs$6;
 
 // --------------------------------------------------------------------
 // Private stuff
@@ -5315,7 +5294,7 @@ Builder$2.prototype = {
     if (superGrammar) {
       // `superGrammar` may be a recipe (i.e. an Array), or an actual grammar instance.
       gDecl.withSuperGrammar(
-        superGrammar instanceof Grammar$3 ? superGrammar : this.fromRecipe(superGrammar)
+        superGrammar instanceof Grammar$2 ? superGrammar : this.fromRecipe(superGrammar)
       );
     }
     if (defaultStartRule) {
@@ -5350,73 +5329,73 @@ Builder$2.prototype = {
   },
 
   terminal(x) {
-    return new pexprs$2.Terminal(x);
+    return new pexprs$1.Terminal(x);
   },
 
   range(from, to) {
-    return new pexprs$2.Range(from, to);
+    return new pexprs$1.Range(from, to);
   },
 
   param(index) {
-    return new pexprs$2.Param(index);
+    return new pexprs$1.Param(index);
   },
 
   alt(...termArgs) {
     let terms = [];
     for (let arg of termArgs) {
-      if (!(arg instanceof pexprs$2.PExpr)) {
+      if (!(arg instanceof pexprs$1.PExpr)) {
         arg = this.fromRecipe(arg);
       }
-      if (arg instanceof pexprs$2.Alt) {
+      if (arg instanceof pexprs$1.Alt) {
         terms = terms.concat(arg.terms);
       } else {
         terms.push(arg);
       }
     }
-    return terms.length === 1 ? terms[0] : new pexprs$2.Alt(terms);
+    return terms.length === 1 ? terms[0] : new pexprs$1.Alt(terms);
   },
 
   seq(...factorArgs) {
     let factors = [];
     for (let arg of factorArgs) {
-      if (!(arg instanceof pexprs$2.PExpr)) {
+      if (!(arg instanceof pexprs$1.PExpr)) {
         arg = this.fromRecipe(arg);
       }
-      if (arg instanceof pexprs$2.Seq) {
+      if (arg instanceof pexprs$1.Seq) {
         factors = factors.concat(arg.factors);
       } else {
         factors.push(arg);
       }
     }
-    return factors.length === 1 ? factors[0] : new pexprs$2.Seq(factors);
+    return factors.length === 1 ? factors[0] : new pexprs$1.Seq(factors);
   },
 
   star(expr) {
-    if (!(expr instanceof pexprs$2.PExpr)) {
+    if (!(expr instanceof pexprs$1.PExpr)) {
       expr = this.fromRecipe(expr);
     }
-    return new pexprs$2.Star(expr);
+    return new pexprs$1.Star(expr);
   },
 
   plus(expr) {
-    if (!(expr instanceof pexprs$2.PExpr)) {
+    if (!(expr instanceof pexprs$1.PExpr)) {
       expr = this.fromRecipe(expr);
     }
-    return new pexprs$2.Plus(expr);
+    return new pexprs$1.Plus(expr);
   },
 
   opt(expr) {
-    if (!(expr instanceof pexprs$2.PExpr)) {
+    if (!(expr instanceof pexprs$1.PExpr)) {
       expr = this.fromRecipe(expr);
     }
-    return new pexprs$2.Opt(expr);
+    return new pexprs$1.Opt(expr);
   },
 
   not(expr) {
-    if (!(expr instanceof pexprs$2.PExpr)) {
+    if (!(expr instanceof pexprs$1.PExpr)) {
       expr = this.fromRecipe(expr);
     }
-    return new pexprs$2.Not(expr);
+    return new pexprs$1.Not(expr);
   },
 
   la(expr) {
@@ -5425,33 +5404,33 @@ Builder$2.prototype = {
   },
 
   lookahead(expr) {
-    if (!(expr instanceof pexprs$2.PExpr)) {
+    if (!(expr instanceof pexprs$1.PExpr)) {
       expr = this.fromRecipe(expr);
     }
-    return new pexprs$2.Lookahead(expr);
+    return new pexprs$1.Lookahead(expr);
   },
 
   lex(expr) {
-    if (!(expr instanceof pexprs$2.PExpr)) {
+    if (!(expr instanceof pexprs$1.PExpr)) {
       expr = this.fromRecipe(expr);
     }
-    return new pexprs$2.Lex(expr);
+    return new pexprs$1.Lex(expr);
   },
 
   app(ruleName, optParams) {
     if (optParams && optParams.length > 0) {
       optParams = optParams.map(function(param) {
-        return param instanceof pexprs$2.PExpr ? param : this.fromRecipe(param);
+        return param instanceof pexprs$1.PExpr ? param : this.fromRecipe(param);
       }, this);
     }
-    return new pexprs$2.Apply(ruleName, optParams);
+    return new pexprs$1.Apply(ruleName, optParams);
   },
 
   // Note that unlike other methods in this class, this method cannot be used as a
   // convenience constructor. It only works with recipes, because it relies on
   // `this.currentDecl` and `this.currentRuleName` being set.
   splice(beforeTerms, afterTerms) {
-    return new pexprs$2.Splice(
+    return new pexprs$1.Splice(
         this.currentDecl.superGrammar,
         this.currentRuleName,
         beforeTerms.map(term => this.fromRecipe(term)),
@@ -5481,7 +5460,7 @@ Builder$2.prototype = {
 var Builder_1 = Builder$2;
 
 var name = "ohm-js";
-var version$2 = "16.1.1";
+var version$2 = "16.3.2";
 var description = "An object-oriented language for parsing and pattern matching";
 var repository = "https://github.com/harc/ohm";
 var keywords = [
@@ -5496,7 +5475,7 @@ var keywords = [
 	"rapid",
 	"prototyping"
 ];
-var homepage = "https://ohmlang.github.io/";
+var homepage = "https://ohmjs.org";
 var bugs = "https://github.com/harc/ohm/issues";
 var main = "index.js";
 var module = "dist/ohm.esm.js";
@@ -5540,33 +5519,35 @@ var contributors = [
 	"Jason Merrill <jwmerrill@gmail.com>",
 	"Ray Toal <rtoal@lmu.edu>",
 	"Yoshiki Ohshima <Yoshiki.Ohshima@acm.org>",
+	"megabuz <3299889+megabuz@users.noreply.github.com>",
 	"stagas <gstagas@gmail.com>",
 	"Jonathan Edwards <JonathanMEdwards@gmail.com>",
 	"Milan Lajtoš <milan.lajtos@me.com>",
 	"Neil Jewers <njjewers@uwaterloo.ca>",
-	"megabuz <3299889+megabuz@users.noreply.github.com>",
 	"Mike Niebling <(none)>",
-	"sfinnie <scott.finnie@gmail.com>",
-	"Justin Chase <justin.m.chase@gmail.com>",
+	"AngryPowman <angrypowman@qq.com>",
+	"Patrick Dubroy <patrick@sourcegraph.com>",
+	"Leslie Ying <acetophore@users.noreply.github.com>",
 	"Pierre Donias <pierre.donias@gmail.com>",
+	"Justin Chase <justin.m.chase@gmail.com>",
 	"Ian Harris <ian@fofgof.xyz>",
-	"Daniel Tomlinson <DanielTomlinson@me.com>",
 	"Stan Rozenraukh <stan@stanistan.com>",
 	"Stephan Seidt <stephan.seidt@gmail.com>",
 	"Steve Phillips <steve@tryingtobeawesome.com>",
 	"Szymon Kaliski <kaliskiszymon@gmail.com>",
 	"Thomas Nyberg <tomnyberg@gmail.com>",
-	"Casey Olson <casey.m.olson@gmail.com>",
+	"Daniel Tomlinson <DanielTomlinson@me.com>",
 	"Vse Mozhet Byt <vsemozhetbyt@gmail.com>",
 	"Wil Chung <10446+iamwilhelm@users.noreply.github.com>",
-	"Arthur Carabott <arthurc@gmail.com>",
+	"Casey Olson <casey.m.olson@gmail.com>",
 	"abego <ub@abego-software.de>",
 	"acslk <d_vd415@hotmail.com>",
 	"codeZeilen <codeZeilen@users.noreply.github.com>",
-	"AngryPowman <angrypowman@qq.com>",
+	"kassadin <kassadin@foxmail.com>",
+	"Arthur Carabott <arthurc@gmail.com>",
+	"owch <bowenrainyday@gmail.com>",
 	"Luca Guzzon <luca.guzzon@gmail.com>",
-	"Leslie Ying <acetophore@users.noreply.github.com>",
-	"owch <bowenrainyday@gmail.com>"
+	"sfinnie <scott.finnie@gmail.com>"
 ];
 var dependencies = {
 };
@@ -5667,13 +5648,13 @@ var builtInRules = makeRecipe$3(["grammar",{"source":"BuiltInRules {\n\n  alnum
 // Imports
 // --------------------------------------------------------------------
 
-const Grammar$2 = Grammar_1;
+const Grammar$1 = Grammar_1;
 
 // --------------------------------------------------------------------
 // Private stuff
 // --------------------------------------------------------------------
 
-Grammar$2.BuiltInRules = builtInRules;
+Grammar$1.BuiltInRules = builtInRules;
 
 var {makeRecipe: makeRecipe$2} = makeRecipe$5;
 var operationsAndAttributes = makeRecipe$2(["grammar",{"source":"OperationsAndAttributes {\n\n  AttributeSignature =\n    name\n\n  OperationSignature =\n    name Formals?\n\n  Formals\n    = \"(\" ListOf<name, \",\"> \")\"\n\n  name  (a name)\n    = nameFirst nameRest*\n\n  nameFirst\n    = \"_\"\n    | letter\n\n  nameRest\n    = \"_\"\n    | alnum\n\n}"},"OperationsAndAttributes",null,"AttributeSignature",{"AttributeSignature":["define",{"sourceInterval":[29,58]},null,[],["app",{"sourceInterval":[54,58]},"name",[]]],"OperationSignature":["define",{"sourceInterval":[62,100]},null,[],["seq",{"sourceInterval":[87,100]},["app",{"sourceInterval":[87,91]},"name",[]],["opt",{"sourceInterval":[92,100]},["app",{"sourceInterval":[92,99]},"Formals",[]]]]],"Formals":["define",{"sourceInterval":[104,143]},null,[],["seq",{"sourceInterval":[118,143]},["terminal",{"sourceInterval":[118,121]},"("],["app",{"sourceInterval":[122,139]},"ListOf",[["app",{"sourceInterval":[129,133]},"name",[]],["terminal",{"sourceInterval":[135,138]},","]]],["terminal",{"sourceInterval":[140,143]},")"]]],"name":["define",{"sourceInterval":[147,187]},"a name",[],["seq",{"sourceInterval":[168,187]},["app",{"sourceInterval":[168,177]},"nameFirst",[]],["star",{"sourceInterval":[178,187]},["app",{"sourceInterval":[178,186]},"nameRest",[]]]]],"nameFirst":["define",{"sourceInterval":[191,223]},null,[],["alt",{"sourceInterval":[207,223]},["terminal",{"sourceInterval":[207,210]},"_"],["app",{"sourceInterval":[217,223]},"letter",[]]]],"nameRest":["define",{"sourceInterval":[227,257]},null,[],["alt",{"sourceInterval":[242,257]},["terminal",{"sourceInterval":[242,245]},"_"],["app",{"sourceInterval":[252,257]},"alnum",[]]]]}]);
@@ -5739,18 +5720,18 @@ function initPrototypeParser(grammar) {
 }
 
 var {makeRecipe: makeRecipe$1} = makeRecipe$5;
-var ohmGrammar$1 = makeRecipe$1(["grammar",{"source":"Ohm {\n\n  Grammars\n    = Grammar*\n\n  Grammar\n    = ident SuperGrammar? \"{\" Rule* \"}\"\n\n  SuperGrammar\n    = \"<:\" ident\n\n  Rule\n    = ident Formals? ruleDescr? \"=\"  RuleBody  -- define\n    | ident Formals?            \":=\" OverrideRuleBody  -- override\n    | ident Formals?            \"+=\" RuleBody  -- extend\n\n  RuleBody\n    = \"|\"? NonemptyListOf<TopLevelTerm, \"|\">\n\n  TopLevelTerm\n    = Seq caseName  -- inline\n    | Seq\n\n  OverrideRuleBody\n    = \"|\"? NonemptyListOf<OverrideTopLevelTerm, \"|\">\n\n  OverrideTopLevelTerm\n    = \"...\"  -- superSplice\n    | TopLevelTerm\n\n  Formals\n    = \"<\" ListOf<ident, \",\"> \">\"\n\n  Params\n    = \"<\" ListOf<Seq, \",\"> \">\"\n\n  Alt\n    = NonemptyListOf<Seq, \"|\">\n\n  Seq\n    = Iter*\n\n  Iter\n    = Pred \"*\"  -- star\n    | Pred \"+\"  -- plus\n    | Pred \"?\"  -- opt\n    | Pred\n\n  Pred\n    = \"~\" Lex  -- not\n    | \"&\" Lex  -- lookahead\n    | Lex\n\n  Lex\n    = \"#\" Base  -- lex\n    | Base\n\n  Base\n    = ident Params? ~(ruleDescr? \"=\" | \":=\" | \"+=\")  -- application\n    | oneCharTerminal \"..\" oneCharTerminal           -- range\n    | terminal                                       -- terminal\n    | \"(\" Alt \")\"                                    -- paren\n\n  ruleDescr  (a rule description)\n    = \"(\" ruleDescrText \")\"\n\n  ruleDescrText\n    = (~\")\" any)*\n\n  caseName\n    = \"--\" (~\"\\n\" space)* name (~\"\\n\" space)* (\"\\n\" | &\"}\")\n\n  name  (a name)\n    = nameFirst nameRest*\n\n  nameFirst\n    = \"_\"\n    | letter\n\n  nameRest\n    = \"_\"\n    | alnum\n\n  ident  (an identifier)\n    = name\n\n  terminal\n    = \"\\\"\" terminalChar* \"\\\"\"\n\n  oneCharTerminal\n    = \"\\\"\" terminalChar \"\\\"\"\n\n  terminalChar\n    = escapeChar\n//    | ~\"\\\\\" ~\"\\\"\" ~\"\\n\" any\n      | ~\"\\\\\" ~\"\\\"\" ~\"\\n\" \"\\u{0}\"..\"\\u{10FFFF}\"\n\n  escapeChar  (an escape sequence)\n    = \"\\\\\\\\\"                                     -- backslash\n    | \"\\\\\\\"\"                                     -- doubleQuote\n    | \"\\\\\\'\"                                     -- singleQuote\n    | \"\\\\b\"                                      -- backspace\n    | \"\\\\n\"                                      -- lineFeed\n    | \"\\\\r\"                                      -- carriageReturn\n    | \"\\\\t\"                                      -- tab\n    | \"\\\\u{\" hexDigit+ \"}\"                       -- unicodeCodePoint\n    | \"\\\\u\" hexDigit hexDigit hexDigit hexDigit  -- unicodeEscape\n    | \"\\\\x\" hexDigit hexDigit                    -- hexEscape\n\n  space\n   += comment\n\n  comment\n    = \"//\" (~\"\\n\" any)* &(\"\\n\" | end)  -- singleLine\n    | \"/*\" (~\"*/\" any)* \"*/\"  -- multiLine\n\n  tokens = token*\n\n  token = caseName | comment | ident | operator | punctuation | terminal | any\n\n  operator = \"<:\" | \"=\" | \":=\" | \"+=\" | \"*\" | \"+\" | \"?\" | \"~\" | \"&\"\n\n  punctuation = \"<\" | \">\" | \",\" | \"--\"\n}"},"Ohm",null,"Grammars",{"Grammars":["define",{"sourceInterval":[9,32]},null,[],["star",{"sourceInterval":[24,32]},["app",{"sourceInterval":[24,31]},"Grammar",[]]]],"Grammar":["define",{"sourceInterval":[36,83]},null,[],["seq",{"sourceInterval":[50,83]},["app",{"sourceInterval":[50,55]},"ident",[]],["opt",{"sourceInterval":[56,69]},["app",{"sourceInterval":[56,68]},"SuperGrammar",[]]],["terminal",{"sourceInterval":[70,73]},"{"],["star",{"sourceInterval":[74,79]},["app",{"sourceInterval":[74,78]},"Rule",[]]],["terminal",{"sourceInterval":[80,83]},"}"]]],"SuperGrammar":["define",{"sourceInterval":[87,116]},null,[],["seq",{"sourceInterval":[106,116]},["terminal",{"sourceInterval":[106,110]},"<:"],["app",{"sourceInterval":[111,116]},"ident",[]]]],"Rule_define":["define",{"sourceInterval":[131,181]},null,[],["seq",{"sourceInterval":[131,170]},["app",{"sourceInterval":[131,136]},"ident",[]],["opt",{"sourceInterval":[137,145]},["app",{"sourceInterval":[137,144]},"Formals",[]]],["opt",{"sourceInterval":[146,156]},["app",{"sourceInterval":[146,155]},"ruleDescr",[]]],["terminal",{"sourceInterval":[157,160]},"="],["app",{"sourceInterval":[162,170]},"RuleBody",[]]]],"Rule_override":["define",{"sourceInterval":[188,248]},null,[],["seq",{"sourceInterval":[188,235]},["app",{"sourceInterval":[188,193]},"ident",[]],["opt",{"sourceInterval":[194,202]},["app",{"sourceInterval":[194,201]},"Formals",[]]],["terminal",{"sourceInterval":[214,218]},":="],["app",{"sourceInterval":[219,235]},"OverrideRuleBody",[]]]],"Rule_extend":["define",{"sourceInterval":[255,305]},null,[],["seq",{"sourceInterval":[255,294]},["app",{"sourceInterval":[255,260]},"ident",[]],["opt",{"sourceInterval":[261,269]},["app",{"sourceInterval":[261,268]},"Formals",[]]],["terminal",{"sourceInterval":[281,285]},"+="],["app",{"sourceInterval":[286,294]},"RuleBody",[]]]],"Rule":["define",{"sourceInterval":[120,305]},null,[],["alt",{"sourceInterval":[131,305]},["app",{"sourceInterval":[131,170]},"Rule_define",[]],["app",{"sourceInterval":[188,235]},"Rule_override",[]],["app",{"sourceInterval":[255,294]},"Rule_extend",[]]]],"RuleBody":["define",{"sourceInterval":[309,362]},null,[],["seq",{"sourceInterval":[324,362]},["opt",{"sourceInterval":[324,328]},["terminal",{"sourceInterval":[324,327]},"|"]],["app",{"sourceInterval":[329,362]},"NonemptyListOf",[["app",{"sourceInterval":[344,356]},"TopLevelTerm",[]],["terminal",{"sourceInterval":[358,361]},"|"]]]]],"TopLevelTerm_inline":["define",{"sourceInterval":[385,408]},null,[],["seq",{"sourceInterval":[385,397]},["app",{"sourceInterval":[385,388]},"Seq",[]],["app",{"sourceInterval":[389,397]},"caseName",[]]]],"TopLevelTerm":["define",{"sourceInterval":[366,418]},null,[],["alt",{"sourceInterval":[385,418]},["app",{"sourceInterval":[385,397]},"TopLevelTerm_inline",[]],["app",{"sourceInterval":[415,418]},"Seq",[]]]],"OverrideRuleBody":["define",{"sourceInterval":[422,491]},null,[],["seq",{"sourceInterval":[445,491]},["opt",{"sourceInterval":[445,449]},["terminal",{"sourceInterval":[445,448]},"|"]],["app",{"sourceInterval":[450,491]},"NonemptyListOf",[["app",{"sourceInterval":[465,485]},"OverrideTopLevelTerm",[]],["terminal",{"sourceInterval":[487,490]},"|"]]]]],"OverrideTopLevelTerm_superSplice":["define",{"sourceInterval":[522,543]},null,[],["terminal",{"sourceInterval":[522,527]},"..."]],"OverrideTopLevelTerm":["define",{"sourceInterval":[495,562]},null,[],["alt",{"sourceInterval":[522,562]},["app",{"sourceInterval":[522,527]},"OverrideTopLevelTerm_superSplice",[]],["app",{"sourceInterval":[550,562]},"TopLevelTerm",[]]]],"Formals":["define",{"sourceInterval":[566,606]},null,[],["seq",{"sourceInterval":[580,606]},["terminal",{"sourceInterval":[580,583]},"<"],["app",{"sourceInterval":[584,602]},"ListOf",[["app",{"sourceInterval":[591,596]},"ident",[]],["terminal",{"sourceInterval":[598,601]},","]]],["terminal",{"sourceInterval":[603,606]},">"]]],"Params":["define",{"sourceInterval":[610,647]},null,[],["seq",{"sourceInterval":[623,647]},["terminal",{"sourceInterval":[623,626]},"<"],["app",{"sourceInterval":[627,643]},"ListOf",[["app",{"sourceInterval":[634,637]},"Seq",[]],["terminal",{"sourceInterval":[639,642]},","]]],["terminal",{"sourceInterval":[644,647]},">"]]],"Alt":["define",{"sourceInterval":[651,685]},null,[],["app",{"sourceInterval":[661,685]},"NonemptyListOf",[["app",{"sourceInterval":[676,679]},"Seq",[]],["terminal",{"sourceInterval":[681,684]},"|"]]]],"Seq":["define",{"sourceInterval":[689,704]},null,[],["star",{"sourceInterval":[699,704]},["app",{"sourceInterval":[699,703]},"Iter",[]]]],"Iter_star":["define",{"sourceInterval":[719,736]},null,[],["seq",{"sourceInterval":[719,727]},["app",{"sourceInterval":[719,723]},"Pred",[]],["terminal",{"sourceInterval":[724,727]},"*"]]],"Iter_plus":["define",{"sourceInterval":[743,760]},null,[],["seq",{"sourceInterval":[743,751]},["app",{"sourceInterval":[743,747]},"Pred",[]],["terminal",{"sourceInterval":[748,751]},"+"]]],"Iter_opt":["define",{"sourceInterval":[767,783]},null,[],["seq",{"sourceInterval":[767,775]},["app",{"sourceInterval":[767,771]},"Pred",[]],["terminal",{"sourceInterval":[772,775]},"?"]]],"Iter":["define",{"sourceInterval":[708,794]},null,[],["alt",{"sourceInterval":[719,794]},["app",{"sourceInterval":[719,727]},"Iter_star",[]],["app",{"sourceInterval":[743,751]},"Iter_plus",[]],["app",{"sourceInterval":[767,775]},"Iter_opt",[]],["app",{"sourceInterval":[790,794]},"Pred",[]]]],"Pred_not":["define",{"sourceInterval":[809,824]},null,[],["seq",{"sourceInterval":[809,816]},["terminal",{"sourceInterval":[809,812]},"~"],["app",{"sourceInterval":[813,816]},"Lex",[]]]],"Pred_lookahead":["define",{"sourceInterval":[831,852]},null,[],["seq",{"sourceInterval":[831,838]},["terminal",{"sourceInterval":[831,834]},"&"],["app",{"sourceInterval":[835,838]},"Lex",[]]]],"Pred":["define",{"sourceInterval":[798,862]},null,[],["alt",{"sourceInterval":[809,862]},["app",{"sourceInterval":[809,816]},"Pred_not",[]],["app",{"sourceInterval":[831,838]},"Pred_lookahead",[]],["app",{"sourceInterval":[859,862]},"Lex",[]]]],"Lex_lex":["define",{"sourceInterval":[876,892]},null,[],["seq",{"sourceInterval":[876,884]},["terminal",{"sourceInterval":[876,879]},"#"],["app",{"sourceInterval":[880,884]},"Base",[]]]],"Lex":["define",{"sourceInterval":[866,903]},null,[],["alt",{"sourceInterval":[876,903]},["app",{"sourceInterval":[876,884]},"Lex_lex",[]],["app",{"sourceInterval":[899,903]},"Base",[]]]],"Base_application":["define",{"sourceInterval":[918,979]},null,[],["seq",{"sourceInterval":[918,963]},["app",{"sourceInterval":[918,923]},"ident",[]],["opt",{"sourceInterval":[924,931]},["app",{"sourceInterval":[924,930]},"Params",[]]],["not",{"sourceInterval":[932,963]},["alt",{"sourceInterval":[934,962]},["seq",{"sourceInterval":[934,948]},["opt",{"sourceInterval":[934,944]},["app",{"sourceInterval":[934,943]},"ruleDescr",[]]],["terminal",{"sourceInterval":[945,948]},"="]],["terminal",{"sourceInterval":[951,955]},":="],["terminal",{"sourceInterval":[958,962]},"+="]]]]],"Base_range":["define",{"sourceInterval":[986,1041]},null,[],["seq",{"sourceInterval":[986,1022]},["app",{"sourceInterval":[986,1001]},"oneCharTerminal",[]],["terminal",{"sourceInterval":[1002,1006]},".."],["app",{"sourceInterval":[1007,1022]},"oneCharTerminal",[]]]],"Base_terminal":["define",{"sourceInterval":[1048,1106]},null,[],["app",{"sourceInterval":[1048,1056]},"terminal",[]]],"Base_paren":["define",{"sourceInterval":[1113,1168]},null,[],["seq",{"sourceInterval":[1113,1124]},["terminal",{"sourceInterval":[1113,1116]},"("],["app",{"sourceInterval":[1117,1120]},"Alt",[]],["terminal",{"sourceInterval":[1121,1124]},")"]]],"Base":["define",{"sourceInterval":[907,1168]},null,[],["alt",{"sourceInterval":[918,1168]},["app",{"sourceInterval":[918,963]},"Base_application",[]],["app",{"sourceInterval":[986,1022]},"Base_range",[]],["app",{"sourceInterval":[1048,1056]},"Base_terminal",[]],["app",{"sourceInterval":[1113,1124]},"Base_paren",[]]]],"ruleDescr":["define",{"sourceInterval":[1172,1231]},"a rule description",[],["seq",{"sourceInterval":[1210,1231]},["terminal",{"sourceInterval":[1210,1213]},"("],["app",{"sourceInterval":[1214,1227]},"ruleDescrText",[]],["terminal",{"sourceInterval":[1228,1231]},")"]]],"ruleDescrText":["define",{"sourceInterval":[1235,1266]},null,[],["star",{"sourceInterval":[1255,1266]},["seq",{"sourceInterval":[1256,1264]},["not",{"sourceInterval":[1256,1260]},["terminal",{"sourceInterval":[1257,1260]},")"]],["app",{"sourceInterval":[1261,1264]},"any",[]]]]],"caseName":["define",{"sourceInterval":[1270,1338]},null,[],["seq",{"sourceInterval":[1285,1338]},["terminal",{"sourceInterval":[1285,1289]},"--"],["star",{"sourceInterval":[1290,1304]},["seq",{"sourceInterval":[1291,1302]},["not",{"sourceInterval":[1291,1296]},["terminal",{"sourceInterval":[1292,1296]},"\n"]],["app",{"sourceInterval":[1297,1302]},"space",[]]]],["app",{"sourceInterval":[1305,1309]},"name",[]],["star",{"sourceInterval":[1310,1324]},["seq",{"sourceInterval":[1311,1322]},["not",{"sourceInterval":[1311,1316]},["terminal",{"sourceInterval":[1312,1316]},"\n"]],["app",{"sourceInterval":[1317,1322]},"space",[]]]],["alt",{"sourceInterval":[1326,1337]},["terminal",{"sourceInterval":[1326,1330]},"\n"],["lookahead",{"sourceInterval":[1333,1337]},["terminal",{"sourceInterval":[1334,1337]},"}"]]]]],"name":["define",{"sourceInterval":[1342,1382]},"a name",[],["seq",{"sourceInterval":[1363,1382]},["app",{"sourceInterval":[1363,1372]},"nameFirst",[]],["star",{"sourceInterval":[1373,1382]},["app",{"sourceInterval":[1373,1381]},"nameRest",[]]]]],"nameFirst":["define",{"sourceInterval":[1386,1418]},null,[],["alt",{"sourceInterval":[1402,1418]},["terminal",{"sourceInterval":[1402,1405]},"_"],["app",{"sourceInterval":[1412,1418]},"letter",[]]]],"nameRest":["define",{"sourceInterval":[1422,1452]},null,[],["alt",{"sourceInterval":[1437,1452]},["terminal",{"sourceInterval":[1437,1440]},"_"],["app",{"sourceInterval":[1447,1452]},"alnum",[]]]],"ident":["define",{"sourceInterval":[1456,1489]},"an identifier",[],["app",{"sourceInterval":[1485,1489]},"name",[]]],"terminal":["define",{"sourceInterval":[1493,1531]},null,[],["seq",{"sourceInterval":[1508,1531]},["terminal",{"sourceInterval":[1508,1512]},"\""],["star",{"sourceInterval":[1513,1526]},["app",{"sourceInterval":[1513,1525]},"terminalChar",[]]],["terminal",{"sourceInterval":[1527,1531]},"\""]]],"oneCharTerminal":["define",{"sourceInterval":[1535,1579]},null,[],["seq",{"sourceInterval":[1557,1579]},["terminal",{"sourceInterval":[1557,1561]},"\""],["app",{"sourceInterval":[1562,1574]},"terminalChar",[]],["terminal",{"sourceInterval":[1575,1579]},"\""]]],"terminalChar":["define",{"sourceInterval":[1583,1690]},null,[],["alt",{"sourceInterval":[1602,1690]},["app",{"sourceInterval":[1602,1612]},"escapeChar",[]],["seq",{"sourceInterval":[1651,1690]},["not",{"sourceInterval":[1651,1656]},["terminal",{"sourceInterval":[1652,1656]},"\\"]],["not",{"sourceInterval":[1657,1662]},["terminal",{"sourceInterval":[1658,1662]},"\""]],["not",{"sourceInterval":[1663,1668]},["terminal",{"sourceInterval":[1664,1668]},"\n"]],["range",{"sourceInterval":[1669,1690]},"\u0000","􏿿"]]]],"escapeChar_backslash":["define",{"sourceInterval":[1733,1788]},null,[],["terminal",{"sourceInterval":[1733,1739]},"\\\\"]],"escapeChar_doubleQuote":["define",{"sourceInterval":[1795,1852]},null,[],["terminal",{"sourceInterval":[1795,1801]},"\\\""]],"escapeChar_singleQuote":["define",{"sourceInterval":[1859,1916]},null,[],["terminal",{"sourceInterval":[1859,1865]},"\\'"]],"escapeChar_backspace":["define",{"sourceInterval":[1923,1978]},null,[],["terminal",{"sourceInterval":[1923,1928]},"\\b"]],"escapeChar_lineFeed":["define",{"sourceInterval":[1985,2039]},null,[],["terminal",{"sourceInterval":[1985,1990]},"\\n"]],"escapeChar_carriageReturn":["define",{"sourceInterval":[2046,2106]},null,[],["terminal",{"sourceInterval":[2046,2051]},"\\r"]],"escapeChar_tab":["define",{"sourceInterval":[2113,2162]},null,[],["terminal",{"sourceInterval":[2113,2118]},"\\t"]],"escapeChar_unicodeCodePoint":["define",{"sourceInterval":[2169,2231]},null,[],["seq",{"sourceInterval":[2169,2189]},["terminal",{"sourceInterval":[2169,2175]},"\\u{"],["plus",{"sourceInterval":[2176,2185]},["app",{"sourceInterval":[2176,2184]},"hexDigit",[]]],["terminal",{"sourceInterval":[2186,2189]},"}"]]],"escapeChar_unicodeEscape":["define",{"sourceInterval":[2238,2297]},null,[],["seq",{"sourceInterval":[2238,2279]},["terminal",{"sourceInterval":[2238,2243]},"\\u"],["app",{"sourceInterval":[2244,2252]},"hexDigit",[]],["app",{"sourceInterval":[2253,2261]},"hexDigit",[]],["app",{"sourceInterval":[2262,2270]},"hexDigit",[]],["app",{"sourceInterval":[2271,2279]},"hexDigit",[]]]],"escapeChar_hexEscape":["define",{"sourceInterval":[2304,2359]},null,[],["seq",{"sourceInterval":[2304,2327]},["terminal",{"sourceInterval":[2304,2309]},"\\x"],["app",{"sourceInterval":[2310,2318]},"hexDigit",[]],["app",{"sourceInterval":[2319,2327]},"hexDigit",[]]]],"escapeChar":["define",{"sourceInterval":[1694,2359]},"an escape sequence",[],["alt",{"sourceInterval":[1733,2359]},["app",{"sourceInterval":[1733,1739]},"escapeChar_backslash",[]],["app",{"sourceInterval":[1795,1801]},"escapeChar_doubleQuote",[]],["app",{"sourceInterval":[1859,1865]},"escapeChar_singleQuote",[]],["app",{"sourceInterval":[1923,1928]},"escapeChar_backspace",[]],["app",{"sourceInterval":[1985,1990]},"escapeChar_lineFeed",[]],["app",{"sourceInterval":[2046,2051]},"escapeChar_carriageReturn",[]],["app",{"sourceInterval":[2113,2118]},"escapeChar_tab",[]],["app",{"sourceInterval":[2169,2189]},"escapeChar_unicodeCodePoint",[]],["app",{"sourceInterval":[2238,2279]},"escapeChar_unicodeEscape",[]],["app",{"sourceInterval":[2304,2327]},"escapeChar_hexEscape",[]]]],"space":["extend",{"sourceInterval":[2363,2382]},null,[],["app",{"sourceInterval":[2375,2382]},"comment",[]]],"comment_singleLine":["define",{"sourceInterval":[2400,2446]},null,[],["seq",{"sourceInterval":[2400,2431]},["terminal",{"sourceInterval":[2400,2404]},"//"],["star",{"sourceInterval":[2405,2417]},["seq",{"sourceInterval":[2406,2415]},["not",{"sourceInterval":[2406,2411]},["terminal",{"sourceInterval":[2407,2411]},"\n"]],["app",{"sourceInterval":[2412,2415]},"any",[]]]],["lookahead",{"sourceInterval":[2418,2431]},["alt",{"sourceInterval":[2420,2430]},["terminal",{"sourceInterval":[2420,2424]},"\n"],["app",{"sourceInterval":[2427,2430]},"end",[]]]]]],"comment_multiLine":["define",{"sourceInterval":[2453,2489]},null,[],["seq",{"sourceInterval":[2453,2475]},["terminal",{"sourceInterval":[2453,2457]},"/*"],["star",{"sourceInterval":[2458,2470]},["seq",{"sourceInterval":[2459,2468]},["not",{"sourceInterval":[2459,2464]},["terminal",{"sourceInterval":[2460,2464]},"*/"]],["app",{"sourceInterval":[2465,2468]},"any",[]]]],["terminal",{"sourceInterval":[2471,2475]},"*/"]]],"comment":["define",{"sourceInterval":[2386,2489]},null,[],["alt",{"sourceInterval":[2400,2489]},["app",{"sourceInterval":[2400,2431]},"comment_singleLine",[]],["app",{"sourceInterval":[2453,2475]},"comment_multiLine",[]]]],"tokens":["define",{"sourceInterval":[2493,2508]},null,[],["star",{"sourceInterval":[2502,2508]},["app",{"sourceInterval":[2502,2507]},"token",[]]]],"token":["define",{"sourceInterval":[2512,2588]},null,[],["alt",{"sourceInterval":[2520,2588]},["app",{"sourceInterval":[2520,2528]},"caseName",[]],["app",{"sourceInterval":[2531,2538]},"comment",[]],["app",{"sourceInterval":[2541,2546]},"ident",[]],["app",{"sourceInterval":[2549,2557]},"operator",[]],["app",{"sourceInterval":[2560,2571]},"punctuation",[]],["app",{"sourceInterval":[2574,2582]},"terminal",[]],["app",{"sourceInterval":[2585,2588]},"any",[]]]],"operator":["define",{"sourceInterval":[2592,2657]},null,[],["alt",{"sourceInterval":[2603,2657]},["terminal",{"sourceInterval":[2603,2607]},"<:"],["terminal",{"sourceInterval":[2610,2613]},"="],["terminal",{"sourceInterval":[2616,2620]},":="],["terminal",{"sourceInterval":[2623,2627]},"+="],["terminal",{"sourceInterval":[2630,2633]},"*"],["terminal",{"sourceInterval":[2636,2639]},"+"],["terminal",{"sourceInterval":[2642,2645]},"?"],["terminal",{"sourceInterval":[2648,2651]},"~"],["terminal",{"sourceInterval":[2654,2657]},"&"]]],"punctuation":["define",{"sourceInterval":[2661,2697]},null,[],["alt",{"sourceInterval":[2675,2697]},["terminal",{"sourceInterval":[2675,2678]},"<"],["terminal",{"sourceInterval":[2681,2684]},">"],["terminal",{"sourceInterval":[2687,2690]},","],["terminal",{"sourceInterval":[2693,2697]},"--"]]]}]);
+var ohmGrammar$1 = makeRecipe$1(["grammar",{"source":"Ohm {\n\n  Grammars\n    = Grammar*\n\n  Grammar\n    = ident SuperGrammar? \"{\" Rule* \"}\"\n\n  SuperGrammar\n    = \"<:\" ident\n\n  Rule\n    = ident Formals? ruleDescr? \"=\"  RuleBody  -- define\n    | ident Formals?            \":=\" OverrideRuleBody  -- override\n    | ident Formals?            \"+=\" RuleBody  -- extend\n\n  RuleBody\n    = \"|\"? NonemptyListOf<TopLevelTerm, \"|\">\n\n  TopLevelTerm\n    = Seq caseName  -- inline\n    | Seq\n\n  OverrideRuleBody\n    = \"|\"? NonemptyListOf<OverrideTopLevelTerm, \"|\">\n\n  OverrideTopLevelTerm\n    = \"...\"  -- superSplice\n    | TopLevelTerm\n\n  Formals\n    = \"<\" ListOf<ident, \",\"> \">\"\n\n  Params\n    = \"<\" ListOf<Seq, \",\"> \">\"\n\n  Alt\n    = NonemptyListOf<Seq, \"|\">\n\n  Seq\n    = Iter*\n\n  Iter\n    = Pred \"*\"  -- star\n    | Pred \"+\"  -- plus\n    | Pred \"?\"  -- opt\n    | Pred\n\n  Pred\n    = \"~\" Lex  -- not\n    | \"&\" Lex  -- lookahead\n    | Lex\n\n  Lex\n    = \"#\" Base  -- lex\n    | Base\n\n  Base\n    = ident Params? ~(ruleDescr? \"=\" | \":=\" | \"+=\")  -- application\n    | oneCharTerminal \"..\" oneCharTerminal           -- range\n    | terminal                                       -- terminal\n    | \"(\" Alt \")\"                                    -- paren\n\n  ruleDescr  (a rule description)\n    = \"(\" ruleDescrText \")\"\n\n  ruleDescrText\n    = (~\")\" any)*\n\n  caseName\n    = \"--\" (~\"\\n\" space)* name (~\"\\n\" space)* (\"\\n\" | &\"}\")\n\n  name  (a name)\n    = nameFirst nameRest*\n\n  nameFirst\n    = \"_\"\n    | letter\n\n  nameRest\n    = \"_\"\n    | alnum\n\n  ident  (an identifier)\n    = name\n\n  terminal\n    = \"\\\"\" terminalChar* \"\\\"\"\n\n  oneCharTerminal\n    = \"\\\"\" terminalChar \"\\\"\"\n\n  terminalChar\n    = escapeChar\n      | ~\"\\\\\" ~\"\\\"\" ~\"\\n\" \"\\u{0}\"..\"\\u{10FFFF}\"\n\n  escapeChar  (an escape sequence)\n    = \"\\\\\\\\\"                                     -- backslash\n    | \"\\\\\\\"\"                                     -- doubleQuote\n    | \"\\\\\\'\"                                     -- singleQuote\n    | \"\\\\b\"                                      -- backspace\n    | \"\\\\n\"                                      -- lineFeed\n    | \"\\\\r\"                                      -- carriageReturn\n    | \"\\\\t\"                                      -- tab\n    | \"\\\\u{\" hexDigit hexDigit? hexDigit?\n             hexDigit? hexDigit? hexDigit? \"}\"   -- unicodeCodePoint\n    | \"\\\\u\" hexDigit hexDigit hexDigit hexDigit  -- unicodeEscape\n    | \"\\\\x\" hexDigit hexDigit                    -- hexEscape\n\n  space\n   += comment\n\n  comment\n    = \"//\" (~\"\\n\" any)* &(\"\\n\" | end)  -- singleLine\n    | \"/*\" (~\"*/\" any)* \"*/\"  -- multiLine\n\n  tokens = token*\n\n  token = caseName | comment | ident | operator | punctuation | terminal | any\n\n  operator = \"<:\" | \"=\" | \":=\" | \"+=\" | \"*\" | \"+\" | \"?\" | \"~\" | \"&\"\n\n  punctuation = \"<\" | \">\" | \",\" | \"--\"\n}"},"Ohm",null,"Grammars",{"Grammars":["define",{"sourceInterval":[9,32]},null,[],["star",{"sourceInterval":[24,32]},["app",{"sourceInterval":[24,31]},"Grammar",[]]]],"Grammar":["define",{"sourceInterval":[36,83]},null,[],["seq",{"sourceInterval":[50,83]},["app",{"sourceInterval":[50,55]},"ident",[]],["opt",{"sourceInterval":[56,69]},["app",{"sourceInterval":[56,68]},"SuperGrammar",[]]],["terminal",{"sourceInterval":[70,73]},"{"],["star",{"sourceInterval":[74,79]},["app",{"sourceInterval":[74,78]},"Rule",[]]],["terminal",{"sourceInterval":[80,83]},"}"]]],"SuperGrammar":["define",{"sourceInterval":[87,116]},null,[],["seq",{"sourceInterval":[106,116]},["terminal",{"sourceInterval":[106,110]},"<:"],["app",{"sourceInterval":[111,116]},"ident",[]]]],"Rule_define":["define",{"sourceInterval":[131,181]},null,[],["seq",{"sourceInterval":[131,170]},["app",{"sourceInterval":[131,136]},"ident",[]],["opt",{"sourceInterval":[137,145]},["app",{"sourceInterval":[137,144]},"Formals",[]]],["opt",{"sourceInterval":[146,156]},["app",{"sourceInterval":[146,155]},"ruleDescr",[]]],["terminal",{"sourceInterval":[157,160]},"="],["app",{"sourceInterval":[162,170]},"RuleBody",[]]]],"Rule_override":["define",{"sourceInterval":[188,248]},null,[],["seq",{"sourceInterval":[188,235]},["app",{"sourceInterval":[188,193]},"ident",[]],["opt",{"sourceInterval":[194,202]},["app",{"sourceInterval":[194,201]},"Formals",[]]],["terminal",{"sourceInterval":[214,218]},":="],["app",{"sourceInterval":[219,235]},"OverrideRuleBody",[]]]],"Rule_extend":["define",{"sourceInterval":[255,305]},null,[],["seq",{"sourceInterval":[255,294]},["app",{"sourceInterval":[255,260]},"ident",[]],["opt",{"sourceInterval":[261,269]},["app",{"sourceInterval":[261,268]},"Formals",[]]],["terminal",{"sourceInterval":[281,285]},"+="],["app",{"sourceInterval":[286,294]},"RuleBody",[]]]],"Rule":["define",{"sourceInterval":[120,305]},null,[],["alt",{"sourceInterval":[131,305]},["app",{"sourceInterval":[131,170]},"Rule_define",[]],["app",{"sourceInterval":[188,235]},"Rule_override",[]],["app",{"sourceInterval":[255,294]},"Rule_extend",[]]]],"RuleBody":["define",{"sourceInterval":[309,362]},null,[],["seq",{"sourceInterval":[324,362]},["opt",{"sourceInterval":[324,328]},["terminal",{"sourceInterval":[324,327]},"|"]],["app",{"sourceInterval":[329,362]},"NonemptyListOf",[["app",{"sourceInterval":[344,356]},"TopLevelTerm",[]],["terminal",{"sourceInterval":[358,361]},"|"]]]]],"TopLevelTerm_inline":["define",{"sourceInterval":[385,408]},null,[],["seq",{"sourceInterval":[385,397]},["app",{"sourceInterval":[385,388]},"Seq",[]],["app",{"sourceInterval":[389,397]},"caseName",[]]]],"TopLevelTerm":["define",{"sourceInterval":[366,418]},null,[],["alt",{"sourceInterval":[385,418]},["app",{"sourceInterval":[385,397]},"TopLevelTerm_inline",[]],["app",{"sourceInterval":[415,418]},"Seq",[]]]],"OverrideRuleBody":["define",{"sourceInterval":[422,491]},null,[],["seq",{"sourceInterval":[445,491]},["opt",{"sourceInterval":[445,449]},["terminal",{"sourceInterval":[445,448]},"|"]],["app",{"sourceInterval":[450,491]},"NonemptyListOf",[["app",{"sourceInterval":[465,485]},"OverrideTopLevelTerm",[]],["terminal",{"sourceInterval":[487,490]},"|"]]]]],"OverrideTopLevelTerm_superSplice":["define",{"sourceInterval":[522,543]},null,[],["terminal",{"sourceInterval":[522,527]},"..."]],"OverrideTopLevelTerm":["define",{"sourceInterval":[495,562]},null,[],["alt",{"sourceInterval":[522,562]},["app",{"sourceInterval":[522,527]},"OverrideTopLevelTerm_superSplice",[]],["app",{"sourceInterval":[550,562]},"TopLevelTerm",[]]]],"Formals":["define",{"sourceInterval":[566,606]},null,[],["seq",{"sourceInterval":[580,606]},["terminal",{"sourceInterval":[580,583]},"<"],["app",{"sourceInterval":[584,602]},"ListOf",[["app",{"sourceInterval":[591,596]},"ident",[]],["terminal",{"sourceInterval":[598,601]},","]]],["terminal",{"sourceInterval":[603,606]},">"]]],"Params":["define",{"sourceInterval":[610,647]},null,[],["seq",{"sourceInterval":[623,647]},["terminal",{"sourceInterval":[623,626]},"<"],["app",{"sourceInterval":[627,643]},"ListOf",[["app",{"sourceInterval":[634,637]},"Seq",[]],["terminal",{"sourceInterval":[639,642]},","]]],["terminal",{"sourceInterval":[644,647]},">"]]],"Alt":["define",{"sourceInterval":[651,685]},null,[],["app",{"sourceInterval":[661,685]},"NonemptyListOf",[["app",{"sourceInterval":[676,679]},"Seq",[]],["terminal",{"sourceInterval":[681,684]},"|"]]]],"Seq":["define",{"sourceInterval":[689,704]},null,[],["star",{"sourceInterval":[699,704]},["app",{"sourceInterval":[699,703]},"Iter",[]]]],"Iter_star":["define",{"sourceInterval":[719,736]},null,[],["seq",{"sourceInterval":[719,727]},["app",{"sourceInterval":[719,723]},"Pred",[]],["terminal",{"sourceInterval":[724,727]},"*"]]],"Iter_plus":["define",{"sourceInterval":[743,760]},null,[],["seq",{"sourceInterval":[743,751]},["app",{"sourceInterval":[743,747]},"Pred",[]],["terminal",{"sourceInterval":[748,751]},"+"]]],"Iter_opt":["define",{"sourceInterval":[767,783]},null,[],["seq",{"sourceInterval":[767,775]},["app",{"sourceInterval":[767,771]},"Pred",[]],["terminal",{"sourceInterval":[772,775]},"?"]]],"Iter":["define",{"sourceInterval":[708,794]},null,[],["alt",{"sourceInterval":[719,794]},["app",{"sourceInterval":[719,727]},"Iter_star",[]],["app",{"sourceInterval":[743,751]},"Iter_plus",[]],["app",{"sourceInterval":[767,775]},"Iter_opt",[]],["app",{"sourceInterval":[790,794]},"Pred",[]]]],"Pred_not":["define",{"sourceInterval":[809,824]},null,[],["seq",{"sourceInterval":[809,816]},["terminal",{"sourceInterval":[809,812]},"~"],["app",{"sourceInterval":[813,816]},"Lex",[]]]],"Pred_lookahead":["define",{"sourceInterval":[831,852]},null,[],["seq",{"sourceInterval":[831,838]},["terminal",{"sourceInterval":[831,834]},"&"],["app",{"sourceInterval":[835,838]},"Lex",[]]]],"Pred":["define",{"sourceInterval":[798,862]},null,[],["alt",{"sourceInterval":[809,862]},["app",{"sourceInterval":[809,816]},"Pred_not",[]],["app",{"sourceInterval":[831,838]},"Pred_lookahead",[]],["app",{"sourceInterval":[859,862]},"Lex",[]]]],"Lex_lex":["define",{"sourceInterval":[876,892]},null,[],["seq",{"sourceInterval":[876,884]},["terminal",{"sourceInterval":[876,879]},"#"],["app",{"sourceInterval":[880,884]},"Base",[]]]],"Lex":["define",{"sourceInterval":[866,903]},null,[],["alt",{"sourceInterval":[876,903]},["app",{"sourceInterval":[876,884]},"Lex_lex",[]],["app",{"sourceInterval":[899,903]},"Base",[]]]],"Base_application":["define",{"sourceInterval":[918,979]},null,[],["seq",{"sourceInterval":[918,963]},["app",{"sourceInterval":[918,923]},"ident",[]],["opt",{"sourceInterval":[924,931]},["app",{"sourceInterval":[924,930]},"Params",[]]],["not",{"sourceInterval":[932,963]},["alt",{"sourceInterval":[934,962]},["seq",{"sourceInterval":[934,948]},["opt",{"sourceInterval":[934,944]},["app",{"sourceInterval":[934,943]},"ruleDescr",[]]],["terminal",{"sourceInterval":[945,948]},"="]],["terminal",{"sourceInterval":[951,955]},":="],["terminal",{"sourceInterval":[958,962]},"+="]]]]],"Base_range":["define",{"sourceInterval":[986,1041]},null,[],["seq",{"sourceInterval":[986,1022]},["app",{"sourceInterval":[986,1001]},"oneCharTerminal",[]],["terminal",{"sourceInterval":[1002,1006]},".."],["app",{"sourceInterval":[1007,1022]},"oneCharTerminal",[]]]],"Base_terminal":["define",{"sourceInterval":[1048,1106]},null,[],["app",{"sourceInterval":[1048,1056]},"terminal",[]]],"Base_paren":["define",{"sourceInterval":[1113,1168]},null,[],["seq",{"sourceInterval":[1113,1124]},["terminal",{"sourceInterval":[1113,1116]},"("],["app",{"sourceInterval":[1117,1120]},"Alt",[]],["terminal",{"sourceInterval":[1121,1124]},")"]]],"Base":["define",{"sourceInterval":[907,1168]},null,[],["alt",{"sourceInterval":[918,1168]},["app",{"sourceInterval":[918,963]},"Base_application",[]],["app",{"sourceInterval":[986,1022]},"Base_range",[]],["app",{"sourceInterval":[1048,1056]},"Base_terminal",[]],["app",{"sourceInterval":[1113,1124]},"Base_paren",[]]]],"ruleDescr":["define",{"sourceInterval":[1172,1231]},"a rule description",[],["seq",{"sourceInterval":[1210,1231]},["terminal",{"sourceInterval":[1210,1213]},"("],["app",{"sourceInterval":[1214,1227]},"ruleDescrText",[]],["terminal",{"sourceInterval":[1228,1231]},")"]]],"ruleDescrText":["define",{"sourceInterval":[1235,1266]},null,[],["star",{"sourceInterval":[1255,1266]},["seq",{"sourceInterval":[1256,1264]},["not",{"sourceInterval":[1256,1260]},["terminal",{"sourceInterval":[1257,1260]},")"]],["app",{"sourceInterval":[1261,1264]},"any",[]]]]],"caseName":["define",{"sourceInterval":[1270,1338]},null,[],["seq",{"sourceInterval":[1285,1338]},["terminal",{"sourceInterval":[1285,1289]},"--"],["star",{"sourceInterval":[1290,1304]},["seq",{"sourceInterval":[1291,1302]},["not",{"sourceInterval":[1291,1296]},["terminal",{"sourceInterval":[1292,1296]},"\n"]],["app",{"sourceInterval":[1297,1302]},"space",[]]]],["app",{"sourceInterval":[1305,1309]},"name",[]],["star",{"sourceInterval":[1310,1324]},["seq",{"sourceInterval":[1311,1322]},["not",{"sourceInterval":[1311,1316]},["terminal",{"sourceInterval":[1312,1316]},"\n"]],["app",{"sourceInterval":[1317,1322]},"space",[]]]],["alt",{"sourceInterval":[1326,1337]},["terminal",{"sourceInterval":[1326,1330]},"\n"],["lookahead",{"sourceInterval":[1333,1337]},["terminal",{"sourceInterval":[1334,1337]},"}"]]]]],"name":["define",{"sourceInterval":[1342,1382]},"a name",[],["seq",{"sourceInterval":[1363,1382]},["app",{"sourceInterval":[1363,1372]},"nameFirst",[]],["star",{"sourceInterval":[1373,1382]},["app",{"sourceInterval":[1373,1381]},"nameRest",[]]]]],"nameFirst":["define",{"sourceInterval":[1386,1418]},null,[],["alt",{"sourceInterval":[1402,1418]},["terminal",{"sourceInterval":[1402,1405]},"_"],["app",{"sourceInterval":[1412,1418]},"letter",[]]]],"nameRest":["define",{"sourceInterval":[1422,1452]},null,[],["alt",{"sourceInterval":[1437,1452]},["terminal",{"sourceInterval":[1437,1440]},"_"],["app",{"sourceInterval":[1447,1452]},"alnum",[]]]],"ident":["define",{"sourceInterval":[1456,1489]},"an identifier",[],["app",{"sourceInterval":[1485,1489]},"name",[]]],"terminal":["define",{"sourceInterval":[1493,1531]},null,[],["seq",{"sourceInterval":[1508,1531]},["terminal",{"sourceInterval":[1508,1512]},"\""],["star",{"sourceInterval":[1513,1526]},["app",{"sourceInterval":[1513,1525]},"terminalChar",[]]],["terminal",{"sourceInterval":[1527,1531]},"\""]]],"oneCharTerminal":["define",{"sourceInterval":[1535,1579]},null,[],["seq",{"sourceInterval":[1557,1579]},["terminal",{"sourceInterval":[1557,1561]},"\""],["app",{"sourceInterval":[1562,1574]},"terminalChar",[]],["terminal",{"sourceInterval":[1575,1579]},"\""]]],"terminalChar":["define",{"sourceInterval":[1583,1660]},null,[],["alt",{"sourceInterval":[1602,1660]},["app",{"sourceInterval":[1602,1612]},"escapeChar",[]],["seq",{"sourceInterval":[1621,1660]},["not",{"sourceInterval":[1621,1626]},["terminal",{"sourceInterval":[1622,1626]},"\\"]],["not",{"sourceInterval":[1627,1632]},["terminal",{"sourceInterval":[1628,1632]},"\""]],["not",{"sourceInterval":[1633,1638]},["terminal",{"sourceInterval":[1634,1638]},"\n"]],["range",{"sourceInterval":[1639,1660]},"\u0000","􏿿"]]]],"escapeChar_backslash":["define",{"sourceInterval":[1703,1758]},null,[],["terminal",{"sourceInterval":[1703,1709]},"\\\\"]],"escapeChar_doubleQuote":["define",{"sourceInterval":[1765,1822]},null,[],["terminal",{"sourceInterval":[1765,1771]},"\\\""]],"escapeChar_singleQuote":["define",{"sourceInterval":[1829,1886]},null,[],["terminal",{"sourceInterval":[1829,1835]},"\\'"]],"escapeChar_backspace":["define",{"sourceInterval":[1893,1948]},null,[],["terminal",{"sourceInterval":[1893,1898]},"\\b"]],"escapeChar_lineFeed":["define",{"sourceInterval":[1955,2009]},null,[],["terminal",{"sourceInterval":[1955,1960]},"\\n"]],"escapeChar_carriageReturn":["define",{"sourceInterval":[2016,2076]},null,[],["terminal",{"sourceInterval":[2016,2021]},"\\r"]],"escapeChar_tab":["define",{"sourceInterval":[2083,2132]},null,[],["terminal",{"sourceInterval":[2083,2088]},"\\t"]],"escapeChar_unicodeCodePoint":["define",{"sourceInterval":[2139,2243]},null,[],["seq",{"sourceInterval":[2139,2221]},["terminal",{"sourceInterval":[2139,2145]},"\\u{"],["app",{"sourceInterval":[2146,2154]},"hexDigit",[]],["opt",{"sourceInterval":[2155,2164]},["app",{"sourceInterval":[2155,2163]},"hexDigit",[]]],["opt",{"sourceInterval":[2165,2174]},["app",{"sourceInterval":[2165,2173]},"hexDigit",[]]],["opt",{"sourceInterval":[2188,2197]},["app",{"sourceInterval":[2188,2196]},"hexDigit",[]]],["opt",{"sourceInterval":[2198,2207]},["app",{"sourceInterval":[2198,2206]},"hexDigit",[]]],["opt",{"sourceInterval":[2208,2217]},["app",{"sourceInterval":[2208,2216]},"hexDigit",[]]],["terminal",{"sourceInterval":[2218,2221]},"}"]]],"escapeChar_unicodeEscape":["define",{"sourceInterval":[2250,2309]},null,[],["seq",{"sourceInterval":[2250,2291]},["terminal",{"sourceInterval":[2250,2255]},"\\u"],["app",{"sourceInterval":[2256,2264]},"hexDigit",[]],["app",{"sourceInterval":[2265,2273]},"hexDigit",[]],["app",{"sourceInterval":[2274,2282]},"hexDigit",[]],["app",{"sourceInterval":[2283,2291]},"hexDigit",[]]]],"escapeChar_hexEscape":["define",{"sourceInterval":[2316,2371]},null,[],["seq",{"sourceInterval":[2316,2339]},["terminal",{"sourceInterval":[2316,2321]},"\\x"],["app",{"sourceInterval":[2322,2330]},"hexDigit",[]],["app",{"sourceInterval":[2331,2339]},"hexDigit",[]]]],"escapeChar":["define",{"sourceInterval":[1664,2371]},"an escape sequence",[],["alt",{"sourceInterval":[1703,2371]},["app",{"sourceInterval":[1703,1709]},"escapeChar_backslash",[]],["app",{"sourceInterval":[1765,1771]},"escapeChar_doubleQuote",[]],["app",{"sourceInterval":[1829,1835]},"escapeChar_singleQuote",[]],["app",{"sourceInterval":[1893,1898]},"escapeChar_backspace",[]],["app",{"sourceInterval":[1955,1960]},"escapeChar_lineFeed",[]],["app",{"sourceInterval":[2016,2021]},"escapeChar_carriageReturn",[]],["app",{"sourceInterval":[2083,2088]},"escapeChar_tab",[]],["app",{"sourceInterval":[2139,2221]},"escapeChar_unicodeCodePoint",[]],["app",{"sourceInterval":[2250,2291]},"escapeChar_unicodeEscape",[]],["app",{"sourceInterval":[2316,2339]},"escapeChar_hexEscape",[]]]],"space":["extend",{"sourceInterval":[2375,2394]},null,[],["app",{"sourceInterval":[2387,2394]},"comment",[]]],"comment_singleLine":["define",{"sourceInterval":[2412,2458]},null,[],["seq",{"sourceInterval":[2412,2443]},["terminal",{"sourceInterval":[2412,2416]},"//"],["star",{"sourceInterval":[2417,2429]},["seq",{"sourceInterval":[2418,2427]},["not",{"sourceInterval":[2418,2423]},["terminal",{"sourceInterval":[2419,2423]},"\n"]],["app",{"sourceInterval":[2424,2427]},"any",[]]]],["lookahead",{"sourceInterval":[2430,2443]},["alt",{"sourceInterval":[2432,2442]},["terminal",{"sourceInterval":[2432,2436]},"\n"],["app",{"sourceInterval":[2439,2442]},"end",[]]]]]],"comment_multiLine":["define",{"sourceInterval":[2465,2501]},null,[],["seq",{"sourceInterval":[2465,2487]},["terminal",{"sourceInterval":[2465,2469]},"/*"],["star",{"sourceInterval":[2470,2482]},["seq",{"sourceInterval":[2471,2480]},["not",{"sourceInterval":[2471,2476]},["terminal",{"sourceInterval":[2472,2476]},"*/"]],["app",{"sourceInterval":[2477,2480]},"any",[]]]],["terminal",{"sourceInterval":[2483,2487]},"*/"]]],"comment":["define",{"sourceInterval":[2398,2501]},null,[],["alt",{"sourceInterval":[2412,2501]},["app",{"sourceInterval":[2412,2443]},"comment_singleLine",[]],["app",{"sourceInterval":[2465,2487]},"comment_multiLine",[]]]],"tokens":["define",{"sourceInterval":[2505,2520]},null,[],["star",{"sourceInterval":[2514,2520]},["app",{"sourceInterval":[2514,2519]},"token",[]]]],"token":["define",{"sourceInterval":[2524,2600]},null,[],["alt",{"sourceInterval":[2532,2600]},["app",{"sourceInterval":[2532,2540]},"caseName",[]],["app",{"sourceInterval":[2543,2550]},"comment",[]],["app",{"sourceInterval":[2553,2558]},"ident",[]],["app",{"sourceInterval":[2561,2569]},"operator",[]],["app",{"sourceInterval":[2572,2583]},"punctuation",[]],["app",{"sourceInterval":[2586,2594]},"terminal",[]],["app",{"sourceInterval":[2597,2600]},"any",[]]]],"operator":["define",{"sourceInterval":[2604,2669]},null,[],["alt",{"sourceInterval":[2615,2669]},["terminal",{"sourceInterval":[2615,2619]},"<:"],["terminal",{"sourceInterval":[2622,2625]},"="],["terminal",{"sourceInterval":[2628,2632]},":="],["terminal",{"sourceInterval":[2635,2639]},"+="],["terminal",{"sourceInterval":[2642,2645]},"*"],["terminal",{"sourceInterval":[2648,2651]},"+"],["terminal",{"sourceInterval":[2654,2657]},"?"],["terminal",{"sourceInterval":[2660,2663]},"~"],["terminal",{"sourceInterval":[2666,2669]},"&"]]],"punctuation":["define",{"sourceInterval":[2673,2709]},null,[],["alt",{"sourceInterval":[2687,2709]},["terminal",{"sourceInterval":[2687,2690]},"<"],["terminal",{"sourceInterval":[2693,2696]},">"],["terminal",{"sourceInterval":[2699,2702]},","],["terminal",{"sourceInterval":[2705,2709]},"--"]]]}]);
 
 // --------------------------------------------------------------------
 // Imports
 // --------------------------------------------------------------------
 
 const Builder = Builder_1;
-const Grammar$1 = Grammar_1;
+const Grammar = Grammar_1;
 const Namespace = Namespace_1;
 const common = common$l;
 const errors = errors$9;
-const pexprs$1 = pexprs$7;
+const pexprs = pexprs$6;
 const util = util$7;
 const version = version$1;
 const {makeRecipe} = makeRecipe$5;
@@ -5763,7 +5744,7 @@ const {makeRecipe} = makeRecipe$5;
 // bottom of this file because loading the grammar requires Ohm itself.
 let ohmGrammar;
 
-const superSplicePlaceholder = Object.create(pexprs$1.PExpr.prototype);
+const superSplicePlaceholder = Object.create(pexprs.PExpr.prototype);
 
 const isBuffer = obj =>
   !!obj.constructor &&
@@ -5818,7 +5799,7 @@ function buildGrammar(match, namespace, optOhmGrammarForTesting) {
       currentRuleFormals = fs.children.map(c => c.visit())[0] || [];
       // If there is no default start rule yet, set it now. This must be done before visiting
       // the body, because it might contain an inline rule definition.
-      if (!decl.defaultStartRule && decl.ensureSuperGrammar() !== Grammar$1.ProtoBuiltInRules) {
+      if (!decl.defaultStartRule && decl.ensureSuperGrammar() !== Grammar.ProtoBuiltInRules) {
         decl.withDefaultStartRule(currentRuleName);
       }
       const body = b.visit();
@@ -5862,7 +5843,7 @@ function buildGrammar(match, namespace, optOhmGrammarForTesting) {
           if (t === superSplicePlaceholder) throw errors.multipleSuperSplices(t);
         });
 
-        return new pexprs$1.Splice(
+        return new pexprs.Splice(
             decl.superGrammar,
             currentRuleName,
             beforeTerms,
@@ -5967,8 +5948,15 @@ function buildGrammar(match, namespace, optOhmGrammarForTesting) {
       return c.visit();
     },
 
-    terminalChar(_) {
-      return common.unescapeChar(this.sourceString);
+    escapeChar(c) {
+      try {
+        return common.unescapeCodePoint(this.sourceString);
+      } catch (err) {
+        if (err instanceof RangeError && err.message.startsWith('Invalid code point ')) {
+          throw errors.invalidCodePoint(c);
+        }
+        throw err; // Rethrow
+      }
     },
 
     NonemptyListOf(x, _, xs) {
@@ -6052,7 +6040,7 @@ main$1.exports = {
   grammarsFromScriptElements,
   makeRecipe,
   ohmGrammar: null, // Initialized below, after Grammar.BuiltInRules.
-  pexprs: pexprs$1,
+  pexprs,
   util,
   version,
 };
@@ -6063,10 +6051,10 @@ main$1.exports._buildGrammar = buildGrammar;
 // Late initialization for stuff that is bootstrapped.
 
 
-util.announceBuiltInRules(Grammar$1.BuiltInRules);
+util.announceBuiltInRules(Grammar.BuiltInRules);
 
 main$1.exports.ohmGrammar = ohmGrammar = ohmGrammar$1;
-Grammar$1.initApplicationParser(ohmGrammar, buildGrammar);
+Grammar.initApplicationParser(ohmGrammar, buildGrammar);
 
 var ohm = main$1.exports;
 
@@ -6240,14 +6228,6 @@ VisitorFamily.prototype.addOperation = function(signature, actions) {
 
 var VisitorFamily_1 = VisitorFamily;
 
-// --------------------------------------------------------------------
-// Imports
-// --------------------------------------------------------------------
-
-const pexprs = pexprs$7;
-const MatchResult = MatchResult_1;
-const Grammar = Grammar_1;
-
 // --------------------------------------------------------------------
 // Operations
 // --------------------------------------------------------------------
@@ -6263,11 +6243,6 @@ const defaultOperation = {
 
     // without customization
     if (!Object.prototype.hasOwnProperty.call(mapping, ctorName)) {
-      // intermediate node
-      if (this._node instanceof pexprs.Alt || this._node instanceof pexprs.Apply) {
-        return children[0].toAST(mapping);
-      }
-
       // lexical rule
       if (this.isLexical()) {
         return this.sourceString;
@@ -6351,8 +6326,8 @@ const defaultOperation = {
 // The optional `mapping` parameter can be used to customize how the nodes of the CST
 // are mapped to the AST (see /doc/extras.md#toastmatchresult-mapping).
 function toAST(res, mapping) {
-  if (!(res instanceof MatchResult) || res.failed()) {
-    throw new Error('toAST() expects a succesfull MatchResult as first parameter');
+  if (typeof res.failed !== 'function' || res.failed()) {
+    throw new Error('toAST() expects a succesful MatchResult as first parameter');
   }
 
   mapping = Object.assign({}, mapping);
@@ -6370,7 +6345,7 @@ function toAST(res, mapping) {
 
 // Returns a semantics containg the toAST(mapping) operation for the given grammar g.
 function semanticsForToAST(g) {
-  if (!(g instanceof Grammar)) {
+  if (typeof g.createSemantics !== 'function') {
     throw new Error('semanticsToAST() expects a Grammar as parameter');
   }