occam-parsers 23.0.84 → 23.0.85

package/src/bnf/parser.js

@@ -2,35 +2,35 @@
 
 import bnf from "./bnf";
 import Rule from "../rule";
-import NameRule from "../rule/name";
-import PartRule from "../rule/part";
-import RuleRule from "../rule/rule";
-import ErrorRule from "../rule/error";
-import EpsilonRule from "../rule/epsilon";
-import DocumentRule from "../rule/document";
-import RuleNameRule from "../rule/ruleName";
-import WildcardRule from "../rule/wildcard";
 import parserMixins from "../mixins/parser";
-import EndOfLineRule from "../rule/endOfLine";
-import PartChoiceRule from "../rule/partChoice";
-import QuantifierRule from "../rule/quantifier";
-import DefinitionRule from "../rule/definition";
-import PrecedentsRule from "../rule/precedence";
-import DefinitionsRule from "../rule/definitions";
-import TerminalPartRule from "../rule/terminalPart";
-import ChoiceOfPartsRule from "../rule/choiceOfParts";
-import TerminalSymbolRule from "../rule/terminalSymbol";
-import NonTerminalPartRule from "../rule/nonTerminalPart";
-import SequenceOfPartsRule from "../rule/sequenceOfParts";
-import OpacityModifierRule from "../rule/opacityModifier";
-import NoWhitespacePartRule from "../rule/noWhitespacePart";
-import CallAheadModifierRule from "../rule/callAheadModifier";
-import RegularExpressionRule from "../rule/regularExpression";
-import OptionalQuantifierRule from "../rule/optionalQuantifier";
-import StartOfContentPartRule from "../rule/startOfContentPart";
-import OneOrMoreQuantifierRule from "../rule/oneOrMoreQuantifier";
-import ZeroOrMoreQuantifierRule from "../rule/zeroOrMoreQuantifier";
-import SignificantTokenTypeRule from "../rule/significantTokenType";
+import NameBNFRule from "../rule/bnf/name";
+import PartBNFRule from "../rule/bnf/part";
+import RuleBNFRule from "../rule/bnf/rule";
+import ErrorBNFRule from "../rule/bnf/error";
+import EpsilonBNFRule from "../rule/bnf/epsilon";
+import DocumentBNFRule from "../rule/bnf/document";
+import RuleNameBNFRule from "../rule/bnf/ruleName";
+import WildcardBNFRule from "../rule/bnf/wildcard";
+import EndOfLineBNFRule from "../rule/bnf/endOfLine";
+import PartChoiceBNFRule from "../rule/bnf/partChoice";
+import QuantifierBNFRule from "../rule/bnf/quantifier";
+import DefinitionBNFRule from "../rule/bnf/definition";
+import PrecedentsBNFRule from "../rule/bnf/precedence";
+import DefinitionsBNFRule from "../rule/bnf/definitions";
+import TerminalPartBNFRule from "../rule/bnf/terminalPart";
+import ChoiceOfPartsBNFRule from "../rule/bnf/choiceOfParts";
+import TerminalSymbolBNFRule from "../rule/bnf/terminalSymbol";
+import NonTerminalPartBNFRule from "../rule/bnf/nonTerminalPart";
+import SequenceOfPartsBNFRule from "../rule/bnf/sequenceOfParts";
+import OpacityModifierBNFRule from "../rule/bnf/opacityModifier";
+import NoWhitespacePartBNFRule from "../rule/bnf/noWhitespacePart";
+import CallAheadModifierBNFRule from "../rule/bnf/callAheadModifier";
+import RegularExpressionBNFRule from "../rule/bnf/regularExpression";
+import OptionalQuantifierBNFRule from "../rule/bnf/optionalQuantifier";
+import StartOfContentPartBNFRule from "../rule/bnf/startOfContentPart";
+import OneOrMoreQuantifierBNFRule from "../rule/bnf/oneOrMoreQuantifier";
+import ZeroOrMoreQuantifierBNFRule from "../rule/bnf/zeroOrMoreQuantifier";
+import SignificantTokenTypeBNFRule from "../rule/bnf/significantTokenType";
 
 import { ruleMapFromRules, startRuleFromRules } from "../utilities/rules";
 
@@ -71,67 +71,65 @@ export default class BNFParser {
   static bnf = bnf;
 
   static fromNothing() {
-    const nameRule = NameRule.fromNothing(),
-          partRule = PartRule.fromNothing(),
-          ruleRule = RuleRule.fromNothing(),
-          errorRule = ErrorRule.fromNothing(),
-          epsilonRule = EpsilonRule.fromNothing(),
-          documentRule = DocumentRule.fromNothing(),
-          ruleNameRule = RuleNameRule.fromNothing(),
-          wildcardRule = WildcardRule.fromNothing(),
-          endOfLineRule = EndOfLineRule.fromNothing(),
-          partChoiceRule = PartChoiceRule.fromNothing(),
-          quantifierRule = QuantifierRule.fromNothing(),
-          definitionRule = DefinitionRule.fromNothing(),
-          precedentsRule = PrecedentsRule.fromNothing(),
-          definitionsRule = DefinitionsRule.fromNothing(),
-          terminalPartRule = TerminalPartRule.fromNothing(),
-          choiceOfPartsRule = ChoiceOfPartsRule.fromNothing(),
-          terminalSymbolRule = TerminalSymbolRule.fromNothing(),
-          nonTerminalPartRule = NonTerminalPartRule.fromNothing(),
-          sequenceOfPartsRule = SequenceOfPartsRule.fromNothing(),
-          opacityModifierRule = OpacityModifierRule.fromNothing(),
-          noWhitespacePartRule = NoWhitespacePartRule.fromNothing(),
-          regularExpressionRule = RegularExpressionRule.fromNothing(),
-          callAheadModifierRule = CallAheadModifierRule.fromNothing(),
-          optionalQuantifierRule = OptionalQuantifierRule.fromNothing(),
-          startOfContentPartRule = StartOfContentPartRule.fromNothing(),
-          oneOrMoreQuantifierRule = OneOrMoreQuantifierRule.fromNothing(),
-          zeroOrMoreQuantifierRule = ZeroOrMoreQuantifierRule.fromNothing(),
-          significantTokenTypeRule = SignificantTokenTypeRule.fromNothing();
-
-    let rules = [
-      documentRule,
-      ruleRule,
-      nameRule,
-      definitionsRule,
-      definitionRule,
-      partRule,
-      nonTerminalPartRule,
-      terminalPartRule,
-      startOfContentPartRule,
-      noWhitespacePartRule,
-      sequenceOfPartsRule,
-      choiceOfPartsRule,
-      partChoiceRule,
-      ruleNameRule,
-      significantTokenTypeRule,
-      regularExpressionRule,
-      terminalSymbolRule,
-      precedentsRule,
-      endOfLineRule,
-      wildcardRule,
-      epsilonRule,
-      quantifierRule,
-      opacityModifierRule,
-      callAheadModifierRule,
-      optionalQuantifierRule,
-      oneOrMoreQuantifierRule,
-      zeroOrMoreQuantifierRule,
-      errorRule
-    ];
-
-    const startRule = startRuleFromRules(rules),
+    const nameBNFRule = NameBNFRule.fromNothing(),
+          partBNFRule = PartBNFRule.fromNothing(),
+          ruleBNFRule = RuleBNFRule.fromNothing(),
+          errorBNFRule = ErrorBNFRule.fromNothing(),
+          epsilonBNFRule = EpsilonBNFRule.fromNothing(),
+          documentBNFRule = DocumentBNFRule.fromNothing(),
+          ruleNameBNFRule = RuleNameBNFRule.fromNothing(),
+          wildcardBNFRule = WildcardBNFRule.fromNothing(),
+          endOfLineBNFRule = EndOfLineBNFRule.fromNothing(),
+          partChoiceBNFRule = PartChoiceBNFRule.fromNothing(),
+          quantifierBNFRule = QuantifierBNFRule.fromNothing(),
+          definitionBNFRule = DefinitionBNFRule.fromNothing(),
+          precedentsBNFRule = PrecedentsBNFRule.fromNothing(),
+          definitionsBNFRule = DefinitionsBNFRule.fromNothing(),
+          terminalPartBNFRule = TerminalPartBNFRule.fromNothing(),
+          choiceOfPartsBNFRule = ChoiceOfPartsBNFRule.fromNothing(),
+          terminalSymbolBNFRule = TerminalSymbolBNFRule.fromNothing(),
+          nonTerminalPartBNFRule = NonTerminalPartBNFRule.fromNothing(),
+          sequenceOfPartsBNFRule = SequenceOfPartsBNFRule.fromNothing(),
+          opacityModifierBNFRule = OpacityModifierBNFRule.fromNothing(),
+          noWhitespacePartBNFRule = NoWhitespacePartBNFRule.fromNothing(),
+          regularExpressionBNFRule = RegularExpressionBNFRule.fromNothing(),
+          callAheadModifierBNFRule = CallAheadModifierBNFRule.fromNothing(),
+          optionalQuantifierBNFRule = OptionalQuantifierBNFRule.fromNothing(),
+          startOfContentPartBNFRule = StartOfContentPartBNFRule.fromNothing(),
+          oneOrMoreQuantifierBNFRule = OneOrMoreQuantifierBNFRule.fromNothing(),
+          zeroOrMoreQuantifierBNFRule = ZeroOrMoreQuantifierBNFRule.fromNothing(),
+          significantTokenTypeBNFRule = SignificantTokenTypeBNFRule.fromNothing(),
+          rules = [
+            documentBNFRule,
+            ruleBNFRule,
+            nameBNFRule,
+            definitionsBNFRule,
+            definitionBNFRule,
+            partBNFRule,
+            nonTerminalPartBNFRule,
+            terminalPartBNFRule,
+            startOfContentPartBNFRule,
+            noWhitespacePartBNFRule,
+            sequenceOfPartsBNFRule,
+            choiceOfPartsBNFRule,
+            partChoiceBNFRule,
+            ruleNameBNFRule,
+            significantTokenTypeBNFRule,
+            regularExpressionBNFRule,
+            terminalSymbolBNFRule,
+            precedentsBNFRule,
+            endOfLineBNFRule,
+            wildcardBNFRule,
+            epsilonBNFRule,
+            quantifierBNFRule,
+            opacityModifierBNFRule,
+            callAheadModifierBNFRule,
+            optionalQuantifierBNFRule,
+            oneOrMoreQuantifierBNFRule,
+            zeroOrMoreQuantifierBNFRule,
+            errorBNFRule
+          ],
+          startRule = startRuleFromRules(rules),
           ruleMap = ruleMapFromRules(rules),
           bnfParser = new BNFParser(startRule, ruleMap);
     

package/src/node/nonTerminal.js

@@ -213,6 +213,16 @@ export default class NonTerminalNode {
     return empty;
   }
 
+  mapChildNode(callback) { return this.childNodes.map(callback); }
+
+  someChildNode(callback) { return this.childNodes.some(callback); }
+
+  everyChildNode(callback) { return this.childNodes.every(callback); }
+
+  reduceChildNode(callback, initialValue) { return this.childNodes.reduce(callback, initialValue); }
+
+  forEachChildNode(callback) { this.childNodes.forEach(callback); }
+
   match(node, depth = Infinity, exactly = false) {
     let matches = false;
 

package/src/rule/bnf/callAheadModifier.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import Rule from "../../rule";
+import CallAheadModifierBNFNode from "../../node/bnf/callAheadModifier";
+import CallAheadModifierRuleDefinition from "../../definition/callAheadModifierRule";
+
+import { callAheadModifierRuleName } from "../../ruleNames";
+
+export default class CallAheadModifierBNFRule extends Rule {
+  static fromNothing() {
+    const name = callAheadModifierRuleName, ///
+          callAheadModifierRuleDefinition = CallAheadModifierRuleDefinition.fromNothing(),
+          opacity = null,
+          definitions = [
+            callAheadModifierRuleDefinition
+          ],
+          NonTerminalNode = CallAheadModifierBNFNode,  ///
+          callAheadModifierRule = new CallAheadModifierBNFRule(name, opacity, definitions, NonTerminalNode);
+
+    return callAheadModifierRule;
+  }
+}

package/src/rule/bnf/choiceOfParts.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import Rule from "../../rule";
+import ChoiceOfPartsBNFNode from "../../node/bnf/choiceOfParts";
+import ChoiceOfPartsDefinition from "../../definition/choiceOfParts";
+
+import { choiceOfPartsRuleName } from "../../ruleNames";
+
+export default class ChoiceOfPartsBNFRule extends Rule {
+  static fromNothing() {
+    const name = choiceOfPartsRuleName, ///
+          choiceOfPartsDefinition = ChoiceOfPartsDefinition.fromNothing(),
+          opacity = null,
+          definitions = [
+            choiceOfPartsDefinition
+          ],
+          NonTerminalNode = ChoiceOfPartsBNFNode, ///
+          choiceOfPartsRule = new ChoiceOfPartsBNFRule(name, opacity, definitions, NonTerminalNode);
+
+    return choiceOfPartsRule;
+  }
+}

package/src/rule/bnf/definition.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import Rule from "../../rule";
+import DefinitionBNFNode from "../../node/bnf/definition";
+import DefinitionDefinition from "../../definition/definition";
+
+import { definitionRuleName } from "../../ruleNames";
+
+export default class DefinitionBNFRule extends Rule {
+  static fromNothing() {
+    const name = definitionRuleName,  ///
+          definitionDefinition = DefinitionDefinition.fromNothing(),
+          opacity = null,
+          definitions = [
+            definitionDefinition
+          ],
+          NonTerminalNode = DefinitionBNFNode,  ///
+          definitionRule = new DefinitionBNFRule(name, opacity, definitions, NonTerminalNode);
+
+    return definitionRule;
+  }
+}

package/src/rule/bnf/definitions.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import Rule from "../../rule";
+import DefinitionsBNFNode from "../../node/bnf/definitions";
+import DefinitionsDefinition from "../../definition/definitions";
+
+import { definitionsRuleName } from "../../ruleNames";
+
+export default class DefinitionsBNFRule extends Rule {
+  static fromNothing() {
+    const definitionsDefinition = DefinitionsDefinition.fromNothing(),
+          name = definitionsRuleName, ///
+          opacity = null,
+          definitions = [
+            definitionsDefinition
+          ],
+          NonTerminalNode = DefinitionsBNFNode, ///
+          definitionsRule = new DefinitionsBNFRule(name, opacity, definitions, NonTerminalNode);
+
+    return definitionsRule;
+  }
+}

package/src/rule/bnf/document.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import Rule from "../../rule";
+import DocumentBNFNode from "../../node/bnf/document";
+import DocumentDefinition from "../../definition/document";
+
+import { documentRuleName } from "../../ruleNames";
+
+export default class DocumentBNFRule extends Rule {
+  static fromNothing() {
+    const documentDefinition = DocumentDefinition.fromNothing(),
+          name = documentRuleName,  ///
+          opacity = null,
+          definitions = [
+            documentDefinition
+          ],
+          NonTerminalNode = DocumentBNFNode,  ///
+          documentRule = new DocumentBNFRule(name, opacity, definitions, NonTerminalNode);
+
+    return documentRule;
+  }
+}

package/src/rule/{endOfLine.js → bnf/endOfLine.js}

@@ -2,15 +2,15 @@
 
 import { specialSymbols } from "occam-lexers";
 
-import Rule from "../rule";
-import EndOfLineBNFNode from "../node/bnf/endOfLine";
-import TerminalSymbolDefinition from "../definition/terminalSymbol";
+import Rule from "../../rule";
+import EndOfLineBNFNode from "../../node/bnf/endOfLine";
+import TerminalSymbolDefinition from "../../definition/terminalSymbol";
 
-import { endOfLineRuleName } from "../ruleNames";
+import { endOfLineRuleName } from "../../ruleNames";
 
 const { endOfLine } = specialSymbols;
 
-export default class EndOfLineRule extends Rule {
+export default class EndOfLineBNFRule extends Rule {
   static fromNothing() {
     const content = endOfLine,
           endOfLineTerminalSymbolDefinition = TerminalSymbolDefinition.fromContent(content),
@@ -20,7 +20,7 @@ export default class EndOfLineRule extends Rule {
             endOfLineTerminalSymbolDefinition
           ],
           NonTerminalNode = EndOfLineBNFNode, ///
-          endOfLineRule = new EndOfLineRule(name, opacity, definitions, NonTerminalNode);
+          endOfLineRule = new EndOfLineBNFRule(name, opacity, definitions, NonTerminalNode);
 
     return endOfLineRule;
   }

package/src/rule/{epsilon.js → bnf/epsilon.js}

@@ -2,15 +2,15 @@
 
 import { specialSymbols } from "occam-lexers";
 
-import Rule from "../rule";
-import EpsilonBNFNode from "../node/bnf/epsilon";
-import TerminalSymbolDefinition from "../definition/terminalSymbol";
+import Rule from "../../rule";
+import EpsilonBNFNode from "../../node/bnf/epsilon";
+import TerminalSymbolDefinition from "../../definition/terminalSymbol";
 
-import { epsilonRuleName } from "../ruleNames";
+import { epsilonRuleName } from "../../ruleNames";
 
 const { epsilon } = specialSymbols;
 
-export default class EpsilonRule extends Rule {
+export default class EpsilonBNFRule extends Rule {
   static fromNothing() {
     const content = epsilon, ///
           epsilonTerminalSymbolDefinition = TerminalSymbolDefinition.fromContent(content),
@@ -20,7 +20,7 @@ export default class EpsilonRule extends Rule {
             epsilonTerminalSymbolDefinition
           ],
           NonTerminalNode = EpsilonBNFNode, ///
-          epsilonRule = new EpsilonRule(name, opacity, definitions, NonTerminalNode);
+          epsilonRule = new EpsilonBNFRule(name, opacity, definitions, NonTerminalNode);
 
     return epsilonRule;
   }

package/src/rule/bnf/error.js

@@ -0,0 +1,26 @@
+"use strict";
+
+import { specialSymbols } from "occam-lexers";
+
+import Rule from "../../rule";
+import ErrorBNFNode from "../../node/bnf/error";
+import ErrorDefinition from "../../definition/error";
+
+import { errorRuleName } from "../../ruleNames";
+
+const { opaque } = specialSymbols;
+
+export default class ErrorBNFRule extends Rule {
+  static fromNothing() {
+    const errorDefinition = ErrorDefinition.fromNothing(),
+          name = errorRuleName, ///
+          opacity = opaque, ///
+          definitions = [
+            errorDefinition
+          ],
+          NonTerminalNode = ErrorBNFNode, ///
+          errorRule = new ErrorBNFRule(name, opacity, definitions, NonTerminalNode);
+
+    return errorRule;
+  }
+}

package/src/rule/bnf/name.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import Rule from "../../rule";
+import NameBNFNode from "../../node/bnf/name";
+import NameDefinition from "../../definition/name";
+
+import { nameRuleName } from "../../ruleNames";
+
+export default class NameBNFRule extends Rule {
+  static fromNothing() {
+    const nameDefinition = NameDefinition.fromNothing(),
+          name = nameRuleName,  ///
+          opacity = null,
+          definitions = [
+            nameDefinition
+          ],
+          NonTerminalNode = NameBNFNode,  ///
+          nameRule = new NameBNFRule(name, opacity, definitions, NonTerminalNode);
+
+    return nameRule;
+  }
+}

package/src/rule/bnf/noWhitespacePart.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import Rule from "../../rule";
+import NoWhitespacePartBNFNode from "../../node/bnf/noWhitespacePart";
+import NoWhitespacePartDefinition from "../../definition/noWhitespacePart";
+
+import { noWhitespacePartRuleName } from "../../ruleNames";
+
+export default class NoWhitespacePartBNFRule extends Rule {
+  static fromNothing() {
+    const noWhitespacePartDefinition = NoWhitespacePartDefinition.fromNothing(),
+          name = noWhitespacePartRuleName,  ///
+          opacity = null,
+          definitions = [
+            noWhitespacePartDefinition
+          ],
+          NonTerminalNode = NoWhitespacePartBNFNode,  ///
+          noWhitespacePartRule = new NoWhitespacePartBNFRule(name, opacity, definitions, NonTerminalNode);
+
+    return noWhitespacePartRule;
+  }
+}

package/src/rule/{nonTerminalPart.js → bnf/nonTerminalPart.js}

@@ -1,13 +1,13 @@
 "use strict";
 
-import Rule from "../rule";
-import RuleNameDefinition from "../definition/ruleName";
-import NonTerminalPartBNFNode from "../node/bnf/part/nonTerminal";
-import RuleNameNonTerminalPartRuleDefinition from "../definition/partRule/nonTerminal/ruleName";
+import Rule from "../../rule";
+import RuleNameDefinition from "../../definition/ruleName";
+import NonTerminalPartBNFNode from "../../node/bnf/part/nonTerminal";
+import RuleNameNonTerminalPartRuleDefinition from "../../definition/partRule/nonTerminal/ruleName";
 
-import { nonTerminalPartRuleName, choiceOfPartsRuleName, sequenceOfPartsRuleName } from "../ruleNames";
+import { nonTerminalPartRuleName, choiceOfPartsRuleName, sequenceOfPartsRuleName } from "../../ruleNames";
 
-export default class NonTerminalPartRule extends Rule {
+export default class NonTerminalPartBNFRule extends Rule {
   static fromNothing() {
     const name = nonTerminalPartRuleName, ///
           choiceOfPartsRuleNameDefinition = RuleNameDefinition.fromRuleName(choiceOfPartsRuleName),
@@ -20,7 +20,7 @@ export default class NonTerminalPartRule extends Rule {
             ruleNameNonTerminalPartRuleDefinition
           ],
           NonTerminalNode = NonTerminalPartBNFNode, ///
-          nonTerminalPartRule = new NonTerminalPartRule(name, opacity, definitions, NonTerminalNode);
+          nonTerminalPartRule = new NonTerminalPartBNFRule(name, opacity, definitions, NonTerminalNode);
 
     return nonTerminalPartRule;
   }

package/src/rule/{oneOrMoreQuantifier.js → bnf/oneOrMoreQuantifier.js}

@@ -2,15 +2,15 @@
 
 import { specialSymbols } from "occam-lexers";
 
-import Rule from "../rule";
-import QuantifierBNFNode from "../node/bnf/quantifier";
-import QuantifierRuleDefinition from "../definition/quantifierRule";
+import Rule from "../../rule";
+import QuantifierBNFNode from "../../node/bnf/quantifier";
+import QuantifierRuleDefinition from "../../definition/quantifierRule";
 
-import { oneOrMoreQuantifierRuleName } from "../ruleNames";
+import { oneOrMoreQuantifierRuleName } from "../../ruleNames";
 
 const { plus } = specialSymbols;
 
-export default class OneOrMoreQuantifierRule extends Rule {
+export default class OneOrMoreQuantifierBNFRule extends Rule {
   static fromNothing() {
     const name = oneOrMoreQuantifierRuleName, ///
           specialSymbol = plus, ///
@@ -20,7 +20,7 @@ export default class OneOrMoreQuantifierRule extends Rule {
             oneOrMoreQuantifierRuleDefinition
           ],
           NonTerminalNode = QuantifierBNFNode,  ///
-          oneOrMoreQuantifierRule = new OneOrMoreQuantifierRule(name, opacity, definitions, NonTerminalNode);
+          oneOrMoreQuantifierRule = new OneOrMoreQuantifierBNFRule(name, opacity, definitions, NonTerminalNode);
 
     return oneOrMoreQuantifierRule;
   }

package/src/rule/bnf/opacityModifier.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import Rule from "../../rule";
+import OpacityModifierBNFNode from "../../node/bnf/opacityModifier";
+import OpacityModifierRuleDefinition from "../../definition/opacityModifierRule";
+
+import { opacityModifierRuleName } from "../../ruleNames";
+
+export default class OpacityModifierBNFRule extends Rule {
+  static fromNothing() {
+    const name = opacityModifierRuleName, ///
+          opacityModifierRuleDefinition = OpacityModifierRuleDefinition.fromNothing(),
+          opacity = null,
+          definitions = [
+            opacityModifierRuleDefinition
+          ],
+          NonTerminalNode = OpacityModifierBNFNode, ///
+          opacityModifierRule = new OpacityModifierBNFRule(name, opacity, definitions, NonTerminalNode);
+
+    return opacityModifierRule;
+  }
+}

package/src/rule/{optionalQuantifier.js → bnf/optionalQuantifier.js}

@@ -2,15 +2,15 @@
 
 import { specialSymbols } from "occam-lexers";
 
-import Rule from "../rule";
-import QuantifierBNFNode from "../node/bnf/quantifier";
-import QuantifierRuleDefinition from "../definition/quantifierRule";
+import Rule from "../../rule";
+import QuantifierBNFNode from "../../node/bnf/quantifier";
+import QuantifierRuleDefinition from "../../definition/quantifierRule";
 
-import { optionalQuantifierRuleName } from "../ruleNames";
+import { optionalQuantifierRuleName } from "../../ruleNames";
 
 const { questionMark } = specialSymbols;
 
-export default class OptionalQuantifierRule extends Rule {
+export default class OptionalQuantifierBNFRule extends Rule {
   static fromNothing() {
     const name = optionalQuantifierRuleName,  ///
           specialSymbol = questionMark, ///
@@ -20,7 +20,7 @@ export default class OptionalQuantifierRule extends Rule {
             optionalQuantifierRuleDefinition
           ],
           NonTerminalNode = QuantifierBNFNode,  ///
-          optionalQuantifierRule = new OptionalQuantifierRule(name, opacity, definitions, NonTerminalNode);
+          optionalQuantifierRule = new OptionalQuantifierBNFRule(name, opacity, definitions, NonTerminalNode);
 
     return optionalQuantifierRule;
   }

package/src/rule/{part.js → bnf/part.js}

@@ -1,13 +1,13 @@
 "use strict";
 
-import Rule from "../rule";
-import PartBNFNode from "../node/bnf/part";
-import TerminalPartRuleDefinition from "../definition/partRule/terminal";
-import NonTerminalPartRuleDefinition from "../definition/partRule/nonTerminal";
+import Rule from "../../rule";
+import PartBNFNode from "../../node/bnf/part";
+import TerminalPartRuleDefinition from "../../definition/partRule/terminal";
+import NonTerminalPartRuleDefinition from "../../definition/partRule/nonTerminal";
 
-import { partRuleName } from "../ruleNames";
+import { partRuleName } from "../../ruleNames";
 
-export default class PartRule extends Rule {
+export default class PartBNFRule extends Rule {
   static fromNothing() {
     const name = partRuleName,  ///
           terminalPartRuleDefinition = TerminalPartRuleDefinition.fromNothing(),
@@ -18,7 +18,7 @@ export default class PartRule extends Rule {
             terminalPartRuleDefinition
           ],
           NonTerminalNode = PartBNFNode,  ///
-          partRule = new PartRule(name, opacity, definitions, NonTerminalNode);
+          partRule = new PartBNFRule(name, opacity, definitions, NonTerminalNode);
 
     return partRule;
   }

package/src/rule/bnf/partChoice.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import Rule from "../../rule";
+import PartChoiceBNFNode from "../../node/bnf/partChoice";
+import PartChoiceDefinition from "../../definition/partChoice";
+
+import { partChoiceRuleName } from "../../ruleNames";
+
+export default class PartChoiceBNFRule extends Rule {
+  static fromNothing() {
+    const name = partChoiceRuleName,  ///
+          partChoiceDefinition = PartChoiceDefinition.fromNothing(),
+          opacity = null,
+          definitions = [
+            partChoiceDefinition
+          ],
+          NonTerminalNode = PartChoiceBNFNode,  ///
+          definitionRule = new PartChoiceBNFRule(name, opacity, definitions, NonTerminalNode);
+
+    return definitionRule;
+  }
+}