yapp 5.1.19 → 5.1.21

package/src/parser/javascript.js

@@ -8,276 +8,264 @@ const { rulesFromBNF, parserFromRules } = parserUtilities;
 
 const bnf = `
 
-  document                   ::=  preamble? ( statement | function | class | error )* ;
+  javaScript      ::=  preamble? ( statement | function | class | error )* ;
 
 
+  preamble        ::=  "\\"use strict\\";" ;
 
-  preamble                   ::=  "\\"use strict\\";" ;
 
-
-
-  statement                  ::=  statementBody... ";"
+  statement       ::=  statementBody... ";"
   
-                               |  "{" ( statement | function )* "}"
+                    |  "{" ( statement | function )* "}"
                                
-                               |  "if" "(" expression... ")" statement ( "else" statement )?
+                    |  "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
+                    |  "while" "(" expression... ")" statement
                                
-                               |  "switch" "(" expression... ")" "{" case* defaultCase? "}"
+                    |  "switch" "(" expression... ")" "{" case* defaultCase? "}"
 
-                               |  try ( ( catch* finally ) | catch+ )
+                    |  try ( ( catch* finally ) | catch+ )
+
+                    ;
 
-                               ;
-                               
-                               
-                               
 
-  class                      ::=  ( "export" "default"? )? "class" name classBody
+  class           ::=  ( "export" "default"? )? "class" name classBody
   
-                               |  "export" "default" "class" classBody
+                    |  "export" "default" "class" classBody
   
-                               ;
+                    ;
 
 
-
-  function                   ::=  ( "export" "default"? )? "async"? "function" name functionBody 
+  function        ::=  ( "export" "default"? )? "async"? "function" name functionBody 
   
-                               |  "export" "default" "async"? "function" 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 )* )
 
-                                           )
+                                 | ( "let" let ( "," let )* )
 
-                               |  "export"? ( ( "var" var ( "," var )* )
-
-                                            | ( "let" let ( "," let )* )
-
-                                            | ( "const" const ( "," const )* )
-
-                                            )
+                                 | ( "const" const ( "," const )* ) )
                                             
-                               |  ( "export" "default" )? expression
+                    |  ( "export" "default" )? expression
 
-                               |  "return" ( ( "(" expression ")" ) | expression? )
+                    |  "return" ( ( "(" expression ")" ) | 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 ;
 
 
+  method          ::=  "static"? name functionBody ;
 
-  constructor                ::=  "constructor" 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
 
+                    |  json
 
-  expression                 ::=  jsx
+                    |  arrowFunction
 
-                               |  json
+                    |  templateLiteral
 
-                               |  arrowFunction
+                    |  anonymousFunction
 
-                               |  templateLiteral
+                    |  "(" expression ")"
 
-                               |  anonymousFunction
+                    |  "{" ( property ( "," property )* )? "}"
 
-                               |  "(" expression ")"
+                    |  "[" ( expression ( "," expression )* ","? )? "]"
 
-                               |  "{" ( property ( "," property )* )? "}"
+                    |  "typeof" ( expression | ( "(" expression ")") )
 
-                               |  "[" ( expression ( "," expression )* ","? )? "]"
+                    |  "void" ( expression | ( "(" expression ")") )
 
-                               |  "typeof" ( expression | ( "(" expression ")") )
+                    |  "new" name<NO_WHITESPACE>"(" expressions? ")"
 
-                               |  "void" ( expression | ( "(" expression ")") )
+                    |  [operator]<NO_WHITESPACE>expression
 
-                               |  "new" name<NO_WHITESPACE>"(" expressions? ")"
+                    |  expression<NO_WHITESPACE>( ( "."<NO_WHITESPACE>name )
 
-                               |  [operator]<NO_WHITESPACE>expression
+                                                | ( "[" expressions "]" )
 
-                               |  expression<NO_WHITESPACE>( ( "."<NO_WHITESPACE>name )
+                                                | ( "(" expressions? ")" )
 
-                                                           | ( "[" expressions "]" )
+                                                | templateLiteral
 
-                                                           | ( "(" expressions? ")" )
+                                                | [operator] )
 
-                                                           | templateLiteral
+                    |  expression ( ( [operator] expression )
 
-                                                           | [operator]
+                                  | ( "?" expression ":" expression )
 
-                                                           )
+                                  | ( "instanceof" expression )
 
-                               |  expression ( ( [operator] expression )
+                                  | ( "in" expression ) )
 
-                                             | ( "?" expression ":" expression )
+                    |  [number]
 
-                                             | ( "instanceof" expression )
+                    |  variable
 
-                                             | ( "in" expression )
+                    |  primitive
 
-                                             )
+                    |  importMeta
 
-                               |  [number]
+                    |  [string-literal]
 
-                               |  variable
+                    |  "super" | "this" | "true" | "false" | "null" | "undefined"
 
-                               |  primitive
+                    ;
 
-                               |  importMeta
 
-                               |  [string-literal]
+  jsx             ::=  jsxCompleteTag | jsxStartTag ( jsx | ( "{" expression? "}" ) | string )* jsxEndTag ;
 
-                               |  "super" | "this" | "true" | "false" | "null" | "undefined"
 
-                               ;
+  jsxCompleteTag  ::=  "<"<NO_WHITESPACE>name jsxAttribute* "/>" ;
 
 
+  jsxStartTag     ::=  "<"<NO_WHITESPACE>name jsxAttribute* ">" ;
 
-  jsx                        ::=  jsxCompleteTag | jsxStartTag ( jsx | ( "{" expression? "}" ) | string )* jsxEndTag ;
 
-  jsxCompleteTag             ::=  "<"<NO_WHITESPACE>name jsxAttribute* "/>" ;
+  jsxEndTag       ::=  "</"<NO_WHITESPACE>name ">" ;
 
-  jsxStartTag                ::=  "<"<NO_WHITESPACE>name jsxAttribute* ">" ;
 
-  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              ::=  "(" arguments? ")" "=>" ( expression | ( "{" statement* "}" ) ) ;
+  arrowFunction   ::=  "(" arguments? ")" "=>" ( expression | ( "{" statement* "}" ) ) ;
                                
 
+  templateLiteral ::=  "\`" ( ( "\${" expression? "}" ) | string )* "\`" ;
+
 
-  templateLiteral            ::=  "\`" ( ( "\${" expression? "}" ) | string )* "\`" ;
+  string          ::=  ( [number] | [special] | [operator]| [keyword] | [identifier] | [string-literal]| [broken-string-literal] | [unassigned] )+ ;
 
 
+  property        ::=  ( ( ( name | [string-literal] ) ":" expression ) | variable ) ;
 
-  string                     ::=  ( [number] | [special] | [operator]| [keyword] | [identifier] | [string-literal]| [broken-string-literal] | [unassigned] )+ ;
 
-  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 )? ;
+
+
+  variable        ::=  [identifier] ;
 
-  variable                   ::=  [identifier] ;
 
-  label                      ::=  [identifier] ;
+  label           ::=  [identifier] ;
 
-  name                       ::=  [identifier] ;
 
+  name            ::=  [identifier] ;
 
 
-  error.                     ::=  . ;
+  error.          ::=  . ;
     
 `;
 

package/src/parser/json.js

@@ -7,23 +7,23 @@ const { rulesFromBNF, parserFromRules } = parserUtilities;
 
 const bnf = `
 
-  document                   ::=  element error* 
+  json     ::=  element error* 
   
-                               |  error+ 
+             |  error+ 
                                
-                               ;
+             ;
 
 
-  element                    ::=  array | object | [string-literal] | [number] | "true" | "false" | "null" ;
+  element  ::=  array | object | [string-literal] | [number] | "true" | "false" | "null" ;
 
 
-  object                     ::=  "{" ( [string-literal] ":" element ( "," [string-literal] ":" element )* )? "}" ;
+  object   ::=  "{" ( [string-literal] ":" element ( "," [string-literal] ":" element )* )? "}" ;
 
   
-  array                      ::=  "[" ( element ( "," element )* )? "]" ;
+  array    ::=  "[" ( element ( "," element )* )? "]" ;
 
 
-  error.                     ::=  . ;
+  error.   ::=  . ;
 
       `,
       rules = rulesFromBNF(bnf);

package/src/parser/plainText.js

@@ -7,7 +7,7 @@ const { rulesFromBNF, parserFromRules } = parserUtilities;
 
 const bnf = `
 
-  document                   ::=  .+ ;
+  plainText  ::=  .+ ;
 
       `,
       rules = rulesFromBNF(bnf);

package/src/parser/xml.js

@@ -7,47 +7,47 @@ const { rulesFromBNF, parserFromRules } = parserUtilities;
 
 const bnf = `
 
-  document                   ::=  declaration? comment* ( simpleElement | complexElement ) comment* error*
+  xml             ::=  declaration? comment* ( simpleElement | complexElement ) comment* error*
   
-                               |  error+
+                    |  error+
                                
-                               ;
+                    ;
 
 
-  declaration                ::=  "<?"<NO_WHITESPACE>"xml" attribute* "?>" ;
+  declaration     ::=  "<?"<NO_WHITESPACE>"xml" attribute* "?>" ;
 
 
-  element                    ::=  comment | simpleElement | complexElement ;
+  element         ::=  comment | simpleElement | complexElement ;
                                
                                
-  comment                    ::=  "<!--" text* "-->" ;
+  comment         ::=  "<!--" text* "-->" ;
 
 
-  simpleElement              ::=  completeTag ;
+  simpleElement   ::=  completeTag ;
 
 
-  complexElement             ::=  startTag ( element | text )* endTag ;
+  complexElement  ::=  startTag ( element | text )* endTag ;
 
 
-  completeTag                ::=  "<"<NO_WHITESPACE>name attribute* "/>" ;
+  completeTag     ::=  "<"<NO_WHITESPACE>name attribute* "/>" ;
 
 
-  startTag                   ::=  "<"<NO_WHITESPACE>name attribute* ">" ;
+  startTag        ::=  "<"<NO_WHITESPACE>name attribute* ">" ;
 
 
-  endTag                     ::=  "</"<NO_WHITESPACE>name ">" ;
+  endTag          ::=  "</"<NO_WHITESPACE>name ">" ;
   
 
-  attribute                  ::=  [identifier]<NO_WHITESPACE>"="<NO_WHITESPACE>[string-literal] ;
+  attribute       ::=  [identifier]<NO_WHITESPACE>"="<NO_WHITESPACE>[string-literal] ;
 
 
-  text                       ::=  ( [identifier] | [string-literal]| [broken-string-literal] | [unassigned] )+ ;
+  text            ::=  ( [identifier] | [string-literal]| [broken-string-literal] | [unassigned] )+ ;
   
   
-  name                       ::=  [identifier] ;
+  name            ::=  [identifier] ;
 
 
-  error.                     ::=  . ;
+  error.          ::=  . ;
 
       `,
       rules = rulesFromBNF(bnf);