yapp 2.2.184 → 3.0.4

package/src/example/view.js

@@ -3,9 +3,7 @@
 import withStyle from "easy-with-style";  ///
 
 import { Element } from "easy";
-import { BNFLexer } from "occam-lexers";
-import { BNFParser } from "occam-parsers";
-import { eliminateLeftRecursion, rewriteNodes } from "occam-grammar-utilities";
+import { rewriteNodes, parserUtilities } from "occam-grammar-utilities";
 import { RowDiv, RowsDiv, ColumnDiv, ColumnsDiv, VerticalSplitterDiv, HorizontalSplitterDiv } from "easy-layout";
 
 import Yapp from "./yapp";
@@ -19,8 +17,7 @@ import MiddleSizeableDiv from "./div/sizeable/middle";
 import ParseTreeTextarea from "./textarea/parseTree";
 import LexicalEntriesTextarea from "./textarea/lexicalEntries";
 
-const bnfLexer = BNFLexer.fromNothing(),
-      bnfParser = BNFParser.fromNothing();
+const { rulesFromBNF } = parserUtilities;
 
 class View extends Element {
   contentChangeHandler(event, element) {
@@ -29,17 +26,12 @@ class View extends Element {
 
   keyUpHandler(event, element) {
     try {
-      const lexicalEntries = this.getLexicalEntries(),
-            entries = lexicalEntries, ///
-            bnf = this.getBNF(),
-            tokens = bnfLexer.tokensFromBNF(bnf);
-
-      let rules = bnfParser.rulesFromTokens(tokens);
-
-      rules = eliminateLeftRecursion(rules);
-
       const { Plugin } = this.constructor,
             { Lexer, Parser } = Plugin,
+            lexicalEntries = this.getLexicalEntries(),
+            bnf = this.getBNF(),
+            entries = lexicalEntries, ///
+            rules = rulesFromBNF(bnf),
             lexer = Lexer.fromEntries(entries),
             parser = Parser.fromRules(rules),
             yappLexer = lexer,  ///
@@ -64,6 +56,7 @@ class View extends Element {
           yappHeight = topSizeableDivHeight;  ///
 
     this.setYappWidth(yappWidth);
+
     this.setYappHeight(yappHeight);
 
     this.resizeYapp();

package/src/index.js

@@ -4,8 +4,6 @@ import Yapp from "./yapp";
 
 export default Yapp;
 
-export { default as YappLexer } from "./lexer/yapp";
-export { default as YappParser } from "./parser/yapp";
 export { default as syntaxStyle } from "./style/syntax";
 export { default as colourScheme } from "./scheme/colour";
 export { default as firaCodeStyle } from "./style/firaCode";

package/src/lexer/javascript.js

@@ -1,6 +1,7 @@
 "use strict";
 
-import { WhitespaceToken,
+import { CommonLexer,
+         WhitespaceToken,
          EndOfLineNonSignificantToken,
          CStyleSingleLineCommentToken,
          SinglyQuotedStringLiteralToken,
@@ -10,8 +11,6 @@ import { WhitespaceToken,
          CStyleMiddleOfMultiLineCommentToken,
          EndOfLineCommentNonSignificantToken } from "occam-lexers";
 
-import YappLexer from "../lexer/yapp";
-
 const entries = [
   {
     "delimiter": "^(?:`|\\$\\{|<\\/|\\/>)"
@@ -36,7 +35,7 @@ const entries = [
   }
 ];
 
-export default class JavaScriptLexer extends YappLexer {
+export default class JavaScriptLexer extends CommonLexer {
   static entries = entries;
 
   static EndOfLineToken = EndOfLineNonSignificantToken; ///
@@ -59,9 +58,7 @@ export default class JavaScriptLexer extends YappLexer {
 
   static DoublyQuotedStringLiteralToken = DoublyQuotedStringLiteralToken;
 
-  static fromNothing() { return YappLexer.fromEntries(JavaScriptLexer, entries); }
-
-  static fromRules(rules) { return YappLexer.fromRules(JavaScriptLexer, rules); }
+  static fromNothing() { return CommonLexer.fromNothing(JavaScriptLexer); }
 
-  static fromEntries(entries) { return YappLexer.fromEntries(JavaScriptLexer, entries); }
+  static fromEntries(entries) { return CommonLexer.fromEntries(JavaScriptLexer, entries); }
 }

package/src/lexer/json.js

@@ -1,7 +1,6 @@
 "use strict";
 
-import YappLexer from "../lexer/yapp";
-import { WhitespaceToken, EndOfLineNonSignificantToken, DoublyQuotedStringLiteralToken, EndOfLineCommentNonSignificantToken } from "occam-lexers";
+import { CommonLexer, WhitespaceToken, EndOfLineNonSignificantToken, DoublyQuotedStringLiteralToken } from "occam-lexers";
 
 const entries = [
   {
@@ -18,14 +17,14 @@ const entries = [
   }
 ];
 
-export default class JSONLexer extends YappLexer {
+export default class JSONLexer extends CommonLexer {
   static entries = entries;
 
   static EndOfLineToken = EndOfLineNonSignificantToken; ///
 
   static WhitespaceToken = WhitespaceToken;
 
-  static EndOfLineCommentToken = EndOfLineCommentNonSignificantToken; ///
+  static EndOfLineCommentToken = null;
 
   static SingleLineCommentToken = null;
 
@@ -41,9 +40,7 @@ export default class JSONLexer extends YappLexer {
 
   static DoublyQuotedStringLiteralToken = DoublyQuotedStringLiteralToken;
 
-  static fromNothing() { return YappLexer.fromEntries(JSONLexer, entries); }
+  static fromNothing() { return CommonLexer.fromNothing(JSONLexer); }
 
-  static fromRules(rules) { return YappLexer.fromRules(JSONLexer, rules); }
-
-  static fromEntries(entries) { return YappLexer.fromEntries(JSONLexer, entries); }
+  static fromEntries(entries) { return CommonLexer.fromEntries(JSONLexer, entries); }
 }

package/src/lexer/plainText.js

@@ -1,8 +1,6 @@
 "use strict";
 
-import { WhitespaceToken, EndOfLineNonSignificantToken, EndOfLineCommentNonSignificantToken } from "occam-lexers";
-
-import YappLexer from "../lexer/yapp";
+import { CommonLexer, WhitespaceToken, EndOfLineNonSignificantToken } from "occam-lexers";
 
 const entries = [
   {
@@ -10,14 +8,14 @@ const entries = [
   }
 ];
 
-export default class PlainTextLexer extends YappLexer {
+export default class PlainTextLexer extends CommonLexer {
   static entries = entries;
 
   static EndOfLineToken = EndOfLineNonSignificantToken; ///
 
   static WhitespaceToken = WhitespaceToken;
 
-  static EndOfLineCommentToken = EndOfLineCommentNonSignificantToken; ///
+  static EndOfLineCommentToken = null;
 
   static SingleLineCommentToken = null;
 
@@ -33,9 +31,7 @@ export default class PlainTextLexer extends YappLexer {
 
   static DoublyQuotedStringLiteralToken = null;
 
-  static fromNothing() { return YappLexer.fromEntries(PlainTextLexer, entries); }
-
-  static fromRules(rules) { return YappLexer.fromRules(PlainTextLexer, rules); }
+  static fromNothing() { return CommonLexer.fromNothing(PlainTextLexer); }
 
-  static fromEntries(entries) { return YappLexer.fromEntries(PlainTextLexer, entries); }
+  static fromEntries(entries) { return CommonLexer.fromEntries(PlainTextLexer, entries); }
 }

package/src/lexer/xml.js

@@ -1,7 +1,6 @@
 "use strict";
 
-import YappLexer from "../lexer/yapp";
-import { WhitespaceToken, EndOfLineNonSignificantToken, DoublyQuotedStringLiteralToken } from "occam-lexers";
+import { CommonLexer, WhitespaceToken, EndOfLineNonSignificantToken, DoublyQuotedStringLiteralToken } from "occam-lexers";
 
 const entries = [
   {
@@ -15,7 +14,7 @@ const entries = [
   }
 ];
 
-export default class XMLLexer extends YappLexer {
+export default class XMLLexer extends CommonLexer {
   static entries = entries;
 
   static EndOfLineToken = EndOfLineNonSignificantToken; ///
@@ -38,9 +37,7 @@ export default class XMLLexer extends YappLexer {
 
   static DoublyQuotedStringLiteralToken = DoublyQuotedStringLiteralToken;
 
-  static fromNothing() { return YappLexer.fromEntries(XMLLexer, entries); }
+  static fromNothing() { return CommonLexer.fromNothing(XMLLexer); }
 
-  static fromRules(rules) { return YappLexer.fromRules(XMLLexer, rules); }
-
-  static fromEntries(entries) { return YappLexer.fromEntries(XMLLexer, entries); }
+  static fromEntries(entries) { return CommonLexer.fromEntries(XMLLexer, entries); }
 }

package/src/parser/javascript.js

@@ -1,297 +1,294 @@
 "use strict";
 
-import YappParser  from "../parser/yapp";
+import { CommonParser } from "occam-parsers";
+import { parserUtilities } from "occam-grammar-utilities";
+
+const { rulesFromBNF, parserFromRules } = parserUtilities;
 
 const bnf = `
 
-    document                   ::=  preamble ( statement | function | class | error )* 
-    
-                                 |  ( statement | function | class | error )+ 
-                                  
-                                 ;
+  document                   ::=  preamble ( statement | function | class | error )* 
+  
+                               |  ( statement | function | class | error )+ 
+                                
+                               ;
 
 
 
-    preamble                   ::=  ( "\\"use strict\\"" | "'use strict'" ) ";" ;
+  preamble                   ::=  ( "\\"use strict\\"" | "'use strict'" ) ";" ;
 
 
 
-    statement                  ::=  statementBody... ";"
-    
-                                 |  "{" ( statement | function )* "}"
-                                 
-                                 |  "if" "(" expression... ")" statement ( "else" statement )?
+  statement                  ::=  statementBody... ";"
+  
+                               |  "{" ( statement | function )* "}"
+                               
+                               |  "if" "(" expression... ")" statement ( "else" statement )?
 
-                                 |  "for" ( ( "(" initialiser ( ";" expression )? ( ";" expression )? ")" statement )
+                               |  "for" ( ( "(" initialiser ( ";" expression )? ( ";" expression )? ")" statement )
 
-                                          | ( "(" variable "in" expression... ")" statement )
+                                        | ( "(" variable "in" expression... ")" statement )
 
-                                          | ( "await"? "(" variable "of" expression... ")" statement ) 
-                                          
-                                          )
+                                        | ( "await"? "(" variable "of" expression... ")" statement ) 
+                                        
+                                        )
 
-                                 |  "do" statement "while" "(" expression... ")"
+                               |  "do" statement "while" "(" expression... ")"
 
-                                 |  "while" "(" expression... ")" statement
-                                 
-                                 |  "switch" "(" expression... ")" "{" case* defaultCase? "}"
+                               |  "while" "(" expression... ")" statement
+                               
+                               |  "switch" "(" expression... ")" "{" case* defaultCase? "}"
 
-                                 |  try ( ( catch* finally ) | catch+ )
+                               |  try ( ( catch* finally ) | catch+ )
 
-                                 ;
-                                 
-                                 
-                                 
+                               ;
+                               
+                               
+                               
 
-    class                      ::=  ( "export" "default"? )? "class" name classBody
-    
-                                 |  "export" "default" "class" classBody
-    
-                                 ;
+  class                      ::=  ( "export" "default"? )? "class" name classBody
+  
+                               |  "export" "default" "class" classBody
+  
+                               ;
 
 
 
-    function                   ::=  ( "export" "default"? )? "async"? "function" name functionBody 
-    
-                                 |  "export" "default" "async"? "function" functionBody
+  function                   ::=  ( "export" "default"? )? "async"? "function" name functionBody 
+  
+                               |  "export" "default" "async"? "function" functionBody
 
-                                 ;
+                               ;
 
 
 
-    statementBody              ::=  "import" ( [string-literal]
+  statementBody              ::=  "import" ( [string-literal]
 
-                                             | ( name "from" [string-literal] )
+                                           | ( name "from" [string-literal] )
 
-                                             | ( "{" names "}" "from" [string-literal] )
+                                           | ( "{" names "}" "from" [string-literal] )
 
-                                             | ( "*" "as" name "from" [string-literal] )
+                                           | ( "*" "as" name "from" [string-literal] )
 
-                                             )
+                                           )
 
-                                 |  "export" ( ( "{" names "}" ( "from" [string-literal] )? )
+                               |  "export" ( ( "{" names "}" ( "from" [string-literal] )? )
 
-                                             | ( "const" "{" fields "}" "=" expression )
+                                           | ( "const" "{" fields "}" "=" expression )
 
-                                             | ( "{" "default" "}" "from" [string-literal] )
+                                           | ( "{" "default" "}" "from" [string-literal] )
 
-                                             | ( "*" ( "as" name )? "from" [string-literal] )
+                                           | ( "*" ( "as" name )? "from" [string-literal] )
 
-                                             )
+                                           )
 
-                                 |  "export"? ( ( "var" var ( "," var )* )
+                               |  "export"? ( ( "var" var ( "," var )* )
 
-                                              | ( "let" let ( "," let )* )
+                                            | ( "let" let ( "," let )* )
 
-                                              | ( "const" const ( "," const )* )
+                                            | ( "const" const ( "," const )* )
 
-                                              )
-                                              
-                                 |  ( "export" "default" )? expression
+                                            )
+                                            
+                               |  ( "export" "default" )? expression
 
-                                 |  "return" expression?
+                               |  "return" expression?
 
-                                 |  "throw" expression
+                               |  "throw" expression
 
-                                 |  "delete" expression
+                               |  "delete" expression
 
-                                 |  "break"
+                               |  "break"
 
-                                 |  "continue"
+                               |  "continue"
 
-                                 |  "debugger"
-                                 
-                                 ;
+                               |  "debugger"
+                               
+                               ;
 
 
 
-    functionBody               ::=  "(" arguments? ")" "{" ( statement | function )* "}" ;
+  functionBody               ::=  "(" arguments? ")" "{" ( statement | function )* "}" ;
 
 
 
-    classBody                  ::=  ( "extends" name )? "{" ( constructor | method | field )* "}" ;
+  classBody                  ::=  ( "extends" name )? "{" ( constructor | method | field )* "}" ;
 
 
 
-    constructor                ::=  "constructor" functionBody ;
+  constructor                ::=  "constructor" functionBody ;
 
-    method                     ::=  "static"? name functionBody ;
+  method                     ::=  "static"? name functionBody ;
 
-    field                      ::=  "static"? name "=" expression... ";" ;
+  field                      ::=  "static"? name "=" expression... ";" ;
 
 
 
-    var                        ::=  variable ( "=" expression )? | destructure "=" expression ;
+  var                        ::=  variable ( "=" expression )? | destructure "=" expression ;
 
-    let                        ::=  variable ( "=" expression )? | destructure "=" expression ;
+  let                        ::=  variable ( "=" expression )? | destructure "=" expression ;
 
-    const                      ::=  ( variable | destructure ) "=" expression ;
+  const                      ::=  ( variable | destructure ) "=" expression ;
 
 
 
-    try                        ::=  "try" "{" statement+ "}" ;
+  try                        ::=  "try" "{" statement+ "}" ;
 
-    catch                      ::=  "catch" "(" [identifier] ")" "{" statement+ "}" ;
+  catch                      ::=  "catch" "(" [identifier] ")" "{" statement+ "}" ;
 
-    finally                    ::=  "finally" "{" statement+ "}" ;
+  finally                    ::=  "finally" "{" statement+ "}" ;
 
 
 
-    case                       ::=  "case" expression ":" statement ( "break" ";" )? ;
+  case                       ::=  "case" expression ":" statement ( "break" ";" )? ;
 
-    defaultCase                ::=  "default" ":" statement ( "break" ";" )? ;
+  defaultCase                ::=  "default" ":" statement ( "break" ";" )? ;
 
 
 
-    initialiser                ::=  expression | "var" var ( "," var )* | "let" let ( "," let )* ;
+  initialiser                ::=  expression | "var" var ( "," var )* | "let" let ( "," let )* ;
 
 
 
-    destructure                ::=  "[" variable ( "=" expression )? ( "," variable ( "=" expression )? )* "]"
+  destructure                ::=  "[" variable ( "=" expression )? ( "," variable ( "=" expression )? )* "]"
 
-                                 |  "{" variable ( "=" expression )? ( "," variable ( "=" expression )? )* "}"
+                               |  "{" variable ( "=" expression )? ( "," variable ( "=" expression )? )* "}"
 
-                                 ;
+                               ;
 
 
 
-    expression                 ::=  jsx
+  expression                 ::=  jsx
 
-                                 |  json
+                               |  json
 
-                                 |  arrowFunction
+                               |  arrowFunction
 
-                                 |  templateLiteral
+                               |  templateLiteral
 
-                                 |  anonymousFunction
+                               |  anonymousFunction
 
-                                 |  "(" expression ")"
+                               |  "(" expression ")"
 
-                                 |  "{" ( property ( "," property )* )? "}"
+                               |  "{" ( property ( "," property )* )? "}"
 
-                                 |  "[" ( expression ( "," expression )* ","? )? "]"
+                               |  "[" ( expression ( "," expression )* ","? )? "]"
 
-                                 |  "typeof" ( expression | ( "(" expression ")") )
+                               |  "typeof" ( expression | ( "(" expression ")") )
 
-                                 |  "void" ( expression | ( "(" expression ")") )
+                               |  "void" ( expression | ( "(" expression ")") )
 
-                                 |  "new" name<NO_WHITESPACE>"(" arguments? ")"
+                               |  "new" name<NO_WHITESPACE>"(" arguments? ")"
 
-                                 |  [operator]<NO_WHITESPACE>expression
+                               |  [operator]<NO_WHITESPACE>expression
 
-                                 |  expression<NO_WHITESPACE>( ( "."<NO_WHITESPACE>name )
+                               |  expression<NO_WHITESPACE>( ( "."<NO_WHITESPACE>name )
 
-                                                             | ( "[" expressions "]" )
+                                                           | ( "[" expressions "]" )
 
-                                                             | ( "(" expressions? ")" )
+                                                           | ( "(" expressions? ")" )
 
-                                                             | templateLiteral
+                                                           | templateLiteral
 
-                                                             | [operator]
+                                                           | [operator]
 
-                                                             )
+                                                           )
 
-                                 |  expression ( ( [operator] expression )
+                               |  expression ( ( [operator] expression )
 
-                                               | ( "?" expression ":" expression )
+                                             | ( "?" expression ":" expression )
 
-                                               | ( "instanceof" expression )
+                                             | ( "instanceof" expression )
 
-                                               | ( "in" expression )
+                                             | ( "in" expression )
 
-                                               )
+                                             )
 
-                                 |  [number]
+                               |  [number]
 
-                                 |  variable
+                               |  variable
 
-                                 |  primitive
+                               |  primitive
 
-                                 |  importMeta
+                               |  importMeta
 
-                                 |  [string-literal]
+                               |  [string-literal]
 
-                                 |  "super" | "this" | "true" | "false" | "null" | "undefined"
+                               |  "super" | "this" | "true" | "false" | "null" | "undefined"
 
-                                 ;
+                               ;
 
 
 
-    jsx                        ::=  jsxCompleteTag | jsxStartTag ( jsx | ( "{" expression? "}" ) | string )* jsxEndTag ;
+  jsx                        ::=  jsxCompleteTag | jsxStartTag ( jsx | ( "{" expression? "}" ) | string )* jsxEndTag ;
 
-    jsxCompleteTag             ::=  "<"<NO_WHITESPACE>name jsxAttribute* "/>" ;
+  jsxCompleteTag             ::=  "<"<NO_WHITESPACE>name jsxAttribute* "/>" ;
 
-    jsxStartTag                ::=  "<"<NO_WHITESPACE>name jsxAttribute* ">" ;
+  jsxStartTag                ::=  "<"<NO_WHITESPACE>name jsxAttribute* ">" ;
 
-    jsxEndTag                  ::=  "</"<NO_WHITESPACE>name ">" ;
+  jsxEndTag                  ::=  "</"<NO_WHITESPACE>name ">" ;
 
-    jsxAttribute               ::=  name ( <NO_WHITESPACE>"=" ( ( <NO_WHITESPACE>[string-literal] ) | ( <NO_WHITESPACE>"{" expression "}" ) ) )? ;
+  jsxAttribute               ::=  name ( <NO_WHITESPACE>"=" ( ( <NO_WHITESPACE>[string-literal] ) | ( <NO_WHITESPACE>"{" expression "}" ) ) )? ;
 
 
 
-    json                       ::=  jsonArray | jsonObject ;
+  json                       ::=  jsonArray | jsonObject ;
 
-    jsonArray                  ::=  "[" ( jsonElement ( "," jsonElement )* )? "]" ;
+  jsonArray                  ::=  "[" ( jsonElement ( "," jsonElement )* )? "]" ;
 
-    jsonObject                 ::=  "{" ( [string-literal] ":" jsonElement ( "," [string-literal] ":" jsonElement )* )? "}" ;
+  jsonObject                 ::=  "{" ( [string-literal] ":" jsonElement ( "," [string-literal] ":" jsonElement )* )? "}" ;
 
-    jsonElement                ::=  json | [string-literal] | [number] | "true" | "false" | "null" ;
+  jsonElement                ::=  json | [string-literal] | [number] | "true" | "false" | "null" ;
 
 
 
-    arrowFunction              ::=  complexArrowFunction | simpleArrowFunction ;
-                                 
-    complexArrowFunction       ::=  "(" arguments? ")" "=>" arrowFunctionBody ;
-     
-    simpleArrowFunction        ::=  argument "=>" arrowFunctionBody ; 
-    
-    arrowFunctionBody          ::=  expression | ( "{" statement* "}" ) ;
+  arrowFunction              ::=  "(" arguments? ")" "=>" ( expression | ( "{" statement* "}" ) ) ;
+                               
 
 
-    templateLiteral            ::=  "\`" ( ( "\${" expression? "}" ) | string )* "\`" ;
+  templateLiteral            ::=  "\`" ( ( "\${" expression? "}" ) | string )* "\`" ;
 
 
 
-    string                     ::=  ( [number] | [special] | [operator]| [keyword] | [identifier] | [string-literal]| [broken-string-literal] | [unassigned] )+ ;
+  string                     ::=  ( [number] | [special] | [operator]| [keyword] | [identifier] | [string-literal]| [broken-string-literal] | [unassigned] )+ ;
 
-    property                   ::=  ( ( ( name | [string-literal] ) ":" expression ) | variable ) ;
+  property                   ::=  ( ( ( name | [string-literal] ) ":" expression ) | variable ) ;
 
-    importMeta                 ::=  "import"<NO_WHITESPACE>"."<NO_WHITESPACE>"meta" ;
+  importMeta                 ::=  "import"<NO_WHITESPACE>"."<NO_WHITESPACE>"meta" ;
 
 
 
-    expressions                ::=  expression ( "," expression )* ;
+  expressions                ::=  expression ( "," expression )* ;
 
-    arguments                  ::=  spreadArgument | ( argument ( "," argument )* ( "," spreadArgument )? ) ;
+  arguments                  ::=  spreadArgument | ( argument ( "," argument )* ( "," spreadArgument )? ) ;
 
-    fields                     ::=  name ( ":" name )? ( "," name ( ":" name )? )* ;
+  fields                     ::=  name ( ":" name )? ( "," name ( ":" name )? )* ;
 
-    names                      ::=  name ( "as" name )? ( "," name ( "as" name )? )* ;
+  names                      ::=  name ( "as" name )? ( "," name ( "as" name )? )* ;
 
 
 
-    spreadArgument             ::=  "..."<NO_WHITESPACE>variable ;
+  spreadArgument             ::=  "..."<NO_WHITESPACE>variable ;
 
-    argument                   ::=  variable ( "=" expression )? ;
+  argument                   ::=  variable ( "=" expression )? | expression ;
 
-    variable                   ::=  [identifier] ;
+  variable                   ::=  [identifier] ;
 
-    label                      ::=  [identifier] ;
+  label                      ::=  [identifier] ;
 
-    name                       ::=  [identifier] ;
+  name                       ::=  [identifier] ;
 
 
 
-    error                      ::=  . ;
+  error                      ::=  . ;
     
-`;
+`,
+      rules = rulesFromBNF(bnf);
 
-export default class JavaScriptParser extends YappParser {
+export default class JavaScriptParser extends CommonParser {
   static bnf = bnf;
 
-  static fromNothing() { return YappParser.fromNothing(JavaScriptParser); }
-
-  static fromBNF(bnf) { return YappParser.fromBNF(JavaScriptParser, bnf); }
+  static fromNothing() { return parserFromRules(JavaScriptParser, rules); }
 
-  static fromRules(rules) { return YappParser.fromRules(JavaScriptParser, rules); }
+  static fromRules(rules) { return CommonParser.fromRules(JavaScriptParser, rules); }
 }