ohm-js 17.2.1 → 17.3.0

package/dist/ohm.cjs

@@ -10,14 +10,14 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 function abstract(optMethodName) {
   const methodName = optMethodName || '';
-  return function() {
+  return function () {
     throw new Error(
-        'this method ' +
+      'this method ' +
         methodName +
         ' is abstract! ' +
         '(it has no implementation in class ' +
         this.constructor.name +
-        ')',
+        ')'
     );
   };
 }
@@ -110,11 +110,11 @@ function StringBuffer() {
   this.strings = [];
 }
 
-StringBuffer.prototype.append = function(str) {
+StringBuffer.prototype.append = function (str) {
   this.strings.push(str);
 };
 
-StringBuffer.prototype.contents = function() {
+StringBuffer.prototype.contents = function () {
   return this.strings.join('');
 };
 
@@ -138,9 +138,9 @@ function unescapeCodePoint(s) {
       case 'x':
         return escapeUnicode(s.slice(2, 4));
       case 'u':
-        return s.charAt(2) === '{' ?
-          escapeUnicode(s.slice(3, -1)) :
-          escapeUnicode(s.slice(2, 6));
+        return s.charAt(2) === '{'
+          ? escapeUnicode(s.slice(3, -1))
+          : escapeUnicode(s.slice(2, 6));
       default:
         return s.charAt(1);
     }
@@ -166,7 +166,7 @@ function unexpectedObjToString(obj) {
       typeName = typeof obj;
     }
     return typeName + ': ' + JSON.stringify(String(obj));
-  } catch (e) {
+  } catch {
     return baseToString;
   }
 }
@@ -198,36 +198,60 @@ var common = /*#__PURE__*/Object.freeze({
   checkNotNull: checkNotNull
 });
 
-// These are just categories that are used in ES5/ES2015.
-// The full list of Unicode categories is here: http://www.fileformat.info/info/unicode/category/index.htm.
-const UnicodeCategories = {
-  // Letters
-  Lu: /\p{Lu}/u,
-  Ll: /\p{Ll}/u,
-  Lt: /\p{Lt}/u,
-  Lm: /\p{Lm}/u,
-  Lo: /\p{Lo}/u,
-
-  // Numbers
-  Nl: /\p{Nl}/u,
-  Nd: /\p{Nd}/u,
-
-  // Marks
-  Mn: /\p{Mn}/u,
-  Mc: /\p{Mc}/u,
-
-  // Punctuation, Connector
-  Pc: /\p{Pc}/u,
-
-  // Separator, Space
-  Zs: /\p{Zs}/u,
-
-  // These two are not real Unicode categories, but our useful for Ohm.
-  // L is a combination of all the letter categories.
-  // Ltmo is a combination of Lt, Lm, and Lo.
-  L: /\p{Letter}/u,
-  Ltmo: /\p{Lt}|\p{Lm}|\p{Lo}/u,
-};
+// The full list of categories from:
+// https://www.unicode.org/Public/UCD/latest/ucd/extracted/DerivedGeneralCategory.txt.
+
+const toRegExp = val => new RegExp(String.raw`\p{${val}}`, 'u');
+
+/*
+  grep -v '^#' DerivedGeneralCategory.txt \
+    | cut -d';' -f2 \
+    | awk 'NF{print $1}' \
+    | sort -u \
+    | awk '{printf "\x27%s\x27,\n",$1}'
+ */
+
+const UnicodeCategories = Object.fromEntries(
+  [
+    'Cc',
+    'Cf',
+    'Cn',
+    'Co',
+    'Cs',
+    'Ll',
+    'Lm',
+    'Lo',
+    'Lt',
+    'Lu',
+    'Mc',
+    'Me',
+    'Mn',
+    'Nd',
+    'Nl',
+    'No',
+    'Pc',
+    'Pd',
+    'Pe',
+    'Pf',
+    'Pi',
+    'Po',
+    'Ps',
+    'Sc',
+    'Sk',
+    'Sm',
+    'So',
+    'Zl',
+    'Zp',
+    'Zs',
+  ].map(cat => [cat, toRegExp(cat)])
+);
+UnicodeCategories['Ltmo'] = /\p{Lt}|\p{Lm}|\p{Lo}/u;
+
+// We only support a few of these for now, but could add more later.
+// See https://www.unicode.org/Public/UCD/latest/ucd/PropertyAliases.txt
+const UnicodeBinaryProperties = Object.fromEntries(
+  ['XID_Start', 'XID_Continue', 'White_Space'].map(prop => [prop, toRegExp(prop)])
+);
 
 // --------------------------------------------------------------------
 // Private stuff
@@ -408,10 +432,18 @@ class Apply extends PExpr {
 // Unicode character
 
 class UnicodeChar extends PExpr {
-  constructor(category) {
+  constructor(categoryOrProp) {
     super();
-    this.category = category;
-    this.pattern = UnicodeCategories[category];
+    this.categoryOrProp = categoryOrProp;
+    if (categoryOrProp in UnicodeCategories) {
+      this.pattern = UnicodeCategories[categoryOrProp];
+    } else if (categoryOrProp in UnicodeBinaryProperties) {
+      this.pattern = UnicodeBinaryProperties[categoryOrProp];
+    } else {
+      throw new Error(
+        `Invalid Unicode category or property name: ${JSON.stringify(categoryOrProp)}`
+      );
+    }
   }
 }
 
@@ -462,9 +494,9 @@ function grammarSyntaxError(matchFailure) {
 // Undeclared grammar
 
 function undeclaredGrammar(grammarName, namespace, interval) {
-  const message = namespace ?
-    `Grammar ${grammarName} is not declared in namespace '${namespace}'` :
-    'Undeclared grammar ' + grammarName;
+  const message = namespace
+    ? `Grammar ${grammarName} is not declared in namespace '${namespace}'`
+    : 'Undeclared grammar ' + grammarName;
   return createError(message, interval);
 }
 
@@ -484,8 +516,8 @@ function grammarDoesNotSupportIncrementalParsing(grammar) {
 
 function undeclaredRule(ruleName, grammarName, optInterval) {
   return createError(
-      'Rule ' + ruleName + ' is not declared in grammar ' + grammarName,
-      optInterval,
+    'Rule ' + ruleName + ' is not declared in grammar ' + grammarName,
+    optInterval
   );
 }
 
@@ -493,8 +525,8 @@ function undeclaredRule(ruleName, grammarName, optInterval) {
 
 function cannotOverrideUndeclaredRule(ruleName, grammarName, optSource) {
   return createError(
-      'Cannot override rule ' + ruleName + ' because it is not declared in ' + grammarName,
-      optSource,
+    'Cannot override rule ' + ruleName + ' because it is not declared in ' + grammarName,
+    optSource
   );
 }
 
@@ -502,8 +534,8 @@ function cannotOverrideUndeclaredRule(ruleName, grammarName, optSource) {
 
 function cannotExtendUndeclaredRule(ruleName, grammarName, optSource) {
   return createError(
-      'Cannot extend rule ' + ruleName + ' because it is not declared in ' + grammarName,
-      optSource,
+    'Cannot extend rule ' + ruleName + ' because it is not declared in ' + grammarName,
+    optSource
   );
 }
 
@@ -522,14 +554,14 @@ function duplicateRuleDeclaration(ruleName, grammarName, declGrammarName, optSou
 
 function wrongNumberOfParameters(ruleName, expected, actual, source) {
   return createError(
-      'Wrong number of parameters for rule ' +
+    'Wrong number of parameters for rule ' +
       ruleName +
       ' (expected ' +
       expected +
       ', got ' +
       actual +
       ')',
-      source,
+    source
   );
 }
 
@@ -537,14 +569,14 @@ function wrongNumberOfParameters(ruleName, expected, actual, source) {
 
 function wrongNumberOfArguments(ruleName, expected, actual, expr) {
   return createError(
-      'Wrong number of arguments for rule ' +
+    'Wrong number of arguments for rule ' +
       ruleName +
       ' (expected ' +
       expected +
       ', got ' +
       actual +
       ')',
-      expr,
+    expr
   );
 }
 
@@ -552,8 +584,8 @@ function wrongNumberOfArguments(ruleName, expected, actual, expr) {
 
 function duplicateParameterNames(ruleName, duplicates, source) {
   return createError(
-      'Duplicate parameter names in rule ' + ruleName + ': ' + duplicates.join(', '),
-      source,
+    'Duplicate parameter names in rule ' + ruleName + ': ' + duplicates.join(', '),
+    source
   );
 }
 
@@ -561,14 +593,14 @@ function duplicateParameterNames(ruleName, duplicates, source) {
 
 function invalidParameter(ruleName, expr) {
   return createError(
-      'Invalid parameter to rule ' +
+    'Invalid parameter to rule ' +
       ruleName +
       ': ' +
       expr +
       ' has arity ' +
       expr.getArity() +
       ', but parameter expressions must have arity 1',
-      expr.source,
+    expr.source
   );
 }
 
@@ -580,8 +612,8 @@ const syntacticVsLexicalNote =
 
 function applicationOfSyntacticRuleFromLexicalContext(ruleName, applyExpr) {
   return createError(
-      'Cannot apply syntactic rule ' + ruleName + ' from here (inside a lexical context)',
-      applyExpr.source,
+    'Cannot apply syntactic rule ' + ruleName + ' from here (inside a lexical context)',
+    applyExpr.source
   );
 }
 
@@ -590,9 +622,9 @@ function applicationOfSyntacticRuleFromLexicalContext(ruleName, applyExpr) {
 function applySyntacticWithLexicalRuleApplication(applyExpr) {
   const {ruleName} = applyExpr;
   return createError(
-      `applySyntactic is for syntactic rules, but '${ruleName}' is a lexical rule. ` +
+    `applySyntactic is for syntactic rules, but '${ruleName}' is a lexical rule. ` +
       syntacticVsLexicalNote,
-      applyExpr.source,
+    applyExpr.source
   );
 }
 
@@ -600,8 +632,8 @@ function applySyntacticWithLexicalRuleApplication(applyExpr) {
 
 function unnecessaryExperimentalApplySyntactic(applyExpr) {
   return createError(
-      'applySyntactic is not required here (in a syntactic context)',
-      applyExpr.source,
+    'applySyntactic is not required here (in a syntactic context)',
+    applyExpr.source
   );
 }
 
@@ -627,8 +659,8 @@ function invalidCodePoint(applyWrapper) {
   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,
+    `U+${fullInterval.contents} is not a valid Unicode code point`,
+    fullInterval
   );
 }
 
@@ -646,8 +678,8 @@ function kleeneExprHasNullableOperand(kleeneExpr, applicationStack) {
     "' (possible infinite loop)";
   if (applicationStack.length > 0) {
     const stackTrace = applicationStack
-        .map(app => new Apply(app.ruleName, app.args))
-        .join('\n');
+      .map(app => new Apply(app.ruleName, app.args))
+      .join('\n');
     message += '\nApplication stack (most recent application last):\n' + stackTrace;
   }
   return createError(message, kleeneExpr.expr.source);
@@ -657,7 +689,7 @@ function kleeneExprHasNullableOperand(kleeneExpr, applicationStack) {
 
 function inconsistentArity(ruleName, expected, actual, expr) {
   return createError(
-      'Rule ' +
+    'Rule ' +
       ruleName +
       ' involves an alternation which has inconsistent arity ' +
       '(expected ' +
@@ -665,7 +697,7 @@ function inconsistentArity(ruleName, expected, actual, expr) {
       ', got ' +
       actual +
       ')',
-      expr.source,
+    expr.source
   );
 }
 
@@ -680,12 +712,12 @@ function multipleErrors(errors) {
 
 function missingSemanticAction(ctorName, name, type, stack) {
   let stackTrace = stack
-      .slice(0, -1)
-      .map(info => {
-        const ans = '  ' + info[0].name + ' > ' + info[1];
-        return info.length === 3 ? ans + " for '" + info[2] + "'" : ans;
-      })
-      .join('\n');
+    .slice(0, -1)
+    .map(info => {
+      const ans = '  ' + info[0].name + ' > ' + info[1];
+      return info.length === 3 ? ans + " for '" + info[2] + "'" : ans;
+    })
+    .join('\n');
   stackTrace += '\n  ' + name + ' > ' + ctorName;
 
   let moreInfo = '';
@@ -850,9 +882,9 @@ function getLineAndColumn(str, offset) {
     // Get the next line.
     const nextLineEndOffset = str.indexOf('\n', lineEndOffset + 1);
     nextLine =
-      nextLineEndOffset === -1 ?
-        str.slice(lineEndOffset) :
-        str.slice(lineEndOffset, nextLineEndOffset);
+      nextLineEndOffset === -1
+        ? str.slice(lineEndOffset)
+        : str.slice(lineEndOffset, nextLineEndOffset);
     // Strip leading and trailing EOL char(s).
     nextLine = nextLine.replace(/^\r?\n/, '').replace(/\r$/, '');
   }
@@ -894,11 +926,23 @@ const uniqueId = (() => {
 
 class Interval {
   constructor(sourceString, startIdx, endIdx) {
-    this.sourceString = sourceString;
+    // Store the full source in a non-enumerable property, so that when
+    // grammars and other objects are printed in the REPL, it's not
+    // cluttered with multiple copies of the same long string.
+    Object.defineProperty(this, '_sourceString', {
+      value: sourceString,
+      configurable: false,
+      enumerable: false,
+      writable: false,
+    });
     this.startIdx = startIdx;
     this.endIdx = endIdx;
   }
 
+  get sourceString() {
+    return this._sourceString;
+  }
+
   get contents() {
     if (this._contents === undefined) {
       this._contents = this.sourceString.slice(this.startIdx, this.endIdx);
@@ -964,13 +1008,13 @@ class Interval {
       throw intervalSourcesDontMatch();
     }
     assert(
-        this.startIdx >= that.startIdx && this.endIdx <= that.endIdx,
-        'other interval does not cover this one',
+      this.startIdx >= that.startIdx && this.endIdx <= that.endIdx,
+      'other interval does not cover this one'
     );
     return new Interval(
-        this.sourceString,
-        this.startIdx - that.startIdx,
-        this.endIdx - that.startIdx,
+      this.sourceString,
+      this.startIdx - that.startIdx,
+      this.endIdx - that.startIdx
     );
   }
 
@@ -989,7 +1033,7 @@ class Interval {
   }
 }
 
-Interval.coverage = function(firstInterval, ...intervals) {
+Interval.coverage = function (firstInterval, ...intervals) {
   let {startIdx, endIdx} = firstInterval;
   for (const interval of intervals) {
     if (interval.sourceString !== firstInterval.sourceString) {
@@ -1003,6 +1047,7 @@ Interval.coverage = function(firstInterval, ...intervals) {
 };
 
 const MAX_CHAR_CODE = 0xffff;
+const MAX_CODE_POINT = 0x10ffff;
 
 class InputStream {
   constructor(source) {
@@ -1048,6 +1093,8 @@ class InputStream {
 
         This is intended to be a locale-invariant comparison, which means it may not obey
         locale-specific expectations (e.g. "i" => "İ").
+
+        See also https://unicode.org/faq/casemap_charprop.html#casemap
        */
       for (idx = 0; idx < s.length; idx++) {
         const actual = this.next();
@@ -1082,13 +1129,13 @@ class InputStream {
 
 class MatchResult {
   constructor(
-      matcher,
-      input,
-      startExpr,
-      cst,
-      cstOffset,
-      rightmostFailurePosition,
-      optRecordedFailures,
+    matcher,
+    input,
+    startExpr,
+    cst,
+    cstOffset,
+    rightmostFailurePosition,
+    optRecordedFailures
   ) {
     this.matcher = matcher;
     this.input = input;
@@ -1099,22 +1146,20 @@ class MatchResult {
     this._rightmostFailures = optRecordedFailures;
 
     if (this.failed()) {
-      /* eslint-disable no-invalid-this */
-      defineLazyProperty(this, 'message', function() {
+      defineLazyProperty(this, 'message', function () {
         const detail = 'Expected ' + this.getExpectedText();
         return (
           getLineAndColumnMessage(this.input, this.getRightmostFailurePosition()) + detail
         );
       });
-      defineLazyProperty(this, 'shortMessage', function() {
+      defineLazyProperty(this, 'shortMessage', function () {
         const detail = 'expected ' + this.getExpectedText();
         const errorInfo = getLineAndColumn(
-            this.input,
-            this.getRightmostFailurePosition(),
+          this.input,
+          this.getRightmostFailurePosition()
         );
         return 'Line ' + errorInfo.lineNum + ', col ' + errorInfo.colNum + ': ' + detail;
       });
-      /* eslint-enable no-invalid-this */
     }
   }
 
@@ -1143,9 +1188,9 @@ class MatchResult {
   }
 
   toString() {
-    return this.succeeded() ?
-      '[match succeeded]' :
-      '[match failed at position ' + this.getRightmostFailurePosition() + ']';
+    return this.succeeded()
+      ? '[match succeeded]'
+      : '[match failed at position ' + this.getRightmostFailurePosition() + ']';
   }
 
   // Return a string summarizing the expected contents of the input stream when
@@ -1211,14 +1256,14 @@ class PosInfo {
     const indexOfFirstInvolvedRule =
       applicationMemoKeyStack.indexOf(headApplication.toMemoKey()) + 1;
     const involvedApplicationMemoKeys = applicationMemoKeyStack.slice(
-        indexOfFirstInvolvedRule,
+      indexOfFirstInvolvedRule
     );
 
-    memoRec.isInvolved = function(applicationMemoKey) {
+    memoRec.isInvolved = function (applicationMemoKey) {
       return involvedApplicationMemoKeys.indexOf(applicationMemoKey) >= 0;
     };
 
-    memoRec.updateInvolvedApplicationMemoKeys = function() {
+    memoRec.updateInvolvedApplicationMemoKeys = function () {
       for (let idx = indexOfFirstInvolvedRule; idx < applicationMemoKeyStack.length; idx++) {
         const applicationMemoKey = applicationMemoKeyStack[idx];
         if (!this.isInvolved(applicationMemoKey)) {
@@ -1252,8 +1297,8 @@ class PosInfo {
     this.memo[memoKey] = memoRec;
     this.maxExaminedLength = Math.max(this.maxExaminedLength, memoRec.examinedLength);
     this.maxRightmostFailureOffset = Math.max(
-        this.maxRightmostFailureOffset,
-        memoRec.rightmostFailureOffset,
+      this.maxRightmostFailureOffset,
+      memoRec.rightmostFailureOffset
     );
     return memoRec;
   }
@@ -1275,8 +1320,8 @@ class PosInfo {
       } else {
         this.maxExaminedLength = Math.max(this.maxExaminedLength, memoRec.examinedLength);
         this.maxRightmostFailureOffset = Math.max(
-            this.maxRightmostFailureOffset,
-            memoRec.rightmostFailureOffset,
+          this.maxRightmostFailureOffset,
+          memoRec.rightmostFailureOffset
         );
       }
     });
@@ -1325,10 +1370,10 @@ function asEscapedString(obj) {
   if (typeof obj === 'string') {
     // Replace non-printable characters with visible symbols.
     return obj
-        .replace(/ /g, DOT_OPERATOR)
-        .replace(/\t/g, SYMBOL_FOR_HORIZONTAL_TABULATION)
-        .replace(/\n/g, SYMBOL_FOR_LINE_FEED)
-        .replace(/\r/g, SYMBOL_FOR_CARRIAGE_RETURN);
+      .replace(/ /g, DOT_OPERATOR)
+      .replace(/\t/g, SYMBOL_FOR_HORIZONTAL_TABULATION)
+      .replace(/\n/g, SYMBOL_FOR_LINE_FEED)
+      .replace(/\r/g, SYMBOL_FOR_CARRIAGE_RETURN);
   }
   return String(obj);
 }
@@ -1359,13 +1404,13 @@ class Trace {
 
   cloneWithExpr(expr) {
     const ans = new Trace(
-        this.input,
-        this.pos,
-        this.pos2,
-        expr,
-        this.succeeded,
-        this.bindings,
-        this.children,
+      this.input,
+      this.pos,
+      this.pos2,
+      expr,
+      this.succeeded,
+      this.bindings,
+      this.children
     );
 
     ans.isHeadOfLeftRecursion = this.isHeadOfLeftRecursion;
@@ -1380,13 +1425,13 @@ class Trace {
   // Record the trace information for the terminating condition of the LR loop.
   recordLRTermination(ruleBodyTrace, value) {
     this.terminatingLREntry = new Trace(
-        this.input,
-        this.pos,
-        this.pos2,
-        this.expr,
-        false,
-        [value],
-        [ruleBodyTrace],
+      this.input,
+      this.pos,
+      this.pos2,
+      this.expr,
+      false,
+      [value],
+      [ruleBodyTrace]
     );
     this.terminatingLREntry.terminatesLR = true;
   }
@@ -1446,7 +1491,7 @@ class Trace {
       const ctorName = node.expr.constructor.name;
       // Don't print anything for Alt nodes.
       if (ctorName === 'Alt') {
-        return; // eslint-disable-line consistent-return
+        return;
       }
       sb.append(getInputExcerpt(node.input, node.pos, 10) + spaces(depth * 2 + 1));
       sb.append((node.succeeded ? CHECK_MARK : BALLOT_X) + ' ' + node.displayString);
@@ -1504,7 +1549,7 @@ any.allowsSkippingPrecedingSpace =
   Terminal.prototype.allowsSkippingPrecedingSpace =
   Range.prototype.allowsSkippingPrecedingSpace =
   UnicodeChar.prototype.allowsSkippingPrecedingSpace =
-    function() {
+    function () {
       return true;
     };
 
@@ -1518,7 +1563,7 @@ Alt.prototype.allowsSkippingPrecedingSpace =
   Not.prototype.allowsSkippingPrecedingSpace =
   Param.prototype.allowsSkippingPrecedingSpace =
   Seq.prototype.allowsSkippingPrecedingSpace =
-    function() {
+    function () {
       return false;
     };
 
@@ -1534,13 +1579,13 @@ awaitBuiltInRules(g => {
 
 let lexifyCount;
 
-PExpr.prototype.assertAllApplicationsAreValid = function(ruleName, grammar) {
+PExpr.prototype.assertAllApplicationsAreValid = function (ruleName, grammar) {
   lexifyCount = 0;
   this._assertAllApplicationsAreValid(ruleName, grammar);
 };
 
 PExpr.prototype._assertAllApplicationsAreValid = abstract(
-    '_assertAllApplicationsAreValid',
+  '_assertAllApplicationsAreValid'
 );
 
 any._assertAllApplicationsAreValid =
@@ -1549,23 +1594,23 @@ any._assertAllApplicationsAreValid =
   Range.prototype._assertAllApplicationsAreValid =
   Param.prototype._assertAllApplicationsAreValid =
   UnicodeChar.prototype._assertAllApplicationsAreValid =
-    function(ruleName, grammar) {
+    function (ruleName, grammar) {
       // no-op
     };
 
-Lex.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) {
+Lex.prototype._assertAllApplicationsAreValid = function (ruleName, grammar) {
   lexifyCount++;
   this.expr._assertAllApplicationsAreValid(ruleName, grammar);
   lexifyCount--;
 };
 
-Alt.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) {
+Alt.prototype._assertAllApplicationsAreValid = function (ruleName, grammar) {
   for (let idx = 0; idx < this.terms.length; idx++) {
     this.terms[idx]._assertAllApplicationsAreValid(ruleName, grammar);
   }
 };
 
-Seq.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) {
+Seq.prototype._assertAllApplicationsAreValid = function (ruleName, grammar) {
   for (let idx = 0; idx < this.factors.length; idx++) {
     this.factors[idx]._assertAllApplicationsAreValid(ruleName, grammar);
   }
@@ -1574,14 +1619,14 @@ Seq.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) {
 Iter.prototype._assertAllApplicationsAreValid =
   Not.prototype._assertAllApplicationsAreValid =
   Lookahead.prototype._assertAllApplicationsAreValid =
-    function(ruleName, grammar) {
+    function (ruleName, grammar) {
       this.expr._assertAllApplicationsAreValid(ruleName, grammar);
     };
 
-Apply.prototype._assertAllApplicationsAreValid = function(
-    ruleName,
-    grammar,
-    skipSyntacticCheck = false,
+Apply.prototype._assertAllApplicationsAreValid = function (
+  ruleName,
+  grammar,
+  skipSyntacticCheck = false
 ) {
   const ruleInfo = grammar.rules[this.ruleName];
   const isContextSyntactic = isSyntactic(ruleName) && lexifyCount === 0;
@@ -1644,7 +1689,7 @@ Apply.prototype._assertAllApplicationsAreValid = function(
 // --------------------------------------------------------------------
 
 PExpr.prototype.assertChoicesHaveUniformArity = abstract(
-    'assertChoicesHaveUniformArity',
+  'assertChoicesHaveUniformArity'
 );
 
 any.assertChoicesHaveUniformArity =
@@ -1654,11 +1699,11 @@ any.assertChoicesHaveUniformArity =
   Param.prototype.assertChoicesHaveUniformArity =
   Lex.prototype.assertChoicesHaveUniformArity =
   UnicodeChar.prototype.assertChoicesHaveUniformArity =
-    function(ruleName) {
+    function (ruleName) {
       // no-op
     };
 
-Alt.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+Alt.prototype.assertChoicesHaveUniformArity = function (ruleName) {
   if (this.terms.length === 0) {
     return;
   }
@@ -1673,7 +1718,7 @@ Alt.prototype.assertChoicesHaveUniformArity = function(ruleName) {
   }
 };
 
-Extend.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+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();
@@ -1683,25 +1728,25 @@ Extend.prototype.assertChoicesHaveUniformArity = function(ruleName) {
   }
 };
 
-Seq.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+Seq.prototype.assertChoicesHaveUniformArity = function (ruleName) {
   for (let idx = 0; idx < this.factors.length; idx++) {
     this.factors[idx].assertChoicesHaveUniformArity(ruleName);
   }
 };
 
-Iter.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+Iter.prototype.assertChoicesHaveUniformArity = function (ruleName) {
   this.expr.assertChoicesHaveUniformArity(ruleName);
 };
 
-Not.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+Not.prototype.assertChoicesHaveUniformArity = function (ruleName) {
   // no-op (not required b/c the nested expr doesn't show up in the CST)
 };
 
-Lookahead.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+Lookahead.prototype.assertChoicesHaveUniformArity = function (ruleName) {
   this.expr.assertChoicesHaveUniformArity(ruleName);
 };
 
-Apply.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+Apply.prototype.assertChoicesHaveUniformArity = function (ruleName) {
   // The arities of the parameter expressions is required to be 1 by
   // `assertAllApplicationsAreValid()`.
 };
@@ -1711,7 +1756,7 @@ Apply.prototype.assertChoicesHaveUniformArity = function(ruleName) {
 // --------------------------------------------------------------------
 
 PExpr.prototype.assertIteratedExprsAreNotNullable = abstract(
-    'assertIteratedExprsAreNotNullable',
+  'assertIteratedExprsAreNotNullable'
 );
 
 any.assertIteratedExprsAreNotNullable =
@@ -1720,23 +1765,23 @@ any.assertIteratedExprsAreNotNullable =
   Range.prototype.assertIteratedExprsAreNotNullable =
   Param.prototype.assertIteratedExprsAreNotNullable =
   UnicodeChar.prototype.assertIteratedExprsAreNotNullable =
-    function(grammar) {
+    function (grammar) {
       // no-op
     };
 
-Alt.prototype.assertIteratedExprsAreNotNullable = function(grammar) {
+Alt.prototype.assertIteratedExprsAreNotNullable = function (grammar) {
   for (let idx = 0; idx < this.terms.length; idx++) {
     this.terms[idx].assertIteratedExprsAreNotNullable(grammar);
   }
 };
 
-Seq.prototype.assertIteratedExprsAreNotNullable = function(grammar) {
+Seq.prototype.assertIteratedExprsAreNotNullable = function (grammar) {
   for (let idx = 0; idx < this.factors.length; idx++) {
     this.factors[idx].assertIteratedExprsAreNotNullable(grammar);
   }
 };
 
-Iter.prototype.assertIteratedExprsAreNotNullable = function(grammar) {
+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);
@@ -1749,11 +1794,11 @@ Opt.prototype.assertIteratedExprsAreNotNullable =
   Not.prototype.assertIteratedExprsAreNotNullable =
   Lookahead.prototype.assertIteratedExprsAreNotNullable =
   Lex.prototype.assertIteratedExprsAreNotNullable =
-    function(grammar) {
+    function (grammar) {
       this.expr.assertIteratedExprsAreNotNullable(grammar);
     };
 
-Apply.prototype.assertIteratedExprsAreNotNullable = function(grammar) {
+Apply.prototype.assertIteratedExprsAreNotNullable = function (grammar) {
   this.args.forEach(arg => {
     arg.assertIteratedExprsAreNotNullable(grammar);
   });
@@ -1797,11 +1842,11 @@ class Node {
   onlyChild() {
     if (this.numChildren() !== 1) {
       throw new Error(
-          'cannot get only child of a node of type ' +
+        'cannot get only child of a node of type ' +
           this.ctorName +
           ' (it has ' +
           this.numChildren() +
-          ' children)',
+          ' children)'
       );
     } else {
       return this.firstChild();
@@ -1811,7 +1856,7 @@ class Node {
   firstChild() {
     if (this.hasNoChildren()) {
       throw new Error(
-          'cannot get first child of a ' + this.ctorName + ' node, which has no children',
+        'cannot get first child of a ' + this.ctorName + ' node, which has no children'
       );
     } else {
       return this.childAt(0);
@@ -1821,7 +1866,7 @@ class Node {
   lastChild() {
     if (this.hasNoChildren()) {
       throw new Error(
-          'cannot get last child of a ' + this.ctorName + ' node, which has no children',
+        'cannot get last child of a ' + this.ctorName + ' node, which has no children'
       );
     } else {
       return this.childAt(this.numChildren() - 1);
@@ -1955,7 +2000,7 @@ class IterationNode extends Node {
 */
 PExpr.prototype.eval = abstract('eval'); // function(state) { ... }
 
-any.eval = function(state) {
+any.eval = function (state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   const cp = inputStream.nextCodePoint();
@@ -1968,7 +2013,7 @@ any.eval = function(state) {
   }
 };
 
-end.eval = function(state) {
+end.eval = function (state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   if (inputStream.atEnd()) {
@@ -1980,7 +2025,7 @@ end.eval = function(state) {
   }
 };
 
-Terminal.prototype.eval = function(state) {
+Terminal.prototype.eval = function (state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   if (!inputStream.matchString(this.obj)) {
@@ -1992,7 +2037,7 @@ Terminal.prototype.eval = function(state) {
   }
 };
 
-Range.prototype.eval = function(state) {
+Range.prototype.eval = function (state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
 
@@ -2011,18 +2056,18 @@ Range.prototype.eval = function(state) {
   }
 };
 
-Param.prototype.eval = function(state) {
+Param.prototype.eval = function (state) {
   return state.eval(state.currentApplication().args[this.index]);
 };
 
-Lex.prototype.eval = function(state) {
+Lex.prototype.eval = function (state) {
   state.enterLexifiedContext();
   const ans = state.eval(this.expr);
   state.exitLexifiedContext();
   return ans;
 };
 
-Alt.prototype.eval = function(state) {
+Alt.prototype.eval = function (state) {
   for (let idx = 0; idx < this.terms.length; idx++) {
     if (state.eval(this.terms[idx])) {
       return true;
@@ -2031,7 +2076,7 @@ Alt.prototype.eval = function(state) {
   return false;
 };
 
-Seq.prototype.eval = function(state) {
+Seq.prototype.eval = function (state) {
   for (let idx = 0; idx < this.factors.length; idx++) {
     const factor = this.factors[idx];
     if (!state.eval(factor)) {
@@ -2041,7 +2086,7 @@ Seq.prototype.eval = function(state) {
   return true;
 };
 
-Iter.prototype.eval = function(state) {
+Iter.prototype.eval = function (state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   const arity = this.getArity();
@@ -2063,8 +2108,8 @@ Iter.prototype.eval = function(state) {
     numMatches++;
     const row = state._bindings.splice(state._bindings.length - arity, arity);
     const rowOffsets = state._bindingOffsets.splice(
-        state._bindingOffsets.length - arity,
-        arity,
+      state._bindingOffsets.length - arity,
+      arity
     );
     for (idx = 0; idx < row.length; idx++) {
       cols[idx].push(row[idx]);
@@ -2088,14 +2133,14 @@ Iter.prototype.eval = function(state) {
   const isOptional = this instanceof Opt;
   for (idx = 0; idx < cols.length; idx++) {
     state._bindings.push(
-        new IterationNode(cols[idx], colOffsets[idx], matchLength, isOptional),
+      new IterationNode(cols[idx], colOffsets[idx], matchLength, isOptional)
     );
     state._bindingOffsets.push(offset);
   }
   return true;
 };
 
-Not.prototype.eval = function(state) {
+Not.prototype.eval = function (state) {
   /*
     TODO:
     - Right now we're just throwing away all of the failures that happen inside a `not`, and
@@ -2121,7 +2166,7 @@ Not.prototype.eval = function(state) {
   return true;
 };
 
-Lookahead.prototype.eval = function(state) {
+Lookahead.prototype.eval = function (state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   if (state.eval(this.expr)) {
@@ -2132,7 +2177,7 @@ Lookahead.prototype.eval = function(state) {
   }
 };
 
-Apply.prototype.eval = function(state) {
+Apply.prototype.eval = function (state) {
   const caller = state.currentApplication();
   const actuals = caller ? caller.args : [];
   const app = this.substituteParams(actuals);
@@ -2155,7 +2200,7 @@ Apply.prototype.eval = function(state) {
   return app.reallyEval(state);
 };
 
-Apply.prototype.handleCycle = function(state) {
+Apply.prototype.handleCycle = function (state) {
   const posInfo = state.getCurrentPosInfo();
   const {currentLeftRecursion} = posInfo;
   const memoKey = this.toMemoKey();
@@ -2178,7 +2223,7 @@ Apply.prototype.handleCycle = function(state) {
   return state.useMemoizedResult(state.inputStream.pos, memoRec);
 };
 
-Apply.prototype.reallyEval = function(state) {
+Apply.prototype.reallyEval = function (state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   const origPosInfo = state.getCurrentPosInfo();
@@ -2248,8 +2293,8 @@ Apply.prototype.reallyEval = function(state) {
   // Fix the input stream's examinedLength -- it should be the maximum examined length
   // across all applications, not just this one.
   inputStream.examinedLength = Math.max(
-      inputStream.examinedLength,
-      origInputStreamExaminedLength,
+    inputStream.examinedLength,
+    origInputStreamExaminedLength
   );
 
   state.exitApplication(origPosInfo, value);
@@ -2257,7 +2302,7 @@ Apply.prototype.reallyEval = function(state) {
   return succeeded;
 };
 
-Apply.prototype.evalOnce = function(expr, state) {
+Apply.prototype.evalOnce = function (expr, state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
 
@@ -2272,7 +2317,7 @@ Apply.prototype.evalOnce = function(expr, state) {
   }
 };
 
-Apply.prototype.growSeedResult = function(body, state, origPos, lrMemoRec, newValue) {
+Apply.prototype.growSeedResult = function (body, state, origPos, lrMemoRec, newValue) {
   if (!newValue) {
     return false;
   }
@@ -2290,13 +2335,13 @@ Apply.prototype.growSeedResult = function(body, state, origPos, lrMemoRec, newVa
       // element in `state.trace`.
       const seedTrace = state.trace[state.trace.length - 1];
       lrMemoRec.traceEntry = new Trace(
-          state.input,
-          origPos,
-          inputStream.pos,
-          this,
-          true,
-          [newValue],
-          [seedTrace.clone()],
+        state.input,
+        origPos,
+        inputStream.pos,
+        this,
+        true,
+        [newValue],
+        [seedTrace.clone()]
       );
     }
     inputStream.pos = origPos;
@@ -2316,17 +2361,19 @@ Apply.prototype.growSeedResult = function(body, state, origPos, lrMemoRec, newVa
   return lrMemoRec.value;
 };
 
-UnicodeChar.prototype.eval = function(state) {
+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(ch.length), origPos);
-    return true;
-  } else {
-    state.processFailure(origPos, this);
-    return false;
+  const cp = inputStream.nextCodePoint();
+  if (cp !== undefined && cp <= MAX_CODE_POINT) {
+    const ch = String.fromCodePoint(cp);
+    if (this.pattern.test(ch)) {
+      state.pushBinding(new TerminalNode(ch.length), origPos);
+      return true;
+    }
   }
+  state.processFailure(origPos, this);
+  return false;
 };
 
 // --------------------------------------------------------------------
@@ -2342,17 +2389,17 @@ any.getArity =
   Param.prototype.getArity =
   Apply.prototype.getArity =
   UnicodeChar.prototype.getArity =
-    function() {
+    function () {
       return 1;
     };
 
-Alt.prototype.getArity = function() {
+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();
 };
 
-Seq.prototype.getArity = function() {
+Seq.prototype.getArity = function () {
   let arity = 0;
   for (let idx = 0; idx < this.factors.length; idx++) {
     arity += this.factors[idx].getArity();
@@ -2360,15 +2407,15 @@ Seq.prototype.getArity = function() {
   return arity;
 };
 
-Iter.prototype.getArity = function() {
+Iter.prototype.getArity = function () {
   return this.expr.getArity();
 };
 
-Not.prototype.getArity = function() {
+Not.prototype.getArity = function () {
   return 0;
 };
 
-Lookahead.prototype.getArity = Lex.prototype.getArity = function() {
+Lookahead.prototype.getArity = Lex.prototype.getArity = function () {
   return this.expr.getArity();
 };
 
@@ -2391,38 +2438,38 @@ function getMetaInfo(expr, grammarInterval) {
 
 PExpr.prototype.outputRecipe = abstract('outputRecipe');
 
-any.outputRecipe = function(formals, grammarInterval) {
+any.outputRecipe = function (formals, grammarInterval) {
   return ['any', getMetaInfo(this, grammarInterval)];
 };
 
-end.outputRecipe = function(formals, grammarInterval) {
+end.outputRecipe = function (formals, grammarInterval) {
   return ['end', getMetaInfo(this, grammarInterval)];
 };
 
-Terminal.prototype.outputRecipe = function(formals, grammarInterval) {
+Terminal.prototype.outputRecipe = function (formals, grammarInterval) {
   return ['terminal', getMetaInfo(this, grammarInterval), this.obj];
 };
 
-Range.prototype.outputRecipe = function(formals, grammarInterval) {
+Range.prototype.outputRecipe = function (formals, grammarInterval) {
   return ['range', getMetaInfo(this, grammarInterval), this.from, this.to];
 };
 
-Param.prototype.outputRecipe = function(formals, grammarInterval) {
+Param.prototype.outputRecipe = function (formals, grammarInterval) {
   return ['param', getMetaInfo(this, grammarInterval), this.index];
 };
 
-Alt.prototype.outputRecipe = function(formals, grammarInterval) {
+Alt.prototype.outputRecipe = function (formals, grammarInterval) {
   return ['alt', getMetaInfo(this, grammarInterval)].concat(
-      this.terms.map(term => term.outputRecipe(formals, grammarInterval)),
+    this.terms.map(term => term.outputRecipe(formals, grammarInterval))
   );
 };
 
-Extend.prototype.outputRecipe = function(formals, grammarInterval) {
+Extend.prototype.outputRecipe = function (formals, grammarInterval) {
   const extension = this.terms[0]; // [extension, original]
   return extension.outputRecipe(formals, grammarInterval);
 };
 
-Splice.prototype.outputRecipe = function(formals, grammarInterval) {
+Splice.prototype.outputRecipe = function (formals, grammarInterval) {
   const beforeTerms = this.terms.slice(0, this.expansionPos);
   const afterTerms = this.terms.slice(this.expansionPos + 1);
   return [
@@ -2433,9 +2480,9 @@ Splice.prototype.outputRecipe = function(formals, grammarInterval) {
   ];
 };
 
-Seq.prototype.outputRecipe = function(formals, grammarInterval) {
+Seq.prototype.outputRecipe = function (formals, grammarInterval) {
   return ['seq', getMetaInfo(this, grammarInterval)].concat(
-      this.factors.map(factor => factor.outputRecipe(formals, grammarInterval)),
+    this.factors.map(factor => factor.outputRecipe(formals, grammarInterval))
   );
 };
 
@@ -2445,7 +2492,7 @@ Star.prototype.outputRecipe =
   Not.prototype.outputRecipe =
   Lookahead.prototype.outputRecipe =
   Lex.prototype.outputRecipe =
-    function(formals, grammarInterval) {
+    function (formals, grammarInterval) {
       return [
         this.constructor.name.toLowerCase(),
         getMetaInfo(this, grammarInterval),
@@ -2453,7 +2500,7 @@ Star.prototype.outputRecipe =
       ];
     };
 
-Apply.prototype.outputRecipe = function(formals, grammarInterval) {
+Apply.prototype.outputRecipe = function (formals, grammarInterval) {
   return [
     'app',
     getMetaInfo(this, grammarInterval),
@@ -2462,8 +2509,8 @@ Apply.prototype.outputRecipe = function(formals, grammarInterval) {
   ];
 };
 
-UnicodeChar.prototype.outputRecipe = function(formals, grammarInterval) {
-  return ['unicodeChar', getMetaInfo(this, grammarInterval), this.category];
+UnicodeChar.prototype.outputRecipe = function (formals, grammarInterval) {
+  return ['unicodeChar', getMetaInfo(this, grammarInterval), this.categoryOrProp];
 };
 
 // --------------------------------------------------------------------
@@ -2483,18 +2530,18 @@ any.introduceParams =
   Range.prototype.introduceParams =
   Param.prototype.introduceParams =
   UnicodeChar.prototype.introduceParams =
-    function(formals) {
+    function (formals) {
       return this;
     };
 
-Alt.prototype.introduceParams = function(formals) {
+Alt.prototype.introduceParams = function (formals) {
   this.terms.forEach((term, idx, terms) => {
     terms[idx] = term.introduceParams(formals);
   });
   return this;
 };
 
-Seq.prototype.introduceParams = function(formals) {
+Seq.prototype.introduceParams = function (formals) {
   this.factors.forEach((factor, idx, factors) => {
     factors[idx] = factor.introduceParams(formals);
   });
@@ -2505,12 +2552,12 @@ Iter.prototype.introduceParams =
   Not.prototype.introduceParams =
   Lookahead.prototype.introduceParams =
   Lex.prototype.introduceParams =
-    function(formals) {
+    function (formals) {
       this.expr = this.expr.introduceParams(formals);
       return this;
     };
 
-Apply.prototype.introduceParams = function(formals) {
+Apply.prototype.introduceParams = function (formals) {
   const index = formals.indexOf(this.ruleName);
   if (index >= 0) {
     if (this.args.length > 0) {
@@ -2531,7 +2578,7 @@ Apply.prototype.introduceParams = function(formals) {
 // --------------------------------------------------------------------
 
 // Returns `true` if this parsing expression may accept without consuming any input.
-PExpr.prototype.isNullable = function(grammar) {
+PExpr.prototype.isNullable = function (grammar) {
   return this._isNullable(grammar, Object.create(null));
 };
 
@@ -2542,15 +2589,15 @@ any._isNullable =
   Param.prototype._isNullable =
   Plus.prototype._isNullable =
   UnicodeChar.prototype._isNullable =
-    function(grammar, memo) {
+    function (grammar, memo) {
       return false;
     };
 
-end._isNullable = function(grammar, memo) {
+end._isNullable = function (grammar, memo) {
   return true;
 };
 
-Terminal.prototype._isNullable = function(grammar, memo) {
+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.
@@ -2560,11 +2607,11 @@ Terminal.prototype._isNullable = function(grammar, memo) {
   }
 };
 
-Alt.prototype._isNullable = function(grammar, memo) {
+Alt.prototype._isNullable = function (grammar, memo) {
   return this.terms.length === 0 || this.terms.some(term => term._isNullable(grammar, memo));
 };
 
-Seq.prototype._isNullable = function(grammar, memo) {
+Seq.prototype._isNullable = function (grammar, memo) {
   return this.factors.every(factor => factor._isNullable(grammar, memo));
 };
 
@@ -2572,15 +2619,15 @@ Star.prototype._isNullable =
   Opt.prototype._isNullable =
   Not.prototype._isNullable =
   Lookahead.prototype._isNullable =
-    function(grammar, memo) {
+    function (grammar, memo) {
       return true;
     };
 
-Lex.prototype._isNullable = function(grammar, memo) {
+Lex.prototype._isNullable = function (grammar, memo) {
   return this.expr._isNullable(grammar, memo);
 };
 
-Apply.prototype._isNullable = function(grammar, memo) {
+Apply.prototype._isNullable = function (grammar, memo) {
   const key = this.toMemoKey();
   if (!Object.prototype.hasOwnProperty.call(memo, key)) {
     const {body} = grammar.rules[this.ruleName];
@@ -2609,19 +2656,19 @@ any.substituteParams =
   Terminal.prototype.substituteParams =
   Range.prototype.substituteParams =
   UnicodeChar.prototype.substituteParams =
-    function(actuals) {
+    function (actuals) {
       return this;
     };
 
-Param.prototype.substituteParams = function(actuals) {
+Param.prototype.substituteParams = function (actuals) {
   return checkNotNull(actuals[this.index]);
 };
 
-Alt.prototype.substituteParams = function(actuals) {
+Alt.prototype.substituteParams = function (actuals) {
   return new Alt(this.terms.map(term => term.substituteParams(actuals)));
 };
 
-Seq.prototype.substituteParams = function(actuals) {
+Seq.prototype.substituteParams = function (actuals) {
   return new Seq(this.factors.map(factor => factor.substituteParams(actuals)));
 };
 
@@ -2629,11 +2676,11 @@ Iter.prototype.substituteParams =
   Not.prototype.substituteParams =
   Lookahead.prototype.substituteParams =
   Lex.prototype.substituteParams =
-    function(actuals) {
+    function (actuals) {
       return new this.constructor(this.expr.substituteParams(actuals));
     };
 
-Apply.prototype.substituteParams = function(actuals) {
+Apply.prototype.substituteParams = function (actuals) {
   if (this.args.length === 0) {
     // Avoid making a copy of this application, as an optimization
     return this;
@@ -2707,15 +2754,15 @@ function resolveDuplicatedNames(argumentNameList) {
 // function(firstArgIndex, noDupCheck) { ... }
 PExpr.prototype.toArgumentNameList = abstract('toArgumentNameList');
 
-any.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+any.toArgumentNameList = function (firstArgIndex, noDupCheck) {
   return ['any'];
 };
 
-end.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+end.toArgumentNameList = function (firstArgIndex, noDupCheck) {
   return ['end'];
 };
 
-Terminal.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+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];
@@ -2725,7 +2772,7 @@ Terminal.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   }
 };
 
-Range.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+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)) {
@@ -2738,11 +2785,11 @@ Range.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   return [argName];
 };
 
-Alt.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+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 =>
-    term.toArgumentNameList(firstArgIndex, true),
+    term.toArgumentNameList(firstArgIndex, true)
   );
 
   const argumentNameList = [];
@@ -2762,7 +2809,7 @@ Alt.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   return argumentNameList;
 };
 
-Seq.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+Seq.prototype.toArgumentNameList = function (firstArgIndex, noDupCheck) {
   // Generate the argument name list, without worrying about duplicates.
   let argumentNameList = [];
   this.factors.forEach(factor => {
@@ -2778,44 +2825,44 @@ Seq.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   return argumentNameList;
 };
 
-Iter.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+Iter.prototype.toArgumentNameList = function (firstArgIndex, noDupCheck) {
   const argumentNameList = this.expr
-      .toArgumentNameList(firstArgIndex, noDupCheck)
-      .map(exprArgumentString =>
-      exprArgumentString[exprArgumentString.length - 1] === 's' ?
-        exprArgumentString + 'es' :
-        exprArgumentString + 's',
-      );
+    .toArgumentNameList(firstArgIndex, noDupCheck)
+    .map(exprArgumentString =>
+      exprArgumentString[exprArgumentString.length - 1] === 's'
+        ? exprArgumentString + 'es'
+        : exprArgumentString + 's'
+    );
   if (!noDupCheck) {
     resolveDuplicatedNames(argumentNameList);
   }
   return argumentNameList;
 };
 
-Opt.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+Opt.prototype.toArgumentNameList = function (firstArgIndex, noDupCheck) {
   return this.expr.toArgumentNameList(firstArgIndex, noDupCheck).map(argName => {
     return 'opt' + argName[0].toUpperCase() + argName.slice(1);
   });
 };
 
-Not.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+Not.prototype.toArgumentNameList = function (firstArgIndex, noDupCheck) {
   return [];
 };
 
 Lookahead.prototype.toArgumentNameList = Lex.prototype.toArgumentNameList =
-  function(firstArgIndex, noDupCheck) {
+  function (firstArgIndex, noDupCheck) {
     return this.expr.toArgumentNameList(firstArgIndex, noDupCheck);
   };
 
-Apply.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+Apply.prototype.toArgumentNameList = function (firstArgIndex, noDupCheck) {
   return [this.ruleName];
 };
 
-UnicodeChar.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+UnicodeChar.prototype.toArgumentNameList = function (firstArgIndex, noDupCheck) {
   return ['$' + firstArgIndex];
 };
 
-Param.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+Param.prototype.toArgumentNameList = function (firstArgIndex, noDupCheck) {
   return ['param' + this.index];
 };
 
@@ -2828,7 +2875,7 @@ Param.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
 // Returns a string representing the PExpr, for use as a UI label, etc.
 PExpr.prototype.toDisplayString = abstract('toDisplayString');
 
-Alt.prototype.toDisplayString = Seq.prototype.toDisplayString = function() {
+Alt.prototype.toDisplayString = Seq.prototype.toDisplayString = function () {
   if (this.source) {
     return this.source.trimmed().contents;
   }
@@ -2844,11 +2891,11 @@ any.toDisplayString =
   Terminal.prototype.toDisplayString =
   Range.prototype.toDisplayString =
   Param.prototype.toDisplayString =
-    function() {
+    function () {
       return this.toString();
     };
 
-Apply.prototype.toDisplayString = function() {
+Apply.prototype.toDisplayString = function () {
   if (this.args.length > 0) {
     const ps = this.args.map(arg => arg.toDisplayString());
     return this.ruleName + '<' + ps.join(',') + '>';
@@ -2857,8 +2904,8 @@ Apply.prototype.toDisplayString = function() {
   }
 };
 
-UnicodeChar.prototype.toDisplayString = function() {
-  return 'Unicode [' + this.category + '] character';
+UnicodeChar.prototype.toDisplayString = function () {
+  return 'Unicode [' + this.categoryOrProp + '] character';
 };
 
 // --------------------------------------------------------------------
@@ -2961,34 +3008,34 @@ class Failure {
 
 PExpr.prototype.toFailure = abstract('toFailure');
 
-any.toFailure = function(grammar) {
+any.toFailure = function (grammar) {
   return new Failure(this, 'any object', 'description');
 };
 
-end.toFailure = function(grammar) {
+end.toFailure = function (grammar) {
   return new Failure(this, 'end of input', 'description');
 };
 
-Terminal.prototype.toFailure = function(grammar) {
+Terminal.prototype.toFailure = function (grammar) {
   return new Failure(this, this.obj, 'string');
 };
 
-Range.prototype.toFailure = function(grammar) {
+Range.prototype.toFailure = function (grammar) {
   // TODO: come up with something better
   return new Failure(this, JSON.stringify(this.from) + '..' + JSON.stringify(this.to), 'code');
 };
 
-Not.prototype.toFailure = function(grammar) {
+Not.prototype.toFailure = function (grammar) {
   const description =
     this.expr === any ? 'nothing' : 'not ' + this.expr.toFailure(grammar);
   return new Failure(this, description, 'description');
 };
 
-Lookahead.prototype.toFailure = function(grammar) {
+Lookahead.prototype.toFailure = function (grammar) {
   return this.expr.toFailure(grammar);
 };
 
-Apply.prototype.toFailure = function(grammar) {
+Apply.prototype.toFailure = function (grammar) {
   let {description} = grammar.rules[this.ruleName];
   if (!description) {
     const article = /^[aeiouAEIOU]/.test(this.ruleName) ? 'an' : 'a';
@@ -2997,23 +3044,23 @@ Apply.prototype.toFailure = function(grammar) {
   return new Failure(this, description, 'description');
 };
 
-UnicodeChar.prototype.toFailure = function(grammar) {
-  return new Failure(this, 'a Unicode [' + this.category + '] character', 'description');
+UnicodeChar.prototype.toFailure = function (grammar) {
+  return new Failure(this, 'a Unicode [' + this.categoryOrProp + '] character', 'description');
 };
 
-Alt.prototype.toFailure = function(grammar) {
+Alt.prototype.toFailure = function (grammar) {
   const fs = this.terms.map(t => t.toFailure(grammar));
   const description = '(' + fs.join(' or ') + ')';
   return new Failure(this, description, 'description');
 };
 
-Seq.prototype.toFailure = function(grammar) {
+Seq.prototype.toFailure = function (grammar) {
   const fs = this.factors.map(f => f.toFailure(grammar));
   const description = '(' + fs.join(' ') + ')';
   return new Failure(this, description, 'description');
 };
 
-Iter.prototype.toFailure = function(grammar) {
+Iter.prototype.toFailure = function (grammar) {
   const description = '(' + this.expr.toFailure(grammar) + this.operator + ')';
   return new Failure(this, description, 'description');
 };
@@ -3031,55 +3078,55 @@ Iter.prototype.toFailure = function(grammar) {
 */
 PExpr.prototype.toString = abstract('toString');
 
-any.toString = function() {
+any.toString = function () {
   return 'any';
 };
 
-end.toString = function() {
+end.toString = function () {
   return 'end';
 };
 
-Terminal.prototype.toString = function() {
+Terminal.prototype.toString = function () {
   return JSON.stringify(this.obj);
 };
 
-Range.prototype.toString = function() {
+Range.prototype.toString = function () {
   return JSON.stringify(this.from) + '..' + JSON.stringify(this.to);
 };
 
-Param.prototype.toString = function() {
+Param.prototype.toString = function () {
   return '$' + this.index;
 };
 
-Lex.prototype.toString = function() {
+Lex.prototype.toString = function () {
   return '#(' + this.expr.toString() + ')';
 };
 
-Alt.prototype.toString = function() {
-  return this.terms.length === 1 ?
-    this.terms[0].toString() :
-    '(' + this.terms.map(term => term.toString()).join(' | ') + ')';
+Alt.prototype.toString = function () {
+  return this.terms.length === 1
+    ? this.terms[0].toString()
+    : '(' + this.terms.map(term => term.toString()).join(' | ') + ')';
 };
 
-Seq.prototype.toString = function() {
-  return this.factors.length === 1 ?
-    this.factors[0].toString() :
-    '(' + this.factors.map(factor => factor.toString()).join(' ') + ')';
+Seq.prototype.toString = function () {
+  return this.factors.length === 1
+    ? this.factors[0].toString()
+    : '(' + this.factors.map(factor => factor.toString()).join(' ') + ')';
 };
 
-Iter.prototype.toString = function() {
+Iter.prototype.toString = function () {
   return this.expr + this.operator;
 };
 
-Not.prototype.toString = function() {
+Not.prototype.toString = function () {
   return '~' + this.expr;
 };
 
-Lookahead.prototype.toString = function() {
+Lookahead.prototype.toString = function () {
   return '&' + this.expr;
 };
 
-Apply.prototype.toString = function() {
+Apply.prototype.toString = function () {
   if (this.args.length > 0) {
     const ps = this.args.map(arg => arg.toString());
     return this.ruleName + '<' + ps.join(',') + '>';
@@ -3088,8 +3135,8 @@ Apply.prototype.toString = function() {
   }
 };
 
-UnicodeChar.prototype.toString = function() {
-  return '\\p{' + this.category + '}';
+UnicodeChar.prototype.toString = function () {
+  return '\\p{' + this.categoryOrProp + '}';
 };
 
 class CaseInsensitiveTerminal extends PExpr {
@@ -3137,9 +3184,9 @@ class CaseInsensitiveTerminal extends PExpr {
 
   toFailure(grammar) {
     return new Failure(
-        this,
-        this.obj.toFailure(grammar) + ' (case-insensitive)',
-        'description',
+      this,
+      this.obj.toFailure(grammar) + ' (case-insensitive)',
+      'description'
     );
   }
 
@@ -3235,8 +3282,8 @@ class MatchState {
     posInfo.exit();
 
     this.rightmostFailurePosition = Math.max(
-        this.rightmostFailurePosition,
-        this._rightmostFailurePositionStack.pop(),
+      this.rightmostFailurePosition,
+      this._rightmostFailurePositionStack.pop()
     );
 
     if (optNode) {
@@ -3372,9 +3419,9 @@ class MatchState {
   }
 
   _getRightmostFailureOffset() {
-    return this.rightmostFailurePosition >= 0 ?
-      this.posToOffset(this.rightmostFailurePosition) :
-      -1;
+    return this.rightmostFailurePosition >= 0
+      ? this.posToOffset(this.rightmostFailurePosition)
+      : -1;
   }
 
   // Returns the memoized trace entry for `expr` at `pos`, if one exists, `null` otherwise.
@@ -3431,8 +3478,8 @@ class MatchState {
     const memoRecRightmostFailurePosition =
       this.inputStream.pos + memoRec.rightmostFailureOffset;
     this.rightmostFailurePosition = Math.max(
-        this.rightmostFailurePosition,
-        memoRecRightmostFailurePosition,
+      this.rightmostFailurePosition,
+      memoRecRightmostFailurePosition
     );
     if (
       this.recordedFailures &&
@@ -3443,8 +3490,8 @@ class MatchState {
     }
 
     this.inputStream.examinedLength = Math.max(
-        this.inputStream.examinedLength,
-        memoRec.examinedLength + origPos,
+      this.inputStream.examinedLength,
+      memoRec.examinedLength + origPos
     );
 
     if (memoRec.value) {
@@ -3522,7 +3569,7 @@ class MatchState {
     let rightmostFailures;
     if (this.recordedFailures) {
       rightmostFailures = Object.keys(this.recordedFailures).map(
-          key => this.recordedFailures[key],
+        key => this.recordedFailures[key]
       );
     }
     const cst = this._bindings[0];
@@ -3530,13 +3577,13 @@ class MatchState {
       cst.grammar = this.grammar;
     }
     return new MatchResult(
-        this.matcher,
-        this.input,
-        this.startExpr,
-        cst,
-        this._bindingOffsets[0],
-        this.rightmostFailurePosition,
-        rightmostFailures,
+      this.matcher,
+      this.input,
+      this.startExpr,
+      cst,
+      this._bindingOffsets[0],
+      this.rightmostFailurePosition,
+      rightmostFailures
     );
   }
 
@@ -3849,11 +3896,11 @@ class Semantics {
     if (superSemantics) {
       if (!(grammar.equals(this.super.grammar) || grammar._inheritsFrom(this.super.grammar))) {
         throw new Error(
-            "Cannot extend a semantics for grammar '" +
+          "Cannot extend a semantics for grammar '" +
             this.super.grammar.name +
             "' for use with grammar '" +
             grammar.name +
-            "' (not a sub-grammar)",
+            "' (not a sub-grammar)"
         );
       }
       this.operations = Object.create(this.super.operations);
@@ -3862,7 +3909,7 @@ class Semantics {
 
       // Assign unique symbols for each of the attributes inherited from the super-semantics so that
       // they are memoized independently.
-      // eslint-disable-next-line guard-for-in
+
       for (const attributeName in this.attributes) {
         Object.defineProperty(this.attributeKeys, attributeName, {
           value: uniqueId(attributeName),
@@ -3891,11 +3938,11 @@ class Semantics {
   // Throws an exception if one or more of them doesn't.
   checkActionDicts() {
     let name;
-    // eslint-disable-next-line guard-for-in
+
     for (name in this.operations) {
       this.operations[name].checkActionDict(this.grammar);
     }
-    // eslint-disable-next-line guard-for-in
+
     for (name in this.attributes) {
       this.attributes[name].checkActionDict(this.grammar);
     }
@@ -3995,9 +4042,9 @@ class Semantics {
     });
 
     const entry =
-      type === 'operation' ?
-        new Operation(name, formals, realActionDict, builtInDefault) :
-        new Attribute(name, realActionDict, builtInDefault);
+      type === 'operation'
+        ? new Operation(name, formals, realActionDict, builtInDefault)
+        : new Attribute(name, realActionDict, builtInDefault);
 
     // The following check is not strictly necessary (it will happen later anyway) but it's better
     // to catch errors early.
@@ -4013,7 +4060,7 @@ class Semantics {
       // Check that the caller passed the correct number of arguments.
       if (arguments.length !== thisThing.formals.length) {
         throw new Error(
-            'Invalid number of arguments passed to ' +
+          'Invalid number of arguments passed to ' +
             name +
             ' ' +
             type +
@@ -4021,7 +4068,7 @@ class Semantics {
             thisThing.formals.length +
             ', got ' +
             arguments.length +
-            ')',
+            ')'
         );
       }
 
@@ -4042,7 +4089,7 @@ class Semantics {
 
     if (type === 'operation') {
       this.Wrapper.prototype[name] = doIt;
-      this.Wrapper.prototype[name].toString = function() {
+      this.Wrapper.prototype[name].toString = function () {
         return '[' + name + ' operation]';
       };
     } else {
@@ -4064,13 +4111,13 @@ class Semantics {
 
     if (!(this.super && name in this.super[typePlural])) {
       throw new Error(
-          'Cannot extend ' +
+        'Cannot extend ' +
           type +
           " '" +
           name +
           "': did not inherit an " +
           type +
-          ' with that name',
+          ' with that name'
       );
     }
     if (hasOwnProperty(this[typePlural], name)) {
@@ -4087,9 +4134,9 @@ class Semantics {
     });
 
     this[typePlural][name] =
-      type === 'operation' ?
-        new Operation(name, inheritedFormals, newActionDict) :
-        new Attribute(name, newActionDict);
+      type === 'operation'
+        ? new Operation(name, inheritedFormals, newActionDict)
+        : new Attribute(name, newActionDict);
 
     // The following check is not strictly necessary (it will happen later anyway) but it's better
     // to catch errors early.
@@ -4102,12 +4149,12 @@ class Semantics {
     }
     if (name in this.operations) {
       throw new Error(
-          'Cannot add ' + type + " '" + name + "': an operation with that name already exists",
+        'Cannot add ' + type + " '" + name + "': an operation with that name already exists"
       );
     }
     if (name in this.attributes) {
       throw new Error(
-          'Cannot add ' + type + " '" + name + "': an attribute with that name already exists",
+        'Cannot add ' + type + " '" + name + "': an attribute with that name already exists"
       );
     }
   }
@@ -4133,8 +4180,8 @@ function parseSignature(signature, type) {
   }
 
   const r = Semantics.prototypeGrammar.match(
-      signature,
-    type === 'operation' ? 'OperationSignature' : 'AttributeSignature',
+    signature,
+    type === 'operation' ? 'OperationSignature' : 'AttributeSignature'
   );
   if (r.failed()) {
     throw new Error(r.message);
@@ -4144,7 +4191,7 @@ function parseSignature(signature, type) {
 }
 
 function newDefaultAction(type, name, doIt) {
-  return function(...children) {
+  return function (...children) {
     const thisThing = this._semantics.operations[name] || this._semantics.attributes[name];
     const args = thisThing.formals.map(formal => this.args[formal]);
 
@@ -4168,12 +4215,12 @@ function newDefaultAction(type, name, doIt) {
 // Semantics instance. When that function is invoked with a CST node as an argument, it returns
 // a wrapper for that node which gives access to the operations and attributes provided by this
 // semantics.
-Semantics.createSemantics = function(grammar, optSuperSemantics) {
+Semantics.createSemantics = function (grammar, optSuperSemantics) {
   const s = new Semantics(
-      grammar,
-    optSuperSemantics !== undefined ?
-      optSuperSemantics :
-      Semantics.BuiltInSemantics._getSemantics(),
+    grammar,
+    optSuperSemantics !== undefined
+      ? optSuperSemantics
+      : Semantics.BuiltInSemantics._getSemantics()
   );
 
   // To enable clients to invoke a semantics like a function, return a function that acts as a proxy
@@ -4181,8 +4228,8 @@ Semantics.createSemantics = function(grammar, optSuperSemantics) {
   const proxy = function ASemantics(matchResult) {
     if (!(matchResult instanceof MatchResult)) {
       throw new TypeError(
-          'Semantics expected a MatchResult, but got ' +
-          unexpectedObjToString(matchResult),
+        'Semantics expected a MatchResult, but got ' +
+          unexpectedObjToString(matchResult)
       );
     }
     if (matchResult.failed()) {
@@ -4192,11 +4239,11 @@ Semantics.createSemantics = function(grammar, optSuperSemantics) {
     const cst = matchResult._cst;
     if (cst.grammar !== grammar) {
       throw new Error(
-          "Cannot use a MatchResult from grammar '" +
+        "Cannot use a MatchResult from grammar '" +
           cst.grammar.name +
           "' with a semantics for '" +
           grammar.name +
-          "'",
+          "'"
       );
     }
     const inputStream = new InputStream(matchResult.input);
@@ -4204,38 +4251,38 @@ Semantics.createSemantics = function(grammar, optSuperSemantics) {
   };
 
   // Forward public methods from the proxy to the semantics instance.
-  proxy.addOperation = function(signature, actionDict) {
+  proxy.addOperation = function (signature, actionDict) {
     s.addOperationOrAttribute('operation', signature, actionDict);
     return proxy;
   };
-  proxy.extendOperation = function(name, actionDict) {
+  proxy.extendOperation = function (name, actionDict) {
     s.extendOperationOrAttribute('operation', name, actionDict);
     return proxy;
   };
-  proxy.addAttribute = function(name, actionDict) {
+  proxy.addAttribute = function (name, actionDict) {
     s.addOperationOrAttribute('attribute', name, actionDict);
     return proxy;
   };
-  proxy.extendAttribute = function(name, actionDict) {
+  proxy.extendAttribute = function (name, actionDict) {
     s.extendOperationOrAttribute('attribute', name, actionDict);
     return proxy;
   };
-  proxy._getActionDict = function(operationOrAttributeName) {
+  proxy._getActionDict = function (operationOrAttributeName) {
     const action =
       s.operations[operationOrAttributeName] || s.attributes[operationOrAttributeName];
     if (!action) {
       throw new Error(
-          '"' +
+        '"' +
           operationOrAttributeName +
           '" is not a valid operation or attribute ' +
           'name in this semantics for "' +
           grammar.name +
-          '"',
+          '"'
       );
     }
     return action.actionDict;
   };
-  proxy._remove = function(operationOrAttributeName) {
+  proxy._remove = function (operationOrAttributeName) {
     let semantic;
     if (operationOrAttributeName in s.operations) {
       semantic = s.operations[operationOrAttributeName];
@@ -4247,16 +4294,16 @@ Semantics.createSemantics = function(grammar, optSuperSemantics) {
     delete s.Wrapper.prototype[operationOrAttributeName];
     return semantic;
   };
-  proxy.getOperationNames = function() {
+  proxy.getOperationNames = function () {
     return Object.keys(s.operations);
   };
-  proxy.getAttributeNames = function() {
+  proxy.getAttributeNames = function () {
     return Object.keys(s.attributes);
   };
-  proxy.getGrammar = function() {
+  proxy.getGrammar = function () {
     return s.grammar;
   };
-  proxy.toRecipe = function(semanticsOnly) {
+  proxy.toRecipe = function (semanticsOnly) {
     return s.toRecipe(semanticsOnly);
   };
 
@@ -4264,7 +4311,7 @@ Semantics.createSemantics = function(grammar, optSuperSemantics) {
   proxy.toString = s.toString.bind(s);
 
   // Returns the semantics for the proxy.
-  proxy._getSemantics = function() {
+  proxy._getSemantics = function () {
     return s;
   };
 
@@ -4356,8 +4403,8 @@ const SPECIAL_ACTION_NAMES = ['_iter', '_terminal', '_nonterminal', '_default'];
 
 function getSortedRuleValues(grammar) {
   return Object.keys(grammar.rules)
-      .sort()
-      .map(name => grammar.rules[name]);
+    .sort()
+    .map(name => grammar.rules[name]);
 }
 
 // Until ES2019, JSON was not a valid subset of JavaScript because U+2028 (line separator)
@@ -4378,11 +4425,11 @@ class Grammar {
     if (optDefaultStartRule) {
       if (!(optDefaultStartRule in rules)) {
         throw new Error(
-            "Invalid start rule: '" +
+          "Invalid start rule: '" +
             optDefaultStartRule +
             "' is not a rule in grammar '" +
             name +
-            "'",
+            "'"
         );
       }
       this.defaultStartRule = optDefaultStartRule;
@@ -4453,7 +4500,6 @@ class Grammar {
   _checkTopDownActionDict(what, name, actionDict) {
     const problems = [];
 
-    // eslint-disable-next-line guard-for-in
     for (const k in actionDict) {
       const v = actionDict[k];
       const isSpecialAction = SPECIAL_ACTION_NAMES.includes(k);
@@ -4483,10 +4529,10 @@ class Grammar {
     if (problems.length > 0) {
       const prettyProblems = problems.map(problem => '- ' + problem);
       const error = new Error(
-          [
-            `Found errors in the action dictionary of the '${name}' ${what}:`,
-            ...prettyProblems,
-          ].join('\n'),
+        [
+          `Found errors in the action dictionary of the '${name}' ${what}:`,
+          ...prettyProblems,
+        ].join('\n')
       );
       error.problems = problems;
       throw error;
@@ -4499,9 +4545,9 @@ class Grammar {
     // All special actions have an expected arity of 0, though all but _terminal
     // are expected to use the rest parameter syntax (e.g. `_iter(...children)`).
     // This is considered to have arity 0, i.e. `((...args) => {}).length` is 0.
-    return SPECIAL_ACTION_NAMES.includes(actionName) ?
-      0 :
-      this.rules[actionName].body.getArity();
+    return SPECIAL_ACTION_NAMES.includes(actionName)
+      ? 0
+      : this.rules[actionName].body.getArity();
   }
 
   _inheritsFrom(grammar) {
@@ -4592,7 +4638,7 @@ class Grammar {
     sb.append('{');
 
     let first = true;
-    // eslint-disable-next-line guard-for-in
+
     for (const ruleName in this.rules) {
       const {body} = this.rules[ruleName];
       if (first) {
@@ -4639,10 +4685,10 @@ class Grammar {
     if (formals.length !== app.args.length) {
       const {source} = this.rules[app.ruleName];
       throw wrongNumberOfParameters(
-          app.ruleName,
-          formals.length,
-          app.args.length,
-          source,
+        app.ruleName,
+        formals.length,
+        app.args.length,
+        source
       );
     }
     return app;
@@ -4661,63 +4707,63 @@ class Grammar {
 // `digit`, and is implicitly the super-grammar of any grammar whose super-grammar
 // isn't specified.
 Grammar.ProtoBuiltInRules = new Grammar(
-    'ProtoBuiltInRules', // name
-    undefined, // supergrammar
-    {
-      any: {
-        body: any,
-        formals: [],
-        description: 'any character',
-        primitive: true,
-      },
-      end: {
-        body: end,
-        formals: [],
-        description: 'end of input',
-        primitive: true,
-      },
-
-      caseInsensitive: {
-        body: new CaseInsensitiveTerminal(new Param(0)),
-        formals: ['str'],
-        primitive: true,
-      },
-      lower: {
-        body: new UnicodeChar('Ll'),
-        formals: [],
-        description: 'a lowercase letter',
-        primitive: true,
-      },
-      upper: {
-        body: new 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 UnicodeChar('Ltmo'),
-        formals: [],
-        description: 'a Unicode character in Lt, Lm, or Lo',
-        primitive: true,
-      },
-
-      // These rules are not truly primitive (they could be written in userland) but are defined
-      // here for bootstrapping purposes.
-      spaces: {
-        body: new Star(new Apply('space')),
-        formals: [],
-      },
-      space: {
-        body: new Range('\x00', ' '),
-        formals: [],
-        description: 'a space',
-      },
+  'ProtoBuiltInRules', // name
+  undefined, // supergrammar
+  {
+    any: {
+      body: any,
+      formals: [],
+      description: 'any character',
+      primitive: true,
     },
+    end: {
+      body: end,
+      formals: [],
+      description: 'end of input',
+      primitive: true,
+    },
+
+    caseInsensitive: {
+      body: new CaseInsensitiveTerminal(new Param(0)),
+      formals: ['str'],
+      primitive: true,
+    },
+    lower: {
+      body: new UnicodeChar('Ll'),
+      formals: [],
+      description: 'a lowercase letter',
+      primitive: true,
+    },
+    upper: {
+      body: new 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 UnicodeChar('Ltmo'),
+      formals: [],
+      description: 'a Unicode character in Lt, Lm, or Lo',
+      primitive: true,
+    },
+
+    // These rules are not truly primitive (they could be written in userland) but are defined
+    // here for bootstrapping purposes.
+    spaces: {
+      body: new Star(new Apply('space')),
+      formals: [],
+    },
+    space: {
+      body: new Range('\x00', ' '),
+      formals: [],
+      description: 'a space',
+    },
+  }
 );
 
 // This method is called from main.js once Ohm has loaded.
-Grammar.initApplicationParser = function(grammar, builderFn) {
+Grammar.initApplicationParser = function (grammar, builderFn) {
   ohmGrammar$1 = grammar;
   buildGrammar$1 = builderFn;
 };
@@ -4745,7 +4791,7 @@ class GrammarDecl {
         // 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.ProtoBuiltInRules : Grammar.BuiltInRules,
+        this.name === 'BuiltInRules' ? Grammar.ProtoBuiltInRules : Grammar.BuiltInRules
       );
     }
     return this.superGrammar;
@@ -4813,10 +4859,10 @@ class GrammarDecl {
   // Creates a Grammar instance, and if it passes the sanity checks, returns it.
   build() {
     const grammar = new Grammar(
-        this.name,
-        this.ensureSuperGrammar(),
-        this.rules,
-        this.defaultStartRule,
+      this.name,
+      this.ensureSuperGrammar(),
+      this.rules,
+      this.defaultStartRule
     );
     // Initialize internal props that are inherited from the super grammar.
     grammar._matchStateInitializer = grammar.superGrammar._matchStateInitializer;
@@ -4917,7 +4963,7 @@ class Builder {
     if (superGrammar) {
       // `superGrammar` may be a recipe (i.e. an Array), or an actual grammar instance.
       gDecl.withSuperGrammar(
-        superGrammar instanceof Grammar ? superGrammar : this.fromRecipe(superGrammar),
+        superGrammar instanceof Grammar ? superGrammar : this.fromRecipe(superGrammar)
       );
     }
     if (defaultStartRule) {
@@ -4941,8 +4987,8 @@ class Builder {
       let source;
       if (gDecl.source && metaInfo && metaInfo.sourceInterval) {
         source = gDecl.source.subInterval(
-            metaInfo.sourceInterval[0],
-            metaInfo.sourceInterval[1] - metaInfo.sourceInterval[0],
+          metaInfo.sourceInterval[0],
+          metaInfo.sourceInterval[1] - metaInfo.sourceInterval[0]
         );
       }
       gDecl[action](ruleName, formals, body, description, source);
@@ -5037,7 +5083,7 @@ class Builder {
 
   app(ruleName, optParams) {
     if (optParams && optParams.length > 0) {
-      optParams = optParams.map(function(param) {
+      optParams = optParams.map(function (param) {
         return param instanceof PExpr ? param : this.fromRecipe(param);
       }, this);
     }
@@ -5049,10 +5095,10 @@ class Builder {
   // `this.currentDecl` and `this.currentRuleName` being set.
   splice(beforeTerms, afterTerms) {
     return new Splice(
-        this.currentDecl.superGrammar,
-        this.currentRuleName,
-        beforeTerms.map(term => this.fromRecipe(term)),
-        afterTerms.map(term => this.fromRecipe(term)),
+      this.currentDecl.superGrammar,
+      this.currentRuleName,
+      beforeTerms.map(term => this.fromRecipe(term)),
+      afterTerms.map(term => this.fromRecipe(term))
     );
   }
 
@@ -5193,10 +5239,10 @@ function buildGrammar(match, namespace, optOhmGrammarForTesting) {
         });
 
         return new Splice(
-            decl.superGrammar,
-            currentRuleName,
-            beforeTerms,
-            afterTerms,
+          decl.superGrammar,
+          currentRuleName,
+          beforeTerms,
+          afterTerms
         ).withSource(this.source);
       } else {
         return builder.alt(...args).withSource(this.source);
@@ -5341,14 +5387,14 @@ function initBuiltInSemantics(builtInRules) {
   };
 
   Semantics.BuiltInSemantics = Semantics.createSemantics(builtInRules, null).addOperation(
-      'asIteration',
-      {
-        emptyListOf: actions.empty,
-        nonemptyListOf: actions.nonEmpty,
-        EmptyListOf: actions.empty,
-        NonemptyListOf: actions.nonEmpty,
-        _iter: actions.self,
-      },
+    'asIteration',
+    {
+      emptyListOf: actions.empty,
+      nonemptyListOf: actions.nonEmpty,
+      EmptyListOf: actions.empty,
+      NonemptyListOf: actions.nonEmpty,
+      _iter: actions.self,
+    }
   );
 }
 
@@ -5537,12 +5583,12 @@ const applyDedent = new Apply('dedent');
 const newAnyBody = new Splice(BuiltInRules, 'any', [applyIndent, applyDedent], []);
 
 const IndentationSensitive = new Builder()
-    .newGrammar('IndentationSensitive')
-    .withSuperGrammar(BuiltInRules)
-    .define('indent', [], new Indentation(true), INDENT_DESCRIPTION, undefined, true)
-    .define('dedent', [], new Indentation(false), DEDENT_DESCRIPTION, undefined, true)
-    .extend('any', [], newAnyBody, 'any character', undefined)
-    .build();
+  .newGrammar('IndentationSensitive')
+  .withSuperGrammar(BuiltInRules)
+  .define('indent', [], new Indentation(true), INDENT_DESCRIPTION, undefined, true)
+  .define('dedent', [], new Indentation(false), DEDENT_DESCRIPTION, undefined, true)
+  .extend('any', [], newAnyBody, 'any character', undefined)
+  .build();
 
 Object.assign(IndentationSensitive, {
   _matchStateInitializer(state) {
@@ -5553,7 +5599,7 @@ Object.assign(IndentationSensitive, {
 });
 
 // Generated by scripts/prebuild.js
-const version = '17.2.1';
+const version = '17.3.0';
 
 Grammar.initApplicationParser(ohmGrammar, buildGrammar);
 
@@ -5581,8 +5627,8 @@ function grammar(source, optNamespace) {
     const secondGrammar = ns[grammarNames[1]];
     const interval = secondGrammar.source;
     throw new Error(
-        getLineAndColumnMessage(interval.sourceString, interval.startIdx) +
-        'Found more than one grammar definition -- use ohm.grammars() instead.',
+      getLineAndColumnMessage(interval.sourceString, interval.startIdx) +
+        'Found more than one grammar definition -- use ohm.grammars() instead.'
     );
   }
   return ns[grammarNames[0]]; // Return the one and only grammar.
@@ -5596,7 +5642,7 @@ function grammars(source, optNamespace) {
       source = source.toString();
     } else {
       throw new TypeError(
-          'Expected string as first argument, got ' + unexpectedObjToString(source),
+        'Expected string as first argument, got ' + unexpectedObjToString(source)
       );
     }
   }