occam-verify-cli 0.0.267 → 0.0.269

package/bin/context/file.js

@@ -186,6 +186,12 @@ class FileContext {
     return labelPresent;
   }
 
+  isMetaAssertionPresent(metaAssertion) {
+    const metaAssertionPresent = false;
+
+    return metaAssertionPresent;
+  }
+
   isTypePresentByTypeName(typeName) {
     const type = this.findTypeByTypeName(typeName),
           typePresent = (type !== null);
@@ -193,12 +199,6 @@ class FileContext {
     return typePresent;
   }
 
-  isMetastatementNodePresent(metaStatementNode) {
-    const metastatementNodePresent = false;
-
-    return metastatementNodePresent;
-  }
-
   isVariablePresentByVariableName(variableName) {
     const variable = this.findVariableByVariableName(variableName),
           variablePresent = (variable !== null);
@@ -230,10 +230,6 @@ class FileContext {
     this.constructors.push(constructor);
   }
 
-  setInAntecedent(inAntecedent) {
-    ///
-  }
-
   static fromPackageContextAndFilePath(packageContext, filePath) {
     const fileContent = packageContext.getFileContent(filePath),
           content = fileContent,  ///

package/bin/context/metaproof.js

@@ -1,12 +1,10 @@
 "use strict";
 
-const { nodeAsString } = require("../utilities/string");
-
 class MetaproofContext {
-  constructor(context, derived, metastatementNodes) {
+  constructor(context, derived, metaAssertions) {
     this.context = context;
     this.derived = derived;
-    this.metastatementNodes = metastatementNodes;
+    this.metaAssertions = metaAssertions;
   }
 
   getContext() {
@@ -17,8 +15,8 @@ class MetaproofContext {
     return this.derived;
   }
 
-  getMetastatementNodes() {
-    return this.metastatementNodes;
+  getMetaAssertions() {
+    return this.metaAssertions;
   }
 
   getRules() { return this.context.getRules(); }
@@ -41,47 +39,41 @@ class MetaproofContext {
 
   isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
 
-  isMetastatementNodePresent(metaStatementNode) {
-    const metastatementNodeA = metaStatementNode; ///
+  isMetaAssertionPresent(metaAssertion) {
+    const metaAssertionA = metaAssertion; ///
 
-    let metastatementNodePresent = this.metastatementNodes.some((metaStatementNode) => {
-      const metastatementNodeB = metaStatementNode, ///
-            metastatementNodeAString = nodeAsString(metastatementNodeA),
-            metastatementNodeBString = nodeAsString(metastatementNodeB),
-            matches = (metastatementNodeAString === metastatementNodeBString);
+    let metaAssertionPresent = this.metaAssertions.some((metaAssertion) => {
+      const metaAssertionB = metaAssertion, ///
+            matches = metaAssertionA.match(metaAssertionB);
 
       if (matches) {
         return true;
       }
     });
 
-    if (!metastatementNodePresent) {
-      metastatementNodePresent = this.context.isMetastatementNodePresent(metaStatementNode);
+    if (!metaAssertionPresent) {
+      metaAssertionPresent = this.context.isMetaAssertionPresent(metaAssertion);
     }
 
-    return metastatementNodePresent;
+    return metaAssertionPresent;
   }
 
   isVariablePresentByVariableName(variableName) { return this.context.isVariablePresentByVariableName(variableName); }
 
   setDerived(derived) {
-    if (derived) {
-      this.metastatementNodes.pop();
-    }
-
     this.derived = derived;
   }
 
   addRule(rule) { this.context.addRule(rule); }
 
-  addMetastatementNode(metastatementNode) {
-    this.metastatementNodes.push(metastatementNode);
+  addMetaAssertion(metaAssertion) {
+    this.metaAssertions.push(metaAssertion);
   }
 
   static fromContext(context) {
     const derived = false,
-          metastatementNodes = [],
-          metaproofContext = new MetaproofContext(context, derived, metastatementNodes);
+          metaAssertions = [],
+          metaproofContext = new MetaproofContext(context, derived, metaAssertions);
 
     return metaproofContext;
   }

package/bin/metaAssertion.js

@@ -0,0 +1,137 @@
+"use strict";
+
+const { nodeQuery } = require("./utilities/query");
+
+const metastatementNodeQuery = nodeQuery("/*/metastatement!");
+
+class MetaAssertion {
+  constructor(metaSubproofNode, metastatementNode) {
+    this.metaSubproofNode = metaSubproofNode;
+    this.metastatementNode = metastatementNode;
+  }
+
+  getMetaSubproofNode() {
+    return this.metaSubproofNode;
+  }
+
+  getMetastatementNode() {
+    return this.metastatementNode;
+  }
+
+  match(metaAssertion) {
+    let matches = false;
+
+    const metastatementNode = metaAssertion.getMetastatementNode();
+
+    if ((metastatementNode !== null) && (this.metastatementNode !== null)) {
+      const nonTerminalNode = this.metastatementNode, ///
+            metaAssertionNonTerminalNode = metastatementNode, ///
+            metaAssertionNonTerminalNodeMatches = matchMetaAssertionNonTerminalNode(metaAssertionNonTerminalNode, nonTerminalNode);
+
+      matches = metaAssertionNonTerminalNodeMatches;  ///
+    }
+
+    return matches;
+  }
+
+  static fromMetaSubproofNode(metaSubproofNode) {
+    const metastatementNode = null,
+          metaAssertion = new MetaAssertion(metaSubproofNode, metastatementNode);
+
+    return metaAssertion;
+  }
+
+  static fromQualifiedMetastatementNode(qualifiedMetastatementNode) {
+    const metaSubproofNode = null,
+          metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+          metaAssertion = new MetaAssertion(metaSubproofNode, metastatementNode);
+
+    return metaAssertion;
+  }
+
+  static fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode) {
+    const metaSubproofNode = null,
+          metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+          metaAssertion = new MetaAssertion(metaSubproofNode, metastatementNode);
+
+    return metaAssertion;
+  }
+}
+
+module.exports = MetaAssertion;
+
+function matchMetaAssertionNode(metaAssertionNode, node) {
+  let metaAssertionNodeMatches = false;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        ruleNodeTerminalNode = metaAssertionNode.isTerminalNode();
+
+  if (nodeTerminalNode === ruleNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            metaAssertionTerminalNode = metaAssertionNode,  ///
+            metaAssertionTerminalNodeMatches = matchMetaAssertionTerminalNode(metaAssertionTerminalNode, terminalNode);
+
+      metaAssertionNodeMatches = metaAssertionTerminalNodeMatches;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            metaAssertionNonTerminalNode = metaAssertionNode,  ///
+            metaAssertionNonTerminalNodeMatches = matchMetaAssertionNonTerminalNode(metaAssertionNonTerminalNode, nonTerminalNode);
+
+      metaAssertionNodeMatches = metaAssertionNonTerminalNodeMatches; ///
+    }
+  }
+
+  return metaAssertionNodeMatches;
+}
+
+function matchMetaAssertionChildNodes(metaAssertionChildNodes, childNodes) {
+  let metaAssertionChildNodesMatches = false;
+
+  const childNodesLength = childNodes.length,
+      metaAssertionChildNodesLength = metaAssertionChildNodes.length;
+
+  if (childNodesLength === metaAssertionChildNodesLength) {
+    metaAssertionChildNodesMatches = childNodes.every((childNode, index) => {
+      const metaAssertionChildNode = metaAssertionChildNodes[index],
+            metaAssertionNode = metaAssertionChildNode, ///
+            node = childNode, ///
+            metaAssertionNodeMatches = matchMetaAssertionNode(metaAssertionNode, node);
+
+      if (metaAssertionNodeMatches) {
+        return true;
+      }
+    })
+  }
+
+  return metaAssertionChildNodesMatches;
+}
+
+function matchMetaAssertionTerminalNode(metaAssertionTerminalNode, terminalNode) {
+  let metaAssertionTerminalNodeMatches = false;
+
+  const matches = metaAssertionTerminalNode.match(terminalNode);
+
+  if (matches) {
+    metaAssertionTerminalNodeMatches = true;
+  }
+
+  return metaAssertionTerminalNodeMatches;
+}
+
+function matchMetaAssertionNonTerminalNode(metaAssertionNonTerminalNode, nonTerminalNode) {
+  let metaAssertionNonTerminalNodeMatches = false;
+
+  const ruleName = nonTerminalNode.getRuleName(),
+        metaAssertionRuleName = metaAssertionNonTerminalNode.getRuleName(); ///
+
+  if (ruleName === metaAssertionRuleName) {
+    const childNodes = nonTerminalNode.getChildNodes(),
+          metaAssertionChildNodes = metaAssertionNonTerminalNode.getChildNodes(),
+          metaAssertionChildNodesMatches = matchMetaAssertionChildNodes(metaAssertionChildNodes, childNodes);
+
+    metaAssertionNonTerminalNodeMatches = metaAssertionChildNodesMatches; ///
+  }
+
+  return metaAssertionNonTerminalNodeMatches;
+}

package/bin/ruleNames.js

@@ -4,7 +4,7 @@ const TERM_RULE_NAME = "term",
       TYPE_RULE_NAME = "type",
       ARGUMENT_RULE_NAME = "argument",
       METAVARIABLE_RULE_NAME = "metavariable",
-      META_CONDITIONAL_PROOF_RULE_NAME = "metaConditionalProof",
+      META_SUBPROOF_RULE_NAME = "metaSubproof",
       QUALIFIED_METASTATEMENT_RULE_NAME = "qualifiedMetastatement",
       UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";
 
@@ -13,7 +13,7 @@ module.exports = {
   TYPE_RULE_NAME,
   ARGUMENT_RULE_NAME,
   METAVARIABLE_RULE_NAME,
-  META_CONDITIONAL_PROOF_RULE_NAME,
+  META_SUBPROOF_RULE_NAME,
   QUALIFIED_METASTATEMENT_RULE_NAME,
   UNQUALIFIED_METASTATEMENT_RULE_NAME
 };

package/bin/verify/metaAntecedent.js

@@ -1,6 +1,7 @@
 "use strict";
 
-const verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
+const MetaAssertion = require("../metaAssertion"),
+      verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
 
 const { nodesQuery } = require("../utilities/query");
 
@@ -16,6 +17,14 @@ function verifyMetaAntecedent(metaAntecedentNode, context) {
           }
         });
 
+  if (metaAntecedentVerified) {
+    unqualifiedMetastatementNodes.forEach((unqualifiedMetastatementNode) => {
+      const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
+
+      context.addMetaAssertion(metaAssertion);
+    });
+  }
+
   return metaAntecedentVerified;
 }
 

package/bin/verify/metaDerivation.js

@@ -1,104 +1,122 @@
 "use strict";
 
-const MetaproofContext = require("../context/metaproof"),
+const MetaAssertion = require("../metaAssertion"),
+      MetaproofContext = require("../context/metaproof"),
       verifyMetaAntecedent = require("../verify/metaAntecedent"),
       verifyQualifiedMetastatement = require("../verify/metastatement/qualified"),
       verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
 
 const { nodeQuery, nodesQuery } = require("../utilities/query"),
-      { META_CONDITIONAL_PROOF_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } = require("../ruleNames");
+      { META_SUBPROOF_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } = require("../ruleNames");
 
-const metaAntecedentNodeQuery = nodeQuery("/metaConditionalProof/metaAntecedent!"),
-      metaDerivationNodeQuery = nodeQuery("/metaConditionalProof/metaDerivation!"),
+const metaAntecedentNodeQuery = nodeQuery("/metaSubproof/metaAntecedent!"),
+      metaDerivationNodeQuery = nodeQuery("/metaSubproof/metaDerivation!"),
       metaDerivationChildNodesQuery = nodesQuery("/metaDerivation/*"),
-      qualifiedMetastatementNodeQuery = nodeQuery("/metaConditionalProof/qualifiedMetastatement!"),
-      unqualifiedMetastatementNodeQuery = nodeQuery("/metaConditionalProof/unqualifiedMetastatement!");
+      qualifiedMetastatementNodeQuery = nodeQuery("/metaSubproof/qualifiedMetastatement!"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/metaSubproof/unqualifiedMetastatement!");
 
 function verifyMetaDerivation(metaDerivationNode, context) {
   const derived = true;
 
   context.setDerived(derived);
 
-  const metaConditionalProofChildNodes = metaDerivationChildNodesQuery(metaDerivationNode),
-        metaConditionalProofChildNodesVerified = metaConditionalProofChildNodes.every((metaConditionalProofChildNode) => {
-          let metaConditionalProofChildNodeVerified;
+  const metaDerivationChildNodes = metaDerivationChildNodesQuery(metaDerivationNode),
+        metaDerivationChildNodesVerified = metaDerivationChildNodes.every((metaDerivationChildNode) => {
+          let metaDerivationChildNodeVerified;
 
-          const ruleName = metaConditionalProofChildNode.getRuleName();
+          const ruleName = metaDerivationChildNode.getRuleName();
 
           switch (ruleName) {
-            case META_CONDITIONAL_PROOF_RULE_NAME: {
-              const metaConditionalProofNode = metaConditionalProofChildNode,  ///
-                    metaConditionalProofVerified = verifyMetaConditionalProof(metaConditionalProofNode, context);
+            case META_SUBPROOF_RULE_NAME: {
+              const metaSubproofNode = metaDerivationChildNode,  ///
+                    metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, context);
 
-              metaConditionalProofChildNodeVerified = metaConditionalProofVerified;  ///
+              if (metaSubproofVerified) {
+                const metaAssertion = MetaAssertion.fromMetaSubproofNode(metaSubproofNode);
+
+                context.addMetaAssertion(metaAssertion);
+
+                metaDerivationChildNodeVerified = true;
+              }
 
               break;
             }
 
             case QUALIFIED_METASTATEMENT_RULE_NAME: {
-              const qualifiedMetastatementNode = metaConditionalProofChildNode,  ///
+              const qualifiedMetastatementNode = metaDerivationChildNode,  ///
                     qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, context);
 
-              metaConditionalProofChildNodeVerified = qualifiedMetastatementVerified;  ///
+              if (qualifiedMetastatementVerified) {
+                const metaAssertion = MetaAssertion.fromQualifiedMetastatementNode(qualifiedMetastatementNode);
+
+                context.addMetaAssertion(metaAssertion);
+
+                metaDerivationChildNodeVerified = qualifiedMetastatementVerified; ///
+              }
 
               break;
             }
 
             case UNQUALIFIED_METASTATEMENT_RULE_NAME: {
-              const unqualifiedMetastatementNode = metaConditionalProofChildNode,  ///
+              const unqualifiedMetastatementNode = metaDerivationChildNode,  ///
                     unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
 
-              metaConditionalProofChildNodeVerified = unqualifiedMetastatementVerified;  ///
+              if (unqualifiedMetastatementVerified) {
+                const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
+
+                context.addMetaAssertion(metaAssertion);
 
+                metaDerivationChildNodeVerified = true;
+              }
               break;
             }
           }
 
-          return metaConditionalProofChildNodeVerified;
+          return metaDerivationChildNodeVerified;
         }),
-        metaDerivationVerified = metaConditionalProofChildNodesVerified;  ///
+        metaDerivationVerified = metaDerivationChildNodesVerified;  ///
 
   return metaDerivationVerified;
 }
 
 module.exports = verifyMetaDerivation;
 
-function verifyMetaConditionalProof(metaConditionalProofNode, context) {
-  let metaConditionalProofVerified = false;
+function verifyMetaSubproof(metaSubproofNode, context) {
+  let metaSubproofVerified = false;
 
   const metaproofContext = MetaproofContext.fromContext(context);
 
   context = metaproofContext; ///
 
-  const metaAntecedentNode = metaAntecedentNodeQuery(metaConditionalProofNode),
+  const metaAntecedentNode = metaAntecedentNodeQuery(metaSubproofNode),
         metaAntecedentVerified = verifyMetaAntecedent(metaAntecedentNode, context);
 
   if (metaAntecedentVerified) {
     let metaDerivationVerified = true;
 
-    const metaDerivationNode = metaDerivationNodeQuery(metaConditionalProofNode);
+    const metaDerivationNode = metaDerivationNodeQuery(metaSubproofNode);
 
     if (metaDerivationNode !== null) {
       metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, context);
     }
 
     if (metaDerivationVerified) {
-      const qualifiedMetastatementNode = qualifiedMetastatementNodeQuery(metaConditionalProofNode),
-            unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaConditionalProofNode);
+      const qualifiedMetastatementNode = qualifiedMetastatementNodeQuery(metaSubproofNode),
+            unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaSubproofNode);
 
       if (qualifiedMetastatementNode !== null) {
         const qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, context);
 
-        metaConditionalProofVerified = qualifiedMetastatementVerified;  ///
+        metaSubproofVerified = qualifiedMetastatementVerified;  ///
       }
 
       if (unqualifiedMetastatementNode !== null) {
         const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
 
-        metaConditionalProofVerified = unqualifiedMetastatementVerified;  ///
+        metaSubproofVerified = unqualifiedMetastatementVerified;  ///
       }
     }
   }
 
-  return metaConditionalProofVerified;
+  return metaSubproofVerified;
 }

package/bin/verify/metaproof.js

@@ -11,7 +11,7 @@ const metastatementNodeQuery = nodeQuery("/qualifiedMetastatement!/metastatement
       metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!"),
       qualifiedStatementNodeQuery = nodeQuery("/metaproof/qualifiedMetastatement!");
 
-function verifyMetaproof(metaproofNode, rules, context) {
+function verifyMetaproof(metaproofNode, context) {
   let metaproofVerified = false;
 
   const metaDerivationNode = metaDerivationNodeQuery(metaproofNode);

package/bin/verify/metastatement/qualified.js

@@ -2,6 +2,8 @@
 
 const { loggingUtilities } = require("necessary");
 
+const MetaAssertion = require("../../metaAssertion");
+
 const { nodeAsString } = require("../../utilities/string"),
       { nodeQuery, referenceNameFromReferenceNode } = require("../../utilities/query");
 
@@ -24,17 +26,17 @@ function verifyQualifiedMetastatement(qualifiedMetastatementNode, context) {
       const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, context);
 
       if (ruleMatchesMetastatement) {
-        context.addMetastatementNode(metastatementNode);
-
-        const metastatementString = nodeAsString(metastatementNode);
-
-        log.info(`Verified the '${metastatementString}' qualified metastatement.`);
-
         qualifiedMetastatementVerified = true;
       }
     }
   }
 
+  if (qualifiedMetastatementVerified) {
+    const metastatementString = nodeAsString(metastatementNode);
+
+    log.info(`Verified the '${metastatementString}' qualified metastatement.`);
+  }
+
   return qualifiedMetastatementVerified;
 }
 

package/bin/verify/metastatement/unqualified.js

@@ -2,6 +2,8 @@
 
 const { loggingUtilities } = require("necessary");
 
+const MetaAssertion = require("../../metaAssertion");
+
 const { nodeQuery } = require("../../utilities/query"),
       { nodeAsString } = require("../../utilities/string");
 
@@ -17,21 +19,20 @@ function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context) {
   if (metastatementNode !== null) {
     const derived = context.isDerived();
 
-    let metastatementPresent = true;  ///
-
     if (derived) {
-      metastatementPresent = context.isMetastatementNodePresent(metastatementNode);
-    }
+      const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode),
+            metaAssertionPresent = context.isMetaAssertionPresent(metaAssertion);
 
-    if (metastatementPresent) {
-      context.addMetastatementNode(metastatementNode);
+      unqualifiedMetastatementVerified = metaAssertionPresent;  ///
+    } else {
+      unqualifiedMetastatementVerified = true;
     }
+  }
 
+  if (unqualifiedMetastatementVerified) {
     const metastatementString = nodeAsString(metastatementNode);
 
     log.info(`Verified the '${metastatementString}' unqualified metastatement.`);
-
-    unqualifiedMetastatementVerified = true;
   }
 
   return unqualifiedMetastatementVerified;

package/bin/verify/premiseOrPremises.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const Premise = require("../premise"),
+      MetaAssertion = require("../metaAssertion"),
       verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
 
 const { nodeQuery, nodesQuery } = require("../utilities/query");
@@ -21,8 +22,11 @@ function verifyPremiseOrPremises(premiseOrPremisesNode, premises, context) {
   if (premiseOrPremisesVerified) {
     unqualifiedMetastatementNodes.forEach((unqualifiedMetastatementNode) => {
       const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+            metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode),
             premise = Premise.fromMetastatementNode(metastatementNode);
 
+      context.addMetaAssertion(metaAssertion);
+
       premises.push(premise);
     });
   }

package/bin/verify/unconditionalInference.js

@@ -1,29 +1,27 @@
 "use strict";
 
-const Conclusion = require("../../conclusion"),
-      verifyUnqualifiedMetastatement = require("../../verify/metastatement/unqualified");
+const Conclusion = require("../conclusion"),
+      verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
 
-const { nodeQuery } = require("../../utilities/query");
+const { nodeQuery } = require("../utilities/query");
 
-const metastatementNodeQuery = nodeQuery("/*/metastatement"),
-      unqualifiedMetastatementNodeQuery = nodeQuery("/rule/unqualifiedMetastatement!");
+const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/unconditionalInference/unqualifiedMetastatement!");
 
-function verifyUnconditionalInference(ruleNode, premises, conclusions, context) {
+function verifyUnconditionalInference(unconditionalInferenceNode, premises, conclusions, context) {
   let unconditionalInferenceVerified = false;
 
-  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(ruleNode);
+  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(unconditionalInferenceNode);
 
-  if (unqualifiedMetastatementNode !== null) {
-    const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
+  const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
 
-    if (unqualifiedMetastatementVerified) {
-      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-            conclusion = Conclusion.fromMetastatementNode(metastatementNode);
+  if (unqualifiedMetastatementVerified) {
+    const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+          conclusion = Conclusion.fromMetastatementNode(metastatementNode);
 
-      conclusions.push(conclusion);
+    conclusions.push(conclusion);
 
-      unconditionalInferenceVerified = true;
-    }
+    unconditionalInferenceVerified = true;
   }
 
   return unconditionalInferenceVerified;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.267",
+  "version": "0.0.269",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,10 +12,10 @@
   "dependencies": {
     "argumentative": "^2.0.15",
     "necessary": "^11.0.40",
-    "occam-custom-grammars": "^5.0.348",
+    "occam-custom-grammars": "^5.0.350",
     "occam-dom": "^3.0.171",
     "occam-grammar-utilities": "^7.0.66",
-    "occam-grammars": "^1.0.315",
+    "occam-grammars": "^1.0.317",
     "occam-open-cli": "^5.0.37",
     "occam-parsers": "^16.0.122"
   },