ohm-js 16.3.0 → 16.3.1

package/dist/ohm.esm.js

@@ -745,7 +745,7 @@ pexprsMain.UnicodeChar = UnicodeChar;
 // --------------------------------------------------------------------
 
 const common$i = common$l;
-const pexprs$m = pexprsMain;
+const pexprs$l = pexprsMain;
 
 // --------------------------------------------------------------------
 // Operations
@@ -754,7 +754,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'
 );
 
@@ -762,12 +762,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;
     };
@@ -775,13 +775,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;
     };
@@ -840,7 +840,7 @@ var Namespace_1 = Namespace$2;
 
 const {assert: assert$3} = common$l;
 const Namespace$1 = Namespace_1;
-const pexprs$l = pexprsMain;
+const pexprs$k = pexprsMain;
 
 // --------------------------------------------------------------------
 // Private stuff
@@ -1052,7 +1052,10 @@ function invalidCodePoint(applyWrapper) {
   // 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);
+  return createError(
+      `U+${fullInterval.contents} is not a valid Unicode code point`,
+      fullInterval
+  );
 }
 
 // ----------------- Kleene operators -----------------
@@ -1069,7 +1072,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;
   }
@@ -1372,7 +1375,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;
@@ -1387,51 +1390,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
@@ -1463,14 +1466,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)) {
@@ -1498,28 +1501,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;
   }
@@ -1534,7 +1537,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();
@@ -1544,25 +1547,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()`.
 };
@@ -1573,39 +1576,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);
@@ -1614,15 +1617,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);
   });
@@ -1987,7 +1990,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;
@@ -2013,9 +2016,9 @@ 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();
@@ -2028,7 +2031,7 @@ 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()) {
@@ -2040,7 +2043,7 @@ 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)) {
@@ -2052,7 +2055,7 @@ pexprs$h.Terminal.prototype.eval = function(state) {
   }
 };
 
-pexprs$h.Range.prototype.eval = function(state) {
+pexprs$g.Range.prototype.eval = function(state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
 
@@ -2071,18 +2074,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 +2094,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 +2104,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,7 +2148,7 @@ 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)
@@ -2155,7 +2158,7 @@ pexprs$h.Iter.prototype.eval = function(state) {
   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 +2184,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 +2195,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 +2218,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 +2241,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 +2318,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;
 
@@ -2335,7 +2338,7 @@ pexprs$h.Apply.prototype.evalOnce = function(expr, state) {
   }
 };
 
-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,7 +2382,7 @@ 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();
@@ -2397,32 +2400,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 +2433,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 +2450,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 +2469,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 +2513,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 +2533,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 +2542,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 +2551,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 +2562,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 +2618,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 +2654,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 +2690,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 +2703,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 +2749,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 +2815,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 +2835,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 +2848,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 +2872,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 +2888,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 +2902,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 +2934,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 +2972,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 +2982,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 +3026,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 +3052,7 @@ pexprs$9.Iter.prototype.toFailure = function(grammar) {
 // --------------------------------------------------------------------
 
 const common$5 = common$l;
-const pexprs$8 = pexprsMain;
+const pexprs$7 = pexprsMain;
 
 // --------------------------------------------------------------------
 // Operations
@@ -3062,57 +3065,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 +3124,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 +3132,7 @@ pexprs$8.UnicodeChar.prototype.toString = function() {
 // Re-export classes
 // --------------------------------------------------------------------
 
-var pexprs$7 = pexprsMain;
+var pexprs$6 = pexprsMain;
 
 // --------------------------------------------------------------------
 // Imports
@@ -3138,7 +3141,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) {
@@ -3298,7 +3301,7 @@ const Interval = Interval_1;
 // Private stuff
 // --------------------------------------------------------------------
 
-function MatchResult$3(
+function MatchResult$2(
     matcher,
     input,
     startExpr,
@@ -3332,19 +3335,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(
@@ -3357,7 +3360,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() + ']';
@@ -3365,7 +3368,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');
   }
@@ -3389,7 +3392,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);
 };
@@ -3398,7 +3401,7 @@ MatchResult$3.prototype.getInterval = function() {
 // Exports
 // --------------------------------------------------------------------
 
-var MatchResult_1 = MatchResult$3;
+var MatchResult_1 = MatchResult$2;
 
 // --------------------------------------------------------------------
 // Private stuff
@@ -3518,10 +3521,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;
 
 // --------------------------------------------------------------------
@@ -3534,7 +3537,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;
@@ -3740,7 +3743,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);
@@ -3869,7 +3872,7 @@ MatchState$1.prototype = {
           key => this.recordedFailures[key]
       );
     }
-    return new MatchResult$2(
+    return new MatchResult$1(
         this.matcher,
         this.input,
         this.startExpr,
@@ -3916,7 +3919,7 @@ var MatchState_1 = MatchState$1;
 
 const MatchState = MatchState_1;
 
-const pexprs$5 = pexprs$7;
+const pexprs$4 = pexprs$6;
 
 // --------------------------------------------------------------------
 // Private stuff
@@ -4000,7 +4003,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]);
 };
 
 // --------------------------------------------------------------------
@@ -4015,7 +4018,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;
@@ -4544,7 +4547,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)
@@ -4728,7 +4731,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
@@ -4749,7 +4752,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;
@@ -4771,12 +4774,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);
   },
@@ -4784,7 +4787,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) {
@@ -4923,7 +4926,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 = {};
@@ -5010,7 +5013,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');
@@ -5040,43 +5043,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,
@@ -5085,11 +5088,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',
       },
@@ -5100,17 +5103,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
@@ -5134,7 +5137,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;
@@ -5205,7 +5208,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,
@@ -5281,7 +5284,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;
@@ -5297,9 +5300,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
@@ -5320,7 +5323,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) {
@@ -5355,73 +5358,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) {
@@ -5430,33 +5433,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)),
@@ -5486,7 +5489,7 @@ Builder$2.prototype = {
 var Builder_1 = Builder$2;
 
 var name = "ohm-js";
-var version$2 = "16.3.0";
+var version$2 = "16.3.1";
 var description = "An object-oriented language for parsing and pattern matching";
 var repository = "https://github.com/harc/ohm";
 var keywords = [
@@ -5501,7 +5504,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";
@@ -5674,13 +5677,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",[]]]]}]);
@@ -5753,11 +5756,11 @@ var ohmGrammar$1 = makeRecipe$1(["grammar",{"source":"Ohm {\n\n  Grammars\n    =
 // --------------------------------------------------------------------
 
 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;
@@ -5770,7 +5773,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 &&
@@ -5825,7 +5828,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();
@@ -5869,7 +5872,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,
@@ -6066,7 +6069,7 @@ main$1.exports = {
   grammarsFromScriptElements,
   makeRecipe,
   ohmGrammar: null, // Initialized below, after Grammar.BuiltInRules.
-  pexprs: pexprs$1,
+  pexprs,
   util,
   version,
 };
@@ -6077,10 +6080,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;
 
@@ -6254,14 +6257,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
 // --------------------------------------------------------------------
@@ -6277,11 +6272,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;
@@ -6365,8 +6355,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);
@@ -6384,7 +6374,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');
   }