ohm-js 17.2.1 → 17.3.0

package/src/pexprs-allowsSkippingPrecedingSpace.js

@@ -20,7 +20,7 @@ pexprs.any.allowsSkippingPrecedingSpace =
   pexprs.Terminal.prototype.allowsSkippingPrecedingSpace =
   pexprs.Range.prototype.allowsSkippingPrecedingSpace =
   pexprs.UnicodeChar.prototype.allowsSkippingPrecedingSpace =
-    function() {
+    function () {
       return true;
     };
 
@@ -34,6 +34,6 @@ pexprs.Alt.prototype.allowsSkippingPrecedingSpace =
   pexprs.Not.prototype.allowsSkippingPrecedingSpace =
   pexprs.Param.prototype.allowsSkippingPrecedingSpace =
   pexprs.Seq.prototype.allowsSkippingPrecedingSpace =
-    function() {
+    function () {
       return false;
     };

package/src/pexprs-assertAllApplicationsAreValid.js

@@ -15,13 +15,13 @@ util.awaitBuiltInRules(g => {
 
 let lexifyCount;
 
-pexprs.PExpr.prototype.assertAllApplicationsAreValid = function(ruleName, grammar) {
+pexprs.PExpr.prototype.assertAllApplicationsAreValid = function (ruleName, grammar) {
   lexifyCount = 0;
   this._assertAllApplicationsAreValid(ruleName, grammar);
 };
 
 pexprs.PExpr.prototype._assertAllApplicationsAreValid = abstract(
-    '_assertAllApplicationsAreValid',
+  '_assertAllApplicationsAreValid'
 );
 
 pexprs.any._assertAllApplicationsAreValid =
@@ -30,23 +30,23 @@ pexprs.any._assertAllApplicationsAreValid =
   pexprs.Range.prototype._assertAllApplicationsAreValid =
   pexprs.Param.prototype._assertAllApplicationsAreValid =
   pexprs.UnicodeChar.prototype._assertAllApplicationsAreValid =
-    function(ruleName, grammar) {
+    function (ruleName, grammar) {
       // no-op
     };
 
-pexprs.Lex.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) {
+pexprs.Lex.prototype._assertAllApplicationsAreValid = function (ruleName, grammar) {
   lexifyCount++;
   this.expr._assertAllApplicationsAreValid(ruleName, grammar);
   lexifyCount--;
 };
 
-pexprs.Alt.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) {
+pexprs.Alt.prototype._assertAllApplicationsAreValid = function (ruleName, grammar) {
   for (let idx = 0; idx < this.terms.length; idx++) {
     this.terms[idx]._assertAllApplicationsAreValid(ruleName, grammar);
   }
 };
 
-pexprs.Seq.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) {
+pexprs.Seq.prototype._assertAllApplicationsAreValid = function (ruleName, grammar) {
   for (let idx = 0; idx < this.factors.length; idx++) {
     this.factors[idx]._assertAllApplicationsAreValid(ruleName, grammar);
   }
@@ -55,14 +55,14 @@ pexprs.Seq.prototype._assertAllApplicationsAreValid = function(ruleName, grammar
 pexprs.Iter.prototype._assertAllApplicationsAreValid =
   pexprs.Not.prototype._assertAllApplicationsAreValid =
   pexprs.Lookahead.prototype._assertAllApplicationsAreValid =
-    function(ruleName, grammar) {
+    function (ruleName, grammar) {
       this.expr._assertAllApplicationsAreValid(ruleName, grammar);
     };
 
-pexprs.Apply.prototype._assertAllApplicationsAreValid = function(
-    ruleName,
-    grammar,
-    skipSyntacticCheck = false,
+pexprs.Apply.prototype._assertAllApplicationsAreValid = function (
+  ruleName,
+  grammar,
+  skipSyntacticCheck = false
 ) {
   const ruleInfo = grammar.rules[this.ruleName];
   const isContextSyntactic = isSyntactic(ruleName) && lexifyCount === 0;

package/src/pexprs-assertChoicesHaveUniformArity.js

@@ -7,7 +7,7 @@ import * as pexprs from './pexprs-main.js';
 // --------------------------------------------------------------------
 
 pexprs.PExpr.prototype.assertChoicesHaveUniformArity = abstract(
-    'assertChoicesHaveUniformArity',
+  'assertChoicesHaveUniformArity'
 );
 
 pexprs.any.assertChoicesHaveUniformArity =
@@ -17,11 +17,11 @@ pexprs.any.assertChoicesHaveUniformArity =
   pexprs.Param.prototype.assertChoicesHaveUniformArity =
   pexprs.Lex.prototype.assertChoicesHaveUniformArity =
   pexprs.UnicodeChar.prototype.assertChoicesHaveUniformArity =
-    function(ruleName) {
+    function (ruleName) {
       // no-op
     };
 
-pexprs.Alt.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+pexprs.Alt.prototype.assertChoicesHaveUniformArity = function (ruleName) {
   if (this.terms.length === 0) {
     return;
   }
@@ -36,7 +36,7 @@ pexprs.Alt.prototype.assertChoicesHaveUniformArity = function(ruleName) {
   }
 };
 
-pexprs.Extend.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+pexprs.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();
@@ -46,25 +46,25 @@ pexprs.Extend.prototype.assertChoicesHaveUniformArity = function(ruleName) {
   }
 };
 
-pexprs.Seq.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+pexprs.Seq.prototype.assertChoicesHaveUniformArity = function (ruleName) {
   for (let idx = 0; idx < this.factors.length; idx++) {
     this.factors[idx].assertChoicesHaveUniformArity(ruleName);
   }
 };
 
-pexprs.Iter.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+pexprs.Iter.prototype.assertChoicesHaveUniformArity = function (ruleName) {
   this.expr.assertChoicesHaveUniformArity(ruleName);
 };
 
-pexprs.Not.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+pexprs.Not.prototype.assertChoicesHaveUniformArity = function (ruleName) {
   // no-op (not required b/c the nested expr doesn't show up in the CST)
 };
 
-pexprs.Lookahead.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+pexprs.Lookahead.prototype.assertChoicesHaveUniformArity = function (ruleName) {
   this.expr.assertChoicesHaveUniformArity(ruleName);
 };
 
-pexprs.Apply.prototype.assertChoicesHaveUniformArity = function(ruleName) {
+pexprs.Apply.prototype.assertChoicesHaveUniformArity = function (ruleName) {
   // The arities of the parameter expressions is required to be 1 by
   // `assertAllApplicationsAreValid()`.
 };

package/src/pexprs-assertIteratedExprsAreNotNullable.js

@@ -7,7 +7,7 @@ import * as pexprs from './pexprs-main.js';
 // --------------------------------------------------------------------
 
 pexprs.PExpr.prototype.assertIteratedExprsAreNotNullable = abstract(
-    'assertIteratedExprsAreNotNullable',
+  'assertIteratedExprsAreNotNullable'
 );
 
 pexprs.any.assertIteratedExprsAreNotNullable =
@@ -16,23 +16,23 @@ pexprs.any.assertIteratedExprsAreNotNullable =
   pexprs.Range.prototype.assertIteratedExprsAreNotNullable =
   pexprs.Param.prototype.assertIteratedExprsAreNotNullable =
   pexprs.UnicodeChar.prototype.assertIteratedExprsAreNotNullable =
-    function(grammar) {
+    function (grammar) {
       // no-op
     };
 
-pexprs.Alt.prototype.assertIteratedExprsAreNotNullable = function(grammar) {
+pexprs.Alt.prototype.assertIteratedExprsAreNotNullable = function (grammar) {
   for (let idx = 0; idx < this.terms.length; idx++) {
     this.terms[idx].assertIteratedExprsAreNotNullable(grammar);
   }
 };
 
-pexprs.Seq.prototype.assertIteratedExprsAreNotNullable = function(grammar) {
+pexprs.Seq.prototype.assertIteratedExprsAreNotNullable = function (grammar) {
   for (let idx = 0; idx < this.factors.length; idx++) {
     this.factors[idx].assertIteratedExprsAreNotNullable(grammar);
   }
 };
 
-pexprs.Iter.prototype.assertIteratedExprsAreNotNullable = function(grammar) {
+pexprs.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);
@@ -45,11 +45,11 @@ pexprs.Opt.prototype.assertIteratedExprsAreNotNullable =
   pexprs.Not.prototype.assertIteratedExprsAreNotNullable =
   pexprs.Lookahead.prototype.assertIteratedExprsAreNotNullable =
   pexprs.Lex.prototype.assertIteratedExprsAreNotNullable =
-    function(grammar) {
+    function (grammar) {
       this.expr.assertIteratedExprsAreNotNullable(grammar);
     };
 
-pexprs.Apply.prototype.assertIteratedExprsAreNotNullable = function(grammar) {
+pexprs.Apply.prototype.assertIteratedExprsAreNotNullable = function (grammar) {
   this.args.forEach(arg => {
     arg.assertIteratedExprsAreNotNullable(grammar);
   });

package/src/pexprs-eval.js

@@ -3,6 +3,7 @@ import * as common from './common.js';
 import * as errors from './errors.js';
 import {IterationNode, NonterminalNode, TerminalNode} from './nodes.js';
 import * as pexprs from './pexprs-main.js';
+import {MAX_CODE_POINT} from './InputStream.js';
 
 // --------------------------------------------------------------------
 // Operations
@@ -26,7 +27,7 @@ import * as pexprs from './pexprs-main.js';
 */
 pexprs.PExpr.prototype.eval = common.abstract('eval'); // function(state) { ... }
 
-pexprs.any.eval = function(state) {
+pexprs.any.eval = function (state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   const cp = inputStream.nextCodePoint();
@@ -39,7 +40,7 @@ pexprs.any.eval = function(state) {
   }
 };
 
-pexprs.end.eval = function(state) {
+pexprs.end.eval = function (state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   if (inputStream.atEnd()) {
@@ -51,7 +52,7 @@ pexprs.end.eval = function(state) {
   }
 };
 
-pexprs.Terminal.prototype.eval = function(state) {
+pexprs.Terminal.prototype.eval = function (state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   if (!inputStream.matchString(this.obj)) {
@@ -63,7 +64,7 @@ pexprs.Terminal.prototype.eval = function(state) {
   }
 };
 
-pexprs.Range.prototype.eval = function(state) {
+pexprs.Range.prototype.eval = function (state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
 
@@ -82,18 +83,18 @@ pexprs.Range.prototype.eval = function(state) {
   }
 };
 
-pexprs.Param.prototype.eval = function(state) {
+pexprs.Param.prototype.eval = function (state) {
   return state.eval(state.currentApplication().args[this.index]);
 };
 
-pexprs.Lex.prototype.eval = function(state) {
+pexprs.Lex.prototype.eval = function (state) {
   state.enterLexifiedContext();
   const ans = state.eval(this.expr);
   state.exitLexifiedContext();
   return ans;
 };
 
-pexprs.Alt.prototype.eval = function(state) {
+pexprs.Alt.prototype.eval = function (state) {
   for (let idx = 0; idx < this.terms.length; idx++) {
     if (state.eval(this.terms[idx])) {
       return true;
@@ -102,7 +103,7 @@ pexprs.Alt.prototype.eval = function(state) {
   return false;
 };
 
-pexprs.Seq.prototype.eval = function(state) {
+pexprs.Seq.prototype.eval = function (state) {
   for (let idx = 0; idx < this.factors.length; idx++) {
     const factor = this.factors[idx];
     if (!state.eval(factor)) {
@@ -112,7 +113,7 @@ pexprs.Seq.prototype.eval = function(state) {
   return true;
 };
 
-pexprs.Iter.prototype.eval = function(state) {
+pexprs.Iter.prototype.eval = function (state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   const arity = this.getArity();
@@ -134,8 +135,8 @@ pexprs.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]);
@@ -159,14 +160,14 @@ pexprs.Iter.prototype.eval = function(state) {
   const isOptional = this instanceof pexprs.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;
 };
 
-pexprs.Not.prototype.eval = function(state) {
+pexprs.Not.prototype.eval = function (state) {
   /*
     TODO:
     - Right now we're just throwing away all of the failures that happen inside a `not`, and
@@ -192,7 +193,7 @@ pexprs.Not.prototype.eval = function(state) {
   return true;
 };
 
-pexprs.Lookahead.prototype.eval = function(state) {
+pexprs.Lookahead.prototype.eval = function (state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   if (state.eval(this.expr)) {
@@ -203,7 +204,7 @@ pexprs.Lookahead.prototype.eval = function(state) {
   }
 };
 
-pexprs.Apply.prototype.eval = function(state) {
+pexprs.Apply.prototype.eval = function (state) {
   const caller = state.currentApplication();
   const actuals = caller ? caller.args : [];
   const app = this.substituteParams(actuals);
@@ -226,7 +227,7 @@ pexprs.Apply.prototype.eval = function(state) {
   return app.reallyEval(state);
 };
 
-pexprs.Apply.prototype.handleCycle = function(state) {
+pexprs.Apply.prototype.handleCycle = function (state) {
   const posInfo = state.getCurrentPosInfo();
   const {currentLeftRecursion} = posInfo;
   const memoKey = this.toMemoKey();
@@ -249,7 +250,7 @@ pexprs.Apply.prototype.handleCycle = function(state) {
   return state.useMemoizedResult(state.inputStream.pos, memoRec);
 };
 
-pexprs.Apply.prototype.reallyEval = function(state) {
+pexprs.Apply.prototype.reallyEval = function (state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
   const origPosInfo = state.getCurrentPosInfo();
@@ -319,8 +320,8 @@ pexprs.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);
@@ -328,7 +329,7 @@ pexprs.Apply.prototype.reallyEval = function(state) {
   return succeeded;
 };
 
-pexprs.Apply.prototype.evalOnce = function(expr, state) {
+pexprs.Apply.prototype.evalOnce = function (expr, state) {
   const {inputStream} = state;
   const origPos = inputStream.pos;
 
@@ -343,7 +344,7 @@ pexprs.Apply.prototype.evalOnce = function(expr, state) {
   }
 };
 
-pexprs.Apply.prototype.growSeedResult = function(body, state, origPos, lrMemoRec, newValue) {
+pexprs.Apply.prototype.growSeedResult = function (body, state, origPos, lrMemoRec, newValue) {
   if (!newValue) {
     return false;
   }
@@ -361,13 +362,13 @@ pexprs.Apply.prototype.growSeedResult = function(body, state, origPos, lrMemoRec
       // 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;
@@ -387,15 +388,17 @@ pexprs.Apply.prototype.growSeedResult = function(body, state, origPos, lrMemoRec
   return lrMemoRec.value;
 };
 
-pexprs.UnicodeChar.prototype.eval = function(state) {
+pexprs.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;
 };

package/src/pexprs-getArity.js

@@ -14,17 +14,17 @@ pexprs.any.getArity =
   pexprs.Param.prototype.getArity =
   pexprs.Apply.prototype.getArity =
   pexprs.UnicodeChar.prototype.getArity =
-    function() {
+    function () {
       return 1;
     };
 
-pexprs.Alt.prototype.getArity = function() {
+pexprs.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.Seq.prototype.getArity = function() {
+pexprs.Seq.prototype.getArity = function () {
   let arity = 0;
   for (let idx = 0; idx < this.factors.length; idx++) {
     arity += this.factors[idx].getArity();
@@ -32,14 +32,14 @@ pexprs.Seq.prototype.getArity = function() {
   return arity;
 };
 
-pexprs.Iter.prototype.getArity = function() {
+pexprs.Iter.prototype.getArity = function () {
   return this.expr.getArity();
 };
 
-pexprs.Not.prototype.getArity = function() {
+pexprs.Not.prototype.getArity = function () {
   return 0;
 };
 
-pexprs.Lookahead.prototype.getArity = pexprs.Lex.prototype.getArity = function() {
+pexprs.Lookahead.prototype.getArity = pexprs.Lex.prototype.getArity = function () {
   return this.expr.getArity();
 };

package/src/pexprs-introduceParams.js

@@ -18,18 +18,18 @@ pexprs.any.introduceParams =
   pexprs.Range.prototype.introduceParams =
   pexprs.Param.prototype.introduceParams =
   pexprs.UnicodeChar.prototype.introduceParams =
-    function(formals) {
+    function (formals) {
       return this;
     };
 
-pexprs.Alt.prototype.introduceParams = function(formals) {
+pexprs.Alt.prototype.introduceParams = function (formals) {
   this.terms.forEach((term, idx, terms) => {
     terms[idx] = term.introduceParams(formals);
   });
   return this;
 };
 
-pexprs.Seq.prototype.introduceParams = function(formals) {
+pexprs.Seq.prototype.introduceParams = function (formals) {
   this.factors.forEach((factor, idx, factors) => {
     factors[idx] = factor.introduceParams(formals);
   });
@@ -40,12 +40,12 @@ pexprs.Iter.prototype.introduceParams =
   pexprs.Not.prototype.introduceParams =
   pexprs.Lookahead.prototype.introduceParams =
   pexprs.Lex.prototype.introduceParams =
-    function(formals) {
+    function (formals) {
       this.expr = this.expr.introduceParams(formals);
       return this;
     };
 
-pexprs.Apply.prototype.introduceParams = function(formals) {
+pexprs.Apply.prototype.introduceParams = function (formals) {
   const index = formals.indexOf(this.ruleName);
   if (index >= 0) {
     if (this.args.length > 0) {

package/src/pexprs-isNullable.js

@@ -6,7 +6,7 @@ import * as pexprs from './pexprs-main.js';
 // --------------------------------------------------------------------
 
 // Returns `true` if this parsing expression may accept without consuming any input.
-pexprs.PExpr.prototype.isNullable = function(grammar) {
+pexprs.PExpr.prototype.isNullable = function (grammar) {
   return this._isNullable(grammar, Object.create(null));
 };
 
@@ -17,15 +17,15 @@ pexprs.any._isNullable =
   pexprs.Param.prototype._isNullable =
   pexprs.Plus.prototype._isNullable =
   pexprs.UnicodeChar.prototype._isNullable =
-    function(grammar, memo) {
+    function (grammar, memo) {
       return false;
     };
 
-pexprs.end._isNullable = function(grammar, memo) {
+pexprs.end._isNullable = function (grammar, memo) {
   return true;
 };
 
-pexprs.Terminal.prototype._isNullable = function(grammar, memo) {
+pexprs.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.
@@ -35,11 +35,11 @@ pexprs.Terminal.prototype._isNullable = function(grammar, memo) {
   }
 };
 
-pexprs.Alt.prototype._isNullable = function(grammar, memo) {
+pexprs.Alt.prototype._isNullable = function (grammar, memo) {
   return this.terms.length === 0 || this.terms.some(term => term._isNullable(grammar, memo));
 };
 
-pexprs.Seq.prototype._isNullable = function(grammar, memo) {
+pexprs.Seq.prototype._isNullable = function (grammar, memo) {
   return this.factors.every(factor => factor._isNullable(grammar, memo));
 };
 
@@ -47,15 +47,15 @@ pexprs.Star.prototype._isNullable =
   pexprs.Opt.prototype._isNullable =
   pexprs.Not.prototype._isNullable =
   pexprs.Lookahead.prototype._isNullable =
-    function(grammar, memo) {
+    function (grammar, memo) {
       return true;
     };
 
-pexprs.Lex.prototype._isNullable = function(grammar, memo) {
+pexprs.Lex.prototype._isNullable = function (grammar, memo) {
   return this.expr._isNullable(grammar, memo);
 };
 
-pexprs.Apply.prototype._isNullable = function(grammar, memo) {
+pexprs.Apply.prototype._isNullable = function (grammar, memo) {
   const key = this.toMemoKey();
   if (!Object.prototype.hasOwnProperty.call(memo, key)) {
     const {body} = grammar.rules[this.ruleName];

package/src/pexprs-main.js

@@ -1,4 +1,4 @@
-import {UnicodeCategories} from './UnicodeCategories.js';
+import {UnicodeBinaryProperties, UnicodeCategories} from './unicode.js';
 import * as common from './common.js';
 
 // --------------------------------------------------------------------
@@ -180,9 +180,17 @@ export class Apply extends PExpr {
 // Unicode character
 
 export 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)}`
+      );
+    }
   }
 }

package/src/pexprs-outputRecipe.js

@@ -20,38 +20,38 @@ function getMetaInfo(expr, grammarInterval) {
 
 pexprs.PExpr.prototype.outputRecipe = abstract('outputRecipe');
 
-pexprs.any.outputRecipe = function(formals, grammarInterval) {
+pexprs.any.outputRecipe = function (formals, grammarInterval) {
   return ['any', getMetaInfo(this, grammarInterval)];
 };
 
-pexprs.end.outputRecipe = function(formals, grammarInterval) {
+pexprs.end.outputRecipe = function (formals, grammarInterval) {
   return ['end', getMetaInfo(this, grammarInterval)];
 };
 
-pexprs.Terminal.prototype.outputRecipe = function(formals, grammarInterval) {
+pexprs.Terminal.prototype.outputRecipe = function (formals, grammarInterval) {
   return ['terminal', getMetaInfo(this, grammarInterval), this.obj];
 };
 
-pexprs.Range.prototype.outputRecipe = function(formals, grammarInterval) {
+pexprs.Range.prototype.outputRecipe = function (formals, grammarInterval) {
   return ['range', getMetaInfo(this, grammarInterval), this.from, this.to];
 };
 
-pexprs.Param.prototype.outputRecipe = function(formals, grammarInterval) {
+pexprs.Param.prototype.outputRecipe = function (formals, grammarInterval) {
   return ['param', getMetaInfo(this, grammarInterval), this.index];
 };
 
-pexprs.Alt.prototype.outputRecipe = function(formals, grammarInterval) {
+pexprs.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))
   );
 };
 
-pexprs.Extend.prototype.outputRecipe = function(formals, grammarInterval) {
+pexprs.Extend.prototype.outputRecipe = function (formals, grammarInterval) {
   const extension = this.terms[0]; // [extension, original]
   return extension.outputRecipe(formals, grammarInterval);
 };
 
-pexprs.Splice.prototype.outputRecipe = function(formals, grammarInterval) {
+pexprs.Splice.prototype.outputRecipe = function (formals, grammarInterval) {
   const beforeTerms = this.terms.slice(0, this.expansionPos);
   const afterTerms = this.terms.slice(this.expansionPos + 1);
   return [
@@ -62,9 +62,9 @@ pexprs.Splice.prototype.outputRecipe = function(formals, grammarInterval) {
   ];
 };
 
-pexprs.Seq.prototype.outputRecipe = function(formals, grammarInterval) {
+pexprs.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))
   );
 };
 
@@ -74,7 +74,7 @@ pexprs.Star.prototype.outputRecipe =
   pexprs.Not.prototype.outputRecipe =
   pexprs.Lookahead.prototype.outputRecipe =
   pexprs.Lex.prototype.outputRecipe =
-    function(formals, grammarInterval) {
+    function (formals, grammarInterval) {
       return [
         this.constructor.name.toLowerCase(),
         getMetaInfo(this, grammarInterval),
@@ -82,7 +82,7 @@ pexprs.Star.prototype.outputRecipe =
       ];
     };
 
-pexprs.Apply.prototype.outputRecipe = function(formals, grammarInterval) {
+pexprs.Apply.prototype.outputRecipe = function (formals, grammarInterval) {
   return [
     'app',
     getMetaInfo(this, grammarInterval),
@@ -91,6 +91,6 @@ pexprs.Apply.prototype.outputRecipe = function(formals, grammarInterval) {
   ];
 };
 
-pexprs.UnicodeChar.prototype.outputRecipe = function(formals, grammarInterval) {
-  return ['unicodeChar', getMetaInfo(this, grammarInterval), this.category];
+pexprs.UnicodeChar.prototype.outputRecipe = function (formals, grammarInterval) {
+  return ['unicodeChar', getMetaInfo(this, grammarInterval), this.categoryOrProp];
 };