occam-verify-cli 0.0.924 → 0.0.926

package/lib/verify/assertion/defined.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return verifyDefinedAssertion;
+    }
+});
+var _term = /*#__PURE__*/ _interop_require_default(require("../../verify/term"));
+var _metaLevel = /*#__PURE__*/ _interop_require_default(require("../../verifier/node/metaLevel"));
+var _array = require("../../utilities/array");
+var _query = require("../../utilities/query");
+var _verify = require("../../utilities/verify");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var termNodeQuery = (0, _query.nodeQuery)("/statement/term!"), variableNodeQuery = (0, _query.nodeQuery)("/statement/term/variable!");
+function verifyDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
+    var statementVerifiedAsDefinedAssertion = false;
+    var statementDefinedAssertion = isStatementDefinedAssertion(definedAssertionNode);
+    if (statementDefinedAssertion) {
+        var definedAssertionString = localContext.nodeAsString(definedAssertionNode);
+        localContext.trace("Verifying the '".concat(definedAssertionString, "' statement as a defined assertion..."), definedAssertionNode);
+        var definedAssertionFunctions = [
+            verifyDerivedStatementAsDefinedAssertion,
+            verifyStatedStatementAsDefinedAssertion
+        ];
+        statementVerifiedAsDefinedAssertion = definedAssertionFunctions.some(function(definedAssertionFunction) {
+            var statementVerifiedAsDefinedAssertion = definedAssertionFunction(definedAssertionNode, assignments, derived, localContext);
+            if (statementVerifiedAsDefinedAssertion) {
+                return true;
+            }
+        });
+        if (statementVerifiedAsDefinedAssertion) {
+            localContext.debug("...verified the '".concat(definedAssertionString, "' statement as a defined assertion."), definedAssertionNode);
+        }
+    }
+    return statementVerifiedAsDefinedAssertion;
+}
+function verifyDerivedStatementAsDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
+    var derivedStatementVerifiedAsDefeindAssertion = false;
+    if (derived) {
+        var definedAssertionString = localContext.nodeAsString(definedAssertionNode);
+        localContext.trace("Verifying the '".concat(definedAssertionString, "' derived statement as a defined assertion..."), definedAssertionNode);
+        var statementNegated = (0, _verify.isAssertionNegated)(definedAssertionNode), variableNode = variableNodeQuery(definedAssertionNode), termNode = termNodeQuery(definedAssertionNode);
+        if (false) {
+        ///
+        } else if (variableNode !== null) {
+            var variable = localContext.findVariableByVariableNode(variableNode);
+            if (variable !== null) {
+                var variableDefined = localContext.isVariableDefined(variable);
+                if (!statementNegated) {
+                    if (variableDefined) {
+                        derivedStatementVerifiedAsDefeindAssertion = true;
+                    }
+                }
+                if (statementNegated) {
+                    if (!variableDefined) {
+                        derivedStatementVerifiedAsDefeindAssertion = true;
+                    }
+                }
+            }
+        } else if (termNode !== null) {
+            var terms = [], termVerified = (0, _term.default)(termNode, terms, localContext, function() {
+                var verifiedAhead = true;
+                return verifiedAhead;
+            });
+            if (termVerified) {
+                var firstTerm = (0, _array.first)(terms), term = firstTerm, termGrounded = localContext.isTermGrounded(term);
+                if (!statementNegated) {
+                    if (termGrounded) {
+                        derivedStatementVerifiedAsDefeindAssertion = true;
+                    }
+                }
+                if (statementNegated) {
+                    if (!termGrounded) {
+                        derivedStatementVerifiedAsDefeindAssertion = true;
+                    }
+                }
+            }
+        }
+        if (derivedStatementVerifiedAsDefeindAssertion) {
+            localContext.debug("...verified the '".concat(definedAssertionString, "' derived statement as a defined assertion."), definedAssertionNode);
+        }
+    }
+    return derivedStatementVerifiedAsDefeindAssertion;
+}
+function verifyStatedStatementAsDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
+    var statedStatementVerifiedAsDefinedAssertion = false;
+    if (!derived) {
+        var definedAssertionString = localContext.nodeAsString(definedAssertionNode);
+        localContext.trace("Verifying the '".concat(definedAssertionString, "' stated statement as a defined assertion..."), definedAssertionNode);
+        var intrinsicLevel = localContext.isIntrinsicLevel();
+        if (intrinsicLevel) {
+            localContext.debug("The '".concat(definedAssertionString, "' stated statement as a defined assertion cannot be verified at intrinsic level."), definedAssertionNode);
+        } else {
+            var nonTerminalNode = definedAssertionNode, nonTerminalNodeVerified = _metaLevel.default.verifyNonTerminalNode(nonTerminalNode, localContext, function() {
+                var verifiedAhead = true;
+                return verifiedAhead;
+            });
+            statedStatementVerifiedAsDefinedAssertion = nonTerminalNodeVerified; ///
+        }
+        if (statedStatementVerifiedAsDefinedAssertion) {
+            localContext.debug("...verified the '".concat(definedAssertionString, "' stated statement as a defined assertion."), definedAssertionNode);
+        }
+    }
+    return statedStatementVerifiedAsDefinedAssertion;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verify/assertion/defined.js"],"sourcesContent":["\"use strict\";\n\nimport verifyTerm from \"../../verify/term\";\nimport metaLevelNodeVerifier from \"../../verifier/node/metaLevel\";\n\nimport { first } from \"../../utilities/array\";\nimport { nodeQuery } from \"../../utilities/query\";\nimport { isAssertionNegated } from \"../../utilities/verify\";\n\nconst termNodeQuery = nodeQuery(\"/statement/term!\"),\n      variableNodeQuery = nodeQuery(\"/statement/term/variable!\");\n\nexport default function verifyDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {\n  let statementVerifiedAsDefinedAssertion = false;\n\n  const statementDefinedAssertion = isStatementDefinedAssertion(definedAssertionNode);\n\n  if (statementDefinedAssertion) {\n    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);\n\n    localContext.trace(`Verifying the '${definedAssertionString}' statement as a defined assertion...`, definedAssertionNode);\n\n    const definedAssertionFunctions = [\n      verifyDerivedStatementAsDefinedAssertion,\n      verifyStatedStatementAsDefinedAssertion\n    ];\n\n    statementVerifiedAsDefinedAssertion = definedAssertionFunctions.some((definedAssertionFunction) => {\n      const statementVerifiedAsDefinedAssertion = definedAssertionFunction(definedAssertionNode, assignments, derived, localContext);\n\n      if (statementVerifiedAsDefinedAssertion) {\n        return true;\n      }\n    });\n\n    if (statementVerifiedAsDefinedAssertion) {\n      localContext.debug(`...verified the '${definedAssertionString}' statement as a defined assertion.`, definedAssertionNode);\n    }\n  }\n\n  return statementVerifiedAsDefinedAssertion;\n}\n\nfunction verifyDerivedStatementAsDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {\n  let derivedStatementVerifiedAsDefeindAssertion = false;\n\n  if (derived) {\n    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);\n\n    localContext.trace(`Verifying the '${definedAssertionString}' derived statement as a defined assertion...`, definedAssertionNode);\n\n    const statementNegated = isAssertionNegated(definedAssertionNode),\n          variableNode = variableNodeQuery(definedAssertionNode),\n          termNode = termNodeQuery(definedAssertionNode);\n\n    if (false) {\n      ///\n    } else if (variableNode !== null) {\n      const variable = localContext.findVariableByVariableNode(variableNode);\n\n      if (variable !== null) {\n        const variableDefined = localContext.isVariableDefined(variable);\n\n        if (!statementNegated) {\n          if (variableDefined) {\n            derivedStatementVerifiedAsDefeindAssertion = true;\n          }\n        }\n\n        if (statementNegated) {\n          if (!variableDefined) {\n            derivedStatementVerifiedAsDefeindAssertion = true;\n          }\n        }\n      }\n    } else if (termNode !== null) {\n      const terms = [],\n            termVerified = verifyTerm(termNode, terms, localContext, () => {\n              const verifiedAhead = true;\n\n              return verifiedAhead;\n            });\n\n      if (termVerified) {\n        const firstTerm = first(terms),\n              term = firstTerm, ///\n              termGrounded = localContext.isTermGrounded(term);\n\n        if (!statementNegated) {\n          if (termGrounded) {\n            derivedStatementVerifiedAsDefeindAssertion = true;\n          }\n        }\n\n        if (statementNegated) {\n          if (!termGrounded) {\n            derivedStatementVerifiedAsDefeindAssertion = true;\n          }\n        }\n      }\n    }\n\n    if (derivedStatementVerifiedAsDefeindAssertion) {\n      localContext.debug(`...verified the '${definedAssertionString}' derived statement as a defined assertion.`, definedAssertionNode);\n    }\n  }\n\n  return derivedStatementVerifiedAsDefeindAssertion;\n}\n\nfunction verifyStatedStatementAsDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {\n  let statedStatementVerifiedAsDefinedAssertion = false;\n\n  if (!derived) {\n    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);\n\n    localContext.trace(`Verifying the '${definedAssertionString}' stated statement as a defined assertion...`, definedAssertionNode);\n\n    const intrinsicLevel = localContext.isIntrinsicLevel();\n\n    if (intrinsicLevel) {\n      localContext.debug(`The '${definedAssertionString}' stated statement as a defined assertion cannot be verified at intrinsic level.`, definedAssertionNode);\n    } else {\n      const nonTerminalNode = definedAssertionNode, ///\n            nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {\n              const verifiedAhead = true;\n\n              return verifiedAhead;\n            });\n\n      statedStatementVerifiedAsDefinedAssertion = nonTerminalNodeVerified; ///\n    }\n\n    if (statedStatementVerifiedAsDefinedAssertion) {\n      localContext.debug(`...verified the '${definedAssertionString}' stated statement as a defined assertion.`, definedAssertionNode);\n    }\n  }\n\n  return statedStatementVerifiedAsDefinedAssertion;\n}\n"],"names":["verifyDefinedAssertion","termNodeQuery","nodeQuery","variableNodeQuery","definedAssertionNode","assignments","derived","localContext","statementVerifiedAsDefinedAssertion","statementDefinedAssertion","isStatementDefinedAssertion","definedAssertionString","nodeAsString","trace","definedAssertionFunctions","verifyDerivedStatementAsDefinedAssertion","verifyStatedStatementAsDefinedAssertion","some","definedAssertionFunction","debug","derivedStatementVerifiedAsDefeindAssertion","statementNegated","isAssertionNegated","variableNode","termNode","variable","findVariableByVariableNode","variableDefined","isVariableDefined","terms","termVerified","verifyTerm","verifiedAhead","firstTerm","first","term","termGrounded","isTermGrounded","statedStatementVerifiedAsDefinedAssertion","intrinsicLevel","isIntrinsicLevel","nonTerminalNode","nonTerminalNodeVerified","metaLevelNodeVerifier","verifyNonTerminalNode"],"mappings":"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"}

package/lib/verify/assertion/subproof.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return verifySubproofAssertion;
+    }
+});
+var _query = require("../../utilities/query");
+var _metaTypeNames = require("../../metaTypeNames");
+var metavariableNodesQuery = (0, _query.nodesQuery)("/subproofAssertion/statement/metavariable!");
+function verifySubproofAssertion(subproofAssertionNode, assignments, derived, localContext) {
+    var subproofAssertionVerified;
+    var subproofAssertionString = localContext.nodeAsString(subproofAssertionNode);
+    localContext.trace("Verifying the '".concat(subproofAssertionString, "' subproof assertion..."), subproofAssertionNode);
+    var verifySubproofAssertionFunctions = [
+        verifyDerivedSubproofAssertion,
+        verifyStatedSubproofAssertion
+    ];
+    subproofAssertionVerified = verifySubproofAssertionFunctions.some(function(verifySubproofAssertionFunction) {
+        var subproofAssertionVerified = verifySubproofAssertionFunction(subproofAssertionNode, assignments, derived, localContext);
+        if (subproofAssertionVerified) {
+            return true;
+        }
+    });
+    if (subproofAssertionVerified) {
+        localContext.debug("...verified the '".concat(subproofAssertionString, "' subproof assertion."), subproofAssertionNode);
+    }
+    return subproofAssertionVerified;
+}
+function verifyDerivedSubproofAssertion(subproofAssertionNode, assignments, derived, localContext) {
+    var derivedSubproofAssertionVerified = false;
+    if (derived) {
+        var subproofAssertionString = localContext.nodeAsString(subproofAssertionNode);
+        if (derivedSubproofAssertionVerified) {
+            localContext.debug("The '".concat(subproofAssertionString, "' derived subproof assertion cannot be verified."), subproofAssertionNode);
+        }
+    }
+    return derivedSubproofAssertionVerified;
+}
+function verifyStatedSubproofAssertion(subproofAssertionNode, assignments, derived, localContext) {
+    var statedSubproofAssertionVerified = false;
+    if (!derived) {
+        var subproofAssertionString = localContext.nodeAsString(subproofAssertionNode);
+        localContext.trace("Verifying the '".concat(subproofAssertionString, "' stated subproof assertion..."), subproofAssertionNode);
+        var metavariableNodes = metavariableNodesQuery(subproofAssertionNode);
+        statedSubproofAssertionVerified = metavariableNodes.every(function(metavariableNode) {
+            var metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
+            if (metavariable !== null) {
+                var metaTypeName = metavariable.getMetaTypeName();
+                if (metaTypeName === _metaTypeNames.STATEMENT_META_TYPE_NAME) {
+                    return true;
+                }
+            }
+        });
+        if (statedSubproofAssertionVerified) {
+            localContext.debug("...verified the '".concat(subproofAssertionString, "' stated subproof assertion."), subproofAssertionNode);
+        }
+    }
+    return statedSubproofAssertionVerified;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy92ZXJpZnkvYXNzZXJ0aW9uL3N1YnByb29mLmpzIl0sInNvdXJjZXNDb250ZW50IjpbIlwidXNlIHN0cmljdFwiO1xuXG5pbXBvcnQgeyBub2Rlc1F1ZXJ5IH0gZnJvbSBcIi4uLy4uL3V0aWxpdGllcy9xdWVyeVwiO1xuaW1wb3J0IHsgU1RBVEVNRU5UX01FVEFfVFlQRV9OQU1FIH0gZnJvbSBcIi4uLy4uL21ldGFUeXBlTmFtZXNcIjtcblxuY29uc3QgbWV0YXZhcmlhYmxlTm9kZXNRdWVyeSA9IG5vZGVzUXVlcnkoXCIvc3VicHJvb2ZBc3NlcnRpb24vc3RhdGVtZW50L21ldGF2YXJpYWJsZSFcIik7XG5cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIHZlcmlmeVN1YnByb29mQXNzZXJ0aW9uKHN1YnByb29mQXNzZXJ0aW9uTm9kZSwgYXNzaWdubWVudHMsIGRlcml2ZWQsIGxvY2FsQ29udGV4dCkge1xuICBsZXQgc3VicHJvb2ZBc3NlcnRpb25WZXJpZmllZDtcblxuICBjb25zdCBzdWJwcm9vZkFzc2VydGlvblN0cmluZyA9IGxvY2FsQ29udGV4dC5ub2RlQXNTdHJpbmcoc3VicHJvb2ZBc3NlcnRpb25Ob2RlKTtcblxuICBsb2NhbENvbnRleHQudHJhY2UoYFZlcmlmeWluZyB0aGUgJyR7c3VicHJvb2ZBc3NlcnRpb25TdHJpbmd9JyBzdWJwcm9vZiBhc3NlcnRpb24uLi5gLCBzdWJwcm9vZkFzc2VydGlvbk5vZGUpO1xuXG4gIGNvbnN0IHZlcmlmeVN1YnByb29mQXNzZXJ0aW9uRnVuY3Rpb25zID0gW1xuICAgIHZlcmlmeURlcml2ZWRTdWJwcm9vZkFzc2VydGlvbixcbiAgICB2ZXJpZnlTdGF0ZWRTdWJwcm9vZkFzc2VydGlvblxuICBdO1xuXG4gIHN1YnByb29mQXNzZXJ0aW9uVmVyaWZpZWQgPSB2ZXJpZnlTdWJwcm9vZkFzc2VydGlvbkZ1bmN0aW9ucy5zb21lKCh2ZXJpZnlTdWJwcm9vZkFzc2VydGlvbkZ1bmN0aW9uKSA9PiB7XG4gICAgY29uc3Qgc3VicHJvb2ZBc3NlcnRpb25WZXJpZmllZCA9IHZlcmlmeVN1YnByb29mQXNzZXJ0aW9uRnVuY3Rpb24oc3VicHJvb2ZBc3NlcnRpb25Ob2RlLCBhc3NpZ25tZW50cywgZGVyaXZlZCwgbG9jYWxDb250ZXh0KTtcblxuICAgIGlmIChzdWJwcm9vZkFzc2VydGlvblZlcmlmaWVkKSB7XG4gICAgICByZXR1cm4gdHJ1ZTtcbiAgICB9XG4gIH0pO1xuXG4gIGlmIChzdWJwcm9vZkFzc2VydGlvblZlcmlmaWVkKSB7XG4gICAgbG9jYWxDb250ZXh0LmRlYnVnKGAuLi52ZXJpZmllZCB0aGUgJyR7c3VicHJvb2ZBc3NlcnRpb25TdHJpbmd9JyBzdWJwcm9vZiBhc3NlcnRpb24uYCwgc3VicHJvb2ZBc3NlcnRpb25Ob2RlKTtcbiAgfVxuXG4gIHJldHVybiBzdWJwcm9vZkFzc2VydGlvblZlcmlmaWVkO1xufVxuXG5mdW5jdGlvbiB2ZXJpZnlEZXJpdmVkU3VicHJvb2ZBc3NlcnRpb24oc3VicHJvb2ZBc3NlcnRpb25Ob2RlLCBhc3NpZ25tZW50cywgZGVyaXZlZCwgbG9jYWxDb250ZXh0KSB7XG4gIGxldCBkZXJpdmVkU3VicHJvb2ZBc3NlcnRpb25WZXJpZmllZCA9IGZhbHNlO1xuXG4gIGlmIChkZXJpdmVkKSB7XG4gICAgY29uc3Qgc3VicHJvb2ZBc3NlcnRpb25TdHJpbmcgPSBsb2NhbENvbnRleHQubm9kZUFzU3RyaW5nKHN1YnByb29mQXNzZXJ0aW9uTm9kZSk7XG5cbiAgICBpZiAoZGVyaXZlZFN1YnByb29mQXNzZXJ0aW9uVmVyaWZpZWQpIHtcbiAgICAgIGxvY2FsQ29udGV4dC5kZWJ1ZyhgVGhlICcke3N1YnByb29mQXNzZXJ0aW9uU3RyaW5nfScgZGVyaXZlZCBzdWJwcm9vZiBhc3NlcnRpb24gY2Fubm90IGJlIHZlcmlmaWVkLmAsIHN1YnByb29mQXNzZXJ0aW9uTm9kZSk7XG4gICAgfVxuICB9XG5cbiAgcmV0dXJuIGRlcml2ZWRTdWJwcm9vZkFzc2VydGlvblZlcmlmaWVkO1xufVxuXG5mdW5jdGlvbiB2ZXJpZnlTdGF0ZWRTdWJwcm9vZkFzc2VydGlvbihzdWJwcm9vZkFzc2VydGlvbk5vZGUsIGFzc2lnbm1lbnRzLCBkZXJpdmVkLCBsb2NhbENvbnRleHQpIHtcbiAgbGV0IHN0YXRlZFN1YnByb29mQXNzZXJ0aW9uVmVyaWZpZWQgPSBmYWxzZTtcblxuICBpZiAoIWRlcml2ZWQpIHtcbiAgICBjb25zdCBzdWJwcm9vZkFzc2VydGlvblN0cmluZyA9IGxvY2FsQ29udGV4dC5ub2RlQXNTdHJpbmcoc3VicHJvb2ZBc3NlcnRpb25Ob2RlKTtcblxuICAgIGxvY2FsQ29udGV4dC50cmFjZShgVmVyaWZ5aW5nIHRoZSAnJHtzdWJwcm9vZkFzc2VydGlvblN0cmluZ30nIHN0YXRlZCBzdWJwcm9vZiBhc3NlcnRpb24uLi5gLCBzdWJwcm9vZkFzc2VydGlvbk5vZGUpO1xuXG4gICAgY29uc3QgbWV0YXZhcmlhYmxlTm9kZXMgPSBtZXRhdmFyaWFibGVOb2Rlc1F1ZXJ5KHN1YnByb29mQXNzZXJ0aW9uTm9kZSk7XG5cbiAgICBzdGF0ZWRTdWJwcm9vZkFzc2VydGlvblZlcmlmaWVkID0gbWV0YXZhcmlhYmxlTm9kZXMuZXZlcnkoKG1ldGF2YXJpYWJsZU5vZGUpID0+IHtcbiAgICAgIGNvbnN0IG1ldGF2YXJpYWJsZSA9IGxvY2FsQ29udGV4dC5maW5kTWV0YXZhcmlhYmxlQnlNZXRhdmFyaWFibGVOb2RlKG1ldGF2YXJpYWJsZU5vZGUpO1xuXG4gICAgICBpZiAobWV0YXZhcmlhYmxlICE9PSBudWxsKSB7XG4gICAgICAgIGNvbnN0IG1ldGFUeXBlTmFtZSA9IG1ldGF2YXJpYWJsZS5nZXRNZXRhVHlwZU5hbWUoKTtcblxuICAgICAgICBpZiAobWV0YVR5cGVOYW1lID09PSBTVEFURU1FTlRfTUVUQV9UWVBFX05BTUUpIHtcbiAgICAgICAgICByZXR1cm4gdHJ1ZTtcbiAgICAgICAgfVxuICAgICAgfVxuICAgIH0pO1xuXG4gICAgaWYgKHN0YXRlZFN1YnByb29mQXNzZXJ0aW9uVmVyaWZpZWQpIHtcbiAgICAgIGxvY2FsQ29udGV4dC5kZWJ1ZyhgLi4udmVyaWZpZWQgdGhlICcke3N1YnByb29mQXNzZXJ0aW9uU3RyaW5nfScgc3RhdGVkIHN1YnByb29mIGFzc2VydGlvbi5gLCBzdWJwcm9vZkFzc2VydGlvbk5vZGUpO1xuICAgIH1cbiAgfVxuXG4gIHJldHVybiBzdGF0ZWRTdWJwcm9vZkFzc2VydGlvblZlcmlmaWVkO1xufVxuIl0sIm5hbWVzIjpbInZlcmlmeVN1YnByb29mQXNzZXJ0aW9uIiwibWV0YXZhcmlhYmxlTm9kZXNRdWVyeSIsIm5vZGVzUXVlcnkiLCJzdWJwcm9vZkFzc2VydGlvbk5vZGUiLCJhc3NpZ25tZW50cyIsImRlcml2ZWQiLCJsb2NhbENvbnRleHQiLCJzdWJwcm9vZkFzc2VydGlvblZlcmlmaWVkIiwic3VicHJvb2ZBc3NlcnRpb25TdHJpbmciLCJub2RlQXNTdHJpbmciLCJ0cmFjZSIsInZlcmlmeVN1YnByb29mQXNzZXJ0aW9uRnVuY3Rpb25zIiwidmVyaWZ5RGVyaXZlZFN1YnByb29mQXNzZXJ0aW9uIiwidmVyaWZ5U3RhdGVkU3VicHJvb2ZBc3NlcnRpb24iLCJzb21lIiwidmVyaWZ5U3VicHJvb2ZBc3NlcnRpb25GdW5jdGlvbiIsImRlYnVnIiwiZGVyaXZlZFN1YnByb29mQXNzZXJ0aW9uVmVyaWZpZWQiLCJzdGF0ZWRTdWJwcm9vZkFzc2VydGlvblZlcmlmaWVkIiwibWV0YXZhcmlhYmxlTm9kZXMiLCJldmVyeSIsIm1ldGF2YXJpYWJsZU5vZGUiLCJtZXRhdmFyaWFibGUiLCJmaW5kTWV0YXZhcmlhYmxlQnlNZXRhdmFyaWFibGVOb2RlIiwibWV0YVR5cGVOYW1lIiwiZ2V0TWV0YVR5cGVOYW1lIiwiU1RBVEVNRU5UX01FVEFfVFlQRV9OQU1FIl0sIm1hcHBpbmdzIjoiQUFBQTs7OzsrQkFPQTs7O2VBQXdCQTs7O3FCQUxHOzZCQUNjO0FBRXpDLElBQU1DLHlCQUF5QkMsSUFBQUEsaUJBQVUsRUFBQztBQUUzQixTQUFTRix3QkFBd0JHLHFCQUFxQixFQUFFQyxXQUFXLEVBQUVDLE9BQU8sRUFBRUMsWUFBWTtJQUN2RyxJQUFJQztJQUVKLElBQU1DLDBCQUEwQkYsYUFBYUcsWUFBWSxDQUFDTjtJQUUxREcsYUFBYUksS0FBSyxDQUFDLEFBQUMsa0JBQXlDLE9BQXhCRix5QkFBd0IsNEJBQTBCTDtJQUV2RixJQUFNUSxtQ0FBbUM7UUFDdkNDO1FBQ0FDO0tBQ0Q7SUFFRE4sNEJBQTRCSSxpQ0FBaUNHLElBQUksQ0FBQyxTQUFDQztRQUNqRSxJQUFNUiw0QkFBNEJRLGdDQUFnQ1osdUJBQXVCQyxhQUFhQyxTQUFTQztRQUUvRyxJQUFJQywyQkFBMkI7WUFDN0IsT0FBTztRQUNUO0lBQ0Y7SUFFQSxJQUFJQSwyQkFBMkI7UUFDN0JELGFBQWFVLEtBQUssQ0FBQyxBQUFDLG9CQUEyQyxPQUF4QlIseUJBQXdCLDBCQUF3Qkw7SUFDekY7SUFFQSxPQUFPSTtBQUNUO0FBRUEsU0FBU0ssK0JBQStCVCxxQkFBcUIsRUFBRUMsV0FBVyxFQUFFQyxPQUFPLEVBQUVDLFlBQVk7SUFDL0YsSUFBSVcsbUNBQW1DO0lBRXZDLElBQUlaLFNBQVM7UUFDWCxJQUFNRywwQkFBMEJGLGFBQWFHLFlBQVksQ0FBQ047UUFFMUQsSUFBSWMsa0NBQWtDO1lBQ3BDWCxhQUFhVSxLQUFLLENBQUMsQUFBQyxRQUErQixPQUF4QlIseUJBQXdCLHFEQUFtREw7UUFDeEc7SUFDRjtJQUVBLE9BQU9jO0FBQ1Q7QUFFQSxTQUFTSiw4QkFBOEJWLHFCQUFxQixFQUFFQyxXQUFXLEVBQUVDLE9BQU8sRUFBRUMsWUFBWTtJQUM5RixJQUFJWSxrQ0FBa0M7SUFFdEMsSUFBSSxDQUFDYixTQUFTO1FBQ1osSUFBTUcsMEJBQTBCRixhQUFhRyxZQUFZLENBQUNOO1FBRTFERyxhQUFhSSxLQUFLLENBQUMsQUFBQyxrQkFBeUMsT0FBeEJGLHlCQUF3QixtQ0FBaUNMO1FBRTlGLElBQU1nQixvQkFBb0JsQix1QkFBdUJFO1FBRWpEZSxrQ0FBa0NDLGtCQUFrQkMsS0FBSyxDQUFDLFNBQUNDO1lBQ3pELElBQU1DLGVBQWVoQixhQUFhaUIsa0NBQWtDLENBQUNGO1lBRXJFLElBQUlDLGlCQUFpQixNQUFNO2dCQUN6QixJQUFNRSxlQUFlRixhQUFhRyxlQUFlO2dCQUVqRCxJQUFJRCxpQkFBaUJFLHVDQUF3QixFQUFFO29CQUM3QyxPQUFPO2dCQUNUO1lBQ0Y7UUFDRjtRQUVBLElBQUlSLGlDQUFpQztZQUNuQ1osYUFBYVUsS0FBSyxDQUFDLEFBQUMsb0JBQTJDLE9BQXhCUix5QkFBd0IsaUNBQStCTDtRQUNoRztJQUNGO0lBRUEsT0FBT2U7QUFDVCJ9

package/lib/verify/assertion/type.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return verifyTypeAssertion;
+    }
+});
+var _variable = /*#__PURE__*/ _interop_require_default(require("../../variable"));
+var _term = /*#__PURE__*/ _interop_require_default(require("../../verify/term"));
+var _variable1 = /*#__PURE__*/ _interop_require_default(require("../../assignment/variable"));
+var _array = require("../../utilities/array");
+var _query = require("../../utilities/query");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var termNodeQuery = (0, _query.nodeQuery)("/typeAssertion/term!"), typeNodeQuery = (0, _query.nodeQuery)("/typeAssertion/type!"), variableNodeQuery = (0, _query.nodeQuery)("/term/variable!");
+function verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext) {
+    var typeAssertionVerified;
+    var typeAssertionString = localContext.nodeAsString(typeAssertionNode);
+    localContext.trace("Verifying the '".concat(typeAssertionString, "' type assertion..."), typeAssertionNode);
+    var verifyTypeAssertionFunctions = [
+        verifyDerivedTypeAssertion,
+        verifyStatedTypeAssertion
+    ];
+    typeAssertionVerified = verifyTypeAssertionFunctions.some(function(verifyTypeAssertionFunction) {
+        var typeAssertionVerified = verifyTypeAssertionFunction(typeAssertionNode, assignments, derived, localContext);
+        if (typeAssertionVerified) {
+            return true;
+        }
+    });
+    if (typeAssertionVerified) {
+        localContext.debug("...verified the '".concat(typeAssertionString, "' type assertion."), typeAssertionNode);
+    }
+    return typeAssertionVerified;
+}
+function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, localContext) {
+    var derivedTypeAssertionVerified = false;
+    if (derived) {
+        var typeAssertionString = localContext.nodeAsString(typeAssertionNode);
+        localContext.trace("Verifying the '".concat(typeAssertionString, "' derived type assertion..."), typeAssertionNode);
+        var terms = [], termNode = termNodeQuery(typeAssertionNode), termVerified = (0, _term.default)(termNode, terms, localContext, function() {
+            var verifiedAhead = false;
+            var typeNode = typeNodeQuery(typeAssertionNode), type = localContext.findTypeByTypeNode(typeNode);
+            if (type !== null) {
+                var firstTerm = (0, _array.first)(terms), term = firstTerm, termType = localContext.getTermType(term), typeEqualToOrSuperTypeOfTermType = type.isEqualToOrSuperTypeOf(termType);
+                if (typeEqualToOrSuperTypeOfTermType) {
+                    var variableNode = variableNodeQuery(termNode);
+                    if (variableNode === null) {
+                        verifiedAhead = true;
+                    } else {
+                        var variable = localContext.findVariableByVariableNode(variableNode);
+                        variable = _variable.default.fromVariableAndType(variable, type);
+                        var variableAssignment = _variable1.default.fromVariable(variable), assignment = variableAssignment; ///
+                        assignments.push(assignment);
+                        verifiedAhead = true;
+                        if (!verifiedAhead) {
+                            assignments.pop();
+                        }
+                    }
+                }
+            }
+            return verifiedAhead;
+        });
+        derivedTypeAssertionVerified = termVerified; ///
+        if (derivedTypeAssertionVerified) {
+            localContext.debug("...verified the '".concat(typeAssertionString, "' derived type assertion."), typeAssertionNode);
+        }
+    }
+    return derivedTypeAssertionVerified;
+}
+function verifyStatedTypeAssertion(typeAssertionNode, assignments, derived, localContext) {
+    var statedTypeAssertionVerified = false;
+    if (!derived) {
+        var typeAssertionString = localContext.nodeAsString(typeAssertionNode);
+        localContext.trace("Verifying the '".concat(typeAssertionString, "' stated type assertion..."), typeAssertionNode);
+        var terms = [], termNode = termNodeQuery(typeAssertionNode), termVerified = (0, _term.default)(termNode, terms, localContext, function() {
+            var verifiedAhead = false;
+            var typeNode = typeNodeQuery(typeAssertionNode), type = localContext.findTypeByTypeNode(typeNode);
+            if (type !== null) {
+                var firstTerm = (0, _array.first)(terms), term = firstTerm, termType = term.getType(), typeEqualToOrSubTypeOfTermType = type.isEqualToOrSubTypeOf(termType);
+                if (typeEqualToOrSubTypeOfTermType) {
+                    var variableNode = variableNodeQuery(termNode);
+                    if (variableNode === null) {
+                        verifiedAhead = true;
+                    } else {
+                        var variable = localContext.findVariableByVariableNode(variableNode);
+                        variable = _variable.default.fromVariableAndType(variable, type);
+                        var variableAssignment = _variable1.default.fromVariable(variable), assignment = variableAssignment; ///
+                        assignments.push(assignment);
+                        verifiedAhead = true;
+                        if (!verifiedAhead) {
+                            assignments.pop();
+                        }
+                    }
+                }
+            }
+            return verifiedAhead;
+        });
+        statedTypeAssertionVerified = termVerified; ///
+        if (statedTypeAssertionVerified) {
+            localContext.debug("...verified the '".concat(typeAssertionString, "' stated type assertion."), typeAssertionNode);
+        }
+    }
+    return statedTypeAssertionVerified;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verify/assertion/type.js"],"sourcesContent":["\"use strict\";\n\nimport Variable from \"../../variable\";\nimport verifyTerm from \"../../verify/term\";\nimport VariableAssignment from \"../../assignment/variable\";\n\nimport { first } from \"../../utilities/array\";\nimport { nodeQuery } from \"../../utilities/query\";\n\nconst termNodeQuery = nodeQuery(\"/typeAssertion/term!\"),\n      typeNodeQuery = nodeQuery(\"/typeAssertion/type!\"),\n      variableNodeQuery = nodeQuery(\"/term/variable!\");\n\nexport default function verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext) {\n  let typeAssertionVerified;\n\n  const typeAssertionString = localContext.nodeAsString(typeAssertionNode);\n\n  localContext.trace(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);\n\n  const verifyTypeAssertionFunctions = [\n    verifyDerivedTypeAssertion,\n    verifyStatedTypeAssertion\n  ];\n\n  typeAssertionVerified = verifyTypeAssertionFunctions.some((verifyTypeAssertionFunction) => {\n    const typeAssertionVerified = verifyTypeAssertionFunction(typeAssertionNode, assignments, derived, localContext);\n\n    if (typeAssertionVerified) {\n      return true;\n    }\n  });\n\n  if (typeAssertionVerified) {\n    localContext.debug(`...verified the '${typeAssertionString}' type assertion.`, typeAssertionNode);\n  }\n\n  return typeAssertionVerified;\n}\n\nfunction verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, localContext) {\n  let derivedTypeAssertionVerified = false;\n\n  if (derived) {\n    const typeAssertionString = localContext.nodeAsString(typeAssertionNode);\n\n    localContext.trace(`Verifying the '${typeAssertionString}' derived type assertion...`, typeAssertionNode);\n\n    const terms = [],\n          termNode = termNodeQuery(typeAssertionNode),\n          termVerified = verifyTerm(termNode, terms, localContext, () => {\n            let verifiedAhead = false;\n\n            const typeNode = typeNodeQuery(typeAssertionNode),\n                  type = localContext.findTypeByTypeNode(typeNode);\n\n            if (type !== null) {\n              const firstTerm = first(terms),\n                    term = firstTerm, ///\n                    termType = localContext.getTermType(term),\n                    typeEqualToOrSuperTypeOfTermType = type.isEqualToOrSuperTypeOf(termType);\n\n              if (typeEqualToOrSuperTypeOfTermType) {\n                const variableNode = variableNodeQuery(termNode);\n\n                if (variableNode === null) {\n                  verifiedAhead = true;\n                } else {\n                  let variable = localContext.findVariableByVariableNode(variableNode);\n\n                  variable = Variable.fromVariableAndType(variable, type);\n\n                  const variableAssignment = VariableAssignment.fromVariable(variable),\n                        assignment = variableAssignment;  ///\n\n                  assignments.push(assignment);\n\n                  verifiedAhead = true;\n\n                  if (!verifiedAhead) {\n                    assignments.pop();\n                  }\n                }\n              }\n            }\n\n            return verifiedAhead;\n          });\n\n    derivedTypeAssertionVerified = termVerified; ///\n\n    if (derivedTypeAssertionVerified) {\n      localContext.debug(`...verified the '${typeAssertionString}' derived type assertion.`, typeAssertionNode);\n    }\n  }\n\n  return derivedTypeAssertionVerified;\n}\n\nfunction verifyStatedTypeAssertion(typeAssertionNode, assignments, derived, localContext) {\n  let statedTypeAssertionVerified = false;\n\n  if (!derived) {\n    const typeAssertionString = localContext.nodeAsString(typeAssertionNode);\n\n    localContext.trace(`Verifying the '${typeAssertionString}' stated type assertion...`, typeAssertionNode);\n\n    const terms = [],\n          termNode = termNodeQuery(typeAssertionNode),\n          termVerified = verifyTerm(termNode, terms, localContext, () => {\n            let verifiedAhead = false;\n\n            const typeNode = typeNodeQuery(typeAssertionNode),\n                  type = localContext.findTypeByTypeNode(typeNode);\n\n            if (type !== null) {\n              const firstTerm = first(terms),\n                    term = firstTerm, ///\n                    termType = term.getType(),\n                    typeEqualToOrSubTypeOfTermType = type.isEqualToOrSubTypeOf(termType);\n\n              if (typeEqualToOrSubTypeOfTermType) {\n                const variableNode = variableNodeQuery(termNode);\n\n                if (variableNode === null) {\n                  verifiedAhead = true;\n                } else {\n                  let variable = localContext.findVariableByVariableNode(variableNode);\n\n                  variable = Variable.fromVariableAndType(variable, type);\n\n                  const variableAssignment = VariableAssignment.fromVariable(variable),\n                        assignment = variableAssignment;  ///\n\n                  assignments.push(assignment);\n\n                  verifiedAhead = true;\n\n                  if (!verifiedAhead) {\n                    assignments.pop();\n                  }\n                }\n              }\n            }\n\n            return verifiedAhead;\n          });\n\n    statedTypeAssertionVerified = termVerified; ///\n\n    if (statedTypeAssertionVerified) {\n      localContext.debug(`...verified the '${typeAssertionString}' stated type assertion.`, typeAssertionNode);\n    }\n  }\n\n  return statedTypeAssertionVerified;\n}\n"],"names":["verifyTypeAssertion","termNodeQuery","nodeQuery","typeNodeQuery","variableNodeQuery","typeAssertionNode","assignments","derived","localContext","typeAssertionVerified","typeAssertionString","nodeAsString","trace","verifyTypeAssertionFunctions","verifyDerivedTypeAssertion","verifyStatedTypeAssertion","some","verifyTypeAssertionFunction","debug","derivedTypeAssertionVerified","terms","termNode","termVerified","verifyTerm","verifiedAhead","typeNode","type","findTypeByTypeNode","firstTerm","first","term","termType","getTermType","typeEqualToOrSuperTypeOfTermType","isEqualToOrSuperTypeOf","variableNode","variable","findVariableByVariableNode","Variable","fromVariableAndType","variableAssignment","VariableAssignment","fromVariable","assignment","push","pop","statedTypeAssertionVerified","getType","typeEqualToOrSubTypeOfTermType","isEqualToOrSubTypeOf"],"mappings":"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"}

package/lib/verify/declaration.js

@@ -25,10 +25,7 @@ function verifyDeclaration(declarationNode, declarations, localContext) {
     var referenceNode = referenceNodeQuery(declarationNode), referenceVerified = verifyReference(referenceNode, localContext);
     if (referenceVerified) {
         var statementNode = statementNodeQuery(declarationNode);
-        var verifyStatement = _metaLevel.default.verifyStatement, derived = false, assignments = [], statementVerified = verifyStatement(statementNode, assignments, derived, localContext, function() {
-            var verifiedAhead = true;
-            return verifiedAhead;
-        });
+        var verifyStatement = _metaLevel.default.verifyStatement, derived = false, assignments = [], statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
         if (statementVerified) {
             var metavariableNode = metavariableNodeQuery(referenceNode), declaration = _declaration.default.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
             declarations.push(declaration);
@@ -62,4 +59,4 @@ function verifyReference(referenceNode, localContext) {
     return referenceVerified;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/verify/equality.js

@@ -64,7 +64,7 @@ function verifyDerivedEquality(equalityNode, assignments, derived, localContext,
         });
         derivedEqualityVerified = termsVerified; ///
         if (derivedEqualityVerified) {
-            localContext.trace("...verified the '".concat(equalityString, "' derived equality."), equalityNode);
+            localContext.debug("...verified the '".concat(equalityString, "' derived equality."), equalityNode);
         }
     }
     return derivedEqualityVerified;
@@ -92,10 +92,10 @@ function verifyStatedEquality(equalityNode, assignments, derived, localContext,
         });
         statedEqualityVerified = termsVerified; ///
         if (statedEqualityVerified) {
-            localContext.trace("...verified the '".concat(equalityString, "' stated equality."), equalityNode);
+            localContext.debug("...verified the '".concat(equalityString, "' stated equality."), equalityNode);
         }
     }
     return statedEqualityVerified;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/equality.js"],"sourcesContent":["\"use strict\";\n\nimport Equality from \"../equality\";\nimport verifyTerms from \"../verify/terms\";\nimport EqualityAssignment from \"../assignment/equality\";\n\nimport { nodeQuery } from \"../utilities/query\";\nimport { first, second } from \"../utilities/array\";\n\nconst leftTermNodeQuery = nodeQuery(\"/equality/argument[0]/term!\"),\n      rightTermNodeQuery = nodeQuery(\"/equality/argument[1]/term!\");\n\nexport default function verifyEquality(equalityNode, assignments, derived, localContext, verifyAhead) {\n  let equalityVerified;\n\n  const equalityString = localContext.nodeAsString(equalityNode);\n\n  localContext.trace(`Verifying the '${equalityString}' equality...`, equalityNode);\n\n  const verifyEqualityFunctions = [\n    verifyDerivedEquality,\n    verifyStatedEquality\n  ];\n\n  equalityVerified = verifyEqualityFunctions.some((verifyEqualityFunction) => {\n    const equalityVerified = verifyEqualityFunction(equalityNode, assignments, derived, localContext, verifyAhead);\n\n    if (equalityVerified) {\n      return true;\n    }\n  });\n\n  if (equalityVerified) {\n    localContext.debug(`...verified the '${equalityString}' equality.`, equalityNode);\n  }\n\n  return equalityVerified;\n}\n\nfunction verifyDerivedEquality(equalityNode, assignments, derived, localContext, verifyAhead) {\n  let derivedEqualityVerified = false;\n\n  if (derived) {\n    const equalityString = localContext.nodeAsString(equalityNode);\n\n    localContext.trace(`Verifying the '${equalityString}' derived equality...`, equalityNode);\n\n    const terms = [],\n          leftTermNode = leftTermNodeQuery(equalityNode),\n          rightTermNode = rightTermNodeQuery(equalityNode),\n          termNodes = [\n            leftTermNode,\n            rightTermNode\n          ],\n          termsVerified = verifyTerms(termNodes, terms, localContext, () => {\n            let verifiedAhead = false;\n\n            const firstTerm = first(terms),\n                  secondTerm = second(terms),\n                  leftTerm = firstTerm, ///\n                  rightTerm = secondTerm, ///\n                  equality = Equality.fromLeftTermRightTermAndEqualityNode(leftTerm, rightTerm, equalityNode);\n\n            if (equality !== null) {\n              const equalityEqual = equality.isEqual(localContext);\n\n              if (equalityEqual) {\n                const equalityAssignment = EqualityAssignment.fromEquality(equality),\n                      assignment = equalityAssignment; ///\n\n                assignments.push(assignment);\n\n                verifiedAhead = verifyAhead();\n\n                if (!verifiedAhead) {\n                  assignments.pop();\n                }\n              }\n            }\n\n            return verifiedAhead;\n          });\n\n    derivedEqualityVerified = termsVerified; ///\n\n    if (derivedEqualityVerified) {\n      localContext.trace(`...verified the '${equalityString}' derived equality.`, equalityNode);\n    }\n  }\n\n  return derivedEqualityVerified;\n}\n\nfunction verifyStatedEquality(equalityNode, assignments, derived, localContext, verifyAhead) {\n  let statedEqualityVerified = false;\n\n  if (!derived) {\n    const equalityString = localContext.nodeAsString(equalityNode);\n\n    localContext.trace(`Verifying the '${equalityString}' stated equality...`, equalityNode);\n\n    const terms = [],\n          leftTermNode = leftTermNodeQuery(equalityNode),\n          rightTermNode = rightTermNodeQuery(equalityNode),\n          termNodes = [\n            leftTermNode,\n            rightTermNode\n          ],\n          termsVerified = verifyTerms(termNodes, terms, localContext, () => {\n            let verifiedAhead = false;\n\n            const firstTerm = first(terms),\n                  secondTerm = second(terms),\n                  leftTerm = firstTerm, ///\n                  rightTerm = secondTerm, ///\n                  equality = Equality.fromLeftTermRightTermAndEqualityNode(leftTerm, rightTerm, equalityNode);\n\n            if (equality !== null) {\n              const equalityAssignment = EqualityAssignment.fromEquality(equality),\n                    assignment = equalityAssignment; ///\n\n              assignments.push(assignment);\n\n              verifiedAhead = verifyAhead();\n\n              if (!verifiedAhead) {\n                assignments.pop();\n              }\n            }\n\n            return verifiedAhead;\n          });\n\n    statedEqualityVerified = termsVerified; ///\n\n    if (statedEqualityVerified) {\n      localContext.trace(`...verified the '${equalityString}' stated equality.`, equalityNode);\n    }\n  }\n\n  return statedEqualityVerified;\n}\n"],"names":["verifyEquality","leftTermNodeQuery","nodeQuery","rightTermNodeQuery","equalityNode","assignments","derived","localContext","verifyAhead","equalityVerified","equalityString","nodeAsString","trace","verifyEqualityFunctions","verifyDerivedEquality","verifyStatedEquality","some","verifyEqualityFunction","debug","derivedEqualityVerified","terms","leftTermNode","rightTermNode","termNodes","termsVerified","verifyTerms","verifiedAhead","firstTerm","first","secondTerm","second","leftTerm","rightTerm","equality","Equality","fromLeftTermRightTermAndEqualityNode","equalityEqual","isEqual","equalityAssignment","EqualityAssignment","fromEquality","assignment","push","pop","statedEqualityVerified"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/equality.js"],"sourcesContent":["\"use strict\";\n\nimport Equality from \"../equality\";\nimport verifyTerms from \"../verify/terms\";\nimport EqualityAssignment from \"../assignment/equality\";\n\nimport { nodeQuery } from \"../utilities/query\";\nimport { first, second } from \"../utilities/array\";\n\nconst leftTermNodeQuery = nodeQuery(\"/equality/argument[0]/term!\"),\n      rightTermNodeQuery = nodeQuery(\"/equality/argument[1]/term!\");\n\nexport default function verifyEquality(equalityNode, assignments, derived, localContext, verifyAhead) {\n  let equalityVerified;\n\n  const equalityString = localContext.nodeAsString(equalityNode);\n\n  localContext.trace(`Verifying the '${equalityString}' equality...`, equalityNode);\n\n  const verifyEqualityFunctions = [\n    verifyDerivedEquality,\n    verifyStatedEquality\n  ];\n\n  equalityVerified = verifyEqualityFunctions.some((verifyEqualityFunction) => {\n    const equalityVerified = verifyEqualityFunction(equalityNode, assignments, derived, localContext, verifyAhead);\n\n    if (equalityVerified) {\n      return true;\n    }\n  });\n\n  if (equalityVerified) {\n    localContext.debug(`...verified the '${equalityString}' equality.`, equalityNode);\n  }\n\n  return equalityVerified;\n}\n\nfunction verifyDerivedEquality(equalityNode, assignments, derived, localContext, verifyAhead) {\n  let derivedEqualityVerified = false;\n\n  if (derived) {\n    const equalityString = localContext.nodeAsString(equalityNode);\n\n    localContext.trace(`Verifying the '${equalityString}' derived equality...`, equalityNode);\n\n    const terms = [],\n          leftTermNode = leftTermNodeQuery(equalityNode),\n          rightTermNode = rightTermNodeQuery(equalityNode),\n          termNodes = [\n            leftTermNode,\n            rightTermNode\n          ],\n          termsVerified = verifyTerms(termNodes, terms, localContext, () => {\n            let verifiedAhead = false;\n\n            const firstTerm = first(terms),\n                  secondTerm = second(terms),\n                  leftTerm = firstTerm, ///\n                  rightTerm = secondTerm, ///\n                  equality = Equality.fromLeftTermRightTermAndEqualityNode(leftTerm, rightTerm, equalityNode);\n\n            if (equality !== null) {\n              const equalityEqual = equality.isEqual(localContext);\n\n              if (equalityEqual) {\n                const equalityAssignment = EqualityAssignment.fromEquality(equality),\n                      assignment = equalityAssignment; ///\n\n                assignments.push(assignment);\n\n                verifiedAhead = verifyAhead();\n\n                if (!verifiedAhead) {\n                  assignments.pop();\n                }\n              }\n            }\n\n            return verifiedAhead;\n          });\n\n    derivedEqualityVerified = termsVerified; ///\n\n    if (derivedEqualityVerified) {\n      localContext.debug(`...verified the '${equalityString}' derived equality.`, equalityNode);\n    }\n  }\n\n  return derivedEqualityVerified;\n}\n\nfunction verifyStatedEquality(equalityNode, assignments, derived, localContext, verifyAhead) {\n  let statedEqualityVerified = false;\n\n  if (!derived) {\n    const equalityString = localContext.nodeAsString(equalityNode);\n\n    localContext.trace(`Verifying the '${equalityString}' stated equality...`, equalityNode);\n\n    const terms = [],\n          leftTermNode = leftTermNodeQuery(equalityNode),\n          rightTermNode = rightTermNodeQuery(equalityNode),\n          termNodes = [\n            leftTermNode,\n            rightTermNode\n          ],\n          termsVerified = verifyTerms(termNodes, terms, localContext, () => {\n            let verifiedAhead = false;\n\n            const firstTerm = first(terms),\n                  secondTerm = second(terms),\n                  leftTerm = firstTerm, ///\n                  rightTerm = secondTerm, ///\n                  equality = Equality.fromLeftTermRightTermAndEqualityNode(leftTerm, rightTerm, equalityNode);\n\n            if (equality !== null) {\n              const equalityAssignment = EqualityAssignment.fromEquality(equality),\n                    assignment = equalityAssignment; ///\n\n              assignments.push(assignment);\n\n              verifiedAhead = verifyAhead();\n\n              if (!verifiedAhead) {\n                assignments.pop();\n              }\n            }\n\n            return verifiedAhead;\n          });\n\n    statedEqualityVerified = termsVerified; ///\n\n    if (statedEqualityVerified) {\n      localContext.debug(`...verified the '${equalityString}' stated equality.`, equalityNode);\n    }\n  }\n\n  return statedEqualityVerified;\n}\n"],"names":["verifyEquality","leftTermNodeQuery","nodeQuery","rightTermNodeQuery","equalityNode","assignments","derived","localContext","verifyAhead","equalityVerified","equalityString","nodeAsString","trace","verifyEqualityFunctions","verifyDerivedEquality","verifyStatedEquality","some","verifyEqualityFunction","debug","derivedEqualityVerified","terms","leftTermNode","rightTermNode","termNodes","termsVerified","verifyTerms","verifiedAhead","firstTerm","first","secondTerm","second","leftTerm","rightTerm","equality","Equality","fromLeftTermRightTermAndEqualityNode","equalityEqual","isEqual","equalityAssignment","EqualityAssignment","fromEquality","assignment","push","pop","statedEqualityVerified"],"mappings":"AAAA;;;;+BAYA;;;eAAwBA;;;+DAVH;4DACG;gEACO;qBAEL;qBACI;;;;;;AAE9B,IAAMC,oBAAoBC,IAAAA,gBAAS,EAAC,gCAC9BC,qBAAqBD,IAAAA,gBAAS,EAAC;AAEtB,SAASF,eAAeI,YAAY,EAAEC,WAAW,EAAEC,OAAO,EAAEC,YAAY,EAAEC,WAAW;IAClG,IAAIC;IAEJ,IAAMC,iBAAiBH,aAAaI,YAAY,CAACP;IAEjDG,aAAaK,KAAK,CAAC,AAAC,kBAAgC,OAAfF,gBAAe,kBAAgBN;IAEpE,IAAMS,0BAA0B;QAC9BC;QACAC;KACD;IAEDN,mBAAmBI,wBAAwBG,IAAI,CAAC,SAACC;QAC/C,IAAMR,mBAAmBQ,uBAAuBb,cAAcC,aAAaC,SAASC,cAAcC;QAElG,IAAIC,kBAAkB;YACpB,OAAO;QACT;IACF;IAEA,IAAIA,kBAAkB;QACpBF,aAAaW,KAAK,CAAC,AAAC,oBAAkC,OAAfR,gBAAe,gBAAcN;IACtE;IAEA,OAAOK;AACT;AAEA,SAASK,sBAAsBV,YAAY,EAAEC,WAAW,EAAEC,OAAO,EAAEC,YAAY,EAAEC,WAAW;IAC1F,IAAIW,0BAA0B;IAE9B,IAAIb,SAAS;QACX,IAAMI,iBAAiBH,aAAaI,YAAY,CAACP;QAEjDG,aAAaK,KAAK,CAAC,AAAC,kBAAgC,OAAfF,gBAAe,0BAAwBN;QAE5E,IAAMgB,QAAQ,EAAE,EACVC,eAAepB,kBAAkBG,eACjCkB,gBAAgBnB,mBAAmBC,eACnCmB,YAAY;YACVF;YACAC;SACD,EACDE,gBAAgBC,IAAAA,cAAW,EAACF,WAAWH,OAAOb,cAAc;YAC1D,IAAImB,gBAAgB;YAEpB,IAAMC,YAAYC,IAAAA,YAAK,EAACR,QAClBS,aAAaC,IAAAA,aAAM,EAACV,QACpBW,WAAWJ,WACXK,YAAYH,YACZI,WAAWC,iBAAQ,CAACC,oCAAoC,CAACJ,UAAUC,WAAW5B;YAEpF,IAAI6B,aAAa,MAAM;gBACrB,IAAMG,gBAAgBH,SAASI,OAAO,CAAC9B;gBAEvC,IAAI6B,eAAe;oBACjB,IAAME,qBAAqBC,kBAAkB,CAACC,YAAY,CAACP,WACrDQ,aAAaH,oBAAoB,GAAG;oBAE1CjC,YAAYqC,IAAI,CAACD;oBAEjBf,gBAAgBlB;oBAEhB,IAAI,CAACkB,eAAe;wBAClBrB,YAAYsC,GAAG;oBACjB;gBACF;YACF;YAEA,OAAOjB;QACT;QAENP,0BAA0BK,eAAe,GAAG;QAE5C,IAAIL,yBAAyB;YAC3BZ,aAAaW,KAAK,CAAC,AAAC,oBAAkC,OAAfR,gBAAe,wBAAsBN;QAC9E;IACF;IAEA,OAAOe;AACT;AAEA,SAASJ,qBAAqBX,YAAY,EAAEC,WAAW,EAAEC,OAAO,EAAEC,YAAY,EAAEC,WAAW;IACzF,IAAIoC,yBAAyB;IAE7B,IAAI,CAACtC,SAAS;QACZ,IAAMI,iBAAiBH,aAAaI,YAAY,CAACP;QAEjDG,aAAaK,KAAK,CAAC,AAAC,kBAAgC,OAAfF,gBAAe,yBAAuBN;QAE3E,IAAMgB,QAAQ,EAAE,EACVC,eAAepB,kBAAkBG,eACjCkB,gBAAgBnB,mBAAmBC,eACnCmB,YAAY;YACVF;YACAC;SACD,EACDE,gBAAgBC,IAAAA,cAAW,EAACF,WAAWH,OAAOb,cAAc;YAC1D,IAAImB,gBAAgB;YAEpB,IAAMC,YAAYC,IAAAA,YAAK,EAACR,QAClBS,aAAaC,IAAAA,aAAM,EAACV,QACpBW,WAAWJ,WACXK,YAAYH,YACZI,WAAWC,iBAAQ,CAACC,oCAAoC,CAACJ,UAAUC,WAAW5B;YAEpF,IAAI6B,aAAa,MAAM;gBACrB,IAAMK,qBAAqBC,kBAAkB,CAACC,YAAY,CAACP,WACrDQ,aAAaH,oBAAoB,GAAG;gBAE1CjC,YAAYqC,IAAI,CAACD;gBAEjBf,gBAAgBlB;gBAEhB,IAAI,CAACkB,eAAe;oBAClBrB,YAAYsC,GAAG;gBACjB;YACF;YAEA,OAAOjB;QACT;QAENkB,yBAAyBpB,eAAe,GAAG;QAE3C,IAAIoB,wBAAwB;YAC1BrC,aAAaW,KAAK,CAAC,AAAC,oBAAkC,OAAfR,gBAAe,uBAAqBN;QAC7E;IACF;IAEA,OAAOwC;AACT"}

package/lib/verify/metastatement.js

@@ -8,7 +8,6 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
-var _judgement = /*#__PURE__*/ _interop_require_default(require("../verify/judgement"));
 var _metaLevel = /*#__PURE__*/ _interop_require_default(require("../verifier/node/metaLevel"));
 var _query = require("../utilities/query");
 function _interop_require_default(obj) {
@@ -90,4 +89,4 @@ function isStatementJudgement(statementNode) {
     return statementJudgement;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/metastatement.js"],"sourcesContent":["\"use strict\";\n\nimport verifyJudgement from \"../verify/judgement\";\nimport metaLevelNodeVerifier from \"../verifier/node/metaLevel\";\n\nimport { nodeQuery } from \"../utilities/query\";\n\nconst judgementNodeQuery = nodeQuery(\"/statement/judgement!\");\n\nfunction verifyStatement(statementNode, assignments, derived, localContext) {\n  let statementVerified;\n\n  const statementString = localContext.nodeAsString(statementNode);\n\n  localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);\n\n  const verifyStatementFunctions = [\n    verifyStatementAsIs\n  ];\n\n  statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {\n    const statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext);\n\n    if (statementVerified) {\n      return true;\n    }\n  });\n\n  if (statementVerified) {\n    localContext.debug(`...verified the '${statementString}' statement.`, statementNode);\n  }\n\n  return statementVerified;\n}\n\nObject.assign(metaLevelNodeVerifier, {\n  verifyStatement\n});\n\nexport default verifyStatement;\n\nfunction verifyStatementAsIs(statementNode, assignments, derived, localContext) {\n  let statementVerifiedAsIs;\n\n  const statementJudgement = isStatementJudgement(statementNode);\n\n  if (!statementJudgement) {\n    const statementString = localContext.nodeAsString(statementNode);\n\n    localContext.trace(`Verifying the '${statementString}' statement as is...`, statementNode);\n\n    const verifyStatementAsIsFunctions = [\n      verifyDerivedStatementAsIs,\n      verifyStatedStatementAsIs\n    ];\n\n    statementVerifiedAsIs = verifyStatementAsIsFunctions.some((verifyStatementAsIsFunction) => {\n      const statementVerifiedAsIs = verifyStatementAsIsFunction(statementNode, assignments, derived, localContext);\n\n      if (statementVerifiedAsIs) {\n        return true;\n      }\n    });\n\n    if (statementVerifiedAsIs) {\n      localContext.debug(`...verified the '${statementString}' statement as is.`, statementNode);\n    }\n  }\n\n  return statementVerifiedAsIs;\n}\n\nfunction verifyDerivedStatementAsIs(statementNode, assignments, derived, localContext) {\n  let derivedStatementVerifiedAsIs = false;\n\n  if (derived) {\n    const statementString = localContext.nodeAsString(statementNode);\n\n    localContext.debug(`Cannot verify the '${statementString}' derived statement as is.`, statementNode);\n  }\n\n  return derivedStatementVerifiedAsIs;\n}\n\nfunction verifyStatedStatementAsIs(statementNode, assignments, derived, localContext) {\n  let statedStatementVerifiedAsIs = false;\n\n  if (!derived) {\n    const statementString = localContext.nodeAsString(statementNode);\n\n    localContext.trace(`Verifying the '${statementString}' stated statement as is...`, statementNode);\n\n    const nonTerminalNode = statementNode, ///\n          nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {\n            const verifiedAhead = true;\n\n            return verifiedAhead;\n          });\n\n    statedStatementVerifiedAsIs = nonTerminalNodeVerified;  ///\n\n    if (statedStatementVerifiedAsIs) {\n      localContext.debug(`...verified the '${statementString}' stated statement as is.`, statementNode);\n    }\n  }\n\n  return statedStatementVerifiedAsIs;\n}\n\nfunction isStatementJudgement(statementNode) {\n  const judgementNode = judgementNodeQuery(statementNode),\n        statementJudgement = (judgementNode !== null);\n\n  return statementJudgement;\n}"],"names":["judgementNodeQuery","nodeQuery","verifyStatement","statementNode","assignments","derived","localContext","statementVerified","statementString","nodeAsString","trace","verifyStatementFunctions","verifyStatementAsIs","some","verifyStatementFunction","debug","Object","assign","metaLevelNodeVerifier","statementVerifiedAsIs","statementJudgement","isStatementJudgement","verifyStatementAsIsFunctions","verifyDerivedStatementAsIs","verifyStatedStatementAsIs","verifyStatementAsIsFunction","derivedStatementVerifiedAsIs","statedStatementVerifiedAsIs","nonTerminalNode","nonTerminalNodeVerified","verifyNonTerminalNode","verifiedAhead","judgementNode"],"mappings":"AAAA;;;;+BAuCA;;;eAAA;;;gEArC4B;gEACM;qBAER;;;;;;AAE1B,IAAMA,qBAAqBC,IAAAA,gBAAS,EAAC;AAErC,SAASC,gBAAgBC,aAAa,EAAEC,WAAW,EAAEC,OAAO,EAAEC,YAAY;IACxE,IAAIC;IAEJ,IAAMC,kBAAkBF,aAAaG,YAAY,CAACN;IAElDG,aAAaI,KAAK,CAAC,AAAC,kBAAiC,OAAhBF,iBAAgB,mBAAiBL;IAEtE,IAAMQ,2BAA2B;QAC/BC;KACD;IAEDL,oBAAoBI,yBAAyBE,IAAI,CAAC,SAACC;QACjD,IAAMP,oBAAoBO,wBAAwBX,eAAeC,aAAaC,SAASC;QAEvF,IAAIC,mBAAmB;YACrB,OAAO;QACT;IACF;IAEA,IAAIA,mBAAmB;QACrBD,aAAaS,KAAK,CAAC,AAAC,oBAAmC,OAAhBP,iBAAgB,iBAAeL;IACxE;IAEA,OAAOI;AACT;AAEAS,OAAOC,MAAM,CAACC,kBAAqB,EAAE;IACnChB,iBAAAA;AACF;IAEA,WAAeA;AAEf,SAASU,oBAAoBT,aAAa,EAAEC,WAAW,EAAEC,OAAO,EAAEC,YAAY;IAC5E,IAAIa;IAEJ,IAAMC,qBAAqBC,qBAAqBlB;IAEhD,IAAI,CAACiB,oBAAoB;QACvB,IAAMZ,kBAAkBF,aAAaG,YAAY,CAACN;QAElDG,aAAaI,KAAK,CAAC,AAAC,kBAAiC,OAAhBF,iBAAgB,yBAAuBL;QAE5E,IAAMmB,+BAA+B;YACnCC;YACAC;SACD;QAEDL,wBAAwBG,6BAA6BT,IAAI,CAAC,SAACY;YACzD,IAAMN,wBAAwBM,4BAA4BtB,eAAeC,aAAaC,SAASC;YAE/F,IAAIa,uBAAuB;gBACzB,OAAO;YACT;QACF;QAEA,IAAIA,uBAAuB;YACzBb,aAAaS,KAAK,CAAC,AAAC,oBAAmC,OAAhBP,iBAAgB,uBAAqBL;QAC9E;IACF;IAEA,OAAOgB;AACT;AAEA,SAASI,2BAA2BpB,aAAa,EAAEC,WAAW,EAAEC,OAAO,EAAEC,YAAY;IACnF,IAAIoB,+BAA+B;IAEnC,IAAIrB,SAAS;QACX,IAAMG,kBAAkBF,aAAaG,YAAY,CAACN;QAElDG,aAAaS,KAAK,CAAC,AAAC,sBAAqC,OAAhBP,iBAAgB,+BAA6BL;IACxF;IAEA,OAAOuB;AACT;AAEA,SAASF,0BAA0BrB,aAAa,EAAEC,WAAW,EAAEC,OAAO,EAAEC,YAAY;IAClF,IAAIqB,8BAA8B;IAElC,IAAI,CAACtB,SAAS;QACZ,IAAMG,kBAAkBF,aAAaG,YAAY,CAACN;QAElDG,aAAaI,KAAK,CAAC,AAAC,kBAAiC,OAAhBF,iBAAgB,gCAA8BL;QAEnF,IAAMyB,kBAAkBzB,eAClB0B,0BAA0BX,kBAAqB,CAACY,qBAAqB,CAACF,iBAAiBtB,cAAc;YACnG,IAAMyB,gBAAgB;YAEtB,OAAOA;QACT;QAENJ,8BAA8BE,yBAA0B,GAAG;QAE3D,IAAIF,6BAA6B;YAC/BrB,aAAaS,KAAK,CAAC,AAAC,oBAAmC,OAAhBP,iBAAgB,8BAA4BL;QACrF;IACF;IAEA,OAAOwB;AACT;AAEA,SAASN,qBAAqBlB,aAAa;IACzC,IAAM6B,gBAAgBhC,mBAAmBG,gBACnCiB,qBAAsBY,kBAAkB;IAE9C,OAAOZ;AACT"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/metastatement.js"],"sourcesContent":["\"use strict\";\n\nimport metaLevelNodeVerifier from \"../verifier/node/metaLevel\";\n\nimport { nodeQuery } from \"../utilities/query\";\n\nconst judgementNodeQuery = nodeQuery(\"/statement/judgement!\");\n\nfunction verifyStatement(statementNode, assignments, derived, localContext) {\n  let statementVerified;\n\n  const statementString = localContext.nodeAsString(statementNode);\n\n  localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);\n\n  const verifyStatementFunctions = [\n    verifyStatementAsIs\n  ];\n\n  statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {\n    const statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext);\n\n    if (statementVerified) {\n      return true;\n    }\n  });\n\n  if (statementVerified) {\n    localContext.debug(`...verified the '${statementString}' statement.`, statementNode);\n  }\n\n  return statementVerified;\n}\n\nObject.assign(metaLevelNodeVerifier, {\n  verifyStatement\n});\n\nexport default verifyStatement;\n\nfunction verifyStatementAsIs(statementNode, assignments, derived, localContext) {\n  let statementVerifiedAsIs;\n\n  const statementJudgement = isStatementJudgement(statementNode);\n\n  if (!statementJudgement) {\n    const statementString = localContext.nodeAsString(statementNode);\n\n    localContext.trace(`Verifying the '${statementString}' statement as is...`, statementNode);\n\n    const verifyStatementAsIsFunctions = [\n      verifyDerivedStatementAsIs,\n      verifyStatedStatementAsIs\n    ];\n\n    statementVerifiedAsIs = verifyStatementAsIsFunctions.some((verifyStatementAsIsFunction) => {\n      const statementVerifiedAsIs = verifyStatementAsIsFunction(statementNode, assignments, derived, localContext);\n\n      if (statementVerifiedAsIs) {\n        return true;\n      }\n    });\n\n    if (statementVerifiedAsIs) {\n      localContext.debug(`...verified the '${statementString}' statement as is.`, statementNode);\n    }\n  }\n\n  return statementVerifiedAsIs;\n}\n\nfunction verifyDerivedStatementAsIs(statementNode, assignments, derived, localContext) {\n  let derivedStatementVerifiedAsIs = false;\n\n  if (derived) {\n    const statementString = localContext.nodeAsString(statementNode);\n\n    localContext.debug(`Cannot verify the '${statementString}' derived statement as is.`, statementNode);\n  }\n\n  return derivedStatementVerifiedAsIs;\n}\n\nfunction verifyStatedStatementAsIs(statementNode, assignments, derived, localContext) {\n  let statedStatementVerifiedAsIs = false;\n\n  if (!derived) {\n    const statementString = localContext.nodeAsString(statementNode);\n\n    localContext.trace(`Verifying the '${statementString}' stated statement as is...`, statementNode);\n\n    const nonTerminalNode = statementNode, ///\n          nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {\n            const verifiedAhead = true;\n\n            return verifiedAhead;\n          });\n\n    statedStatementVerifiedAsIs = nonTerminalNodeVerified;  ///\n\n    if (statedStatementVerifiedAsIs) {\n      localContext.debug(`...verified the '${statementString}' stated statement as is.`, statementNode);\n    }\n  }\n\n  return statedStatementVerifiedAsIs;\n}\n\nfunction isStatementJudgement(statementNode) {\n  const judgementNode = judgementNodeQuery(statementNode),\n        statementJudgement = (judgementNode !== null);\n\n  return statementJudgement;\n}"],"names":["judgementNodeQuery","nodeQuery","verifyStatement","statementNode","assignments","derived","localContext","statementVerified","statementString","nodeAsString","trace","verifyStatementFunctions","verifyStatementAsIs","some","verifyStatementFunction","debug","Object","assign","metaLevelNodeVerifier","statementVerifiedAsIs","statementJudgement","isStatementJudgement","verifyStatementAsIsFunctions","verifyDerivedStatementAsIs","verifyStatedStatementAsIs","verifyStatementAsIsFunction","derivedStatementVerifiedAsIs","statedStatementVerifiedAsIs","nonTerminalNode","nonTerminalNodeVerified","verifyNonTerminalNode","verifiedAhead","judgementNode"],"mappings":"AAAA;;;;+BAsCA;;;eAAA;;;gEApCkC;qBAER;;;;;;AAE1B,IAAMA,qBAAqBC,IAAAA,gBAAS,EAAC;AAErC,SAASC,gBAAgBC,aAAa,EAAEC,WAAW,EAAEC,OAAO,EAAEC,YAAY;IACxE,IAAIC;IAEJ,IAAMC,kBAAkBF,aAAaG,YAAY,CAACN;IAElDG,aAAaI,KAAK,CAAC,AAAC,kBAAiC,OAAhBF,iBAAgB,mBAAiBL;IAEtE,IAAMQ,2BAA2B;QAC/BC;KACD;IAEDL,oBAAoBI,yBAAyBE,IAAI,CAAC,SAACC;QACjD,IAAMP,oBAAoBO,wBAAwBX,eAAeC,aAAaC,SAASC;QAEvF,IAAIC,mBAAmB;YACrB,OAAO;QACT;IACF;IAEA,IAAIA,mBAAmB;QACrBD,aAAaS,KAAK,CAAC,AAAC,oBAAmC,OAAhBP,iBAAgB,iBAAeL;IACxE;IAEA,OAAOI;AACT;AAEAS,OAAOC,MAAM,CAACC,kBAAqB,EAAE;IACnChB,iBAAAA;AACF;IAEA,WAAeA;AAEf,SAASU,oBAAoBT,aAAa,EAAEC,WAAW,EAAEC,OAAO,EAAEC,YAAY;IAC5E,IAAIa;IAEJ,IAAMC,qBAAqBC,qBAAqBlB;IAEhD,IAAI,CAACiB,oBAAoB;QACvB,IAAMZ,kBAAkBF,aAAaG,YAAY,CAACN;QAElDG,aAAaI,KAAK,CAAC,AAAC,kBAAiC,OAAhBF,iBAAgB,yBAAuBL;QAE5E,IAAMmB,+BAA+B;YACnCC;YACAC;SACD;QAEDL,wBAAwBG,6BAA6BT,IAAI,CAAC,SAACY;YACzD,IAAMN,wBAAwBM,4BAA4BtB,eAAeC,aAAaC,SAASC;YAE/F,IAAIa,uBAAuB;gBACzB,OAAO;YACT;QACF;QAEA,IAAIA,uBAAuB;YACzBb,aAAaS,KAAK,CAAC,AAAC,oBAAmC,OAAhBP,iBAAgB,uBAAqBL;QAC9E;IACF;IAEA,OAAOgB;AACT;AAEA,SAASI,2BAA2BpB,aAAa,EAAEC,WAAW,EAAEC,OAAO,EAAEC,YAAY;IACnF,IAAIoB,+BAA+B;IAEnC,IAAIrB,SAAS;QACX,IAAMG,kBAAkBF,aAAaG,YAAY,CAACN;QAElDG,aAAaS,KAAK,CAAC,AAAC,sBAAqC,OAAhBP,iBAAgB,+BAA6BL;IACxF;IAEA,OAAOuB;AACT;AAEA,SAASF,0BAA0BrB,aAAa,EAAEC,WAAW,EAAEC,OAAO,EAAEC,YAAY;IAClF,IAAIqB,8BAA8B;IAElC,IAAI,CAACtB,SAAS;QACZ,IAAMG,kBAAkBF,aAAaG,YAAY,CAACN;QAElDG,aAAaI,KAAK,CAAC,AAAC,kBAAiC,OAAhBF,iBAAgB,gCAA8BL;QAEnF,IAAMyB,kBAAkBzB,eAClB0B,0BAA0BX,kBAAqB,CAACY,qBAAqB,CAACF,iBAAiBtB,cAAc;YACnG,IAAMyB,gBAAgB;YAEtB,OAAOA;QACT;QAENJ,8BAA8BE,yBAA0B,GAAG;QAE3D,IAAIF,6BAA6B;YAC/BrB,aAAaS,KAAK,CAAC,AAAC,oBAAmC,OAAhBP,iBAAgB,8BAA4BL;QACrF;IACF;IAEA,OAAOwB;AACT;AAEA,SAASN,qBAAqBlB,aAAa;IACzC,IAAM6B,gBAAgBhC,mBAAmBG,gBACnCiB,qBAAsBY,kBAAkB;IAE9C,OAAOZ;AACT"}

package/lib/verify/proof.js

@@ -17,18 +17,18 @@ function _interop_require_default(obj) {
     };
 }
 var derivationNodeQuery = (0, _query.nodeQuery)("/proof/derivation!");
-function verifyProof(proofNode, conclusion, substitutions, localContext) {
+function verifyProof(proofNode, statementNode, substitutions, localContext) {
     var proofVerified = false;
     localContext = _local.default.fromLocalContext(localContext); ///
     var derivationNode = derivationNodeQuery(proofNode), derivationVerified = (0, _derivation.default)(derivationNode, substitutions, localContext);
     if (derivationVerified) {
         var lastProofStep = localContext.getLastProofStep();
         if (lastProofStep !== null) {
-            var proofStep = lastProofStep, statementNode = proofStep.getStatementNode(), conclusionStatementNode = conclusion.getStatementNode(), statementNodeMatchesConclusionStatementNode = statementNode.match(conclusionStatementNode);
-            proofVerified = statementNodeMatchesConclusionStatementNode; ///
+            var lastProofStepStatementNode = lastProofStep.getStatementNode(), lastStatementNode = lastProofStepStatementNode, statementNodeMatchesLastStatementNode = statementNode.match(lastStatementNode);
+            proofVerified = statementNodeMatchesLastStatementNode; ///
         }
     }
     return proofVerified;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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