occam-verify-cli 1.0.192 → 1.0.199

package/src/dom/assertion/property.js

@@ -103,10 +103,9 @@ export default domAssigned(class PropertyAssertion {
   verifyTerm(assignments, stated, context) {
     let termVerified;
 
-    const termString = this.term.getString(),
-          propertyAssertionString = this.string; ///
+    const termString = this.term.getString();
 
-    context.trace(`Verifying the '${propertyAssertionString}' property assertion's '${termString}' term...`);
+    context.trace(`Verifying the '${termString}' term...`);
 
     termVerified = this.term.verify(context, () => {
       const verifiedAhead = true;
@@ -115,7 +114,7 @@ export default domAssigned(class PropertyAssertion {
     });
 
     if (termVerified) {
-      context.debug(`...verified the '${propertyAssertionString}' property assertion's '${termString}' term.`);
+      context.debug(`...verified the '${termString}' term.`);
     }
 
     return termVerified;
@@ -124,15 +123,14 @@ export default domAssigned(class PropertyAssertion {
   verifyPropertyRelation(assignments, stated, context) {
     let propertyRelationVerified;
 
-    const propertyRelationString = this.propertyRelation.getString(),
-          propertyAssertionString = this.string; ///
+    const propertyRelationString = this.propertyRelation.getString();
 
-    context.trace(`Verifying the '${propertyAssertionString}' property assertion's '${propertyRelationString}' property relation...`);
+    context.trace(`Verifying the '${propertyRelationString}' property relation...`);
 
     propertyRelationVerified = this.propertyRelation.verify(context);
 
     if (propertyRelationVerified) {
-      context.debug(`...verified the '${propertyAssertionString}' property assertion's '${propertyRelationString}' property relation.`);
+      context.debug(`...verified the '${propertyRelationString}' property relation.`);
     }
 
     return propertyRelationVerified;

package/src/dom/assertion/satisfies.js

@@ -3,10 +3,6 @@
 import dom from "../../dom";
 
 import { domAssigned } from "../../dom";
-import { nodeQuery, nodesQuery } from "../../utilities/query";
-
-const termNodesQuery = nodesQuery("/satisfiesAssertion/term"),
-      satisfiesAssertionNodeQuery = nodeQuery("/statement/satisfiesAssertion");
 
 export default domAssigned(class SatisfiesAssertion {
   constructor(string, node, tokens, terms, reference) {
@@ -107,10 +103,9 @@ export default domAssigned(class SatisfiesAssertion {
   verifyReference(assignments, stated, context) {
     let referenceVerified = false;
 
-    const referenceString = this.reference.getString(),
-          satisfiesAssertionString = this.string; ///
+    const referenceString = this.reference.getString();
 
-    context.trace(`Verifying the '${satisfiesAssertionString}' satisfies assertion's '${referenceString}' reference...`);
+    context.trace(`Verifying the '${referenceString}' reference...`);
 
     const axiom = context.findAxiomByReference(this.reference, context);
 
@@ -123,7 +118,7 @@ export default domAssigned(class SatisfiesAssertion {
     }
 
     if (referenceVerified) {
-      context.debug(`...verified the '${satisfiesAssertionString}' satisfies assertion's '${referenceString}' reference.`);
+      context.debug(`...verified the '${referenceString}' reference.`);
     }
 
     return referenceVerified;
@@ -134,7 +129,7 @@ export default domAssigned(class SatisfiesAssertion {
   static fromStatementNode(statementNode, context) {
     let satisfiesAssertion = null;
 
-    const satisfiesAssertionNode = satisfiesAssertionNodeQuery(statementNode);
+    const satisfiesAssertionNode = statementNode.getSatisfiedAssertionNode();
 
     if (satisfiesAssertionNode !== null) {
       const { Reference } = dom,
@@ -166,7 +161,7 @@ function termsStringFromTerms(terms) {
 }
 
 function termsFromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
-  const termNodes = termNodesQuery(satisfiesAssertionNode),
+  const termNodes = satisfiesAssertionNode.getTermNodes(),
         terms = termNodes.map((termNode) => {
           const { Term } = dom,
                 term = Term.fromTermNode(termNode, context);

package/src/dom/declaration/complexType.js

@@ -3,7 +3,7 @@
 import dom from "../../dom";
 
 import { domAssigned } from "../../dom";
-import { stringFromTypeNameNameAndSuperTypes } from "../../utilities/type";
+import { superTypesStringFromSuperTypes, stringFromTypeNameNameAndSuperTypes } from "../../utilities/type";
 
 export default domAssigned(class ComplexTypeDeclaration {
   constructor(fileContext, string, type) {
@@ -160,7 +160,7 @@ export default domAssigned(class ComplexTypeDeclaration {
       this.fileContext.debug(`The '${propertyString}' property appears more than once.`);
     } else {
       const superTypeProperty = superTypeProperties.find((superTypeProperty) => {
-        const propertyNameMatches = superTypeProperty.matchPropertyNames(propertyNames);
+        const propertyNameMatches = superTypeProperty.matchPropertyName(propertyName);
 
         if (propertyNameMatches) {
           return true;

package/src/dom/declaration/constructor.js

@@ -78,10 +78,9 @@ export default domAssigned(class ConstructorDeclaration {
     type = this.constructor.getType();
 
     const typeName = type.getName(),
-          typeString = type.getString(),
-          constructorString = this.constructor.getString();
+          typeString = type.getString();
 
-    this.fileContext.trace(`Verifying the '${constructorString}' constructor's '${typeString}' type...`);
+    this.fileContext.trace(`Verifying the '${typeString}' type...`);
 
     const includeSupertypes = false,
           provisional = type.isProvisional(includeSupertypes);
@@ -91,14 +90,14 @@ export default domAssigned(class ConstructorDeclaration {
     const typePresent = (type !== null)
 
     if (!typePresent) {
-      this.fileContext.debug(`The '${constructorString}' constructor's '${typeString}' type is not present.`);
+      this.fileContext.debug(`The '${typeString}' type is not present.`);
     } else {
       const provisionalMatches = type.matchProvisional(provisional);
 
       if (!provisionalMatches) {
         provisional ?
-          this.fileContext.debug(`The '${constructorString}' constructor's '${typeString}' type is present but it should be provisional.`) :
-            this.fileContext.debug(`The '${constructorString}' constructor's '${typeString}' type is present but it should not be provisional.`);
+          this.fileContext.debug(`The '${typeString}' type is present but it should be provisional.`) :
+            this.fileContext.debug(`The '${typeString}' type is present but it should not be provisional.`);
       } else {
         this.constructor.setType(type);
 
@@ -107,7 +106,7 @@ export default domAssigned(class ConstructorDeclaration {
     }
 
     if (constructorTypeVerified) {
-      this.fileContext.debug(`...verified the '${constructorString}' constructor's '${typeString}' type.`);
+      this.fileContext.debug(`...verified the '${typeString}' type.`);
     }
 
     return constructorTypeVerified;

package/src/dom/declaration/variable.js

@@ -80,10 +80,9 @@ export default domAssigned(class VariableDeclaration {
     type = this.variable.getType();
 
     const typeName = type.getName(),
-          typeString = type.getString(),
-          variableString = this.variable.getString();
+          typeString = type.getString();
 
-    this.fileContext.trace(`Verifying the '${variableString}' variable's '${typeString}' type...`);
+    this.fileContext.trace(`Verifying the '${typeString}' type...`);
 
     const includeSupertypes = false,
           provisional = type.isProvisional(includeSupertypes);
@@ -93,14 +92,14 @@ export default domAssigned(class VariableDeclaration {
     const typePresent = (type !== null)
 
     if (!typePresent) {
-      this.fileContext.debug(`The '${variableString}' variable's '${typeString}' type is not present.`);
+      this.fileContext.debug(`The '${typeString}' type is not present.`);
     } else {
       const provisionalMatches = type.matchProvisional(provisional);
 
       if (!provisionalMatches) {
         provisional ?
-          this.fileContext.debug(`The '${variableString}' variable's '${typeString}' type is present but it should be provisional.`) :
-            this.fileContext.debug(`The '${variableString}' variable's '${typeString}' type is present but it should not be provisional.`);
+          this.fileContext.debug(`The '${typeString}' type is present but it should be provisional.`) :
+            this.fileContext.debug(`The '${typeString}' type is present but it should not be provisional.`);
       } else {
         this.variable.setType(type);
 
@@ -109,7 +108,7 @@ export default domAssigned(class VariableDeclaration {
     }
 
     if (variableTypeVerified) {
-      this.fileContext.debug(`...verified the '${variableString}' variable's '${typeString}' type.`);
+      this.fileContext.debug(`...verified the '${typeString}' type.`);
     }
 
     return variableTypeVerified;

package/src/dom/declaration.js

@@ -85,15 +85,14 @@ export default domAssigned(class Declaration {
   verifyReference(assignments, stated, context) {
     let referenceVerified;
 
-    const referenceString = this.reference.getString(),
-          declarationString = this.string;  ///
+    const referenceString = this.reference.getString();
 
-    context.trace(`Verifying the '${declarationString}' declaration's '${referenceString}' reference...`);
+    context.trace(`Verifying the '${referenceString}' reference...`);
 
     referenceVerified = this.reference.verify(context);
 
     if (referenceVerified) {
-      context.debug(`...verified the '${declarationString}' declaration's '${referenceString}' reference.`);
+      context.debug(`...verified the '${referenceString}' reference.`);
     }
 
     return referenceVerified;
@@ -102,10 +101,9 @@ export default domAssigned(class Declaration {
   verifyStatement(assignments, stated, context) {
     let statementVerified;
 
-    const statementString = this.statement.getString(),
-          declarationString = this.string;  ///
+    const statementString = this.statement.getString();
 
-    context.trace(`Verifying the '${declarationString}' declaration's '${statementString}' statement...`);
+    context.trace(`Verifying the '${statementString}' statement...`);
 
     stated = true;  ///
 
@@ -114,7 +112,7 @@ export default domAssigned(class Declaration {
     statementVerified = this.statement.verify(assignments, stated, context);
 
     if (statementVerified) {
-      context.debug(`...verified the '${declarationString}' declaration's '${statementString}' statement.`);
+      context.debug(`...verified the '${statementString}' statement.`);
     }
 
     return statementVerified;
@@ -174,10 +172,9 @@ export default domAssigned(class Declaration {
 
     const context = generalContext,  ///
           statementString = statement.getString(),
-          declarationString = this.string,  ///
           declarationStatementString = this.statement.getString();
 
-    context.trace(`Unifying the '${statementString}' statement with the '${declarationString}' declaration's '${declarationStatementString}' statement...`);
+    context.trace(`Unifying the '${statementString}' statement with the '${declarationStatementString}' statement...`);
 
     const generalStatement = this.statement,
           specificStatement = statement,  ///
@@ -186,7 +183,7 @@ export default domAssigned(class Declaration {
     statementUnified = statementUUnifiedIntrinsically;  ///
 
     if (statementUnified) {
-      context.debug(`...unified the '${statementString}' statement with the '${declarationString}' declaration's '${declarationStatementString}' statement.`);
+      context.debug(`...unified the '${statementString}' statement with the '${declarationStatementString}' statement.`);
     }
 
     return statementUnified;
@@ -197,17 +194,16 @@ export default domAssigned(class Declaration {
 
     const context = generalContext, ///
           labelString = label.getString(),
-          referenceString = this.reference.getString(),
-          declarationString = this.string;  ///
+          referenceString = this.reference.getString();
 
-    context.trace(`Unifying the '${labelString}' label with the '${declarationString}' declaration's '${referenceString}' reference...`);
+    context.trace(`Unifying the '${labelString}' label with the '${referenceString}' reference...`);
 
     const labelUnified = this.reference.unifyLabel(label, substitutions, context);
 
     labelUnifiedWithReference = labelUnified; ///
 
     if (labelUnifiedWithReference) {
-      context.debug(`...unified the '${labelString}' label with the '${declarationString}' declaration's '${referenceString}' reference.`);
+      context.debug(`...unified the '${labelString}' label with the '${referenceString}' reference.`);
     }
 
     return labelUnifiedWithReference;

package/src/dom/frame.js

@@ -214,10 +214,9 @@ export default domAssigned(class Frame {
       const sOrNothing = (declarationsLength > 1) ?
                            S :
                              NOTHING,
-            frameString = this.string,  ///
             declarationsString = declarationsStringFromDeclarations(this.declarations);
 
-      context.trace(`Verifying the '${frameString}' frame's '${declarationsString}' declaration${sOrNothing}...`);
+      context.trace(`Verifying the '${declarationsString}' declaration${sOrNothing}...`);
 
       stated = true;  ///
 
@@ -230,7 +229,7 @@ export default domAssigned(class Frame {
       });
 
       if (declarationsVerified) {
-        context.debug(`...verified the '${frameString}' frame's '${declarationsString}' declaration${sOrNothing}.`);
+        context.debug(`...verified the '${declarationsString}' declaration${sOrNothing}.`);
       }
     }
 
@@ -246,10 +245,9 @@ export default domAssigned(class Frame {
       const sOrNothing = (metavariablesLength > 1) ?
                            S :
                              NOTHING,
-            frameString = this.string,  ///
             metavariablesString = metavariablesStringFromMetavariables(this.metavariables);
 
-      context.trace(`Verifying the '${frameString}' frame's '${metavariablesString}' metavariable${sOrNothing}...`);
+      context.trace(`Verifying the '${metavariablesString}' metavariable${sOrNothing}...`);
 
       metavariablesVerified = this.metavariables.every((metavariable) => {
         const metavariableVerified = metavariable.verify(context);
@@ -258,7 +256,7 @@ export default domAssigned(class Frame {
       });
 
       if (metavariablesVerified) {
-        context.debug(`...verified the '${frameString}' frame's '${metavariablesString}' metavariable${sOrNothing}.`);
+        context.debug(`...verified the '${metavariablesString}' metavariable${sOrNothing}.`);
       }
     }
 

package/src/dom/judgement.js

@@ -70,15 +70,14 @@ export default domAssigned(class Judgement {
   verifyFrame(assignments, stated, context) {
     let frameVerified;
 
-    const frameString = this.frame.getString(),
-          judgementString = this.string;  ///
+    const frameString = this.frame.getString();
 
-    context.trace(`Verifying the '${judgementString}' judgement's '${frameString}' frame...`);
+    context.trace(`Verifying the '${frameString}' frame...`);
 
     frameVerified = this.frame.verify(assignments, stated, context);
 
     if (frameVerified) {
-      context.debug(`...verified the '${judgementString}' judgement's '${frameString}' frame.`);
+      context.debug(`...verified the '${frameString}' frame.`);
     }
 
     return frameVerified;
@@ -87,15 +86,14 @@ export default domAssigned(class Judgement {
   verifyDeclaration(assignments, stated, context) {
     let declarationVerified;
 
-    const judgementString = this.string,  ///
-          declarationString = this.declaration.getString();
+    const declarationString = this.declaration.getString();
 
-    context.trace(`Verifying the '${judgementString}' judgement's '${declarationString}' declaration...`);
+    context.trace(`Verifying the '${declarationString}' declaration...`);
 
     declarationVerified = this.declaration.verify(assignments, stated, context);
 
     if (declarationVerified) {
-      context.debug(`...verified the '${judgementString}' judgement's '${declarationString}' declaration.`);
+      context.debug(`...verified the '${declarationString}' declaration.`);
     }
 
     return declarationVerified;

package/src/dom/propertyRelation.js

@@ -67,10 +67,9 @@ export default domAssigned(class PropertyRelation {
   verifyTerm(context) {
     let termVerified;
 
-    const termString = this.term.getString(),
-          propertyRelationString = this.string; ///
+    const termString = this.term.getString();
 
-    context.trace(`Verifying the '${propertyRelationString}' property relation's '${termString}' term...`);
+    context.trace(`Verifying the '${termString}' term...`);
 
     termVerified = this.term.verify(context, () => {
       const verifiedAhead = true;
@@ -79,7 +78,7 @@ export default domAssigned(class PropertyRelation {
     });
 
     if (termVerified) {
-      context.debug(`...verified the '${propertyRelationString}' property relation's '${termString}' term.`);
+      context.debug(`...verified the '${termString}' term.`);
     }
 
     return termVerified;
@@ -88,10 +87,9 @@ export default domAssigned(class PropertyRelation {
   verifyProperty(context) {
     let propertyVerified;
 
-    const propertyString = this.property.getString(),
-          propertyRelationString = this.string; ///
+    const propertyString = this.property.getString();
 
-    context.trace(`Verifying the '${propertyRelationString}' property relation's '${propertyString}' property...`);
+    context.trace(`Verifying the '${propertyString}' property...`);
 
     const termType = this.term.getType(),
           propertyName = this.property.getName(),
@@ -118,7 +116,7 @@ export default domAssigned(class PropertyRelation {
     }
 
     if (propertyVerified) {
-      context.debug(`...verified the '${propertyRelationString}' property relation's '${propertyString}' property.`);
+      context.debug(`...verified the '${propertyString}' property.`);
     }
 
     return propertyVerified;

package/src/dom/term.js

@@ -6,7 +6,6 @@ import dom from "../dom";
 import LocalContext from "../context/local";
 import verifyMixins from "../mixins/term/verify";
 
-import { nodeQuery } from "../utilities/query"
 import { domAssigned } from "../dom";
 import { termFromTermNode } from "../utilities/node";
 import { termNodeFromTermString } from "../context/partial/term";
@@ -14,8 +13,6 @@ import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
 const { filter, compress } = arrayUtilities;
 
-const containedAssertionTermNodeQuery = nodeQuery("/containedAssertion/term");
-
 export default domAssigned(class Term {
   constructor(string, node, type) {
     this.string = string;

package/src/dom/topLevelMetaAssertion.js

@@ -1,13 +1,12 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
+import dom from "../dom";
 import LocalContext from "../context/local";
-import TopLevelAssertion from "./topLevelAssertion";
+import Substitutions from "../substitutions";
 
-import { proofFromProofNode, labelsFromLabelNodes, deductionFromDeductionNode, suppositionsFromSuppositionNodes, stringFromLabelsAndDeduction } from "./topLevelAssertion";
-import { labelsFromJSON,
-         labelsToLabelsJSON,
+import { proofFromProofNode, deductionFromDeductionNode, suppositionsFromSuppositionNodes } from "./topLevelAssertion";
+import { labelFromJSON,
+         labelToLabelJSON,
          deductionFromJSON,
          suppositionsFromJSON,
          substitutionsFromJSON,
@@ -15,27 +14,47 @@ import { labelsFromJSON,
          suppositionsToSuppositionsJSON,
          substitutionsToSubstitutionsJSON } from "../utilities/json";
 
-const { first } = arrayUtilities;
-
-export default class TopLevelMetaAssertion extends TopLevelAssertion {
-  constructor(fileContext, string, labels, suppositions, deduction, proof, substitutions) {
-    super(fileContext, string, labels, suppositions, deduction, proof);
-
+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;
   }
 
-  getSubstitutions() {
-    return this.substitutions;
+  getFileContext() {
+    return this.fileContext;
+  }
+
+  getString() {
+    return this.string;
   }
 
   getLabel() {
-    const labels = this.getLabels(),
-          firstLabel = first(labels),
-          label = firstLabel; ///
+    return this.label;
+  }
 
-    return label;
+  getSuppositions() {
+    return this.suppositions;
+  }
+
+  getDeduction() {
+    return this.deduction;
+  }
+
+  getProof() {
+    return this.proof;
+  }
+
+  getSubstitutions() {
+    return this.substitutions;
   }
 
+  getStatement() { return this.deduction.getStatement(); }
+
   matchReference(reference) {
     const label = this.getLabel(),
           referenceMatches = label.matchReference(reference);
@@ -46,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) => {
@@ -78,29 +97,23 @@ export default class TopLevelMetaAssertion extends TopLevelAssertion {
   }
 
   verifyLabels() {
-    const labelsVerified = this.labels.every((label) => {
-      const nameOnly = false,
-            labelVerified = label.verify(nameOnly);
-
-      if (labelVerified) {
-        return true;
-      }
-    });
+    const nameOnly = false,
+          labelVerified = this.label.verify(nameOnly);
 
-    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
@@ -110,13 +123,13 @@ export default class TopLevelMetaAssertion extends TopLevelAssertion {
   }
 
   static fromJSON(Class, json, fileContext) {
-    const labels = labelsFromJSON(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),
-          topLevelMetaAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof, substitutions);
+          string = stringFromLabelAndDeduction(label, deduction),
+          topLevelMetaAssertion = new Class(fileContext, string, label, suppositions, deduction, proof, substitutions);
 
     return topLevelMetaAssertion;
   }
@@ -124,16 +137,47 @@ export default class TopLevelMetaAssertion extends TopLevelAssertion {
   static fromNode(Class, node, fileContext) {
     const topLevelAssertionNode = node, ///
           proofNode = topLevelAssertionNode.getProofNode(),
-          labelNodes = topLevelAssertionNode.getLabelNodes(),
+          labelNode = topLevelAssertionNode.getLabelNode(),
           deductionNode = topLevelAssertionNode.getDeductionNode(),
           suppositionNodes = topLevelAssertionNode.getSuppositionNodes(),
           proof = proofFromProofNode(proofNode, fileContext),
-          labels = labelsFromLabelNodes(labelNodes, fileContext),
+          label = labelFromLabelNode(labelNode, fileContext),
           deduction = deductionFromDeductionNode(deductionNode, fileContext),
           suppositions = suppositionsFromSuppositionNodes(suppositionNodes, fileContext),
-          string = stringFromLabelsAndDeduction(labels, deduction),
-          topLevelMetaAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof);
+          substitutions = Substitutions.fromNothing(),
+          string = stringFromLabelAndDeduction(label, deduction),
+          topLevelMetaAssertion = new Class(fileContext, string, label, suppositions, deduction, proof, substitutions);
 
     return topLevelMetaAssertion;
   }
 }
+
+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 string;
+}

package/src/dom/type.js

@@ -286,11 +286,11 @@ 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),
+          properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
           string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
           type = new Type(string, name, superTypes, properties, provisional);
 

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) {