occam-verify-cli 1.0.185 → 1.0.198

package/src/dom/topLevelMetaAssertion.js

@@ -1,16 +1,12 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import dom from "../dom";
 import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
-import TopLevelAssertion from "./topLevelAssertion";
 
-import { nodeQuery } from "../utilities/query";
-import { proofFromNode, deductionFromNode, suppositionsFromNode, stringFromLabelsAndDeduction } from "./topLevelAssertion";
-import { labelsFromJSON,
-         labelsToLabelsJSON,
+import { proofFromProofNode, deductionFromDeductionNode, suppositionsFromSuppositionNodes } from "./topLevelAssertion";
+import { labelFromJSON,
+         labelToLabelJSON,
          deductionFromJSON,
          suppositionsFromJSON,
          substitutionsFromJSON,
@@ -18,29 +14,47 @@ import { labelsFromJSON,
          suppositionsToSuppositionsJSON,
          substitutionsToSubstitutionsJSON } from "../utilities/json";
 
-const { first } = arrayUtilities;
+export default class TopLevelMetaAssertion {
+  constructor(fileContext, string, label, suppositions, deduction, proof, substitutions) {
+    this.fileContext = fileContext;
+    this.string = string;
+    this.label = label;
+    this.suppositions = suppositions;
+    this.deduction = deduction;
+    this.proof = proof;
+    this.substitutions = substitutions;
+  }
 
-const labelNodeQuery = nodeQuery("/*/parenthesisedLabel/label");
+  getFileContext() {
+    return this.fileContext;
+  }
 
-export default class TopLevelMetaAssertion extends TopLevelAssertion {
-  constructor(fileContext, string, labels, suppositions, deduction, proof, substitutions) {
-    super(fileContext, string, labels, suppositions, deduction, proof);
+  getString() {
+    return this.string;
+  }
 
-    this.substitutions = substitutions;
+  getLabel() {
+    return this.label;
   }
 
-  getSubstitutions() {
-    return this.substitutions;
+  getSuppositions() {
+    return this.suppositions;
   }
 
-  getLabel() {
-    const labels = this.getLabels(),
-          firstLabel = first(labels),
-          label = firstLabel; ///
+  getDeduction() {
+    return this.deduction;
+  }
+
+  getProof() {
+    return this.proof;
+  }
 
-    return label;
+  getSubstitutions() {
+    return this.substitutions;
   }
 
+  getStatement() { return this.deduction.getStatement(); }
+
   matchReference(reference) {
     const label = this.getLabel(),
           referenceMatches = label.matchReference(reference);
@@ -51,9 +65,9 @@ export default class TopLevelMetaAssertion extends TopLevelAssertion {
   verify() {
     let verified = false;
 
-    const labelsVerified = this.verifyLabels();
+    const labelVerified = this.verifyLabels();
 
-    if (labelsVerified) {
+    if (labelVerified) {
       const localContext = LocalContext.fromFileContext(this.fileContext),
             context = localContext, ///
             suppositionsVerified = this.suppositions.every((supposition) => {
@@ -83,29 +97,23 @@ export default class TopLevelMetaAssertion extends TopLevelAssertion {
   }
 
   verifyLabels() {
-    const labelsVerified = this.labels.every((label) => {
-      const nameOnly = false,
-            labelVerified = label.verify(nameOnly);
+    const nameOnly = false,
+          labelVerified = this.label.verify(nameOnly);
 
-      if (labelVerified) {
-        return true;
-      }
-    });
-
-    return labelsVerified;
+    return labelVerified;
   }
 
   toJSON() {
-    const labelsJSON = labelsToLabelsJSON(this.labels),
+    const labelJSON = labelToLabelJSON(this.label),
           deductionJSON = deductionToDeductionJSON(this.deduction),
           suppositionsJSON = suppositionsToSuppositionsJSON(this.suppositions),
           substitutionsJSON = substitutionsToSubstitutionsJSON(this.substitutions),
-          labels = labelsJSON,  ///
+          label = labelJSON,  ///
           deduction = deductionJSON,  ///
           suppositions = suppositionsJSON,  ///
           substitutions = substitutionsJSON,  ///
           json = {
-            labels,
+            label,
             deduction,
             suppositions,
             substitutions
@@ -115,37 +123,61 @@ export default class TopLevelMetaAssertion extends TopLevelAssertion {
   }
 
   static fromJSON(Class, json, fileContext) {
-    const labels = labelsFromJSON(json, fileContext),
-          substitutions = substitutionsFromJSON(json, fileContext),
-          suppositions = suppositionsFromJSON(json, fileContext),
+    const label = labelFromJSON(json, fileContext),
           deduction = deductionFromJSON(json, fileContext),
+          suppositions = suppositionsFromJSON(json, fileContext),
+          substitutions = substitutionsFromJSON(json, fileContext),
           proof = null,
-          string = stringFromLabelsAndDeduction(labels, deduction),
-          topLevelAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof, substitutions);
+          string = stringFromLabelAndDeduction(label, deduction),
+          topLevelMetaAssertion = new Class(fileContext, string, label, suppositions, deduction, proof, substitutions);
 
-    return topLevelAssertion;
+    return topLevelMetaAssertion;
   }
 
   static fromNode(Class, node, fileContext) {
-    const labels = labelsFromNode(node, fileContext),
+    const topLevelAssertionNode = node, ///
+          proofNode = topLevelAssertionNode.getProofNode(),
+          labelNode = topLevelAssertionNode.getLabelNode(),
+          deductionNode = topLevelAssertionNode.getDeductionNode(),
+          suppositionNodes = topLevelAssertionNode.getSuppositionNodes(),
+          proof = proofFromProofNode(proofNode, fileContext),
+          label = labelFromLabelNode(labelNode, fileContext),
+          deduction = deductionFromDeductionNode(deductionNode, fileContext),
+          suppositions = suppositionsFromSuppositionNodes(suppositionNodes, fileContext),
           substitutions = Substitutions.fromNothing(),
-          suppositions = suppositionsFromNode(node, fileContext),
-          deduction = deductionFromNode(node, fileContext),
-          proof = proofFromNode(node, fileContext),
-          string = stringFromLabelsAndDeduction(labels, deduction),
-          metaLemma = new Class(fileContext, string, labels, suppositions, deduction, proof, substitutions);
+          string = stringFromLabelAndDeduction(label, deduction),
+          topLevelMetaAssertion = new Class(fileContext, string, label, suppositions, deduction, proof, substitutions);
 
-    return metaLemma;
+    return topLevelMetaAssertion;
   }
 }
 
-function labelsFromNode(node, fileContext) {
-  const { Label } = dom,
-        labelNode = labelNodeQuery(node),
-        label = Label.fromLabelNode(labelNode, fileContext),
-        labels = [
-          label
-        ];
+function labelFromLabelNode(labelNode, fileContext) {
+  let label = null;
+
+  const { Label } = dom;
+
+  if (labelNode !== null) {
+    label = Label.fromLabelNode(labelNode, fileContext);
+  }
+
+  return label;
+}
+
+function labelStringFromLabel(label) {
+  const labelsString = (label !== null) ?
+                          label.getString() :
+                            null;
+
+  return labelsString;
+}
+
+function stringFromLabelAndDeduction(label, deduction) {
+  const deductionString = deduction.getString(),
+        labelString = labelStringFromLabel(label),
+        string = (labelString === null) ?
+                    deductionString : ///
+                     `${labelString} :: ${deductionString}`;
 
-  return labels;
+  return string;
 }

package/src/dom/type.js

@@ -4,17 +4,14 @@ import { arrayUtilities } from "necessary";
 
 import dom from "../dom";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { OBJECT_TYPE_NAME } from "../typeNames";
 import { typeFromTypeNode } from "../utilities/node";
-import { superTypesStringFromSuperTypes } from "../utilities/type";
+import { stringFromTypeNameNameAndSuperTypes } from "../utilities/type";
 import { superTypesFromJSON, propertiesFromJSON, superTypesToSuperTypesJSON, propertiesToPropertiesJSON } from "../utilities/json";
 
 const { push, first } = arrayUtilities;
 
-const typeAssertionTypeNodeQuery = nodeQuery("/typeAssertion/type");
-
 class Type {
   constructor(string, name, superTypes, properties, provisional) {
     this.string = string;
@@ -108,15 +105,7 @@ class Type {
   }
 
   isEqualTo(type) {
-    let equalTo = false;
-
-    if (this.type === type) {
-      equalTo = true;
-    } else {
-      if (type.name === null) {
-
-      }
-    }
+    const equalTo = (this === type);
 
     return equalTo;
   }
@@ -224,7 +213,8 @@ class Type {
     const { name, provisional } = json,
           properties = propertiesFromJSON(json, fileContext),
           superTypes = superTypesFromJSON(json, fileContext),
-          string = stringFromNameAndSuperTypes(name, superTypes),
+          typeName = name,  ///
+          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
           type = new Type(string, name, superTypes, properties, provisional);
 
     return type;
@@ -237,8 +227,7 @@ class Type {
   }
 
   static fromTypeAssertionNode(typeAssertionNode, fileContext) {
-    const typeAssertionTypeNode = typeAssertionTypeNodeQuery(typeAssertionNode),
-          typeNode = typeAssertionTypeNode, ///
+    const typeNode = typeAssertionNode.getTypeNode(),
           type = typeFromTypeNode(typeNode, fileContext);
 
     return type;
@@ -247,10 +236,11 @@ class Type {
   static fromTypeAndProvisional(type, provisional) {
     const name = type.getName(),
           superType = type, ///
+          typeName = name,  ///
           superTypes = [
             superType
           ],
-          string = stringFromNameAndSuperTypes(name, superTypes),
+          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
           properties = type.getProperties();
 
     type = new Type(string, name, superTypes, properties, provisional);  ///
@@ -264,7 +254,7 @@ class Type {
           typeName = typeDeclarationNode.getTypeName(),
           name = typeName,  ///
           superTypes = superTypesFromTypeDeclarationNode(typeDeclarationNode, fileContext),
-          string = stringFromNameAndSuperTypes(name, superTypes),
+          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
           type = new Type(string, name, superTypes, properties, provisional);
 
     return type;
@@ -296,12 +286,12 @@ class Type {
   }
 
   static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
-    const properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
-          provisional = complexTypeDeclarationNode.isProvisional(),
+    const provisional = complexTypeDeclarationNode.isProvisional(),
           typeName = complexTypeDeclarationNode.getTypeName(),
           name = typeName,
           superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
-          string = stringFromNameAndSuperTypes(name, superTypes),
+          properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
+          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
           type = new Type(string, name, superTypes, properties, provisional);
 
     return type;
@@ -310,22 +300,6 @@ class Type {
 
 export default domAssigned(Type);
 
-function stringFromNameAndSuperTypes(name, superTypes) {
-  let string;
-
-  if (name === null) {
-    string = OBJECT_TYPE_NAME;  ///
-  } else {
-    const superTypesString = superTypesStringFromSuperTypes(superTypes);
-
-    string = (superTypesString !== null) ?
-               `${name}:${superTypesString}` :
-                  name; ///
-  }
-
-  return string;
-}
-
 function superTypesFromTypeDeclarationNode(typeDeclarationNode, fileContext) {
   const superTypeNodes = typeDeclarationNode.getSuperTypeNodes(),
         superTypes = superTypeNodes.map((superTypeNode) => {

package/src/dom/variable.js

@@ -4,16 +4,12 @@ import dom from "../dom";
 import LocalContext from "../context/local";
 import TermSubstitution from "../substitution/term";
 
-import { nodeQuery } from "../utilities/query";
-import { ObjectType } from "./type";
 import { domAssigned } from "../dom";
 import { EMPTY_STRING } from "../constants";
 import { typeFromTypeNode } from "../utilities/node";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 import { variableNodeFromVariableString } from "../context/partial/variable";
 
-const termVariableNodeQuery = nodeQuery("/term/variable!");
-
 export default domAssigned(class Variable {
   constructor(string, node, name, type, propertyRelations) {
     this.string = string;
@@ -209,10 +205,10 @@ export default domAssigned(class Variable {
   static fromTermNode(termNode, context) {
     let variable = null;
 
-    const termVariableNode = termVariableNodeQuery(termNode);
+    const singularVariableNode = termNode.getSingularVariableNode();
 
-    if (termVariableNode !== null) {
-      const variableNode = termVariableNode,  ///
+    if (singularVariableNode !== null) {
+      const variableNode = singularVariableNode,  ///
             type = null;
 
       variable = variableFromVariableNodeAndType(variableNode, type, context);
@@ -234,11 +230,7 @@ export default domAssigned(class Variable {
   }
 
   static fromVariableNodeAndType(variableNode, type, context) {
-    let variable = null;
-
-    if (variableNode !== null) {
-      variable = variableFromVariableNodeAndType(variableNode, type, context);
-    }
+    const variable = variableFromVariableNodeAndType(variableNode, type, context);
 
     return variable;
   }

package/src/equivalence.js

@@ -1,10 +1,7 @@
 "use strict";
 
-import { nodeQuery } from "./utilities/query";
 import { stripBracketsFromTermNode } from "./utilities/brackets";
 
-const variableNodeQuery = nodeQuery("/term/variable!");
-
 export default class Equivalence {
   constructor(terms) {
     this.terms = terms;
@@ -100,10 +97,10 @@ export default class Equivalence {
     const variableNodeA = variableNode, ///
           variableNodeMatches = this.someTerm((term) => {
             const termNode = term.getNode(),
-              variableNode = variableNodeQuery(termNode);
+                  singularVariableNode = termNode.getSingularVariableNode();
 
-            if (variableNode !== null) {
-              const variableNodeB = variableNode, ///
+            if (singularVariableNode !== null) {
+              const variableNodeB = singularVariableNode, ///
                     variableNodeAMatchesVariableNodeB = variableNodeA.match(variableNodeB);
 
               if (variableNodeAMatchesVariableNodeB) {

package/src/mixins/term/verify.js

@@ -2,10 +2,6 @@
 
 import dom from "../../dom";
 
-import { nodeQuery } from "../../utilities/query";
-
-const variableNodeQuery = nodeQuery("/term/variable!");
-
 function unifyWithBracketedConstructor(term, context, verifyAhead) {
   let unifiedWithBracketedConstructor;
 
@@ -39,14 +35,12 @@ function verifyTermAsVariable(term, localContext, verifyAhead) {
   const { Variable } = dom,
         context = localContext, ///
         termNode = term.getNode(),
-        variableNode = variableNodeQuery(termNode);
-
-  let variable;
-
-  variable = Variable.fromVariableNode(variableNode, context);
+        singularVariableNode = termNode.getSingularVariableNode();
 
-  if (variable !== null) {
-    const termString = term.getString();
+  if (singularVariableNode !== null) {
+    const variableNode = singularVariableNode,
+          variable = Variable.fromVariableNode(variableNode, context),
+          termString = term.getString();
 
     localContext.trace(`Verifying the '${termString}' term as a variable...`);
 

package/src/node/argument.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+import { TERM_RULE_NAME } from "../ruleNames";
+
+export default class ArgumentNode extends NonTerminalNode {
+  getSingularTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          singularTermNode = this.getSingularTNodeByRuleName(ruleName);
+
+    return singularTermNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ArgumentNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/assertion/contained.js

@@ -1,7 +1,53 @@
 "use strict";
 
-import Node from "../../node";
+import NonTerminalNode from "../../node/nonTerminal";
 
-export default class ContainedAssertionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ContainedAssertionNode, ruleName, childNodes, opacity, precedence); }
+import { MISSING } from "../../constants";
+import { TERM_RULE_NAME, FRAME_RULE_NAME, STATEMENT_RULE_NAME } from "../../ruleNames";
+
+export default class ContainedAssertionNode extends NonTerminalNode {
+  isNegated() {
+    let negated = false;
+
+    this.someChildNode((childNode) => {
+      const childNodeTerminalNode = childNode.isTerminalNode();
+
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode, ///
+              content = terminalNode.getContent(),
+              contentMessing = (content === MISSING);
+
+        if (contentMessing) {
+          negated = true;
+
+          return true;
+        }
+      }
+    });
+
+    return negated;
+  }
+
+  getTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
+
+    return termNode;
+  }
+
+  getFrameNode() {
+    const ruleName = FRAME_RULE_NAME,
+          frameNode = this.getNodeByRuleName(ruleName);
+
+    return frameNode;
+  }
+
+  getStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
+
+    return statementNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ContainedAssertionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/assertion/defined.js

@@ -1,7 +1,46 @@
 "use strict";
 
-import Node from "../../node";
+import NonTerminalNode from "../../node/nonTerminal";
 
-export default class DefinedAssertionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(DefinedAssertionNode, ruleName, childNodes, opacity, precedence); }
+import { UNDEFINED } from "../../constants";
+import { FRAME_RULE_NAME, TERM_RULE_NAME } from "../../ruleNames";
+
+export default class DefinedAssertionNode extends NonTerminalNode {
+  isNegated() {
+    let negated = false;
+
+    this.someChildNode((childNode) => {
+      const childNodeTerminalNode = childNode.isTerminalNode();
+
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode, ///
+              content = terminalNode.getContent(),
+              contentUndefined = (content === UNDEFINED);
+
+        if (contentUndefined) {
+          negated = true;
+
+          return true;
+        }
+      }
+    });
+
+    return negated;
+  }
+
+  getTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
+
+    return termNode;
+  }
+
+  getFrameNode() {
+    const ruleName = FRAME_RULE_NAME,
+          frameNode = this.getNodeByRuleName(ruleName);
+
+    return frameNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(DefinedAssertionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/assertion/property.js

@@ -1,7 +1,23 @@
 "use strict";
 
-import Node from "../../node";
+import NonTerminalNode from "../../node/nonTerminal";
 
-export default class PropertyAssertionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(PropertyAssertionNode, ruleName, childNodes, opacity, precedence); }
+import { TERM_RULE_NAME, PROPERTY_RELATION_RULE_NAME } from "../../ruleNames";
+
+export default class PropertyAssertionNode extends NonTerminalNode {
+  getTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
+
+    return termNode;
+  }
+
+  getFrameNode() {
+    const ruleName = PROPERTY_RELATION_RULE_NAME,
+          propertyRelationNode = this.getNodeByRuleName(ruleName);
+
+    return propertyRelationNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PropertyAssertionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/assertion/satisfies.js

@@ -1,7 +1,23 @@
 "use strict";
 
-import Node from "../../node";
+import NonTerminalNode from "../../node/nonTerminal";
 
-export default class SatisfiesAssertionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(SatisfiesAssertionNode, ruleName, childNodes, opacity, precedence); }
+import { TERM_RULE_NAME, METAVARIABLE_RULE_NAME } from "../../ruleNames";
+
+export default class SatisfiesAssertionNode extends NonTerminalNode {
+  getTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
+
+    return termNode;
+  }
+
+  getFrameNode() {
+    const ruleName = METAVARIABLE_RULE_NAME,
+          metavariableNode = this.getNodeByRuleName(ruleName);
+
+    return metavariableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SatisfiesAssertionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/assertion/subproof.js

@@ -1,7 +1,16 @@
 "use strict";
 
-import Node from "../../node";
+import NonTerminalNode from "../../node/nonTerminal";
 
-export default class SubproofAssertionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(SubproofAssertionNode, ruleName, childNodes, opacity, precedence); }
+import { STATEMENT_RULE_NAME } from "../../ruleNames";
+
+export default class SubproofAssertionNode extends NonTerminalNode {
+  getStatementNodes() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNodes = this.getNodesByRuleName(ruleName);
+
+    return statementNodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SubproofAssertionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/assertion/type.js

@@ -1,7 +1,23 @@
 "use strict";
 
-import Node from "../../node";
+import NonTerminalNode from "../../node/nonTerminal";
 
-export default class TypeAssertionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(TypeAssertionNode, ruleName, childNodes, opacity, precedence); }
+import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../../ruleNames";
+
+export default class TypeAssertionNode extends NonTerminalNode {
+  getTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
+
+    return termNode;
+  }
+
+  getTypeNode() {
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
+
+    return typeNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TypeAssertionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/axiom.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import Node from "../node";
+import TopLevelAssertionNode from "../node/topLevelAssertion";
 
-export default class AxiomNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(AxiomNode, ruleName, childNodes, opacity, precedence); }
+export default class AxiomNode extends TopLevelAssertionNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(AxiomNode, ruleName, childNodes, opacity, precedence); }
 }