occam-verify-cli 0.0.272 → 0.0.274

package/{bin → src}/premise.js

@@ -1,17 +1,17 @@
 "use strict";
 
-const MetaSubstitution = require("./metaSubstitution");
+import MetaSubstitution from "./metaSubstitution";
 
-const { first, second } = require("./utilities/array"),
-      { nodeQuery, nodesQuery } = require("./utilities/query"),
-      { metavariableNameFromMetavariableNode } = require("./utilities/query"),
-      { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } = require("./ruleNames");
+import { first, second } from "./utilities/array";
+import { nodeQuery, nodesQuery } from "./utilities/query";
+import { metavariableNameFromMetavariableNode } from "./utilities/query";
+import { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "./ruleNames";
 
 const metastatementNodesQuery = nodesQuery("/metaSubproofAssertion/metastatement"),
       metaSubproofAssertionNodeQuery = nodeQuery("/metastatement/metaSubproofAssertion!"),
       qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/metaSubproof/qualifiedMetastatement|unqualifiedMetastatement/metastatement!");
 
-class Premise {
+export default class Premise {
   constructor(metastatementNode) {
     this.metastatementNode = metastatementNode;
   }
@@ -66,8 +66,6 @@ class Premise {
   }
 }
 
-module.exports = Premise;
-
 function matchPremiseNode(premiseNode, node, metaSubstitutions) {
   let premiseNodeMatches = false;
 

package/{bin → src}/rule.js

@@ -1,10 +1,10 @@
 "use strict";
 
-const { prune } = require("./utilities/array"),
-      { someSubArray } = require("./utilities/array"),
-      { labelsAsString } = require("./utilities/string");
+import { prune } from "./utilities/array";
+import { someSubArray } from "./utilities/array";
+import { labelsAsString } from "./utilities/string";
 
-class Rule {
+export default class Rule {
   constructor(labels, premises, conclusion) {
     this.labels = labels;
     this.premises = premises;
@@ -24,17 +24,28 @@ class Rule {
   }
 
   matchMetastatement(metastatementNode, context) {
-    const metaAssertions = context.getMetaAssertions(),
-          premisesLength = this.premises.length,
-          matchesMetastatement = someSubArray(metaAssertions, premisesLength, (metaAssertions) => {
-            const premisesMatchConclusion = matchPremisesAndConclusion(this.premises, this.conclusion, metaAssertions, metastatementNode);
+    let metastatementNatches;
 
-            if (premisesMatchConclusion) {
-              return true;
-            }
-          });
+    const premisesLength = this.premises.length;
 
-    return matchesMetastatement;
+    if (premisesLength === 0) {
+      const metaSubstitutions = [],
+            conclusionMatches = matchConclusion(this.conclusion, metastatementNode, metaSubstitutions);
+
+      metastatementNatches = conclusionMatches; ///
+    } else {
+      const metaAssertions = context.getMetaAssertions();
+
+      metastatementNatches = someSubArray(metaAssertions, premisesLength, (metaAssertions) => {
+        const premisesMatchConclusion = matchPremisesAndConclusion(this.premises, this.conclusion, metaAssertions, metastatementNode);
+
+        if (premisesMatchConclusion) {
+          return true;
+        }
+      });
+    }
+
+    return metastatementNatches;
   }
 
   asString() {
@@ -50,8 +61,6 @@ class Rule {
   }
 }
 
-module.exports = Rule;
-
 function matchPremise(premise, metaAssertions, metaSubstitutions) {
   const metaAssertion = prune(metaAssertions, (metaAssertion) => {
     const metaSubproofNode = metaAssertion.getMetaSubproofNode(),

package/src/ruleNames.js

@@ -0,0 +1,10 @@
+"use strict";
+
+export const TERM_RULE_NAME = "term";
+export const TYPE_RULE_NAME = "type";
+export const ARGUMENT_RULE_NAME = "argument";
+export const METAVARIABLE_RULE_NAME = "metavariable";
+export const METASTATEMENT_RULE_NAME = "metastatement";
+export const META_SUBPROOF_RULE_NAME = "metaSubproof";
+export const QUALIFIED_METASTATEMENT_RULE_NAME = "qualifiedMetastatement";
+export const UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";

package/{bin → src}/type.js

@@ -1,6 +1,6 @@
 "use strict";
 
-class Type {
+export default class Type {
   constructor(name, superType) {
     this.name = name;
     this.superType = superType;
@@ -116,5 +116,3 @@ class Type {
     return type;
   }
 }
-
-module.exports = Type;

package/{bin → src}/utilities/array.js

@@ -1,14 +1,14 @@
 "use strict";
 
-const { arrayUtilities } = require("necessary");
+import { arrayUtilities } from "necessary";
 
-const permutationsMatrix = require("../permutationsMatrix");
+import permutationsMatrix from "../permutationsMatrix";
 
-const { MAXIMUM_INDEXES_LENGTH, MAXIMUM_PERMUTATION_LENGTH } = require("../constants");
+import { MAXIMUM_INDEXES_LENGTH, MAXIMUM_PERMUTATION_LENGTH } from "../constants";
 
-const { push, last, prune, first, third, second, filter } = arrayUtilities;
+export const { push, last, prune, first, third, second, filter } = arrayUtilities;
 
-function someSubArray(array, subArrayLength, callback) {
+export function someSubArray(array, subArrayLength, callback) {
   let found = false;
 
   const arrayLength = array.length,
@@ -16,10 +16,18 @@ function someSubArray(array, subArrayLength, callback) {
         permutationLength = subArrayLength; ///
 
   if (permutationLength <= MAXIMUM_PERMUTATION_LENGTH) {
-    const offset = (indexesLength <= MAXIMUM_INDEXES_LENGTH) ?
-                     0 :
-                      indexesLength - MAXIMUM_INDEXES_LENGTH,
-          permutations = permutationsMatrix[indexesLength][permutationLength];
+    let offset,
+        permutations;
+
+    if (indexesLength > MAXIMUM_INDEXES_LENGTH) {
+      offset = indexesLength - MAXIMUM_INDEXES_LENGTH;
+
+      permutations = permutationsMatrix[MAXIMUM_INDEXES_LENGTH][permutationLength];
+    } else {
+      offset = 0;
+
+      permutations = permutationsMatrix[indexesLength][permutationLength];
+    }
 
     if (permutations !== null) {
       found = permutations.some((permutation) => {
@@ -46,7 +54,7 @@ function someSubArray(array, subArrayLength, callback) {
   return found;
 }
 
-function leftDifference(arrayA, arrayB) {
+export function leftDifference(arrayA, arrayB) {
   filter(arrayA, (elementA) => {
     const arrayBIncludesElementA = arrayB.includes(elementA);
 
@@ -56,7 +64,7 @@ function leftDifference(arrayA, arrayB) {
   });
 }
 
-function rightDifference(arrayA, arrayB) {
+export function rightDifference(arrayA, arrayB) {
   filter(arrayB, (elementB) => {
     const arrayAIncludesElementB = arrayA.includes(elementB);
 
@@ -65,16 +73,3 @@ function rightDifference(arrayA, arrayB) {
     }
   });
 }
-
-module.exports = {
-  push,
-  last,
-  prune,
-  first,
-  third,
-  second,
-  filter,
-  someSubArray,
-  leftDifference,
-  rightDifference
-};

package/{bin → src}/utilities/metastatement.js

@@ -1,11 +1,11 @@
 "use strict";
 
-const { first, second, third } = require("../utilities/array"),
-      { METASTATEMENT_RULE_NAME } = require("../ruleNames"),
-      { LEFT_BRACKET, RIGHT_BRACKET, BRACKETED_METASTATEMENT_CHILD_NODES_LENGTH } = require("../constants");
+import { first, second, third } from "../utilities/array";
+import { METASTATEMENT_RULE_NAME } from "../ruleNames";
+import { LEFT_BRACKET, RIGHT_BRACKET, BRACKETED_METASTATEMENT_CHILD_NODES_LENGTH } from "../constants";
 
-function matchBracketedMetastatementChildNode(childNodes, callback) {
-  let bracketedMetastatementChildNodeMatches = false;
+export function bracketedMetastatementChildNodeFromChildNodes(childNodes) {
+  let bracketedMetastatementChildNode = null;
 
   const childNodesLength = childNodes.length;
 
@@ -29,16 +29,22 @@ function matchBracketedMetastatementChildNode(childNodes, callback) {
             nonTerminalNodeRuleNameMetastatementRuleName = (nonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
 
       if (firstTerminalNodeContentLeftBracket && nonTerminalNodeRuleNameMetastatementRuleName && secondTerminalNodeContentRightBracket) {
-        const bracketedMetastatementChildNode = nonTerminalNode;  ///
-
-        bracketedMetastatementChildNodeMatches = callback(bracketedMetastatementChildNode);
+        bracketedMetastatementChildNode = nonTerminalNode;  ///
       }
     }
   }
 
-  return bracketedMetastatementChildNodeMatches;
+  return bracketedMetastatementChildNode;
 }
 
-module.exports = {
-  matchBracketedMetastatementChildNode
-};
+export function matchBracketedMetastatementChildNode(childNodes, callback) {
+  let bracketedMetastatementChildNodeMatches = false;
+
+  const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromChildNodes(childNodes);
+
+  if (bracketedMetastatementChildNode !== null) {
+    bracketedMetastatementChildNodeMatches = callback(bracketedMetastatementChildNode);
+  }
+
+  return bracketedMetastatementChildNodeMatches;
+}

package/{bin → src}/utilities/permutations.js

@@ -1,9 +1,9 @@
 "use strict";
 
-const { fileSystemUtilities } = require("necessary");
+import { fileSystemUtilities } from "necessary";
 
-const { push, last, first } = require("../utilities/array"),
-      { MAXIMUM_INDEXES_LENGTH, MAXIMUM_PERMUTATION_LENGTH } = require("../constants");
+import { push, last, first } from "../utilities/array";
+import { MAXIMUM_INDEXES_LENGTH, MAXIMUM_PERMUTATION_LENGTH } from "../constants";
 
 const { writeFile } = fileSystemUtilities;
 
@@ -37,7 +37,7 @@ function writePermutationsMatrixFile() {
         
 const permutationsMatrix = ${permutationsMatrixJSON};
   
-module.exports = permutationsMatrix;      
+export default permutationsMatrix;      
   `;
 
   writeFile(permutationsMatrixFileName, permutationsMatrixFileContent)

package/{bin → src}/utilities/query.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const { Query } = require("occam-dom");
+import { Query } from "occam-dom";
 
 const typeTerminalNodeQuery = nodeQuery("/type/@type"),
       labelNameTerminalNodeQuery = nodeQuery("/label/@name"),
@@ -8,7 +8,7 @@ const typeTerminalNodeQuery = nodeQuery("/type/@type"),
       referenceNameTerminalNodeQuery = nodeQuery("/reference/@name"),
       metavariableNameTerminalNodeQuery = nodeQuery("/metavariable/@name");
 
-function nodeQuery(expression) {
+export function nodeQuery(expression) {
   const query = Query.fromExpression(expression);
 
   return function(node) {
@@ -22,7 +22,7 @@ function nodeQuery(expression) {
   };
 }
 
-function nodesQuery(expression) {
+export function nodesQuery(expression) {
   const query = Query.fromExpression(expression);
 
   return function(node) {
@@ -36,7 +36,7 @@ function nodesQuery(expression) {
   };
 }
 
-function typeNameFromTypeNode(typeNode) {
+export function typeNameFromTypeNode(typeNode) {
   let typeName = null;
 
   if (typeNode !== null) {
@@ -49,7 +49,7 @@ function typeNameFromTypeNode(typeNode) {
   return typeName;
 }
 
-function labelNameFromLabelNode(labelNode) {
+export function labelNameFromLabelNode(labelNode) {
   const labelNameTerminalNode = labelNameTerminalNodeQuery(labelNode),
         labelNameTerminalNodeContent = labelNameTerminalNode.getContent(),
         labelName = labelNameTerminalNodeContent; ///
@@ -57,7 +57,7 @@ function labelNameFromLabelNode(labelNode) {
   return labelName;
 }
 
-function variableNameFromVariableNode(variableNode) {
+export function variableNameFromVariableNode(variableNode) {
   const variableNameTerminalNode = variableNameTerminalNodeQuery(variableNode),
         variableNameTerminalNodeContent = variableNameTerminalNode.getContent(),
         variableName = variableNameTerminalNodeContent; ///
@@ -65,7 +65,7 @@ function variableNameFromVariableNode(variableNode) {
   return variableName;
 }
 
-function referenceNameFromReferenceNode(referenceNode) {
+export function referenceNameFromReferenceNode(referenceNode) {
   const referenceNameTerminalNode = referenceNameTerminalNodeQuery(referenceNode),
         referenceNameTerminalNodeContent = referenceNameTerminalNode.getContent(),
         referenceName = referenceNameTerminalNodeContent; ///
@@ -73,20 +73,10 @@ function referenceNameFromReferenceNode(referenceNode) {
   return referenceName;
 }
 
-function metavariableNameFromMetavariableNode(metavariableNode) {
+export function metavariableNameFromMetavariableNode(metavariableNode) {
   const metavariableNameTerminalNode = metavariableNameTerminalNodeQuery(metavariableNode),
         metavariableNameTerminalNodeContent = metavariableNameTerminalNode.getContent(),
         metavariableName = metavariableNameTerminalNodeContent; ///
 
   return metavariableName;
 }
-
-module.exports = {
-  nodeQuery,
-  nodesQuery,
-  typeNameFromTypeNode,
-  labelNameFromLabelNode,
-  variableNameFromVariableNode,
-  referenceNameFromReferenceNode,
-  metavariableNameFromMetavariableNode
-};

package/{bin → src}/utilities/string.js

@@ -1,8 +1,8 @@
 "use strict";
 
-const { COMMA, EMPTY_STRING } = require("../constants");
+import { COMMA, EMPTY_STRING } from "../constants";
 
-function nodeAsString(node, string = EMPTY_STRING) {
+export function nodeAsString(node, string = EMPTY_STRING) {
   const nodeTerminalNode = node.isTerminalNode();
 
   if (nodeTerminalNode) {
@@ -22,7 +22,7 @@ function nodeAsString(node, string = EMPTY_STRING) {
   return string;
 }
 
-function nodesAsString(nodes) {
+export function nodesAsString(nodes) {
   const string = nodes.reduce((string, node) => {
     const nodeString = nodeAsString(node);
 
@@ -38,14 +38,8 @@ function nodesAsString(nodes) {
   return string;
 }
 
-function labelsAsString(labels) {
+export function labelsAsString(labels) {
   const labelsString = labels.join(COMMA);
 
   return labelsString;
 }
-
-module.exports = {
-  nodeAsString,
-  nodesAsString,
-  labelsAsString
-};

package/{bin → src}/variable.js

@@ -1,6 +1,6 @@
 "use strict";
 
-class Variable {
+export default class Variable {
   constructor(type, name, value) {
     this.type = type;
     this.name = name;
@@ -50,5 +50,3 @@ class Variable {
     return variable;
   }
 }
-
-module.exports = Variable;

package/src/verify/IndicativeConditional.js

@@ -0,0 +1,20 @@
+"use strict";
+
+import verifyUnqualifiedStatement from "../verify/metastatement/unqualified";
+
+import { nodesQuery } from "../utilities/query";
+
+const unqualifiedStatementNodesQuery = nodesQuery("/indicativeConditional/unqualifiedStatement");
+
+export default function verifyIndicativeConditional(indicativeConditionalNode, statementNodes, context) {
+  const unqualifiedStatementNodes = unqualifiedStatementNodesQuery(indicativeConditionalNode),
+        indicativeConditionalVerified = unqualifiedStatementNodes.every((unqualifiedStatementNode) => {
+          const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, context);
+
+          if (unqualifiedStatementVerified) {
+            return true;
+          }
+        });
+
+  return indicativeConditionalVerified;
+}

package/{bin → src}/verify/assertion/type.js

@@ -1,19 +1,15 @@
 "use strict";
 
-const { loggingUtilities } = require("necessary");
+import Variable from "../../variable";
+import verifyTermAsVariable from "../../verify/termAsVariable";
 
-const Variable = require("../../variable"),
-      verifyTermAsVariable = require("../../verify/termAsVariable");
-
-const { first } = require("../../utilities/array"),
-      { nodeQuery, typeNameFromTypeNode } = require("../../utilities/query");
-
-const { log } = loggingUtilities;
+import { first } from "../../utilities/array";
+import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term"),
       typeNodeQuery = nodeQuery("/typeAssertion/type");
 
-function verifyTypeAssertion(typeAssertionNode, context) {
+export default function verifyTypeAssertion(typeAssertionNode, context) {
   let typeAssertionVerified = false;
 
   const typeNode = typeNodeQuery(typeAssertionNode),
@@ -21,7 +17,7 @@ function verifyTypeAssertion(typeAssertionNode, context) {
         typePresent = context.isTypePresentByTypeName(typeName);
 
   if (!typePresent) {
-    log.error(`The ${typeName} type is not present.`);
+    context.error(`The ${typeName} type is not present.`);
   } else {
     const derived = context.isDerived();
 
@@ -41,7 +37,7 @@ function verifyTypeAssertion(typeAssertionNode, context) {
               value = firstValue;
 
         if (value !== undefined) {
-          log.error(`The value of the ${variableName} variable is not undefined.`);
+          context.error(`The value of the ${variableName} variable is not undefined.`);
         } else {
           const type = context.findTypeByTypeName(typeName),
                 firstType = first(types),
@@ -49,7 +45,7 @@ function verifyTypeAssertion(typeAssertionNode, context) {
                 typeSubTypeOfVariableType = type.isSubTypeOf(variableType);
 
           if (!typeSubTypeOfVariableType) {
-            log.error(`The asserted type of the ${variableName} variable is not a sub-type of its declared type.`);
+            context.error(`The asserted type of the ${variableName} variable is not a sub-type of its declared type.`);
           } else {
             const name = variableName,  ///
                   variable = Variable.fromTypeAndName(type, name);
@@ -65,5 +61,3 @@ function verifyTypeAssertion(typeAssertionNode, context) {
 
   return typeAssertionVerified;
 }
-
-module.exports = verifyTypeAssertion;

package/src/verify/axiom.js

@@ -0,0 +1,68 @@
+"use strict";
+
+import ProofContext from "../context/proof";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+import verifyIndicativeConditional from "../verify/indicativeConditional";
+
+import { first, second } from "../utilities/array";
+import { nodesAsString } from "../utilities/string";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const labelNodesQuery = nodesQuery("/axiom/label"),
+      statementNodeQuery = nodeQuery("/*/statement"),
+      unqualifiedStatementNodeQuery = nodeQuery("/axiom/unqualifiedStatement!"),
+      indicativeConditionalNodeQuery = nodeQuery("/axiom/indicativeConditional!");
+
+export default function verifyAxiom(axiomNode, context) {
+  const labelNodes = labelNodesQuery(axiomNode),
+        labelsString = nodesAsString(labelNodes);
+
+  context.debug(`Verifying the '${labelsString}' axiom...`);
+
+  const proofContext = ProofContext.fromContext(context);
+
+  context = proofContext; ///
+
+  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(axiomNode),
+        indicativeConditionalNode = indicativeConditionalNodeQuery(axiomNode);
+
+  let axiomVerified = false;
+
+  if (unqualifiedStatementNode !== null) {
+    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, context);
+
+    if (unqualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode),
+            labels = labelsString,  ///
+            axiom = Axiom.fromStatementNodeAndLabels(statementNode, labels);
+
+      context.addAxiom(axiom);
+
+      axiomVerified = true;
+    }
+  }
+
+  if (indicativeConditionalNode !== null) {
+    const statementNodes = [],
+          indicativeConditionalVerified = verifyIndicativeConditional(indicativeConditionalNode, statementNodes, context);
+
+    if (indicativeConditionalVerified !== null) {
+      const labels = labelsString,  ///
+            firstStatementNode = first(statementNodes),
+            secondStatementNode = second(statementNodes),
+            suppositionStatementNode = firstStatementNode,  ///
+            consequentStatementNode = secondStatementNode,  ///
+            axiom = Axiom.fromSuppositionStatementNodeConsequentStatementNodeAndLabels(suppositionStatementNode, consequentStatementNode, labels);
+
+      context.addAxiom(axiom);
+
+      axiomVerified = true;
+    }
+  }
+
+  if (axiomVerified) {
+    context.info(`Verified the '${labelsString}' axiom.`);
+  }
+
+  return axiomVerified;
+}

package/{bin → src}/verify/conclusion.js

@@ -1,14 +1,14 @@
 "use strict";
 
-const Conclusion = require("../conclusion"),
-      verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
+import Conclusion from "../conclusion";
+import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
-const { nodeQuery } = require("../utilities/query");
+import { nodeQuery } from "../utilities/query";
 
 const metastatementNodeQuery = nodeQuery("/*/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/conclusion/unqualifiedMetastatement!");
 
-function verifyConclusion(conclusionNode, conclusions, context) {
+export default function verifyConclusion(conclusionNode, conclusions, context) {
   let conclusionVerified = false;
 
   const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(conclusionNode);
@@ -28,5 +28,3 @@ function verifyConclusion(conclusionNode, conclusions, context) {
 
   return conclusionVerified;
 }
-
-module.exports = verifyConclusion;

package/src/verify/conditinalInference.js

@@ -0,0 +1,25 @@
+"use strict";
+
+import verifyConclusion from "../verify/conclusion";
+import verifyPremiseOrPremises from "../verify/premiseOrPremises";
+
+import { nodeQuery } from "../utilities/query";
+
+const conclusionNodeQuery = nodeQuery("/conditionalInference/conclusion!"),
+      premiseOrPremisesNodeQuery = nodeQuery("/conditionalInference/premise|premises!");
+
+export default function verifyConditionalInference(conditionalInferenceNode, premises, conclusions, context) {
+  let conditionalInferenceVerified = false;
+
+  const conclusionNode = conclusionNodeQuery(conditionalInferenceNode),
+        premiseOrPremisesNode = premiseOrPremisesNodeQuery(conditionalInferenceNode),
+        premiseOrPremisesVerified = verifyPremiseOrPremises(premiseOrPremisesNode, premises, context);
+
+  if (premiseOrPremisesVerified) {
+    const conclusionVerified = verifyConclusion(conclusionNode, conclusions, context);
+
+    conditionalInferenceVerified = conclusionVerified;
+  }
+
+  return conditionalInferenceVerified;
+}

package/{bin → src}/verify/declaration/combinator.js

@@ -1,17 +1,15 @@
 "use strict";
 
-const verifyStatementAsCombinator = require("../../verify/statementAsCombinator");
+import verifyStatementAsCombinator from "../../verify/statementAsCombinator";
 
-const { nodeQuery } = require("../../utilities/query");
+import { nodeQuery } from "../../utilities/query";
 
 const statementNodeQuery = nodeQuery("/combinatorDeclaration/statement");
 
-function verifyCombinatorDeclaration(combinatorDeclarationNode, context) {
+export default function verifyCombinatorDeclaration(combinatorDeclarationNode, context) {
   const statementNode = statementNodeQuery(combinatorDeclarationNode),
         statementVerifiedAsCombinator = verifyStatementAsCombinator(statementNode, context),
         combinatorDeclarationVerified = statementVerifiedAsCombinator; ///
 
   return combinatorDeclarationVerified;
 }
-
-module.exports = verifyCombinatorDeclaration;

package/{bin → src}/verify/declaration/constructor.js

@@ -1,13 +1,13 @@
 "use strict";
 
-const verifyTermAsConstructor = require("../../verify/termAsConstructor");
+import verifyTermAsConstructor from "../../verify/termAsConstructor";
 
-const { nodeQuery } = require("../../utilities/query");
+import { nodeQuery } from "../../utilities/query";
 
 const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
       typeNodeQuery = nodeQuery("/constructorDeclaration/type");
 
-function verifyConstructorDeclaration(constructorDeclarationNode, context) {
+export default function verifyConstructorDeclaration(constructorDeclarationNode, context) {
   const termNode = termNodeQuery(constructorDeclarationNode),
         typeNode = typeNodeQuery(constructorDeclarationNode),
         termVerifiedAsConstructor = verifyTermAsConstructor(termNode, typeNode, context),
@@ -15,5 +15,3 @@ function verifyConstructorDeclaration(constructorDeclarationNode, context) {
 
   return constructorDeclarationVerified;
 }
-
-module.exports = verifyConstructorDeclaration;