ohm-js 17.2.1 → 17.3.0

package/src/pexprs-substituteParams.js

@@ -19,19 +19,19 @@ pexprs.any.substituteParams =
   pexprs.Terminal.prototype.substituteParams =
   pexprs.Range.prototype.substituteParams =
   pexprs.UnicodeChar.prototype.substituteParams =
-    function(actuals) {
+    function (actuals) {
       return this;
     };
 
-pexprs.Param.prototype.substituteParams = function(actuals) {
+pexprs.Param.prototype.substituteParams = function (actuals) {
   return checkNotNull(actuals[this.index]);
 };
 
-pexprs.Alt.prototype.substituteParams = function(actuals) {
+pexprs.Alt.prototype.substituteParams = function (actuals) {
   return new pexprs.Alt(this.terms.map(term => term.substituteParams(actuals)));
 };
 
-pexprs.Seq.prototype.substituteParams = function(actuals) {
+pexprs.Seq.prototype.substituteParams = function (actuals) {
   return new pexprs.Seq(this.factors.map(factor => factor.substituteParams(actuals)));
 };
 
@@ -39,11 +39,11 @@ pexprs.Iter.prototype.substituteParams =
   pexprs.Not.prototype.substituteParams =
   pexprs.Lookahead.prototype.substituteParams =
   pexprs.Lex.prototype.substituteParams =
-    function(actuals) {
+    function (actuals) {
       return new this.constructor(this.expr.substituteParams(actuals));
     };
 
-pexprs.Apply.prototype.substituteParams = function(actuals) {
+pexprs.Apply.prototype.substituteParams = function (actuals) {
   if (this.args.length === 0) {
     // Avoid making a copy of this application, as an optimization
     return this;

package/src/pexprs-toArgumentNameList.js

@@ -65,15 +65,15 @@ function resolveDuplicatedNames(argumentNameList) {
 // function(firstArgIndex, noDupCheck) { ... }
 pexprs.PExpr.prototype.toArgumentNameList = abstract('toArgumentNameList');
 
-pexprs.any.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs.any.toArgumentNameList = function (firstArgIndex, noDupCheck) {
   return ['any'];
 };
 
-pexprs.end.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs.end.toArgumentNameList = function (firstArgIndex, noDupCheck) {
   return ['end'];
 };
 
-pexprs.Terminal.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs.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];
@@ -83,7 +83,7 @@ pexprs.Terminal.prototype.toArgumentNameList = function(firstArgIndex, noDupChec
   }
 };
 
-pexprs.Range.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs.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)) {
@@ -96,11 +96,11 @@ pexprs.Range.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck)
   return [argName];
 };
 
-pexprs.Alt.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs.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 = [];
@@ -120,7 +120,7 @@ pexprs.Alt.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   return argumentNameList;
 };
 
-pexprs.Seq.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs.Seq.prototype.toArgumentNameList = function (firstArgIndex, noDupCheck) {
   // Generate the argument name list, without worrying about duplicates.
   let argumentNameList = [];
   this.factors.forEach(factor => {
@@ -136,44 +136,44 @@ pexprs.Seq.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
   return argumentNameList;
 };
 
-pexprs.Iter.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs.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;
 };
 
-pexprs.Opt.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs.Opt.prototype.toArgumentNameList = function (firstArgIndex, noDupCheck) {
   return this.expr.toArgumentNameList(firstArgIndex, noDupCheck).map(argName => {
     return 'opt' + argName[0].toUpperCase() + argName.slice(1);
   });
 };
 
-pexprs.Not.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs.Not.prototype.toArgumentNameList = function (firstArgIndex, noDupCheck) {
   return [];
 };
 
 pexprs.Lookahead.prototype.toArgumentNameList = pexprs.Lex.prototype.toArgumentNameList =
-  function(firstArgIndex, noDupCheck) {
+  function (firstArgIndex, noDupCheck) {
     return this.expr.toArgumentNameList(firstArgIndex, noDupCheck);
   };
 
-pexprs.Apply.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs.Apply.prototype.toArgumentNameList = function (firstArgIndex, noDupCheck) {
   return [this.ruleName];
 };
 
-pexprs.UnicodeChar.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs.UnicodeChar.prototype.toArgumentNameList = function (firstArgIndex, noDupCheck) {
   return ['$' + firstArgIndex];
 };
 
-pexprs.Param.prototype.toArgumentNameList = function(firstArgIndex, noDupCheck) {
+pexprs.Param.prototype.toArgumentNameList = function (firstArgIndex, noDupCheck) {
   return ['param' + this.index];
 };
 

package/src/pexprs-toDisplayString.js

@@ -8,7 +8,7 @@ import * as pexprs from './pexprs-main.js';
 // Returns a string representing the PExpr, for use as a UI label, etc.
 pexprs.PExpr.prototype.toDisplayString = abstract('toDisplayString');
 
-pexprs.Alt.prototype.toDisplayString = pexprs.Seq.prototype.toDisplayString = function() {
+pexprs.Alt.prototype.toDisplayString = pexprs.Seq.prototype.toDisplayString = function () {
   if (this.source) {
     return this.source.trimmed().contents;
   }
@@ -24,11 +24,11 @@ pexprs.any.toDisplayString =
   pexprs.Terminal.prototype.toDisplayString =
   pexprs.Range.prototype.toDisplayString =
   pexprs.Param.prototype.toDisplayString =
-    function() {
+    function () {
       return this.toString();
     };
 
-pexprs.Apply.prototype.toDisplayString = function() {
+pexprs.Apply.prototype.toDisplayString = function () {
   if (this.args.length > 0) {
     const ps = this.args.map(arg => arg.toDisplayString());
     return this.ruleName + '<' + ps.join(',') + '>';
@@ -37,6 +37,6 @@ pexprs.Apply.prototype.toDisplayString = function() {
   }
 };
 
-pexprs.UnicodeChar.prototype.toDisplayString = function() {
-  return 'Unicode [' + this.category + '] character';
+pexprs.UnicodeChar.prototype.toDisplayString = function () {
+  return 'Unicode [' + this.categoryOrProp + '] character';
 };

package/src/pexprs-toFailure.js

@@ -8,34 +8,34 @@ import {Failure} from './Failure.js';
 
 pexprs.PExpr.prototype.toFailure = abstract('toFailure');
 
-pexprs.any.toFailure = function(grammar) {
+pexprs.any.toFailure = function (grammar) {
   return new Failure(this, 'any object', 'description');
 };
 
-pexprs.end.toFailure = function(grammar) {
+pexprs.end.toFailure = function (grammar) {
   return new Failure(this, 'end of input', 'description');
 };
 
-pexprs.Terminal.prototype.toFailure = function(grammar) {
+pexprs.Terminal.prototype.toFailure = function (grammar) {
   return new Failure(this, this.obj, 'string');
 };
 
-pexprs.Range.prototype.toFailure = function(grammar) {
+pexprs.Range.prototype.toFailure = function (grammar) {
   // TODO: come up with something better
   return new Failure(this, JSON.stringify(this.from) + '..' + JSON.stringify(this.to), 'code');
 };
 
-pexprs.Not.prototype.toFailure = function(grammar) {
+pexprs.Not.prototype.toFailure = function (grammar) {
   const description =
     this.expr === pexprs.any ? 'nothing' : 'not ' + this.expr.toFailure(grammar);
   return new Failure(this, description, 'description');
 };
 
-pexprs.Lookahead.prototype.toFailure = function(grammar) {
+pexprs.Lookahead.prototype.toFailure = function (grammar) {
   return this.expr.toFailure(grammar);
 };
 
-pexprs.Apply.prototype.toFailure = function(grammar) {
+pexprs.Apply.prototype.toFailure = function (grammar) {
   let {description} = grammar.rules[this.ruleName];
   if (!description) {
     const article = /^[aeiouAEIOU]/.test(this.ruleName) ? 'an' : 'a';
@@ -44,23 +44,23 @@ pexprs.Apply.prototype.toFailure = function(grammar) {
   return new Failure(this, description, 'description');
 };
 
-pexprs.UnicodeChar.prototype.toFailure = function(grammar) {
-  return new Failure(this, 'a Unicode [' + this.category + '] character', 'description');
+pexprs.UnicodeChar.prototype.toFailure = function (grammar) {
+  return new Failure(this, 'a Unicode [' + this.categoryOrProp + '] character', 'description');
 };
 
-pexprs.Alt.prototype.toFailure = function(grammar) {
+pexprs.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');
 };
 
-pexprs.Seq.prototype.toFailure = function(grammar) {
+pexprs.Seq.prototype.toFailure = function (grammar) {
   const fs = this.factors.map(f => f.toFailure(grammar));
   const description = '(' + fs.join(' ') + ')';
   return new Failure(this, description, 'description');
 };
 
-pexprs.Iter.prototype.toFailure = function(grammar) {
+pexprs.Iter.prototype.toFailure = function (grammar) {
   const description = '(' + this.expr.toFailure(grammar) + this.operator + ')';
   return new Failure(this, description, 'description');
 };

package/src/pexprs-toString.js

@@ -14,55 +14,55 @@ import * as pexprs from './pexprs-main.js';
 */
 pexprs.PExpr.prototype.toString = abstract('toString');
 
-pexprs.any.toString = function() {
+pexprs.any.toString = function () {
   return 'any';
 };
 
-pexprs.end.toString = function() {
+pexprs.end.toString = function () {
   return 'end';
 };
 
-pexprs.Terminal.prototype.toString = function() {
+pexprs.Terminal.prototype.toString = function () {
   return JSON.stringify(this.obj);
 };
 
-pexprs.Range.prototype.toString = function() {
+pexprs.Range.prototype.toString = function () {
   return JSON.stringify(this.from) + '..' + JSON.stringify(this.to);
 };
 
-pexprs.Param.prototype.toString = function() {
+pexprs.Param.prototype.toString = function () {
   return '$' + this.index;
 };
 
-pexprs.Lex.prototype.toString = function() {
+pexprs.Lex.prototype.toString = function () {
   return '#(' + this.expr.toString() + ')';
 };
 
-pexprs.Alt.prototype.toString = function() {
-  return this.terms.length === 1 ?
-    this.terms[0].toString() :
-    '(' + this.terms.map(term => term.toString()).join(' | ') + ')';
+pexprs.Alt.prototype.toString = function () {
+  return this.terms.length === 1
+    ? this.terms[0].toString()
+    : '(' + this.terms.map(term => term.toString()).join(' | ') + ')';
 };
 
-pexprs.Seq.prototype.toString = function() {
-  return this.factors.length === 1 ?
-    this.factors[0].toString() :
-    '(' + this.factors.map(factor => factor.toString()).join(' ') + ')';
+pexprs.Seq.prototype.toString = function () {
+  return this.factors.length === 1
+    ? this.factors[0].toString()
+    : '(' + this.factors.map(factor => factor.toString()).join(' ') + ')';
 };
 
-pexprs.Iter.prototype.toString = function() {
+pexprs.Iter.prototype.toString = function () {
   return this.expr + this.operator;
 };
 
-pexprs.Not.prototype.toString = function() {
+pexprs.Not.prototype.toString = function () {
   return '~' + this.expr;
 };
 
-pexprs.Lookahead.prototype.toString = function() {
+pexprs.Lookahead.prototype.toString = function () {
   return '&' + this.expr;
 };
 
-pexprs.Apply.prototype.toString = function() {
+pexprs.Apply.prototype.toString = function () {
   if (this.args.length > 0) {
     const ps = this.args.map(arg => arg.toString());
     return this.ruleName + '<' + ps.join(',') + '>';
@@ -71,6 +71,6 @@ pexprs.Apply.prototype.toString = function() {
   }
 };
 
-pexprs.UnicodeChar.prototype.toString = function() {
-  return '\\p{' + this.category + '}';
+pexprs.UnicodeChar.prototype.toString = function () {
+  return '\\p{' + this.categoryOrProp + '}';
 };

package/src/semanticsDeferredInit.js

@@ -19,14 +19,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,
+    }
   );
 }
 

package/src/unicode.js

@@ -0,0 +1,54 @@
+// 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}'
+ */
+
+export 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
+export const UnicodeBinaryProperties = Object.fromEntries(
+  ['XID_Start', 'XID_Continue', 'White_Space'].map(prop => [prop, toRegExp(prop)])
+);

package/src/util.js

@@ -134,9 +134,9 @@ export 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$/, '');
   }

package/src/version.js

@@ -1,2 +1,2 @@
 // Generated by scripts/prebuild.js
-export const version = '17.2.1';
+export const version = '17.3.0';

package/src/UnicodeCategories.js

@@ -1,30 +0,0 @@
-// 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.
-export 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,
-};