occam-verify-cli 0.0.508 → 0.0.509

package/src/verify/consequence.js

@@ -1,11 +1,13 @@
 "use strict";
 
 import Consequence from "../consequence";
+import verifyUnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 import { nodeAsString } from "../utilities/string";
 
-const statementNodeQuery = nodeQuery("/consequence/unqualifiedStatement!/statement!");
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/consequence/unqualifiedStatement!");
 
 export default function verifyConsequence(consequenceNode, consequences, proofContext) {
   let consequenceVerified = false;
@@ -16,10 +18,14 @@ export default function verifyConsequence(consequenceNode, consequences, proofCo
 
   proofContext.debug(`Verifying the ${consequenceString} consequence...`);
 
-  const statementNode = statementNodeQuery(consequenceNode);
+  const derived = false,
+        assertions = [],
+        unqualifiedStatementNode = unqualifiedStatementNodeQuery(consequenceNode),
+        unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assertions, derived, proofContext);
 
-  if (statementNode !== null) {
-    const consequence = Consequence.fromStatementNode(statementNode);
+  if (unqualifiedStatementVerified) {
+    const statementNode = statementNodeQuery(unqualifiedStatementNode),
+          consequence = Consequence.fromStatementNode(statementNode);
 
     consequences.push(consequence);
 

package/src/verify/derivation.js

@@ -123,8 +123,10 @@ function verifyChild(childNode, proofContext) {
     }
 
     case UNQUALIFIED_STATEMENT_RULE_NAME: {
-      const unqualifiedStatementNode = childNode,  ///
-            unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+      const derived = true,
+            assertions = [],
+            unqualifiedStatementNode = childNode,  ///
+            unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assertions, derived, proofContext);
 
       if (unqualifiedStatementVerified) {
         const statementNode = statementNodeQuery(unqualifiedStatementNode),

package/src/verify/metastatement/qualified.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import verifyMetastatement from "../../verify/metastatement";
+
 import { nodeAsString } from "../../utilities/string";
 import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
 
@@ -18,14 +20,26 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
 
     metaproofContext.debug(`Verifying the ${metastatementString} qualified metastatement...`);
 
-    const referenceNode = referenceNodeQuery(qualifiedMetastatementNode),
-          referenceName = referenceNameFromReferenceNode(referenceNode),
-          rule = metaproofContext.findRuleByReferenceName(referenceName);
+    let ruleMatchesStatement = true;
+
+    const referenceNode = referenceNodeQuery(qualifiedMetastatementNode);
+
+    if (referenceNode !== null) {
+      const referenceName = referenceNameFromReferenceNode(referenceNode),
+            rule = metaproofContext.findRuleByReferenceName(referenceName);
+
+      if (rule !== null) {
+        const ruleMatchesStatement = rule.matchMetastatement(metastatementNode, metaproofContext);
+
+        qualifiedMetastatementVerified = ruleMatchesStatement;  ///
+      }
+    }
 
-    if (rule !== null) {
-      const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metaproofContext);
+    if (ruleMatchesStatement) {
+      const assertions = [],
+            metastatementVerified = verifyMetastatement(metastatementNode, assertions, metaproofContext);
 
-      qualifiedMetastatementVerified = ruleMatchesMetastatement;  ///
+      qualifiedMetastatementVerified = metastatementVerified; ///
     }
   }
 

package/src/verify/metastatement/unqualified.js

@@ -1,11 +1,13 @@
 "use strict";
 
+import verifyMetastatement from "../metastatement";
+
 import { nodeQuery } from "../../utilities/query";
 import { nodeAsString } from "../../utilities/string";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
-export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, metaproofContext) {
+export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assertions, derived, metaproofContext) {
   let unqualifiedMetastatementVerified = false;
 
   metaproofContext.begin(unqualifiedMetastatementNode);
@@ -17,9 +19,17 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
 
     metaproofContext.debug(`Verifying the ${metastatementString} unqualified metastatement...`);
 
-    const metaAssertionMatches = metaproofContext.matchMetastatement(metastatementNode);
+    let metastatementMatches = true;
+
+    if (derived) {
+      metastatementMatches = metaproofContext.matchMetastatement(metastatementNode);
+    }
+
+    if (metastatementMatches) {
+      const metastatementVerified = verifyMetastatement(metastatementNode, assertions, metaproofContext);
 
-    unqualifiedMetastatementVerified = metaAssertionMatches;  ///
+      unqualifiedMetastatementVerified = metastatementVerified; ///
+    }
   }
 
   unqualifiedMetastatementVerified ?

package/src/verify/metastatement.js

@@ -1,7 +1,7 @@
 "use strict";
 
-export default function verifyMetastatement(metastatementNode, qualified, metaproofContext) {
-  let metastatementVerified = true;
+export default function verifyMetastatement(metastatementNode, assertions, metaproofContext) {
+  let metastatementVerified = true; ///
 
   metaproofContext.begin(metastatementNode);
 

package/src/verify/premise.js

@@ -2,11 +2,13 @@
 
 import Premise from "../premise";
 import MetaproofStep from "../step/metaproof";
+import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 import { nodeAsString } from "../utilities/string";
 
-const metastatementNodeQuery = nodeQuery("/premise/unqualifiedMetastatement!/metastatement!");
+const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/premise/unqualifiedMetastatement!");
 
 export default function verifyPremise(premiseNode, premises, metaproofContext) {
   let premiseVerified;
@@ -17,10 +19,14 @@ export default function verifyPremise(premiseNode, premises, metaproofContext) {
 
   metaproofContext.debug(`Verifying the ${premiseString} premise...`);
 
-  const metastatementNode = metastatementNodeQuery(premiseNode);
+  const derived = false,
+        assertions = [],
+        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(premiseNode),
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assertions, derived, metaproofContext);
 
-  if (metastatementNode !== null) {
-    const metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode),
+  if (unqualifiedMetastatementVerified) {
+    const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+          metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode),
           premise = Premise.fromMetastatementNode(metastatementNode);
 
     premises.push(premise);

package/src/verify/ruleDerivation.js

@@ -123,8 +123,10 @@ function verifyChild(childNode, metaproofContext) {
     }
 
     case UNQUALIFIED_METASTATEMENT_RULE_NAME: {
-      const unqualifiedMetastatementNode = childNode,  ///
-            unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, metaproofContext);
+      const derived = true,
+            assertions = [],
+            unqualifiedMetastatementNode = childNode,  ///
+            unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assertions, derived, metaproofContext);
 
       if (unqualifiedMetastatementVerified) {
         const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),

package/src/verify/statement/qualified.js

@@ -5,8 +5,8 @@ import verifyStatement from "../../verify/statement";
 import { nodeAsString } from "../../utilities/string";
 import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
 
-const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
-      referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!");
+const referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
+      statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
 
 export default function verifyQualifiedStatement(qualifiedStatementNode, proofContext) {
   let qualifiedStatementVerified = false;
@@ -20,23 +20,25 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, proofCo
 
     proofContext.debug(`Verifying the ${statementString} qualified statement...`);
 
-    const referenceNode = referenceNodeQuery(qualifiedStatementNode);
+    let ruleMatchesStatement = true;
 
-    if (referenceNode === null) {
-      const qualified = true,
-            statementVerified = verifyStatement(statementNode, qualified, proofContext);
+    const referenceNode = referenceNodeQuery(qualifiedStatementNode);
 
-      qualifiedStatementVerified = statementVerified; ///
-    } else {
+    if (referenceNode !== null) {
       const referenceName = referenceNameFromReferenceNode(referenceNode),
             rule = proofContext.findRuleByReferenceName(referenceName);
 
       if (rule !== null) {
-        const ruleMatchesStatement = rule.matchStatement(statementNode, proofContext);
-
-        qualifiedStatementVerified = ruleMatchesStatement;  ///
+        ruleMatchesStatement = rule.matchStatement(statementNode, proofContext);
       }
     }
+
+    if (ruleMatchesStatement) {
+      const assertions = [],
+            statementVerified = verifyStatement(statementNode, assertions, proofContext);
+
+      qualifiedStatementVerified = statementVerified; ///
+    }
   }
 
   qualifiedStatementVerified ?

package/src/verify/statement/unqualified.js

@@ -1,11 +1,13 @@
 "use strict";
 
+import verifyStatement from "../statement";
+
 import { nodeQuery } from "../../utilities/query";
 import { nodeAsString } from "../../utilities/string";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
-export default function verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext) {
+export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assertions, derived, proofContext) {
   let unqualifiedStatementVerified = false;
 
   proofContext.begin(unqualifiedStatementNode);
@@ -17,9 +19,17 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, pro
 
     proofContext.debug(`Verifying the ${statementString} unqualified statement...`);
 
-    const assertionMatches = proofContext.matchStatement(statementNode);
+    let statementMatches = true;
+
+    if (derived) {
+      statementMatches = proofContext.matchStatement(statementNode);
+    }
+
+    if (statementMatches) {
+      const statementVerified = verifyStatement(statementNode, assertions, proofContext);
 
-    unqualifiedStatementVerified = assertionMatches;  ///
+      unqualifiedStatementVerified = statementVerified;  ///
+    }
   }
 
   unqualifiedStatementVerified ?

package/src/verify/statement.js

@@ -1,24 +1,33 @@
 "use strict";
 
+import verifyTerm from "../verify/term";
 import verifyTypeAssertion from "../verify/assertion/type";
 
-import { nodeQuery } from "../utilities/query";
+import { first } from "../utilities/array";
+import { nodeAsString } from "../utilities/string";
+import { ARGUMENT_RULE_NAME } from "../ruleNames";
+import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
 
-const typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
+const termNodeQuery = nodeQuery("/argument/term!"),
+      typeNodeQuery = nodeQuery("/argument/type!"),
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
-export default function verifyStatement(statementNode, qualified, proofContext) {
+export default function verifyStatement(statementNode, assertions, proofContext) {
   let statementVerified = false;
 
   proofContext.begin(statementNode);
 
-  if (!statementVerified) {
-    const typeAssertionNode = typeAssertionNodeQuery(statementNode);
+  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
-    if (typeAssertionNode !== null) {
-      const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, qualified, proofContext);
+  if (typeAssertionNode !== null) {
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assertions, proofContext);
 
-      statementVerified = typeAssertionVerified; ///
-    }
+    statementVerified = typeAssertionVerified; ///
+  } else {
+    const context = proofContext, ///
+          statementVerifiedAgainstCombinators = verifyStatementAgainstCombinators(statementNode, context);
+
+    statementVerified = statementVerifiedAgainstCombinators;  ///
   }
 
   statementVerified ?
@@ -27,3 +36,160 @@ export default function verifyStatement(statementNode, qualified, proofContext)
 
   return statementVerified;
 }
+
+function verifyStatementAgainstCombinators(statementNode, context) {
+  let statementVerifiedAgainstCombinators = false;
+
+  context.begin(statementNode);
+
+  const combinators = context.getCombinators(),
+        combinator = combinators.find((combinator) => {
+          const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
+
+          if (statementVerifiedAgainstCombinator) {
+            return true;
+          }
+        }) || null;
+
+  if (combinator !== null) {
+    statementVerifiedAgainstCombinators = true;
+  }
+
+  statementVerifiedAgainstCombinators ?
+    context.complete(statementNode) :
+      context.halt(statementNode);
+
+  return statementVerifiedAgainstCombinators;
+}
+
+function verifyStatementAgainstCombinator(statementNode, combinator, context) {
+  const combinatorStatementNode = combinator.getStatementNode(),
+        node = statementNode,  ///
+        combinatorNode = combinatorStatementNode, ///
+        nodeVerified = verifyNode(node, combinatorNode, context),
+        statementVerifiedAgainstCombinator = nodeVerified;  ///
+
+  return statementVerifiedAgainstCombinator;
+}
+
+function verifyNode(node, combinatorNode, context) {
+  let nodeVerified;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        combinatorNodeTerminalNode = combinatorNode.isTerminalNode();
+
+  if (nodeTerminalNode === combinatorNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            combinatorTerminalNode = combinatorNode,  ///
+            terminalNodeVerified = verifyTerminalNode(terminalNode, combinatorTerminalNode, context);
+
+      nodeVerified = terminalNodeVerified;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            combinatorNonTerminalNode = combinatorNode,  ///
+            nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, context);
+
+      nodeVerified = nonTerminalNodeVerified; ///
+    }
+  }
+
+  return nodeVerified;
+}
+
+function verifyNodes(nodes, combinatorNodes, context) {
+  let nodesVerified = false;
+
+  const nodesLength = nodes.length,
+        combinatorNodesLength = combinatorNodes.length;
+
+  if (nodesLength === combinatorNodesLength) {
+    nodesVerified = nodes.every((node, index) => {
+      const combinatorNode = combinatorNodes[index],
+            nodeVerified = verifyNode(node, combinatorNode, context);
+
+      if (nodeVerified) {
+        return true;
+      }
+    });
+  }
+
+  return nodesVerified;
+}
+
+function verifyTerminalNode(terminalNode, combinatorTerminalNode, context) {
+  let terminalNodeVerified = false;
+
+  const matches = terminalNode.match(combinatorTerminalNode);
+
+  if (matches) {
+    terminalNodeVerified = true;
+  }
+
+  return terminalNodeVerified;
+}
+
+function verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, context) {
+  let nonTerminalNodeVerified = false;
+
+  const ruleName = nonTerminalNode.getRuleName(), ///
+        combinatorRuleName = combinatorNonTerminalNode.getRuleName(); ///
+
+  if (ruleName === combinatorRuleName) {
+    switch (ruleName) {
+      case ARGUMENT_RULE_NAME: {
+        const argumentNode = nonTerminalNode, ///
+              combinatorArgumentNode = combinatorNonTerminalNode, ///
+              argumentNodeVerified = verifyArgumentNode(argumentNode, combinatorArgumentNode, context);
+
+        nonTerminalNodeVerified = argumentNodeVerified; ///
+
+        break;
+      }
+
+      default: {
+        const childNodes = nonTerminalNode.getChildNodes(),
+              combinatorChildNodes = combinatorNonTerminalNode.getChildNodes(),
+              nodes = childNodes, ///
+              combinatorNodes = combinatorChildNodes, ///
+              nodesVerified = verifyNodes(nodes, combinatorNodes, context);
+
+        nonTerminalNodeVerified = nodesVerified; ///
+
+        break;
+      }
+    }
+  }
+
+  return nonTerminalNodeVerified;
+}
+
+function verifyArgumentNode(argumentNode, combinatorArgumentNode, context) {
+  let argumentNodeVerified = false;
+
+  const termNode = termNodeQuery(argumentNode);
+
+  if (termNode === null) {
+    const argumentString = nodeAsString(argumentNode);
+
+    context.error(`The ${argumentString} argument should be a term, not a type`);
+  } else {
+    const types = [],
+          termVerified = verifyTerm(termNode, types, context);
+
+    if (termVerified) {
+      const firstType = first(types),
+            termType = firstType, ///
+            typeNode = typeNodeQuery(combinatorArgumentNode),
+            typeName = typeNameFromTypeNode(typeNode),
+            type = context.findTypeByTypeName(typeName),
+            statementTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
+
+      if (statementTypeEqualToOrSubTypeOfType) {
+        argumentNodeVerified = true;
+      }
+    }
+  }
+
+  return argumentNodeVerified;
+}

package/src/verify/supposition.js

@@ -2,12 +2,13 @@
 
 import ProofStep from "../step/proof";
 import Supposition from "../supposition";
-import verifyStatement from "./statement";
+import verifyUnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 import { nodeAsString } from "../utilities/string";
 
-const statementNodeQuery = nodeQuery("/supposition/unqualifiedStatement!/statement!");
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement!");
 
 export default function verifySupposition(suppositionNode, suppositions, proofContext) {
   let suppositionVerified;
@@ -18,20 +19,23 @@ export default function verifySupposition(suppositionNode, suppositions, proofCo
 
   proofContext.debug(`Verifying the ${suppositionString} supposition...`);
 
-  const statementNode = statementNodeQuery(suppositionNode);
+  const derived = false,
+        assertions = [],
+        unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
+        unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assertions, derived, proofContext);
 
-  if (statementNode !== null) {
-    const qualified = false,
-          statementVerified = verifyStatement(statementNode, qualified, proofContext);
+  if (unqualifiedStatementVerified) {
+    const statementNode = statementNodeQuery(unqualifiedStatementNode),
+          proofStep = ProofStep.fromStatementNode(statementNode),
+          supposition = Supposition.fromStatementNode(statementNode);
 
-    if (statementVerified) {
-      const proofStep = ProofStep.fromStatementNode(statementNode),
-            supposition = Supposition.fromStatementNode(statementNode);
+    suppositions.push(supposition);
 
-      suppositions.push(supposition);
+    proofContext.addProofStep(proofStep);
 
-      proofContext.addProofStep(proofStep);
-    }
+    assertions.every((assertion) => {
+      assertion.assert(proofContext);
+    });
 
     suppositionVerified = true;
   }

package/lib/verify/metaDerivation.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return verifyMetaDerivation;
-    }
-});
-var _metaproof = /*#__PURE__*/ _interopRequireDefault(require("../step/metaproof"));
-var _qualified = /*#__PURE__*/ _interopRequireDefault(require("../verify/metastatement/qualified"));
-var _unqualified = /*#__PURE__*/ _interopRequireDefault(require("../verify/metastatement/unqualified"));
-var _query = require("../utilities/query");
-var _ruleNames = require("../ruleNames");
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var childNodesQuery = (0, _query.nodesQuery)("/metaDerivation|metaSubDerivation/*"), metastatementNodeQuery = (0, _query.nodeQuery)("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!");
-function verifyMetaDerivation(metaDerivationNode, metaproofContext) {
-    var metaDerivationVerified;
-    metaproofContext.begin(metaDerivationNode);
-    var childNodes = childNodesQuery(metaDerivationNode);
-    metaDerivationVerified = childNodes.every(function(childNode) {
-        var childVerified = verifyChild(childNode, metaproofContext);
-        if (childVerified) {
-            return true;
-        }
-    });
-    metaDerivationVerified ? metaproofContext.complete(metaDerivationNode) : metaproofContext.halt(metaDerivationNode);
-    return metaDerivationVerified;
-}
-function verifyChild(childNode, metaproofContext) {
-    var childVerified;
-    var childNodeRuleName = childNode.getRuleName();
-    switch(childNodeRuleName){
-        case _ruleNames.QUALIFIED_METASTATEMENT_RULE_NAME:
-            {
-                var qualifiedMetastatementNode = childNode, qualifiedMetastatementVerified = (0, _qualified.default)(qualifiedMetastatementNode, metaproofContext);
-                if (qualifiedMetastatementVerified) {
-                    var metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode), metaproofStep = _metaproof.default.fromMetastatementNode(metastatementNode);
-                    metaproofContext.addMetaproofStep(metaproofStep);
-                    childVerified = qualifiedMetastatementVerified; ///
-                }
-                break;
-            }
-        case _ruleNames.UNQUALIFIED_METASTATEMENT_RULE_NAME:
-            {
-                var unqualifiedMetastatementNode = childNode, unqualifiedMetastatementVerified = (0, _unqualified.default)(unqualifiedMetastatementNode, metaproofContext);
-                if (unqualifiedMetastatementVerified) {
-                    var metastatementNode1 = metastatementNodeQuery(unqualifiedMetastatementNode), metaproofStep1 = _metaproof.default.fromMetastatementNode(metastatementNode1);
-                    metaproofContext.addMetaproofStep(metaproofStep1);
-                    childVerified = true;
-                }
-                break;
-            }
-    }
-    return childVerified;
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92ZXJpZnkvbWV0YURlcml2YXRpb24uanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCBNZXRhcHJvb2ZTdGVwIGZyb20gXCIuLi9zdGVwL21ldGFwcm9vZlwiO1xuaW1wb3J0IHZlcmlmeVF1YWxpZmllZE1ldGFzdGF0ZW1lbnQgZnJvbSBcIi4uL3ZlcmlmeS9tZXRhc3RhdGVtZW50L3F1YWxpZmllZFwiO1xuaW1wb3J0IHZlcmlmeVVucXVhbGlmaWVkTWV0YXN0YXRlbWVudCBmcm9tIFwiLi4vdmVyaWZ5L21ldGFzdGF0ZW1lbnQvdW5xdWFsaWZpZWRcIjtcblxuaW1wb3J0IHsgbm9kZVF1ZXJ5LCBub2Rlc1F1ZXJ5IH0gZnJvbSBcIi4uL3V0aWxpdGllcy9xdWVyeVwiO1xuaW1wb3J0IHsgUVVBTElGSUVEX01FVEFTVEFURU1FTlRfUlVMRV9OQU1FLCBVTlFVQUxJRklFRF9NRVRBU1RBVEVNRU5UX1JVTEVfTkFNRSB9IGZyb20gXCIuLi9ydWxlTmFtZXNcIjtcblxuY29uc3QgY2hpbGROb2Rlc1F1ZXJ5ID0gbm9kZXNRdWVyeShcIi9tZXRhRGVyaXZhdGlvbnxtZXRhU3ViRGVyaXZhdGlvbi8qXCIpLFxuICAgICAgbWV0YXN0YXRlbWVudE5vZGVRdWVyeSA9IG5vZGVRdWVyeShcIi9xdWFsaWZpZWRNZXRhc3RhdGVtZW50fHVucXVhbGlmaWVkTWV0YXN0YXRlbWVudC9tZXRhc3RhdGVtZW50IVwiKTtcblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gdmVyaWZ5TWV0YURlcml2YXRpb24obWV0YURlcml2YXRpb25Ob2RlLCBtZXRhcHJvb2ZDb250ZXh0KSB7XG4gIGxldCBtZXRhRGVyaXZhdGlvblZlcmlmaWVkO1xuXG4gIG1ldGFwcm9vZkNvbnRleHQuYmVnaW4obWV0YURlcml2YXRpb25Ob2RlKTtcblxuICBjb25zdCBjaGlsZE5vZGVzID0gY2hpbGROb2Rlc1F1ZXJ5KG1ldGFEZXJpdmF0aW9uTm9kZSk7XG5cbiAgbWV0YURlcml2YXRpb25WZXJpZmllZCA9IGNoaWxkTm9kZXMuZXZlcnkoKGNoaWxkTm9kZSkgPT4ge1xuICAgIGNvbnN0IGNoaWxkVmVyaWZpZWQgPSB2ZXJpZnlDaGlsZChjaGlsZE5vZGUsIG1ldGFwcm9vZkNvbnRleHQpO1xuXG4gICAgaWYgKGNoaWxkVmVyaWZpZWQpIHtcbiAgICAgIHJldHVybiB0cnVlO1xuICAgIH1cbiAgfSk7XG5cbiAgbWV0YURlcml2YXRpb25WZXJpZmllZCA/XG4gICAgbWV0YXByb29mQ29udGV4dC5jb21wbGV0ZShtZXRhRGVyaXZhdGlvbk5vZGUpIDpcbiAgICAgIG1ldGFwcm9vZkNvbnRleHQuaGFsdChtZXRhRGVyaXZhdGlvbk5vZGUpO1xuXG4gIHJldHVybiBtZXRhRGVyaXZhdGlvblZlcmlmaWVkO1xufVxuXG5mdW5jdGlvbiB2ZXJpZnlDaGlsZChjaGlsZE5vZGUsIG1ldGFwcm9vZkNvbnRleHQpIHtcbiAgbGV0IGNoaWxkVmVyaWZpZWQ7XG5cbiAgY29uc3QgY2hpbGROb2RlUnVsZU5hbWUgPSBjaGlsZE5vZGUuZ2V0UnVsZU5hbWUoKTtcblxuICBzd2l0Y2ggKGNoaWxkTm9kZVJ1bGVOYW1lKSB7XG4gICAgY2FzZSBRVUFMSUZJRURfTUVUQVNUQVRFTUVOVF9SVUxFX05BTUU6IHtcbiAgICAgIGNvbnN0IHF1YWxpZmllZE1ldGFzdGF0ZW1lbnROb2RlID0gY2hpbGROb2RlLCAgLy8vXG4gICAgICAgICAgICBxdWFsaWZpZWRNZXRhc3RhdGVtZW50VmVyaWZpZWQgPSB2ZXJpZnlRdWFsaWZpZWRNZXRhc3RhdGVtZW50KHF1YWxpZmllZE1ldGFzdGF0ZW1lbnROb2RlLCBtZXRhcHJvb2ZDb250ZXh0KTtcblxuICAgICAgaWYgKHF1YWxpZmllZE1ldGFzdGF0ZW1lbnRWZXJpZmllZCkge1xuICAgICAgICBjb25zdCBtZXRhc3RhdGVtZW50Tm9kZSA9IG1ldGFzdGF0ZW1lbnROb2RlUXVlcnkocXVhbGlmaWVkTWV0YXN0YXRlbWVudE5vZGUpLFxuICAgICAgICAgICAgICBtZXRhcHJvb2ZTdGVwID0gTWV0YXByb29mU3RlcC5mcm9tTWV0YXN0YXRlbWVudE5vZGUobWV0YXN0YXRlbWVudE5vZGUpO1xuXG4gICAgICAgIG1ldGFwcm9vZkNvbnRleHQuYWRkTWV0YXByb29mU3RlcChtZXRhcHJvb2ZTdGVwKTtcblxuICAgICAgICBjaGlsZFZlcmlmaWVkID0gcXVhbGlmaWVkTWV0YXN0YXRlbWVudFZlcmlmaWVkOyAvLy9cbiAgICAgIH1cblxuICAgICAgYnJlYWs7XG4gICAgfVxuXG4gICAgY2FzZSBVTlFVQUxJRklFRF9NRVRBU1RBVEVNRU5UX1JVTEVfTkFNRToge1xuICAgICAgY29uc3QgdW5xdWFsaWZpZWRNZXRhc3RhdGVtZW50Tm9kZSA9IGNoaWxkTm9kZSwgIC8vL1xuICAgICAgICAgICAgdW5xdWFsaWZpZWRNZXRhc3RhdGVtZW50VmVyaWZpZWQgPSB2ZXJpZnlVbnF1YWxpZmllZE1ldGFzdGF0ZW1lbnQodW5xdWFsaWZpZWRNZXRhc3RhdGVtZW50Tm9kZSwgbWV0YXByb29mQ29udGV4dCk7XG5cbiAgICAgIGlmICh1bnF1YWxpZmllZE1ldGFzdGF0ZW1lbnRWZXJpZmllZCkge1xuICAgICAgICBjb25zdCBtZXRhc3RhdGVtZW50Tm9kZSA9IG1ldGFzdGF0ZW1lbnROb2RlUXVlcnkodW5xdWFsaWZpZWRNZXRhc3RhdGVtZW50Tm9kZSksXG4gICAgICAgICAgICAgIG1ldGFwcm9vZlN0ZXAgPSBNZXRhcHJvb2ZTdGVwLmZyb21NZXRhc3RhdGVtZW50Tm9kZShtZXRhc3RhdGVtZW50Tm9kZSk7XG5cbiAgICAgICAgbWV0YXByb29mQ29udGV4dC5hZGRNZXRhcHJvb2ZTdGVwKG1ldGFwcm9vZlN0ZXApO1xuXG4gICAgICAgIGNoaWxkVmVyaWZpZWQgPSB0cnVlO1xuICAgICAgfVxuXG4gICAgICBicmVhaztcbiAgICB9XG4gIH1cblxuICByZXR1cm4gY2hpbGRWZXJpZmllZDtcbn1cbiJdLCJuYW1lcyI6WyJ2ZXJpZnlNZXRhRGVyaXZhdGlvbiIsImNoaWxkTm9kZXNRdWVyeSIsIm5vZGVzUXVlcnkiLCJtZXRhc3RhdGVtZW50Tm9kZVF1ZXJ5Iiwibm9kZVF1ZXJ5IiwibWV0YURlcml2YXRpb25Ob2RlIiwibWV0YXByb29mQ29udGV4dCIsIm1ldGFEZXJpdmF0aW9uVmVyaWZpZWQiLCJiZWdpbiIsImNoaWxkTm9kZXMiLCJldmVyeSIsImNoaWxkTm9kZSIsImNoaWxkVmVyaWZpZWQiLCJ2ZXJpZnlDaGlsZCIsImNvbXBsZXRlIiwiaGFsdCIsImNoaWxkTm9kZVJ1bGVOYW1lIiwiZ2V0UnVsZU5hbWUiLCJRVUFMSUZJRURfTUVUQVNUQVRFTUVOVF9SVUxFX05BTUUiLCJxdWFsaWZpZWRNZXRhc3RhdGVtZW50Tm9kZSIsInF1YWxpZmllZE1ldGFzdGF0ZW1lbnRWZXJpZmllZCIsInZlcmlmeVF1YWxpZmllZE1ldGFzdGF0ZW1lbnQiLCJtZXRhc3RhdGVtZW50Tm9kZSIsIm1ldGFwcm9vZlN0ZXAiLCJNZXRhcHJvb2ZTdGVwIiwiZnJvbU1ldGFzdGF0ZW1lbnROb2RlIiwiYWRkTWV0YXByb29mU3RlcCIsIlVOUVVBTElGSUVEX01FVEFTVEFURU1FTlRfUlVMRV9OQU1FIiwidW5xdWFsaWZpZWRNZXRhc3RhdGVtZW50Tm9kZSIsInVucXVhbGlmaWVkTWV0YXN0YXRlbWVudFZlcmlmaWVkIiwidmVyaWZ5VW5xdWFsaWZpZWRNZXRhc3RhdGVtZW50Il0sIm1hcHBpbmdzIjoiQUFBQTs7OzsrQkFZQTs7O2VBQXdCQTs7OzhEQVZFOzhEQUNlO2dFQUNFO3FCQUVMO3lCQUNpRDs7Ozs7O0FBRXZGLElBQU1DLGtCQUFrQkMsSUFBQUEsaUJBQVUsRUFBQyx3Q0FDN0JDLHlCQUF5QkMsSUFBQUEsZ0JBQVMsRUFBQztBQUUxQixTQUFTSixxQkFBcUJLLGtCQUFrQixFQUFFQyxnQkFBZ0IsRUFBRTtJQUNqRixJQUFJQztJQUVKRCxpQkFBaUJFLEtBQUssQ0FBQ0g7SUFFdkIsSUFBTUksYUFBYVIsZ0JBQWdCSTtJQUVuQ0UseUJBQXlCRSxXQUFXQyxLQUFLLENBQUMsU0FBQ0MsV0FBYztRQUN2RCxJQUFNQyxnQkFBZ0JDLFlBQVlGLFdBQVdMO1FBRTdDLElBQUlNLGVBQWU7WUFDakIsT0FBTyxJQUFJO1FBQ2IsQ0FBQztJQUNIO0lBRUFMLHlCQUNFRCxpQkFBaUJRLFFBQVEsQ0FBQ1Qsc0JBQ3hCQyxpQkFBaUJTLElBQUksQ0FBQ1YsbUJBQW1CO0lBRTdDLE9BQU9FO0FBQ1Q7QUFFQSxTQUFTTSxZQUFZRixTQUFTLEVBQUVMLGdCQUFnQixFQUFFO0lBQ2hELElBQUlNO0lBRUosSUFBTUksb0JBQW9CTCxVQUFVTSxXQUFXO0lBRS9DLE9BQVFEO1FBQ04sS0FBS0UsNENBQWlDO1lBQUU7Z0JBQ3RDLElBQU1DLDZCQUE2QlIsV0FDN0JTLGlDQUFpQ0MsSUFBQUEsa0JBQTRCLEVBQUNGLDRCQUE0QmI7Z0JBRWhHLElBQUljLGdDQUFnQztvQkFDbEMsSUFBTUUsb0JBQW9CbkIsdUJBQXVCZ0IsNkJBQzNDSSxnQkFBZ0JDLGtCQUFhLENBQUNDLHFCQUFxQixDQUFDSDtvQkFFMURoQixpQkFBaUJvQixnQkFBZ0IsQ0FBQ0g7b0JBRWxDWCxnQkFBZ0JRLGdDQUFnQyxHQUFHO2dCQUNyRCxDQUFDO2dCQUVELEtBQU07WUFDUjtRQUVBLEtBQUtPLDhDQUFtQztZQUFFO2dCQUN4QyxJQUFNQywrQkFBK0JqQixXQUMvQmtCLG1DQUFtQ0MsSUFBQUEsb0JBQThCLEVBQUNGLDhCQUE4QnRCO2dCQUV0RyxJQUFJdUIsa0NBQWtDO29CQUNwQyxJQUFNUCxxQkFBb0JuQix1QkFBdUJ5QiwrQkFDM0NMLGlCQUFnQkMsa0JBQWEsQ0FBQ0MscUJBQXFCLENBQUNIO29CQUUxRGhCLGlCQUFpQm9CLGdCQUFnQixDQUFDSDtvQkFFbENYLGdCQUFnQixJQUFJO2dCQUN0QixDQUFDO2dCQUVELEtBQU07WUFDUjtJQUNGO0lBRUEsT0FBT0E7QUFDVCJ9

package/lib/verify/metaproof.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return verifyMetaproof;
-    }
-});
-var _metaDerivation = /*#__PURE__*/ _interopRequireDefault(require("../verify/metaDerivation"));
-var _matcher = require("../matcher");
-var _query = require("../utilities/query");
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var metaDerivationNodeQuery = (0, _query.nodeQuery)("/metaproof/metaDerivation!");
-function verifyMetaproof(metaproofNode, conclusion, metaproofContext) {
-    var metaproofVerified = false;
-    metaproofContext.begin(metaproofNode);
-    var metaDerivationNode = metaDerivationNodeQuery(metaproofNode), metaDerivationVerified = (0, _metaDerivation.default)(metaDerivationNode, metaproofContext);
-    if (metaDerivationVerified) {
-        var lastMetaproofStep = metaproofContext.getLastMetaproofStep(), metaproofStep = lastMetaproofStep, metastatementNode = metaproofStep.getMetastatementNode(), conclusionMetastatementNode = conclusion.getMetastatementNode(), nodeA = metastatementNode, nodeB = conclusionMetastatementNode, nodeMatches = _matcher.matcher.matchNode(nodeA, nodeB);
-        metaproofVerified = nodeMatches; ///
-    }
-    metaproofVerified ? metaproofContext.complete(metaproofNode) : metaproofContext.complete(metaproofNode);
-    return metaproofVerified;
-}
-
-//# sourceMappingURL=data:application/json;base64,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