occam-verify-cli 1.0.172 → 1.0.176

package/src/dom/term.js

@@ -7,6 +7,7 @@ import LocalContext from "../context/local";
 import verifyMixins from "../mixins/term/verify";
 
 import { domAssigned } from "../dom";
+import { termFromTermNode } from "../utilities/node";
 import { nodeQuery, nodesQuery } from "../utilities/query"
 import { termNodeFromTermString } from "../context/partial/term";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
@@ -19,8 +20,7 @@ const variableNodesQuery = nodesQuery("//variable"),
       definedAssertionTermNodeQuery = nodeQuery("/definedAssertion/term"),
       propertyRelationTermNodeQuery = nodeQuery("/propertyRelation/term"),
       propertyAssertionTermNodeQuery = nodeQuery("/propertyAssertion/term"),
-      containedAssertionTermNodeQuery = nodeQuery("/containedAssertion/term"),
-      constructorDeclarationTermNodeQuery = nodeQuery("/constructorDeclaration/term");
+      containedAssertionTermNodeQuery = nodeQuery("/containedAssertion/term");
 
 export default domAssigned(class Term {
   constructor(string, node, type) {
@@ -79,6 +79,8 @@ export default domAssigned(class Term {
     return termNodeMatches;
   }
 
+  isProvisional() { return this.type.isProvisional(); }
+
   isEqualTo(term) {
     const termString = term.getString(),
           equalTo = (termString === this.string);
@@ -282,10 +284,11 @@ export default domAssigned(class Term {
     return term;
   }
 
-  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {
+  static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {
     const { Type } = dom,
-          constructorDeclarationTermNode = constructorDeclarationTermNodeQuery(constructorDeclarationNode),
-          termNode = constructorDeclarationTermNode,  ///
+          termNode = constructorDeclarationNode.getTermNode(),
+          localContext = LocalContext.fromFileContext(fileContext),
+          context = localContext, ///
           term = termFromTermNode(termNode, context),
           type = Type.fromConstructorDeclarationNode(constructorDeclarationNode, context);
 
@@ -295,12 +298,3 @@ export default domAssigned(class Term {
   }
 });
 
-function termFromTermNode(termNode, context) {
-  const { Term } = dom,
-        node = termNode,  ///
-        string = context.nodeAsString(node),
-        type = null,
-        term = new Term(string, node, type);
-
-  return term;
-}

package/src/dom/type.js

@@ -4,25 +4,16 @@ import { arrayUtilities } from "necessary";
 
 import dom from "../dom";
 
+import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { OBJECT_TYPE_NAME } from "../typeNames";
-import { typeNameFromTypeNode } from "../utilities/name";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-import { PROVISIONAL, PROVISIONALLY } from "../constants";
+import { typeFromTypeNode } from "../utilities/node";
 import { superTypesStringFromSuperTypes } from "../utilities/type";
 import { superTypesFromJSON, propertiesFromJSON, superTypesToSuperTypesJSON, propertiesToPropertiesJSON } from "../utilities/json";
 
 const { push, first } = arrayUtilities;
 
-const typeAssertionTypeNodeQuery = nodeQuery("/typeAssertion/type"),
-      typeDeclarationTypeNodeQuery = nodeQuery("/typeDeclaration|complexTypeDeclaration/type"),
-      propertyDeclarationNodesQuery = nodesQuery("/complexTypeDeclaration/propertyDeclaration"),
-      propertyDeclarationTypeNodeQuery = nodeQuery("/propertyDeclaration/type"),
-      variableDeclarationTypeNodeQuery = nodeQuery("/variableDeclaration/type"),
-      typeDeclarationSuperTypeNodesQuery = nodesQuery("/typeDeclaration|complexTypeDeclaration/types/type"),
-      constructorDeclarationSuperTypeNodeQuery = nodeQuery("/constructorDeclaration/type"),
-      firstTypeDeclarationPrimaryKeywordTerminalNodeQuery = nodeQuery("/typeDeclaration|complexTypeDeclaration/@primary-keyword[0]"),
-      lastVariableDeclarationSecondaryKeywordTerminalNodeQuery = nodeQuery("/variableDeclaration/@secondary-keyword[-1]");
+const typeAssertionTypeNodeQuery = nodeQuery("/typeAssertion/type");
 
 class Type {
   constructor(string, name, superTypes, properties, provisional) {
@@ -100,7 +91,18 @@ class Type {
   }
 
   isBasic() {
-    const basic = basicFromSuperTypes(this.superTypes);
+    let basic = false;
+
+    const superTypesLength = this.superTypes.length;
+
+    if (superTypesLength === 1) {
+      const firstSuperType = first(this.superTypes),
+            superType = firstSuperType; ///
+
+      if (superType === objectType) {
+        basic = true;
+      }
+    }
 
     return basic;
   }
@@ -258,9 +260,10 @@ class Type {
 
   static fromTypeDeclarationNode(typeDeclarationNode, fileContext) {
     const properties = [],
-          provisional = provisionalFromTypeDeclarationNode(typeDeclarationNode, fileContext),
+          provisional = typeDeclarationNode.isProvisional(),
+          typeName = typeDeclarationNode.getTypeName(),
+          name = typeName,  ///
           superTypes = superTypesFromTypeDeclarationNode(typeDeclarationNode, fileContext),
-          name = nameFromTypeDeclarationNode(typeDeclarationNode, fileContext),
           string = stringFromNameAndSuperTypes(name, superTypes),
           type = new Type(string, name, superTypes, properties, provisional);
 
@@ -268,37 +271,36 @@ class Type {
   }
 
   static fromPropertyDeclarationNode(propertyDeclarationNode, fileContext) {
-    const propertyDeclarationTypeNode = propertyDeclarationTypeNodeQuery(propertyDeclarationNode),
-          typeNode = propertyDeclarationTypeNode, ///
+    const typeNode = propertyDeclarationNode.getTypeNode(),
           type = typeFromTypeNode(typeNode, fileContext);
 
     return type;
   }
 
-  static fromVariableDeclarationNode(variableDeclarationNode, fileContext) {
-    const properties = null,
-          superTypes = null,
-          provisional = provisionalFromVariableDeclarationNode(variableDeclarationNode, fileContext),
-          name = nameFromVariableDeclarationNode(variableDeclarationNode, fileContext),
-          string = stringFromName(name),
-          type = new Type(string, name, superTypes, properties, provisional);
+  static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {
+    let type;
 
-    return type;
-  }
+    const typeNode = constructorDeclarationNode.getTypeNode();
 
-  static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {
-    const constructorDeclarationSuperTypeNode = constructorDeclarationSuperTypeNodeQuery(constructorDeclarationNode),
-          typeNode = constructorDeclarationSuperTypeNode, ///
-          type = typeFromTypeNode(typeNode, fileContext);
+    if (typeNode === null) {
+      type = objectType;
+    } else {
+      const provisional = constructorDeclarationNode.isProvisional();
+
+      type = typeFromTypeNode(typeNode, fileContext);
+
+      type.setProvisional(provisional);
+    }
 
     return type;
   }
 
   static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
     const properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
-          provisional = provisionalFromTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
+          provisional = complexTypeDeclarationNode.isProvisional(),
+          typeName = complexTypeDeclarationNode.getTypeName(),
+          name = typeName,
           superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
-          name = nameFromComplexTypeDeclaration(complexTypeDeclarationNode, fileContext),
           string = stringFromNameAndSuperTypes(name, superTypes),
           type = new Type(string, name, superTypes, properties, provisional);
 
@@ -308,51 +310,6 @@ class Type {
 
 export default domAssigned(Type);
 
-function stringFromName(name) {
-  const string = (name !== null) ?
-                   name :
-                     OBJECT_TYPE_NAME;
-
-  return string;
-}
-
-function typeFromTypeNode(typeNode, fileContext) {
-  let type;
-
-  if (typeNode === null) {
-    type = objectType;
-  } else {
-    const { Type } = dom,
-          typeName = typeNameFromTypeNode(typeNode),
-          name = typeName,  ///
-          string = name,  ///
-          superTypes = null,
-          properties = null,
-          provisional = null;
-
-    type = new Type(string, name, superTypes, properties, provisional);
-  }
-
-  return type;
-}
-
-function basicFromSuperTypes(superTypes) {
-  let basic = false;
-
-  const superTypesLength = superTypes.length;
-
-  if (superTypesLength === 1) {
-    const firstSuperType = first(superTypes),
-          superType = firstSuperType; ///
-
-    if (superType === objectType) {
-      basic = true;
-    }
-  }
-
-  return basic;
-}
-
 function stringFromNameAndSuperTypes(name, superTypes) {
   let string;
 
@@ -369,44 +326,10 @@ function stringFromNameAndSuperTypes(name, superTypes) {
   return string;
 }
 
-function nameFromTypeDeclarationNode(typeDeclarationNode, fileContext) {
-  const typeDeclarationTypeNode = typeDeclarationTypeNodeQuery(typeDeclarationNode),
-        typeNode = typeDeclarationTypeNode, ///
-        typeName = typeNameFromTypeNode(typeNode),
-        name = typeName;  ///
-
-  return name;
-}
-
-function nameFromComplexTypeDeclaration(complexTypeDeclarationNode, fileContext) {
-  const typeDeclarationTypeNode = typeDeclarationTypeNodeQuery(complexTypeDeclarationNode),
-        typeNode = typeDeclarationTypeNode, ///
-        typeName = typeNameFromTypeNode(typeNode),
-        name = typeName;  ///
-
-  return name;
-}
-
-function nameFromVariableDeclarationNode(variableDeclarationNode, fileContext) {
-  let name = null;
-
-  const variableDeclarationTypeNode = variableDeclarationTypeNodeQuery(variableDeclarationNode);
-
-  if (variableDeclarationTypeNode !== null) {
-    const typeNode = variableDeclarationTypeNode, ///
-          typeName = typeNameFromTypeNode(typeNode);
-
-    name = typeName;  ///
-  }
-
-  return name;
-}
-
 function superTypesFromTypeDeclarationNode(typeDeclarationNode, fileContext) {
-  const typeDeclarationSuperTypeNodes = typeDeclarationSuperTypeNodesQuery(typeDeclarationNode),
-        superTypes = typeDeclarationSuperTypeNodes.map((typeDeclarationSuperTypeNode) => {
-          const superTypeNode = typeDeclarationSuperTypeNode, ///
-                superType = Type.fromTypeNode(superTypeNode, fileContext);
+  const superTypeNodes = typeDeclarationNode.getSuperTypeNodes(),
+        superTypes = superTypeNodes.map((superTypeNode) => {
+          const superType = Type.fromTypeNode(superTypeNode, fileContext);
 
           return superType;
         }),
@@ -419,35 +342,10 @@ function superTypesFromTypeDeclarationNode(typeDeclarationNode, fileContext) {
   return superTypes;
 }
 
-function provisionalFromTypeDeclarationNode(typeDeclarationNode, fileContext) {
-  const firstTypeDeclarationPrimaryKeywordTerminalNode = firstTypeDeclarationPrimaryKeywordTerminalNodeQuery(typeDeclarationNode),
-        content = firstTypeDeclarationPrimaryKeywordTerminalNode.getContent(),
-        contentProvisional = (content === PROVISIONAL),
-        provisional = contentProvisional; ///
-
-  return provisional;
-}
-
-function provisionalFromVariableDeclarationNode(variableDeclarationNode, fileContext) {
-  let provisional = false;
-
-  const lastVariableDeclarationSecondaryKeywordTerminalNode = lastVariableDeclarationSecondaryKeywordTerminalNodeQuery(variableDeclarationNode);
-
-  if (lastVariableDeclarationSecondaryKeywordTerminalNode !== null) {
-    const content = lastVariableDeclarationSecondaryKeywordTerminalNode.getContent(),
-          contentProvisional = (content === PROVISIONALLY);
-
-    provisional = contentProvisional; ///
-  }
-
-  return provisional;
-}
-
 function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
-  const typeDeclarationSuperTypeNodes = typeDeclarationSuperTypeNodesQuery(complexTypeDeclarationNode),
-        superTypes = typeDeclarationSuperTypeNodes.map((typeDeclarationSuperTypeNode) => {
-          const superTypeNode = typeDeclarationSuperTypeNode, ///
-                superType = Type.fromTypeNode(superTypeNode, fileContext);
+  const superTypeNodes = complexTypeDeclarationNode.getSuperTypeNodes(),
+        superTypes = superTypeNodes.map((superTypeNode) => {
+          const superType = Type.fromTypeNode(superTypeNode, fileContext);
 
           return superType;
         }),
@@ -461,10 +359,10 @@ function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fi
 }
 
 function propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
-  const propertyDeclarationNodes = propertyDeclarationNodesQuery(complexTypeDeclarationNode),
+  const { Property } = dom,
+        propertyDeclarationNodes = complexTypeDeclarationNode.getPropertyDeclarationNodes(),
         properties = propertyDeclarationNodes.map((propertyDeclarationNode) => {
-          const { Property } = dom,
-                property = Property.fromPropertyDeclarationNode(propertyDeclarationNode, fileContext);
+          const property = Property.fromPropertyDeclarationNode(propertyDeclarationNode, fileContext);
 
           return property;
         });
@@ -473,27 +371,9 @@ function propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fi
 }
 
 class ObjectType extends Type {
-  getProperties() {
-    const properties = [];
-
-    return properties;
-  }
-
-  // matchName(name) {
-  //   const nameMatches = ((name === null) || (name === OBJECT_TYPE_NAME));
-  //
-  //   return nameMatches;
-  // }
-  //
-  // matchTypeName(typeName) {
-  //   const typeNameMatches = ((typeName === null) || (typeName === OBJECT_TYPE_NAME));
-  //
-  //   return typeNameMatches;
-  // }
-
   static fromNothing() {
-    const name = null,
-          string = OBJECT_TYPE_NAME,  ///
+    const name = OBJECT_TYPE_NAME,
+          string = name,  ///
           superTypes = [],
           properties = [],
           provisional = false,

package/src/dom/variable.js

@@ -8,12 +8,11 @@ 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 { variableNameFromVariableNode } from "../utilities/name";
 import { variableNodeFromVariableString } from "../context/partial/variable";
 
-const termVariableNodeQuery = nodeQuery("/term/variable!"),
-      variableDeclarationVariableNodeQuery = nodeQuery("/variableDeclaration/variable");
+const termVariableNodeQuery = nodeQuery("/term/variable!");
 
 export default domAssigned(class Variable {
   constructor(string, node, name, type, propertyRelations) {
@@ -197,7 +196,7 @@ export default domAssigned(class Variable {
           context = localContext, ///
           variableString = string,  ///
           variableNode = variableNodeFromVariableString(variableString, context),
-          variableName = variableNameFromVariableNode(variableNode),
+          variableName = variableNode.getVariableName(),
           node = variableNode,
           name = variableName,  ///
           type = typeFromJSON(json, fileContext),
@@ -245,13 +244,22 @@ export default domAssigned(class Variable {
   }
 
   static fromVariableDeclarationNode(variableDeclarationNode, fileContext) {
-    const { Type } = dom,
-          variableDeclarationVariableNode = variableDeclarationVariableNodeQuery(variableDeclarationNode),
-          variableNode = variableDeclarationVariableNode, ///
+    const { Variable } = dom,
           localContext = LocalContext.fromFileContext(fileContext),
-          context = localContext, ///
-          type = Type.fromVariableDeclarationNode(variableDeclarationNode, fileContext),
-          variable = variableFromVariableNodeAndType(variableNode, type, context);
+          context = localContext,
+          provisional = variableDeclarationNode.isProvisional(),
+          typeNode = variableDeclarationNode.getTypeNode(),
+          type = typeFromTypeNode(typeNode);
+
+    type.setProvisional(provisional);
+
+    const variableNode = variableDeclarationNode.getVariableNode(),
+          variableName = variableDeclarationNode.getVariableName(),
+          node = variableNode,  ///
+          name = variableName,  ///
+          string = context.nodeAsString(node),
+          propertyRelations = [],
+          variable = new Variable(string, node, name, type, propertyRelations);
 
     return variable;
   }
@@ -281,7 +289,7 @@ export default domAssigned(class Variable {
 function variableFromVariableNodeAndType(variableNode, type, context) {
   const { Variable } = dom,
         node = variableNode,  ///
-        variableName = variableNameFromVariableNode(variableNode),
+        variableName = variableNode.getVariableName(),
         string = context.nodeAsString(node),
         name = variableName,  ///
         propertyRelations = [],

package/src/mixins/node.js

@@ -0,0 +1,201 @@
+"use strict";
+
+function fromFirstChildNode(callback) {
+  let result;
+
+  const firstIndex = 0;
+
+  this.forwardsSomeChildNode((childNode, index) => {
+    if (index === firstIndex) {
+      const firstChildNode = childNode; ///
+
+      result = callback(firstChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+function fromSecondChildNode(callback) {
+  let result;
+
+  const secondIndex = 1;
+
+  this.forwardsSomeChildNode((childNode, index) => {
+    if (index === secondIndex) {
+      const firstChildNode = childNode; ///
+
+      result = callback(firstChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+function fromThirdChildNode(callback) {
+  let result;
+
+  const thirdIndex = 2;
+
+  this.forwardsSomeChildNode((childNode, index) => {
+    if (index === thirdIndex) {
+      const thirdChildNode = childNode; ///
+
+      result = callback(thirdChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+function fromFourthChildNode(callback) {
+  let result;
+
+  const fourthIndex = 3;
+
+  this.forwardsSomeChildNode((childNode, index) => {
+    if (index === fourthIndex) {
+      const fourthChildNode = childNode; ///
+
+      result = callback(fourthChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+function fromFifthChildNode(callback) {
+  let result;
+
+  const fifthIndex = 4;
+
+  this.forwardsSomeChildNode((childNode, index) => {
+    if (index === fifthIndex) {
+      const fifthChildNode = childNode; ///
+
+      result = callback(fifthChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+function fromFirstLastChildNode(callback) {
+  let result;
+
+  const multiplicity = this.getMultiplicity(),
+        firstLastIndex = multiplicity - 1;
+
+  this.backwardsSomeChildNode((childNode, index) => {
+    if (index === firstLastIndex) {
+      const firstLastChildNode = childNode; ///
+
+      result = callback(firstLastChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+function fromSecondLastChildNode(callback) {
+  let result;
+
+  const multiplicity = this.getMultiplicity(),
+        secondLastIndex = multiplicity - 2;
+
+  this.backwardsSomeChildNode((childNode, index) => {
+    if (index === secondLastIndex) {
+      const secondLastChildNode = childNode; ///
+
+      result = callback(secondLastChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+function fromThirdLastChildNode(callback) {
+  let result;
+
+  const multiplicity = this.getMultiplicity(),
+        thirdLastIndex = multiplicity - 3;
+
+  this.backwardsSomeChildNode((childNode, index) => {
+    if (index === thirdLastIndex) {
+      const thirdLastChildNode = childNode; ///
+
+      result = callback(thirdLastChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+function fromFourthLastChildNode(callback) {
+  let result;
+
+  const multiplicity = this.getMultiplicity(),
+        fourthLastIndex = multiplicity - 4;
+
+  this.backwardsSomeChildNode((childNode, index) => {
+    if (index === fourthLastIndex) {
+      const fourthLastChildNode = childNode; ///
+
+      result = callback(fourthLastChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+function fromFifthLastChildNode(callback) {
+  let result;
+
+  const multiplicity = this.getMultiplicity(),
+        fifthLastIndex = multiplicity - 5;
+
+  this.backwardsSomeChildNode((childNode, index) => {
+    if (index === fifthLastIndex) {
+      const fifthLastChildNode = childNode; ///
+
+      result = callback(fifthLastChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+const nodeMixins = {
+  fromFirstChildNode,
+  fromSecondChildNode,
+  fromThirdChildNode,
+  fromFourthChildNode,
+  fromFifthChildNode,
+  fromFirstLastChildNode,
+  fromSecondLastChildNode,
+  fromThirdLastChildNode,
+  fromFourthLastChildNode,
+  fromFifthLastChildNode
+};
+
+export default nodeMixins;

package/src/node/assertion/contained.js

@@ -2,4 +2,6 @@
 
 import Node from "../../node";
 
-export default class ContainedAssertionNode extends Node {}
+export default class ContainedAssertionNode extends Node {
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return Node.fromRuleNameChildNodesAndOpacity(ContainedAssertionNode, ruleName, childNodes, opacity); }
+}

package/src/node/assertion/defined.js

@@ -2,4 +2,6 @@
 
 import Node from "../../node";
 
-export default class DefinedAssertionNode extends Node {}
+export default class DefinedAssertionNode extends Node {
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return Node.fromRuleNameChildNodesAndOpacity(DefinedAssertionNode, ruleName, childNodes, opacity); }
+}

package/src/node/assertion/property.js

@@ -2,4 +2,6 @@
 
 import Node from "../../node";
 
-export default class PropertyAssertionNode extends Node {}
+export default class PropertyAssertionNode extends Node {
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return Node.fromRuleNameChildNodesAndOpacity(PropertyAssertionNode, ruleName, childNodes, opacity); }
+}

package/src/node/assertion/satisfies.js

@@ -2,4 +2,6 @@
 
 import Node from "../../node";
 
-export default class SatisfiesAssertionNode extends Node {}
+export default class SatisfiesAssertionNode extends Node {
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return Node.fromRuleNameChildNodesAndOpacity(SatisfiesAssertionNode, ruleName, childNodes, opacity); }
+}

package/src/node/assertion/subproof.js

@@ -2,4 +2,6 @@
 
 import Node from "../../node";
 
-export default class SubproofAssertionNode extends Node {}
+export default class SubproofAssertionNode extends Node {
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return Node.fromRuleNameChildNodesAndOpacity(SubproofAssertionNode, ruleName, childNodes, opacity); }
+}

package/src/node/assertion/type.js

@@ -2,4 +2,6 @@
 
 import Node from "../../node";
 
-export default class TypeAssertionNode extends Node {}
+export default class TypeAssertionNode extends Node {
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return Node.fromRuleNameChildNodesAndOpacity(TypeAssertionNode, ruleName, childNodes, opacity); }
+}

package/src/node/axiom.js

@@ -2,4 +2,6 @@
 
 import Node from "../node";
 
-export default class AxiomNode extends Node {}
+export default class AxiomNode extends Node {
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return Node.fromRuleNameChildNodesAndOpacity(AxiomNode, ruleName, childNodes, opacity); }
+}

package/src/node/combinator.js

@@ -2,4 +2,6 @@
 
 import Node from "../node";
 
-export default class CombinatorNode extends Node {}
+export default class CombinatorNode extends Node {
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return Node.fromRuleNameChildNodesAndOpacity(CombinatorNode, ruleName, childNodes, opacity); }
+}