occam-custom-grammars 5.0.1228 → 5.0.1230

package/lib/utilities/validate.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get validateBNF () {
+        return validateBNF;
+    },
+    get validateVocabulary () {
+        return validateVocabulary;
+    }
+});
+var _necessary = require("necessary");
+var _typesMap = /*#__PURE__*/ _interop_require_default(require("../typesMap"));
+var _nominal = require("../utilities/nominal");
+var _constants = require("../constants");
+var _query = require("../utilities/query");
+var _grammar = require("../utilities/grammar");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var first = _necessary.arrayUtilities.first, second = _necessary.arrayUtilities.second;
+var expressionNodesQuery = (0, _query.nodesQuery)("//expression"), ruleNameTerminalNodeQuery = (0, _query.nodeQuery)("/document/rule/name/@*!"), stringLiteralTerminalNodesQuery = (0, _query.nodesQuery)("//stringLiteral/@*!"), significantTokenTypeTerminalNodesQuery = (0, _query.nodesQuery)("//significantTokenType/@*!");
+function validateBNF(bnf, ruleName) {
+    var content = bnf, tokens = _grammar.customGrammarBNFLexer.tokenise(content), node = _grammar.customGrammarBNFParser.parse(tokens);
+    if (node === null) {
+        return;
+    }
+    var ruleNameTerminalNode = ruleNameTerminalNodeQuery(node);
+    if (ruleNameTerminalNode !== null) {
+        var name = nameFromRuleNameTerminalNode(ruleNameTerminalNode);
+        if (name !== ruleName) {
+            throw new Error("The '".concat(name, "' rule should be named '").concat(ruleName, "'."));
+        }
+    }
+    var types = _typesMap.default[ruleName], significantTokenTypeTerminalNodes = significantTokenTypeTerminalNodesQuery(node);
+    significantTokenTypeTerminalNodes.forEach(function(significantTokenTypeTerminalNode) {
+        var type = typeFromSignificantTokenTypeTerminalNode(significantTokenTypeTerminalNode), typesIncludeType = types.includes(type);
+        if (!typesIncludeType) {
+            throw new Error("The '".concat(type, "' type is not included in the '").concat(ruleName, "' rule's types."));
+        }
+    });
+    var stringLiteralTerminalNodes = stringLiteralTerminalNodesQuery(node);
+    stringLiteralTerminalNodes.forEach(function(stringLiteralTerminalNode) {
+        var content = contentFromStringLiteralTerminalNode(stringLiteralTerminalNode);
+        if (content === _constants.UNDERSCORE_CHARACTER) {
+            throw new Error('The "'.concat(content, '" string literal cannot be an underscore.'));
+        }
+        var tokens = _nominal.nominalLexer.tokenise(content), tokensLength = tokens.length;
+        if (tokensLength !== 1) {
+            throw new Error('Tokenising the "'.concat(content, '" string literal does not result in a single token.'));
+        }
+        var firstToken = first(tokens), token = firstToken, type = token.getType(), typesIncludeType = types.includes(type);
+        if (!typesIncludeType) {
+            throw new Error('The "'.concat(content, "\" string literal's token's '").concat(type, "' type is not included in the '").concat(ruleName, "' rule's types."));
+        }
+    });
+}
+function validateVocabulary(vocabulary) {
+    var content = vocabulary, tokens = _grammar.customGrammarVocabularyLexer.tokenise(content), node = _grammar.customGrammarVocabularyParser.parse(tokens);
+    if (node === null) {
+        return;
+    }
+    var expressionNodes = expressionNodesQuery(node);
+    expressionNodes.forEach(function(expressionNode) {
+        var content = contentFromExpressionNode(expressionNode), tokens = _nominal.nominalLexer.tokenise(content), tokensLength = tokens.length;
+        if (tokensLength > 1) {
+            throw new Error("Tokenising the '".concat(content, "' content results in more than one token."));
+        }
+        var firstToken = first(tokens), token = firstToken, type = token.getType();
+        if (type !== UNASSIGNED_TYPE) {
+            throw new Error("The '".concat(type, "' type of the '").concat(content, "' token is not 'unassigned'."));
+        }
+        if (content === _constants.UNDERSCORE_CHARACTER) {
+            throw new Error("The '".concat(content, "' token cannot be an underscore."));
+        }
+    });
+}
+function nameFromRuleNameTerminalNode(ruleNameTerminalNode) {
+    var name;
+    var content = ruleNameTerminalNode.getContent();
+    name = content; ///
+    return name;
+}
+function contentFromStringLiteralTerminalNode(stringLiteralTerminalNode) {
+    var content;
+    content = stringLiteralTerminalNode.getContent();
+    var matches = content.match(/"([^"]*)"/), secondMatch = second(matches);
+    content = secondMatch; ///
+    return content;
+}
+function typeFromSignificantTokenTypeTerminalNode(significantTokenTypeTerminalNode) {
+    var type;
+    var content = significantTokenTypeTerminalNode.getContent(), matches = content.match(/\[([^\]]*)\]/), secondMatch = second(matches);
+    type = secondMatch; ///
+    return type;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/validate.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport typesMap from \"../typesMap\";\n\nimport { nominalLexer } from \"../utilities/nominal\";\nimport { UNDERSCORE_CHARACTER } from \"../constants\";\nimport { nodeQuery, nodesQuery } from \"../utilities/query\";\nimport { customGrammarBNFLexer, customGrammarBNFParser, customGrammarVocabularyLexer, customGrammarVocabularyParser } from \"../utilities/grammar\";\n\nconst { first, second } = arrayUtilities;\n\nconst expressionNodesQuery = nodesQuery(\"//expression\"),\n      ruleNameTerminalNodeQuery = nodeQuery(\"/document/rule/name/@*!\"),\n      stringLiteralTerminalNodesQuery = nodesQuery(\"//stringLiteral/@*!\"),\n      significantTokenTypeTerminalNodesQuery = nodesQuery(\"//significantTokenType/@*!\");\n\nexport function validateBNF(bnf, ruleName) {\n  const content = bnf,\n        tokens = customGrammarBNFLexer.tokenise(content),\n        node = customGrammarBNFParser.parse(tokens);\n\n  if (node === null) {\n    return;\n  }\n\n  const ruleNameTerminalNode = ruleNameTerminalNodeQuery(node);\n\n  if (ruleNameTerminalNode !== null) {\n    const name = nameFromRuleNameTerminalNode(ruleNameTerminalNode);\n\n    if (name !== ruleName) {\n      throw new Error(`The '${name}' rule should be named '${ruleName}'.`);\n    }\n  }\n\n  const types = typesMap[ruleName],\n        significantTokenTypeTerminalNodes = significantTokenTypeTerminalNodesQuery(node);\n\n  significantTokenTypeTerminalNodes.forEach((significantTokenTypeTerminalNode) => {\n    const type = typeFromSignificantTokenTypeTerminalNode(significantTokenTypeTerminalNode),\n          typesIncludeType = types.includes(type);\n\n    if (!typesIncludeType) {\n      throw new Error(`The '${type}' type is not included in the '${ruleName}' rule's types.`)\n    }\n  });\n\n  const stringLiteralTerminalNodes = stringLiteralTerminalNodesQuery(node);\n\n  stringLiteralTerminalNodes.forEach((stringLiteralTerminalNode) => {\n    const content = contentFromStringLiteralTerminalNode(stringLiteralTerminalNode);\n\n    if (content === UNDERSCORE_CHARACTER) {\n      throw new Error(`The \"${content}\" string literal cannot be an underscore.`);\n    }\n\n    const tokens = nominalLexer.tokenise(content),\n          tokensLength = tokens.length;\n\n    if (tokensLength !== 1) {\n      throw new Error(`Tokenising the \"${content}\" string literal does not result in a single token.`);\n    }\n\n    const firstToken = first(tokens),\n          token = firstToken, ///\n          type = token.getType(),\n          typesIncludeType = types.includes(type);\n\n    if (!typesIncludeType) {\n      throw new Error(`The \"${content}\" string literal's token's '${type}' type is not included in the '${ruleName}' rule's types.`)\n    }\n  });\n}\n\nexport function validateVocabulary(vocabulary) {\n  const content = vocabulary, ///\n        tokens = customGrammarVocabularyLexer.tokenise(content),\n        node = customGrammarVocabularyParser.parse(tokens);\n\n  if (node === null) {\n    return;\n  }\n\n  const expressionNodes = expressionNodesQuery(node);\n\n  expressionNodes.forEach((expressionNode) => {\n    const content = contentFromExpressionNode(expressionNode),\n          tokens = nominalLexer.tokenise(content),\n          tokensLength = tokens.length;\n\n    if (tokensLength > 1) {\n      throw new Error(`Tokenising the '${content}' content results in more than one token.`);\n    }\n\n    const firstToken = first(tokens),\n          token = firstToken,\n          type = token.getType();\n\n    if (type !== UNASSIGNED_TYPE) {\n      throw new Error(`The '${type}' type of the '${content}' token is not 'unassigned'.`);\n    }\n\n    if (content === UNDERSCORE_CHARACTER) {\n      throw new Error(`The '${content}' token cannot be an underscore.`);\n    }\n  });\n}\n\nfunction nameFromRuleNameTerminalNode(ruleNameTerminalNode) {\n  let name;\n\n  const content = ruleNameTerminalNode.getContent();\n\n  name = content; ///\n\n  return name;\n}\n\nfunction contentFromStringLiteralTerminalNode(stringLiteralTerminalNode) {\n  let content;\n\n  content = stringLiteralTerminalNode.getContent();\n\n  const matches = content.match(/\"([^\"]*)\"/),\n        secondMatch = second(matches);\n\n  content = secondMatch; ///\n\n  return content;\n}\n\nfunction typeFromSignificantTokenTypeTerminalNode(significantTokenTypeTerminalNode) {\n  let type;\n\n  const content = significantTokenTypeTerminalNode.getContent(),\n        matches = content.match(/\\[([^\\]]*)\\]/),\n        secondMatch = second(matches);\n\n  type = secondMatch; ///\n\n  return type;\n}\n"],"names":["validateBNF","validateVocabulary","first","arrayUtilities","second","expressionNodesQuery","nodesQuery","ruleNameTerminalNodeQuery","nodeQuery","stringLiteralTerminalNodesQuery","significantTokenTypeTerminalNodesQuery","bnf","ruleName","content","tokens","customGrammarBNFLexer","tokenise","node","customGrammarBNFParser","parse","ruleNameTerminalNode","name","nameFromRuleNameTerminalNode","Error","types","typesMap","significantTokenTypeTerminalNodes","forEach","significantTokenTypeTerminalNode","type","typeFromSignificantTokenTypeTerminalNode","typesIncludeType","includes","stringLiteralTerminalNodes","stringLiteralTerminalNode","contentFromStringLiteralTerminalNode","UNDERSCORE_CHARACTER","nominalLexer","tokensLength","length","firstToken","token","getType","vocabulary","customGrammarVocabularyLexer","customGrammarVocabularyParser","expressionNodes","expressionNode","contentFromExpressionNode","UNASSIGNED_TYPE","getContent","matches","match","secondMatch"],"mappings":"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"}

package/lib/utilities/vocabulary.js

@@ -2,60 +2,23 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get expressionsFromVocabulary () {
+Object.defineProperty(exports, "expressionsFromVocabulary", {
+    enumerable: true,
+    get: function() {
         return expressionsFromVocabulary;
-    },
-    get validateVocabulary () {
-        return validateVocabulary;
     }
 });
-var _occamlexers = require("occam-lexers");
-var _occamgrammars = require("occam-grammars");
 var _necessary = require("necessary");
 var _query = require("../utilities/query");
-var _constants = require("../constants");
-var errorNodesQuery = (0, _query.nodesQuery)("//error"), expressionNodesQuery = (0, _query.nodesQuery)("//expression");
-var nominalLexer = _occamlexers.CommonLexer.fromNothing(_occamgrammars.NominalLexer), customGrammarVocabularyLexer = _occamgrammars.CustomGrammarVocabularyLexer.fromNothing(), customGrammarVocabularyParser = _occamgrammars.CustomGrammarVocabularyParser.fromNothing();
-var first = _necessary.arrayUtilities.first, second = _necessary.arrayUtilities.second;
-function validateVocabulary(vocabulary) {
-    if (vocabulary === null || vocabulary === _constants.EMPTY_STRING) {
-        return;
-    }
-    var content = vocabulary, tokens = customGrammarVocabularyLexer.tokenise(content), node = customGrammarVocabularyParser.parse(tokens);
-    if (node === null) {
-        throw new Error("The vocabulary cannot be parsed.");
-    }
-    var errorNodes = errorNodesQuery(node), errorNodesLength = errorNodes.length;
-    if (errorNodesLength > 0) {
-        throw new Error("The vocabulary contains errors.");
-    }
-    var expressionNodes = expressionNodesQuery(node);
-    expressionNodes.forEach(function(expressionNode) {
-        var content = contentFromExpressionNode(expressionNode), tokens = nominalLexer.tokenise(content), tokensLength = tokens.length;
-        if (tokensLength > 1) {
-            throw new Error("Tokenising '".concat(content, "' results in more than one token."));
-        }
-        var firstToken = first(tokens), token = firstToken, type = token.getType();
-        if (type !== _constants.UNASSIGNED_TYPE) {
-            throw new Error("The '".concat(type, "' type of the '").concat(content, "' token is not 'unassigned'."));
-        }
-        if (content === _constants.UNDERSCORE_CHARACTER) {
-            throw new Error("The '".concat(content, "' token cannot be an underscore."));
-        }
-    });
-}
+var _grammar = require("../utilities/grammar");
+var second = _necessary.arrayUtilities.second;
+var expressionNodesQuery = (0, _query.nodesQuery)("//expression");
 function expressionsFromVocabulary(vocabulary, expressions) {
-    if (vocabulary === null || vocabulary === _constants.EMPTY_STRING) {
+    var content = vocabulary, tokens = _grammar.customGrammarVocabularyLexer.tokenise(content), node = _grammar.customGrammarVocabularyParser.parse(tokens);
+    if (node === null) {
         return;
     }
-    var content = vocabulary, tokens = customGrammarVocabularyLexer.tokenise(content), node = customGrammarVocabularyParser.parse(tokens), expressionNodes = expressionNodesQuery(node);
+    var expressionNodes = expressionNodesQuery(node);
     expressionNodes.forEach(function(expressionNode) {
         var content = contentFromExpressionNode(expressionNode), expression = content; ///
         expressions.push(expression);
@@ -66,4 +29,4 @@ function contentFromExpressionNode(expressionNode) {
     return content;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-custom-grammars",
   "author": "James Smith",
-  "version": "5.0.1228",
+  "version": "5.0.1230",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-custom-grammars",
   "description": "Occam's custom grammars.",
@@ -14,7 +14,7 @@
     "occam-grammar-utilities": "^8.0.345",
     "occam-grammars": "^1.3.311",
     "occam-lexers": "^23.1.1",
-    "occam-parsers": "^23.1.1",
+    "occam-parsers": "^23.1.3",
     "occam-query": "^4.1.109"
   },
   "devDependencies": {

package/src/constants.js

@@ -2,5 +2,10 @@
 
 export const EMPTY_STRING = "";
 export const VERTICAL_BAR = "|";
+export const VERTICAL_SPACE = `
+
+`
 export const UNASSIGNED_TYPE = "unassigned";
+export const STUFF_RULE_NAME = "stuff";
+export const NONSENSE_RULE_NAME = "nonsense";
 export const UNDERSCORE_CHARACTER = "_";

package/src/customGrammar/combined.js

@@ -1,17 +1,21 @@
 "use strict";
 
 import { arrayUtilities } from "necessary";
+import { specialSymbols } from "occam-lexers";
 import { parserUtilities } from "occam-parsers";
 import { eliminateLeftRecursion } from "occam-grammar-utilities";
 
 import defaultCustomGrammar from "../customGrammar/default";
 
-import { EMPTY_STRING, VERTICAL_BAR } from "../constants";
-import { validateVocabulary, expressionsFromVocabulary } from "../utilities/vocabulary";
+import { expressionsFromVocabulary } from "../utilities/vocabulary";
+import { VERTICAL_BAR, VERTICAL_SPACE } from "../constants";
+import { validateBNF, validateVocabulary } from "../utilities/validate";
+import { TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
 import { TYPE_VOCABULARY_NAME, SYMBOL_VOCABULARY_NAME } from "../vocabularyNames";
 
-const { rulesFromBNF } = parserUtilities,
-      { unshift, backwardsForEach } = arrayUtilities;
+const { opaque  } = specialSymbols,
+      { rulesFromBNF } = parserUtilities,
+      { unshift, forwardsForEach, backwardsForEach } = arrayUtilities;
 
 export default class CombinedCustomGrammar {
   constructor(rules, entries) {
@@ -45,7 +49,7 @@ export default class CombinedCustomGrammar {
       customGrammars = [ defaultCustomGrammar, ...customGrammars ]; ///
     }
 
-    const rules = rulesFromCustomGrammarsAndDefaultBNF(customGrammars),
+    const rules = rulesFromCustomGrammars(customGrammars),
           entries = entriesFromCustomGrammars(customGrammars),
           combinedCustomGrammar = new CombinedCustomGrammar(rules, entries);
 
@@ -57,7 +61,7 @@ export default class CombinedCustomGrammar {
       customGrammars = [ defaultCustomGrammar, ...customGrammars ]; ///
     }
 
-    const rules = rulesFromCustomGrammarsAndDefaultBNF(customGrammars),
+    const rules = rulesFromCustomGrammars(customGrammars),
           entries = entriesFromCustomGrammars(customGrammars),
           combinedCustomGrammar = new CombinedCustomGrammar(rules, entries);
     
@@ -65,16 +69,34 @@ export default class CombinedCustomGrammar {
   }
 }
 
-function rulesFromCustomGrammarsAndDefaultBNF(customGrammars) {
-  const bnfs = customGrammars.map((customGrammar) => {
-          const bnf = customGrammar.getBNF();
+function rulesFromCustomGrammars(customGrammars) {
+  const ruleNames = [
+          TERM_RULE_NAME,
+          STATEMENT_RULE_NAME,
+        ],
+        bnfs = ruleNames.map((ruleName) => {
+          const bnf = bnfFromCustomGrammars(customGrammars, ruleName);
 
           return bnf;
         }),
-        bnf = bnfs.join(EMPTY_STRING),
+        bnf = bnfs.join(VERTICAL_SPACE),
         rules = rulesFromBNF(bnf);
 
-  combineRules(rules)
+  combineRules(rules);
+
+  const opacity = opaque; ///
+
+  ruleNames.forEach((ruleName) => {
+    const rule = rules.find((rule) => {
+      const name = rule.getName();
+
+      if (name === ruleName) {
+        return true;
+      }
+    });
+
+    rule.setOpacity(opacity);
+  });
 
   return rules;
 }
@@ -117,6 +139,25 @@ function entryFromCustomGrammars(customGrammars, vocabularyName) {
   return entry;
 }
 
+function bnfFromCustomGrammars(customGrammars, ruleName) {
+  const bnfs = [];
+
+  forwardsForEach(customGrammars, (customGrammar) => {
+    const bnf = customGrammar.getBNF(ruleName),
+          customGrammarDefaultCustomGrammar = customGrammar.isDefaultCustomGrammar();
+
+    if (!customGrammarDefaultCustomGrammar) {
+      validateBNF(bnf, ruleName);
+    }
+
+    bnfs.push(bnf);
+  });
+
+  const bnf = bnfs.join(VERTICAL_SPACE);
+
+  return bnf;
+}
+
 function combineRules(rules) {
   let outerIndex = 0,
       length = rules.length;

package/src/customGrammar/default.js

@@ -4,13 +4,13 @@ import CustomGrammar from "../customGrammar";
 
 import { DEFAULT_CUSTOM_GRAMMAR_NAME } from "../grammarNames";
 
-export const termBNF = `term.                                ::=  "(" argument ")"
+export const termBNF = `term                                 ::=  "(" argument ")"
 
                                        |  variable 
                                        
                                        ;`;
 
-export const statementBNF = `statement.                           ::=  "(" metaArgument ")" 
+export const statementBNF = `statement                            ::=  "(" metaArgument ")" 
                                                   
                                        |  equality
 

package/src/customGrammar.js

@@ -34,34 +34,12 @@ export default class CustomGrammar {
     return this.symbolVocabulary;
   }
 
-  getBNF(ruleName = null) {
+  getBNF(ruleName) {
     let bnf;
 
     switch (ruleName) {
       case TERM_RULE_NAME: bnf = this.termBNF; break;
       case STATEMENT_RULE_NAME: bnf = this.statementBNF; break;
-
-      default: {
-        const ruleNames = [
-                TERM_RULE_NAME,
-                STATEMENT_RULE_NAME
-              ],
-              combinedBNF = ruleNames.reduce((combinedBNF, ruleName) => {
-                const bnf = this.getBNF(ruleName);
-
-                if (bnf !== EMPTY_STRING) {
-                  combinedBNF = `${combinedBNF}
-            
-${bnf}`;
-                }
-
-                return combinedBNF;
-              }, EMPTY_STRING);
-
-        bnf = combinedBNF;  ///
-
-        break;
-      }
     }
 
     return bnf;

package/src/example/view.js

@@ -30,7 +30,7 @@ const { rulesAsString } = rulesUtilities,
 
 class View extends Element {
   keyUpHandler = (event, element) => {
-    try {
+    // try {
       const bnf = this.getBNF(),
             name = this.getName(),
             ruleName = this.getRuleName(),
@@ -78,13 +78,13 @@ class View extends Element {
             nominalBNF = rulesString;  ///
 
       this.setNominalBNF(nominalBNF);
-    } catch (error) {
-      console.log(error);
-
-      this.clearParseTree();
-
-      this.clearNominalBNF();
-    }
+    // } catch (error) {
+    //   console.log(error);
+    //
+    //   this.clearParseTree();
+    //
+    //   this.clearNominalBNF();
+    // }
   }
 
   changeHandler = (event, element) => {
@@ -132,16 +132,16 @@ class View extends Element {
               Custom grammar
             </SubHeading>
             <NameSelect onChange={changeHandler} />
-            <SubHeading>
-              BNF
-            </SubHeading>
-            <RuleNameSelect onChange={changeHandler} />
-            <BNFTextarea onKeyUp={keyUpHandler} />
             <SubHeading>
               Vocabulary
             </SubHeading>
             <VocabularyNameSelect onChange={changeHandler} />
             <VocabularyTextarea onKeyUp={keyUpHandler} />
+            <SubHeading>
+              BNF
+            </SubHeading>
+            <RuleNameSelect onChange={changeHandler} />
+            <BNFTextarea onKeyUp={keyUpHandler} />
             <SubHeading>
               Start rule
             </SubHeading>

package/src/typesMap.js

@@ -0,0 +1,50 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import { nominalParser } from "./utilities/nominal";
+import { TERM_RULE_NAME, STATEMENT_RULE_NAME } from "./ruleNames";
+import { STUFF_RULE_NAME, NONSENSE_RULE_NAME } from "./constants";
+
+const { first } = arrayUtilities;
+
+const ruleMap = nominalParser.getRuleMap(),
+      stuffRule = ruleMap[STUFF_RULE_NAME],
+      nonsenseRule = ruleMap[NONSENSE_RULE_NAME],
+      stuffTypes = typesFromRule(stuffRule),
+      nonsenseTypes = typesFromRule(nonsenseRule),
+      termTypes = stuffTypes, ///
+      statementTypes = nonsenseTypes,
+      typesMap = {
+        [TERM_RULE_NAME]: termTypes,
+        [STATEMENT_RULE_NAME]: statementTypes
+      };
+
+export default typesMap;
+
+function typesFromRule(rule) {
+  let parts;
+
+  const definitions = rule.getDefinitions(),
+        firstDDefinition = first(definitions),
+        definition = firstDDefinition;  ///
+
+  parts = definition.getParts();
+
+  const firstPart = first(parts),
+        oneOrMorePartsPart = firstPart, ///
+        part = oneOrMorePartsPart.getPart(),
+        choiceOrPartsPart = part; ///
+
+  parts = choiceOrPartsPart.getParts();
+
+  const types = parts.map((part) => {
+    const significantTokenTypePart = part,  ///
+          significantTokenType = significantTokenTypePart.getSignificantTokenType(),
+          type = significantTokenType;  ///
+
+    return type;
+  });
+
+  return types;
+}

package/src/utilities/grammar.js

@@ -0,0 +1,12 @@
+"use strict";
+
+import { CustomGrammarBNFLexer, CustomGrammarBNFParser } from "occam-grammars";
+import { CustomGrammarVocabularyLexer, CustomGrammarVocabularyParser } from "occam-grammars";
+
+export const customGrammarBNFLexer = CustomGrammarBNFLexer.fromNothing();
+
+export const customGrammarBNFParser = CustomGrammarBNFParser.fromNothing();
+
+export const customGrammarVocabularyLexer = CustomGrammarVocabularyLexer.fromNothing();
+
+export const customGrammarVocabularyParser = CustomGrammarVocabularyParser.fromNothing();

package/src/utilities/nominal.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import { CommonLexer } from "occam-lexers";
+import { CommonParser } from "occam-parsers";
+import { NominalLexer, NominalParser } from "occam-grammars";
+
+export const nominalLexer = CommonLexer.fromNothing(NominalLexer);
+
+export const nominalParser = CommonParser.fromNothing(NominalParser);