occam-verify-cli 0.0.1059 → 0.0.1063

package/lib/assertion/contained.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return ContainedAssertion;
+    }
+});
+var _shim = /*#__PURE__*/ _interop_require_default(require("../shim"));
+var _assertion = require("../utilities/assertion");
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var ContainedAssertion = /*#__PURE__*/ function() {
+    function ContainedAssertion(string, node, term, frame, negated, statement) {
+        _class_call_check(this, ContainedAssertion);
+        this.string = string;
+        this.node = node;
+        this.term = term;
+        this.frame = frame;
+        this.negated = negated;
+        this.statement = statement;
+    }
+    _create_class(ContainedAssertion, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getTerm",
+            value: function getTerm() {
+                return this.term;
+            }
+        },
+        {
+            key: "getFrame",
+            value: function getFrame() {
+                return this.frame;
+            }
+        },
+        {
+            key: "isNegated",
+            value: function isNegated() {
+                return this.negated;
+            }
+        },
+        {
+            key: "getStatement",
+            value: function getStatement() {
+                return this.statement;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, localContext) {
+                var verified = false;
+                var containedAssertionString = this.string; ///
+                localContext.trace("Verifying the '".concat(containedAssertionString, "' contained assertion..."));
+                assignments = null; ///
+                stated = true; ///
+                var termVerified = true, frameVerified = true, statementVerified;
+                if (this.term !== null) {
+                    termVerified = this.term.verify(localContext, function() {
+                        var verifiedAhead = true;
+                        return verifiedAhead;
+                    });
+                }
+                if (this.frame !== null) {
+                    frameVerified = this.frame.verify(localContext);
+                }
+                statementVerified = this.statement.verify(assignments, stated, localContext);
+                if (termVerified && frameVerified && statementVerified) {
+                    var verifiedWhenStated = false, verifiedWhenDerived = false;
+                    if (stated) {
+                        verifiedWhenStated = this.verifyWhenStated(assignments, localContext);
+                    } else {
+                        verifiedWhenDerived = this.verifyWhenDerived(localContext);
+                    }
+                    if (verifiedWhenStated || verifiedWhenDerived) {
+                        verified = true;
+                    }
+                }
+                if (verified) {
+                    localContext.debug("...verified the '".concat(containedAssertionString, "' contained assertion."));
+                }
+                return verified;
+            }
+        },
+        {
+            key: "verifyWhenStated",
+            value: function verifyWhenStated(assignments, localContext) {
+                var verifiedWhenStated;
+                var containedAssertionString = this.string; ///
+                localContext.trace("Verifying the '".concat(containedAssertionString, "' stated contained assertion..."));
+                verifiedWhenStated = true;
+                if (verifiedWhenStated) {
+                    localContext.debug("...verified the '".concat(containedAssertionString, "' stated contained assertion."));
+                }
+                return verifiedWhenStated;
+            }
+        },
+        {
+            key: "verifyWhenDerived",
+            value: function verifyWhenDerived(localContext) {
+                var verifiedWhenDerived = false;
+                var containedAssertionString = this.string; ///
+                localContext.trace("Verifying the '".concat(containedAssertionString, "' derived contained assertion..."));
+                if (this.term !== null) {
+                    var variable = this.term.getVariable(localContext);
+                    if (variable !== null) {
+                        var variableContained = this.statement.isVariableContained(variable, localContext);
+                        if (!this.negated && variableContained) {
+                            verifiedWhenDerived = true;
+                        }
+                        if (this.negated && !variableContained) {
+                            verifiedWhenDerived = true;
+                        }
+                    }
+                }
+                if (this.frame !== null) {
+                    var metavariable = this.frame.getVariable(localContext);
+                    if (metavariable !== null) {
+                        var metavariableContained = this.statement.isMetavariableContained(metavariable, localContext);
+                        if (!this.negated && metavariableContained) {
+                            verifiedWhenDerived = true;
+                        }
+                        if (this.negated && !metavariableContained) {
+                            verifiedWhenDerived = true;
+                        }
+                    }
+                }
+                if (verifiedWhenDerived) {
+                    localContext.debug("...verified the '".concat(containedAssertionString, "' derived contained assertion."));
+                }
+                return verifiedWhenDerived;
+            }
+        }
+    ], [
+        {
+            key: "fromContainedAssertionNode",
+            value: function fromContainedAssertionNode(containedAssertionNode, localContext) {
+                var containedAssertion = null;
+                if (containedAssertionNode !== null) {
+                    var Term = _shim.default.Term, Frame = _shim.default.Frame, Statement = _shim.default.Statement, node = containedAssertionNode, string = localContext.nodeAsString(node), term = Term.fromContainedAssertionNode(containedAssertionNode, localContext), frame = Frame.fromContainedAssertionNode(containedAssertionNode, localContext), statement = Statement.fromContainedAssertionNode(containedAssertionNode, localContext), containedAssertionNegated = (0, _assertion.isAssertionNegated)(containedAssertionNode), negated = containedAssertionNegated; ///
+                    containedAssertion = new ContainedAssertion(string, node, term, frame, negated, statement);
+                }
+                return containedAssertion;
+            }
+        }
+    ]);
+    return ContainedAssertion;
+}();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/assertion/contained.js"],"sourcesContent":["\"use strict\";\n\nimport shim from \"../shim\";\n\nimport { isAssertionNegated } from \"../utilities/assertion\";\n\nexport default class ContainedAssertion {\n  constructor(string, node, term, frame, negated, statement) {\n    this.string = string;\n    this.node = node;\n    this.term = term;\n    this.frame = frame;\n    this.negated = negated;\n    this.statement = statement;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getTerm() {\n    return this.term;\n  }\n\n  getFrame() {\n    return this.frame;\n  }\n\n  isNegated() {\n    return this.negated;\n  }\n\n  getStatement() {\n    return this.statement;\n  }\n\n  verify(assignments, stated, localContext) {\n    let verified = false;\n\n    const containedAssertionString = this.string; ///\n\n    localContext.trace(`Verifying the '${containedAssertionString}' contained assertion...`);\n\n    assignments = null; ///\n\n    stated = true;  ///\n\n    let termVerified = true,  ///\n        frameVerified = true, ///\n        statementVerified;\n\n    if (this.term !== null) {\n      termVerified = this.term.verify(localContext, () => {\n        const verifiedAhead = true;\n\n        return verifiedAhead;\n      });\n    }\n\n    if (this.frame !== null) {\n      frameVerified = this.frame.verify(localContext);\n    }\n\n    statementVerified = this.statement.verify(assignments, stated, localContext);\n\n    if (termVerified && frameVerified && statementVerified) {\n      let verifiedWhenStated = false,\n          verifiedWhenDerived = false;\n\n      if (stated) {\n        verifiedWhenStated = this.verifyWhenStated(assignments, localContext);\n      } else {\n        verifiedWhenDerived = this.verifyWhenDerived(localContext);\n      }\n\n      if (verifiedWhenStated || verifiedWhenDerived) {\n        verified = true;\n      }\n    }\n\n    if (verified) {\n      localContext.debug(`...verified the '${containedAssertionString}' contained assertion.`);\n    }\n\n    return verified;\n  }\n\n  verifyWhenStated(assignments, localContext) {\n    let verifiedWhenStated;\n\n    const containedAssertionString = this.string; ///\n\n    localContext.trace(`Verifying the '${containedAssertionString}' stated contained assertion...`);\n\n    verifiedWhenStated = true;\n\n    if (verifiedWhenStated) {\n      localContext.debug(`...verified the '${containedAssertionString}' stated contained assertion.`);\n    }\n\n    return verifiedWhenStated;\n  }\n\n  verifyWhenDerived(localContext) {\n    let verifiedWhenDerived = false;\n\n    const containedAssertionString = this.string; ///\n\n    localContext.trace(`Verifying the '${containedAssertionString}' derived contained assertion...`);\n\n    if (this.term !== null) {\n      const variable = this.term.getVariable(localContext);\n\n      if (variable !== null) {\n        const variableContained = this.statement.isVariableContained(variable, localContext);\n\n        if (!this.negated && variableContained) {\n          verifiedWhenDerived = true;\n        }\n\n        if (this.negated && !variableContained) {\n          verifiedWhenDerived = true;\n        }\n      }\n    }\n\n    if (this.frame !== null) {\n      const metavariable = this.frame.getVariable(localContext);\n\n      if (metavariable !== null) {\n        const metavariableContained = this.statement.isMetavariableContained(metavariable, localContext);\n\n        if (!this.negated && metavariableContained) {\n          verifiedWhenDerived = true;\n        }\n\n        if (this.negated && !metavariableContained) {\n          verifiedWhenDerived = true;\n        }\n      }\n    }\n\n    if (verifiedWhenDerived) {\n      localContext.debug(`...verified the '${containedAssertionString}' derived contained assertion.`);\n    }\n\n    return verifiedWhenDerived;\n  }\n\n  static fromContainedAssertionNode(containedAssertionNode, localContext) {\n    let containedAssertion = null;\n\n    if (containedAssertionNode !== null) {\n      const { Term, Frame, Statement } = shim,\n            node = containedAssertionNode,  ///\n            string = localContext.nodeAsString(node),\n            term = Term.fromContainedAssertionNode(containedAssertionNode, localContext),\n            frame = Frame.fromContainedAssertionNode(containedAssertionNode, localContext),\n            statement = Statement.fromContainedAssertionNode(containedAssertionNode, localContext),\n            containedAssertionNegated = isAssertionNegated(containedAssertionNode),\n            negated = containedAssertionNegated;  ///\n\n      containedAssertion = new ContainedAssertion(string, node, term, frame, negated, statement);\n    }\n\n    return containedAssertion;\n  }\n}\n"],"names":["ContainedAssertion","string","node","term","frame","negated","statement","getString","getNode","getTerm","getFrame","isNegated","getStatement","verify","assignments","stated","localContext","verified","containedAssertionString","trace","termVerified","frameVerified","statementVerified","verifiedAhead","verifiedWhenStated","verifiedWhenDerived","verifyWhenStated","verifyWhenDerived","debug","variable","getVariable","variableContained","isVariableContained","metavariable","metavariableContained","isMetavariableContained","fromContainedAssertionNode","containedAssertionNode","containedAssertion","Term","shim","Frame","Statement","nodeAsString","containedAssertionNegated","isAssertionNegated"],"mappings":"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"}

package/lib/assertion/defined.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return DefinedAssertion;
+    }
+});
+var _shim = /*#__PURE__*/ _interop_require_default(require("../shim"));
+var _assertion = require("../utilities/assertion");
+var _name = require("../utilities/name");
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var DefinedAssertion = /*#__PURE__*/ function() {
+    function DefinedAssertion(string, node, term, frame) {
+        _class_call_check(this, DefinedAssertion);
+        this.string = string;
+        this.node = node;
+        this.term = term;
+        this.frame = frame;
+    }
+    _create_class(DefinedAssertion, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getTerm",
+            value: function getTerm() {
+                return this.term;
+            }
+        },
+        {
+            key: "getStatement",
+            value: function getStatement() {
+                return this.frame;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, localContext) {
+                var verified = false;
+                var definedAssertionString = this.string; ///
+                localContext.trace("Verifying the '".concat(definedAssertionString, "' defined assertion..."));
+                var termVerified = true, frameVerified = true; ///
+                if (this.term !== null) {
+                    termVerified = this.term.verify(localContext, function() {
+                        var verifiedAhead = true;
+                        return verifiedAhead;
+                    });
+                }
+                if (this.frame !== null) {
+                    frameVerified = this.frame.verify(localContext);
+                }
+                if (termVerified && frameVerified) {
+                    var verifiedWhenStated = false, verifiedWhenDerived = false;
+                    if (stated) {
+                        verifiedWhenStated = this.verifyWhenStated(localContext);
+                    } else {
+                        verifiedWhenDerived = this.verifyWhenDerived(localContext);
+                    }
+                    if (verifiedWhenStated || verifiedWhenDerived) {
+                        verified = true;
+                    }
+                }
+                if (verified) {
+                    localContext.debug("...verified the '".concat(definedAssertionString, "' defined assertion."));
+                }
+                return verified;
+            }
+        },
+        {
+            key: "verifyWhenStated",
+            value: function verifyWhenStated(localContext) {
+                var verifiedWhenStated;
+                var definedAssertionString = this.string; ///
+                localContext.trace("Verifying the '".concat(definedAssertionString, "' stated defined assertion..."));
+                verifiedWhenStated = true;
+                if (verifiedWhenStated) {
+                    localContext.debug("...verified the '".concat(definedAssertionString, "' stated defined assertion."));
+                }
+                return verifiedWhenStated;
+            }
+        },
+        {
+            key: "verifyWhenDerived",
+            value: function verifyWhenDerived(localContext) {
+                var verifiedWhenDerived = false;
+                var definedAssertionString = this.string; ///
+                localContext.trace("Verifying the '".concat(definedAssertionString, "' derived defined assertion..."));
+                debugger;
+                if (this.term !== null) {}
+                if (this.frame !== null) {}
+                if (verifiedWhenDerived) {
+                    localContext.debug("...verified the '".concat(definedAssertionString, "' derived defined assertion."));
+                }
+                return verifiedWhenDerived;
+            }
+        }
+    ], [
+        {
+            key: "fromDefinedAssertionNode",
+            value: function fromDefinedAssertionNode(definedAssertionNode, localContext) {
+                var definedAssertion = null;
+                if (definedAssertionNode !== null) {
+                    var Term = _shim.default.Term, Frame = _shim.default.Frame, node = definedAssertionNode, string = localContext.nodeAsString(node), term = Term.fromDefinedAssertionNode(definedAssertionNode, localContext), frame = Frame.fromDefinedAssertionNode(definedAssertionNode, localContext), definedAssertionNegated = (0, _assertion.isAssertionNegated)(definedAssertionNode), negated = definedAssertionNegated; ///
+                    definedAssertion = new DefinedAssertion(string, node, term, frame, negated);
+                }
+                return definedAssertion;
+            }
+        }
+    ]);
+    return DefinedAssertion;
+}();
+function verifyDerivedDefinedAssertion(definedAssertionNode, assignments, stated, localContext) {
+    var derivedDefinedAssertionVerified = false;
+    if (!stated) {
+        var definedAssertionString = localContext.nodeAsString(definedAssertionNode);
+        localContext.trace("Verifying the '".concat(definedAssertionString, "' derived defined assertion..."), definedAssertionNode);
+        var assertionNegated = (0, _assertion.isAssertionNegated)(definedAssertionNode), metavariableNode = metavariableNodeQuery(definedAssertionNode), variableNode = variableNodeQuery(definedAssertionNode);
+        if (false) {
+        ///
+        } else if (metavariableNode !== null) {
+            var metavariableName = (0, _name.metavariableNameFromMetavariableNode)(metavariableNode), metavariableDefinedByMetavariableName = localContext.isMetavariableDefinedByMetavariableName(metavariableName);
+            if (!assertionNegated) {
+                if (metavariableDefinedByMetavariableName) {
+                    derivedDefinedAssertionVerified = true;
+                }
+            }
+            if (assertionNegated) {
+                if (!metavariableDefinedByMetavariableName) {
+                    derivedDefinedAssertionVerified = true;
+                }
+            }
+        } else if (variableNode !== null) {
+            var variableName = (0, _name.variableNameFromVariableNode)(variableNode), variable = localContext.findVariableByVariableName(variableName), variableDefined = localContext.isVariableDefined(variable);
+            if (!assertionNegated) {
+                if (variableDefined) {
+                    derivedDefinedAssertionVerified = true;
+                }
+            }
+            if (assertionNegated) {
+                if (!variableDefined) {
+                    derivedDefinedAssertionVerified = true;
+                }
+            }
+        }
+        if (derivedDefinedAssertionVerified) {
+            localContext.debug("...verified the '".concat(definedAssertionString, "' derived defined assertion."), definedAssertionNode);
+        }
+    }
+    return derivedDefinedAssertionVerified;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/assertion/defined.js"],"sourcesContent":["\"use strict\";\n\nimport shim from \"../shim\";\n\nimport { isAssertionNegated } from \"../utilities/assertion\";\nimport { variableNameFromVariableNode, metavariableNameFromMetavariableNode } from \"../utilities/name\";\n\nexport default class DefinedAssertion {\n  constructor(string, node, term, frame) {\n    this.string = string;\n    this.node = node;\n    this.term = term;\n    this.frame= frame\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getTerm() {\n    return this.term;\n  }\n\n  getStatement() {\n    return this.frame;\n  }\n\n  verify(assignments, stated, localContext) {\n    let verified = false;\n\n    const definedAssertionString = this.string; ///\n\n    localContext.trace(`Verifying the '${definedAssertionString}' defined assertion...`);\n\n    let termVerified = true,  ///\n        frameVerified = true; ///\n\n    if (this.term !== null) {\n      termVerified = this.term.verify(localContext, () => {\n        const verifiedAhead = true;\n\n        return verifiedAhead;\n      });\n    }\n\n    if (this.frame!== null) {\n      frameVerified = this.frame.verify(localContext);\n    }\n\n    if (termVerified && frameVerified) {\n      let verifiedWhenStated = false,\n          verifiedWhenDerived = false;\n\n      if (stated) {\n        verifiedWhenStated = this.verifyWhenStated(localContext);\n      } else {\n        verifiedWhenDerived = this.verifyWhenDerived(localContext);\n      }\n\n      if (verifiedWhenStated || verifiedWhenDerived) {\n        verified = true;\n      }\n    }\n\n    if (verified) {\n      localContext.debug(`...verified the '${definedAssertionString}' defined assertion.`);\n    }\n\n    return verified;\n  }\n\n  verifyWhenStated(localContext) {\n    let verifiedWhenStated;\n\n    const definedAssertionString = this.string; ///\n\n    localContext.trace(`Verifying the '${definedAssertionString}' stated defined assertion...`);\n\n    verifiedWhenStated = true;\n\n    if (verifiedWhenStated) {\n      localContext.debug(`...verified the '${definedAssertionString}' stated defined assertion.`);\n    }\n\n    return verifiedWhenStated;\n  }\n\n  verifyWhenDerived(localContext) {\n    let verifiedWhenDerived = false;\n\n    const definedAssertionString = this.string; ///\n\n    localContext.trace(`Verifying the '${definedAssertionString}' derived defined assertion...`);\n\n    debugger\n\n    if (this.term !== null) {\n\n    }\n\n    if (this.frame!== null) {\n\n    }\n\n    if (verifiedWhenDerived) {\n      localContext.debug(`...verified the '${definedAssertionString}' derived defined assertion.`);\n    }\n\n    return verifiedWhenDerived;\n  }\n\n  static fromDefinedAssertionNode(definedAssertionNode, localContext) {\n    let definedAssertion = null;\n\n    if (definedAssertionNode !== null) {\n      const { Term, Frame } = shim,\n            node = definedAssertionNode,  ///\n            string = localContext.nodeAsString(node),\n            term = Term.fromDefinedAssertionNode(definedAssertionNode, localContext),\n            frame = Frame.fromDefinedAssertionNode(definedAssertionNode, localContext),\n            definedAssertionNegated = isAssertionNegated(definedAssertionNode),\n            negated = definedAssertionNegated;  ///\n\n      definedAssertion = new DefinedAssertion(string, node, term, frame, negated);\n    }\n\n    return definedAssertion;\n  }\n}\n\nfunction verifyDerivedDefinedAssertion(definedAssertionNode, assignments, stated, localContext) {\n  let derivedDefinedAssertionVerified = false;\n\n  if (!stated) {\n    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);\n\n    localContext.trace(`Verifying the '${definedAssertionString}' derived defined assertion...`, definedAssertionNode);\n\n    const assertionNegated = isAssertionNegated(definedAssertionNode),\n      metavariableNode = metavariableNodeQuery(definedAssertionNode),\n      variableNode = variableNodeQuery(definedAssertionNode);\n\n    if (false) {\n      ///\n    } else if (metavariableNode !== null) {\n      const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),\n        metavariableDefinedByMetavariableName = localContext.isMetavariableDefinedByMetavariableName(metavariableName);\n\n      if (!assertionNegated) {\n        if (metavariableDefinedByMetavariableName) {\n          derivedDefinedAssertionVerified = true;\n        }\n      }\n\n      if (assertionNegated) {\n        if (!metavariableDefinedByMetavariableName) {\n          derivedDefinedAssertionVerified = true;\n        }\n      }\n    } else if (variableNode !== null) {\n      const variableName = variableNameFromVariableNode(variableNode),\n        variable = localContext.findVariableByVariableName(variableName),\n        variableDefined = localContext.isVariableDefined(variable);\n\n      if (!assertionNegated) {\n        if (variableDefined) {\n          derivedDefinedAssertionVerified = true;\n        }\n      }\n\n      if (assertionNegated) {\n        if (!variableDefined) {\n          derivedDefinedAssertionVerified = true;\n        }\n      }\n    }\n\n    if (derivedDefinedAssertionVerified) {\n      localContext.debug(`...verified the '${definedAssertionString}' derived defined assertion.`, definedAssertionNode);\n    }\n  }\n\n  return derivedDefinedAssertionVerified;\n}\n"],"names":["DefinedAssertion","string","node","term","frame","getString","getNode","getTerm","getStatement","verify","assignments","stated","localContext","verified","definedAssertionString","trace","termVerified","frameVerified","verifiedAhead","verifiedWhenStated","verifiedWhenDerived","verifyWhenStated","verifyWhenDerived","debug","fromDefinedAssertionNode","definedAssertionNode","definedAssertion","Term","shim","Frame","nodeAsString","definedAssertionNegated","isAssertionNegated","negated","verifyDerivedDefinedAssertion","derivedDefinedAssertionVerified","assertionNegated","metavariableNode","metavariableNodeQuery","variableNode","variableNodeQuery","metavariableName","metavariableNameFromMetavariableNode","metavariableDefinedByMetavariableName","isMetavariableDefinedByMetavariableName","variableName","variableNameFromVariableNode","variable","findVariableByVariableName","variableDefined","isVariableDefined"],"mappings":"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"}

package/lib/assertion/subproof.js

@@ -81,8 +81,8 @@ var SubproofAssertion = /*#__PURE__*/ function() {
                 if (verifiedWhenStated || verifiedWhenDerived) {
                     assignments = null; ///
                     stated = true; ///
-                    var subproofAssertionNode = this.node; ///
-                    verified = _metaLevel1.default.verify(subproofAssertionNode, assignments, stated, localContext);
+                    var subproofAssertionNode = this.node, verifiedAtMetaLevel = _metaLevel1.default.verify(subproofAssertionNode, assignments, stated, localContext);
+                    verified = verifiedAtMetaLevel; ///
                 }
                 if (verified) {
                     localContext.debug("...verified the '".concat(subproofAssertionString, "' subproof assertion."));
@@ -178,4 +178,4 @@ function statementsStringFromStatements(statements) {
     return statementsString;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/assertion/subproof.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport shim from \"../shim\";\nimport LocalContext from \"../context/local\";\nimport metaLevelUnifier from \"../unifier/metaLevel\";\nimport metaLevelVerifier from \"../verifier/metaLevel\";\n\nimport { nodeQuery, nodesQuery } from \"../utilities/query\";\n\nconst { front, last, match } = arrayUtilities;\n\nconst statementNodesQuery = nodesQuery(\"/subproofAssertion/statement\"),\n      subproofAssertionNodeQuery = nodeQuery(\"/statement/subproofAssertion\");\n\nexport default class SubproofAssertion {\n  constructor(string, node, statements) {\n    this.string = string;\n    this.node = node;\n    this.statements = statements;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getStatements() {\n    return this.statements;\n  }\n\n  verify(assignments, stated, localContext) {\n    let verified;\n\n    const subproofAssertionString = this.string;  ///\n\n    localContext.trace(`Verifying the '${subproofAssertionString}' subproof assertion...`);\n\n    let verifiedWhenStated = false,\n        verifiedWhenDerived = false;\n\n    if (stated) {\n      verifiedWhenStated = this.verifyWhenStated(localContext);\n    } else {\n      verifiedWhenDerived = this.verifyWhenDerived(localContext);\n    }\n\n    if (verifiedWhenStated || verifiedWhenDerived) {\n      assignments = null; ///\n\n      stated = true;  ///\n\n      const subproofAssertionNode = this.node;  ///\n\n      verified = metaLevelVerifier.verify(subproofAssertionNode, assignments, stated, localContext);\n    }\n\n    if (verified) {\n      localContext.debug(`...verified the '${subproofAssertionString}' subproof assertion.`);\n    }\n\n    return verified;\n  }\n\n  verifyWhenStated(localContext) {\n    let verifiedWhenStated;\n\n    const subproofAssertionString = this.string;  ///\n\n    localContext.trace(`Verifying the '${subproofAssertionString}' stated subproof assertion...`);\n\n    verifiedWhenStated = true;\n\n    if (verifiedWhenStated) {\n      localContext.debug(`...verified the '${subproofAssertionString}' stated subproof assertion.`);\n    }\n\n    return verifiedWhenStated;\n  }\n\n  verifyWhenDerived(localContext) {\n    let derivedSubproofAssertionVerified;\n\n    const subproofAssertionString = this.string;  ///\n\n    localContext.trace(`Verifying the '${subproofAssertionString}' derived subproof assertion...`);\n\n    derivedSubproofAssertionVerified = false;\n\n    localContext.debug(`The '${subproofAssertionString}' derived subproof assertion cannot be verified.`);\n\n    return derivedSubproofAssertionVerified;\n  }\n\n  unifySubproof(subproof, substitutions, fileContext, localContext) {\n    let subproofUnified;\n\n    const subproofString = subproof.getString(),\n          subproofStatements = subproof.getStatements(),\n          subproofAssertionString = this.string;  ///\n\n    localContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);\n\n    subproofUnified = match(this.statements, subproofStatements, (statement, subproofStatement) => {\n      const statementNode = statement.getNode(),\n            subproofStatementNode = subproofStatement.getNode(),\n            nodeA = statementNode,  ///\n            nodeB = subproofStatementNode,  ///\n            fileContextA = fileContext,  ///\n            localContextA = LocalContext.fromFileContext(fileContextA),\n            localContextB = localContext, ///\n            unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);\n\n      if (unified) {\n        return true;\n      }\n    });\n\n    if (subproofUnified) {\n      localContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);\n    }\n\n    return subproofUnified;\n  }\n\n  static fromStatementNode(statementNode, fileContext) {\n    let subproofAssertion = null;\n\n    const subproofAssertionNode = subproofAssertionNodeQuery(statementNode);\n\n    if (subproofAssertionNode !== null) {\n      const { Statement } = shim,\n            statementNodes = statementNodesQuery(subproofAssertionNode),\n            statement = Statement.fromStatementNode(statementNode, fileContext),\n            statementString = statement.getString(),\n            localContext = LocalContext.fromFileContext(fileContext),\n            statements = statementNodes.map((statementNode) => {\n              const statement = Statement.fromStatementNode(statementNode, localContext);\n\n              return statement;\n            }),\n            node = subproofAssertionNode, ///\n            string = statementString; ///\n\n      subproofAssertion = new SubproofAssertion(string, node, statements);\n    }\n\n    return subproofAssertion;\n  }\n\n  static fromSubproofAssertionNode(subproofAssertionNode, localContext) {\n    let subproofAssertion = null;\n\n    if (subproofAssertionNode !== null) {\n      const { Statement } = shim,\n            statementNodes = statementNodesQuery(subproofAssertionNode),\n            statements = statementNodes.map((statementNode) => {\n              const statement = Statement.fromStatementNode(statementNode, localContext);\n\n              return statement;\n            }),\n            node = subproofAssertionNode, ///\n            string = stringFromStatements(statements);\n\n      subproofAssertion = new SubproofAssertion(string, node, statements);\n    }\n\n    return subproofAssertion;\n  }\n}\n\nfunction stringFromStatements(statements) {\n  const frontStatements = front(statements),\n        lastStatement = last(statements),\n        frontStatementsString = statementsStringFromStatements(frontStatements),\n        lastStatementString = lastStatement.getString(),\n        string = `[${frontStatementsString}] ... ${lastStatementString}`;\n\n  return string;\n}\n\nfunction statementsStringFromStatements(statements) {\n  const statementsString = statements.reduce((statementsString, statement) => {\n    const statementString = statement.getString();\n\n    statementsString = (statementsString !== null) ?\n                        `${statementsString}, ${statementString}` :\n                           statementString;  ///\n\n    return statementsString;\n  }, null);\n\n  return statementsString\n}"],"names":["SubproofAssertion","front","arrayUtilities","last","match","statementNodesQuery","nodesQuery","subproofAssertionNodeQuery","nodeQuery","string","node","statements","getString","getNode","getStatements","verify","assignments","stated","localContext","verified","subproofAssertionString","trace","verifiedWhenStated","verifiedWhenDerived","verifyWhenStated","verifyWhenDerived","subproofAssertionNode","metaLevelVerifier","debug","derivedSubproofAssertionVerified","unifySubproof","subproof","substitutions","fileContext","subproofUnified","subproofString","subproofStatements","statement","subproofStatement","statementNode","subproofStatementNode","nodeA","nodeB","fileContextA","localContextA","LocalContext","fromFileContext","localContextB","unified","metaLevelUnifier","unify","fromStatementNode","subproofAssertion","Statement","shim","statementNodes","statementString","map","fromSubproofAssertionNode","stringFromStatements","frontStatements","lastStatement","frontStatementsString","statementsStringFromStatements","lastStatementString","statementsString","reduce"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/assertion/subproof.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport shim from \"../shim\";\nimport LocalContext from \"../context/local\";\nimport metaLevelUnifier from \"../unifier/metaLevel\";\nimport metaLevelVerifier from \"../verifier/metaLevel\";\n\nimport { nodeQuery, nodesQuery } from \"../utilities/query\";\n\nconst { front, last, match } = arrayUtilities;\n\nconst statementNodesQuery = nodesQuery(\"/subproofAssertion/statement\"),\n      subproofAssertionNodeQuery = nodeQuery(\"/statement/subproofAssertion\");\n\nexport default class SubproofAssertion {\n  constructor(string, node, statements) {\n    this.string = string;\n    this.node = node;\n    this.statements = statements;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getStatements() {\n    return this.statements;\n  }\n\n  verify(assignments, stated, localContext) {\n    let verified;\n\n    const subproofAssertionString = this.string;  ///\n\n    localContext.trace(`Verifying the '${subproofAssertionString}' subproof assertion...`);\n\n    let verifiedWhenStated = false,\n        verifiedWhenDerived = false;\n\n    if (stated) {\n      verifiedWhenStated = this.verifyWhenStated(localContext);\n    } else {\n      verifiedWhenDerived = this.verifyWhenDerived(localContext);\n    }\n\n    if (verifiedWhenStated || verifiedWhenDerived) {\n      assignments = null; ///\n\n      stated = true;  ///\n\n      const subproofAssertionNode = this.node,  ///\n            verifiedAtMetaLevel = metaLevelVerifier.verify(subproofAssertionNode, assignments, stated, localContext);\n\n      verified = verifiedAtMetaLevel; ///\n    }\n\n    if (verified) {\n      localContext.debug(`...verified the '${subproofAssertionString}' subproof assertion.`);\n    }\n\n    return verified;\n  }\n\n  verifyWhenStated(localContext) {\n    let verifiedWhenStated;\n\n    const subproofAssertionString = this.string;  ///\n\n    localContext.trace(`Verifying the '${subproofAssertionString}' stated subproof assertion...`);\n\n    verifiedWhenStated = true;\n\n    if (verifiedWhenStated) {\n      localContext.debug(`...verified the '${subproofAssertionString}' stated subproof assertion.`);\n    }\n\n    return verifiedWhenStated;\n  }\n\n  verifyWhenDerived(localContext) {\n    let derivedSubproofAssertionVerified;\n\n    const subproofAssertionString = this.string;  ///\n\n    localContext.trace(`Verifying the '${subproofAssertionString}' derived subproof assertion...`);\n\n    derivedSubproofAssertionVerified = false;\n\n    localContext.debug(`The '${subproofAssertionString}' derived subproof assertion cannot be verified.`);\n\n    return derivedSubproofAssertionVerified;\n  }\n\n  unifySubproof(subproof, substitutions, fileContext, localContext) {\n    let subproofUnified;\n\n    const subproofString = subproof.getString(),\n          subproofStatements = subproof.getStatements(),\n          subproofAssertionString = this.string;  ///\n\n    localContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);\n\n    subproofUnified = match(this.statements, subproofStatements, (statement, subproofStatement) => {\n      const statementNode = statement.getNode(),\n            subproofStatementNode = subproofStatement.getNode(),\n            nodeA = statementNode,  ///\n            nodeB = subproofStatementNode,  ///\n            fileContextA = fileContext,  ///\n            localContextA = LocalContext.fromFileContext(fileContextA),\n            localContextB = localContext, ///\n            unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);\n\n      if (unified) {\n        return true;\n      }\n    });\n\n    if (subproofUnified) {\n      localContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);\n    }\n\n    return subproofUnified;\n  }\n\n  static fromStatementNode(statementNode, fileContext) {\n    let subproofAssertion = null;\n\n    const subproofAssertionNode = subproofAssertionNodeQuery(statementNode);\n\n    if (subproofAssertionNode !== null) {\n      const { Statement } = shim,\n            statementNodes = statementNodesQuery(subproofAssertionNode),\n            statement = Statement.fromStatementNode(statementNode, fileContext),\n            statementString = statement.getString(),\n            localContext = LocalContext.fromFileContext(fileContext),\n            statements = statementNodes.map((statementNode) => {\n              const statement = Statement.fromStatementNode(statementNode, localContext);\n\n              return statement;\n            }),\n            node = subproofAssertionNode, ///\n            string = statementString; ///\n\n      subproofAssertion = new SubproofAssertion(string, node, statements);\n    }\n\n    return subproofAssertion;\n  }\n\n  static fromSubproofAssertionNode(subproofAssertionNode, localContext) {\n    let subproofAssertion = null;\n\n    if (subproofAssertionNode !== null) {\n      const { Statement } = shim,\n            statementNodes = statementNodesQuery(subproofAssertionNode),\n            statements = statementNodes.map((statementNode) => {\n              const statement = Statement.fromStatementNode(statementNode, localContext);\n\n              return statement;\n            }),\n            node = subproofAssertionNode, ///\n            string = stringFromStatements(statements);\n\n      subproofAssertion = new SubproofAssertion(string, node, statements);\n    }\n\n    return subproofAssertion;\n  }\n}\n\nfunction stringFromStatements(statements) {\n  const frontStatements = front(statements),\n        lastStatement = last(statements),\n        frontStatementsString = statementsStringFromStatements(frontStatements),\n        lastStatementString = lastStatement.getString(),\n        string = `[${frontStatementsString}] ... ${lastStatementString}`;\n\n  return string;\n}\n\nfunction statementsStringFromStatements(statements) {\n  const statementsString = statements.reduce((statementsString, statement) => {\n    const statementString = statement.getString();\n\n    statementsString = (statementsString !== null) ?\n                        `${statementsString}, ${statementString}` :\n                           statementString;  ///\n\n    return statementsString;\n  }, null);\n\n  return statementsString\n}"],"names":["SubproofAssertion","front","arrayUtilities","last","match","statementNodesQuery","nodesQuery","subproofAssertionNodeQuery","nodeQuery","string","node","statements","getString","getNode","getStatements","verify","assignments","stated","localContext","verified","subproofAssertionString","trace","verifiedWhenStated","verifiedWhenDerived","verifyWhenStated","verifyWhenDerived","subproofAssertionNode","verifiedAtMetaLevel","metaLevelVerifier","debug","derivedSubproofAssertionVerified","unifySubproof","subproof","substitutions","fileContext","subproofUnified","subproofString","subproofStatements","statement","subproofStatement","statementNode","subproofStatementNode","nodeA","nodeB","fileContextA","localContextA","LocalContext","fromFileContext","localContextB","unified","metaLevelUnifier","unify","fromStatementNode","subproofAssertion","Statement","shim","statementNodes","statementString","map","fromSubproofAssertionNode","stringFromStatements","frontStatements","lastStatement","frontStatementsString","statementsStringFromStatements","lastStatementString","statementsString","reduce"],"mappings":"AAAA;;;;;;;eAgBqBA;;;yBAdU;2DAEd;4DACQ;gEACI;iEACC;qBAEQ;;;;;;;;;;;;;;;;;;;;;;;;;AAEtC,IAAQC,QAAuBC,yBAAc,CAArCD,OAAOE,OAAgBD,yBAAc,CAA9BC,MAAMC,QAAUF,yBAAc,CAAxBE;AAErB,IAAMC,sBAAsBC,IAAAA,iBAAU,EAAC,iCACjCC,6BAA6BC,IAAAA,gBAAS,EAAC;AAE9B,IAAA,AAAMR,kCAAN;aAAMA,kBACPS,MAAM,EAAEC,IAAI,EAAEC,UAAU;gCADjBX;QAEjB,IAAI,CAACS,MAAM,GAAGA;QACd,IAAI,CAACC,IAAI,GAAGA;QACZ,IAAI,CAACC,UAAU,GAAGA;;kBAJDX;;YAOnBY,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACH,MAAM;YACpB;;;YAEAI,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACH,IAAI;YAClB;;;YAEAI,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACH,UAAU;YACxB;;;YAEAI,KAAAA;mBAAAA,SAAAA,OAAOC,WAAW,EAAEC,MAAM,EAAEC,YAAY;gBACtC,IAAIC;gBAEJ,IAAMC,0BAA0B,IAAI,CAACX,MAAM,EAAG,GAAG;gBAEjDS,aAAaG,KAAK,CAAC,AAAC,kBAAyC,OAAxBD,yBAAwB;gBAE7D,IAAIE,qBAAqB,OACrBC,sBAAsB;gBAE1B,IAAIN,QAAQ;oBACVK,qBAAqB,IAAI,CAACE,gBAAgB,CAACN;gBAC7C,OAAO;oBACLK,sBAAsB,IAAI,CAACE,iBAAiB,CAACP;gBAC/C;gBAEA,IAAII,sBAAsBC,qBAAqB;oBAC7CP,cAAc,MAAM,GAAG;oBAEvBC,SAAS,MAAO,GAAG;oBAEnB,IAAMS,wBAAwB,IAAI,CAAChB,IAAI,EACjCiB,sBAAsBC,mBAAiB,CAACb,MAAM,CAACW,uBAAuBV,aAAaC,QAAQC;oBAEjGC,WAAWQ,qBAAqB,GAAG;gBACrC;gBAEA,IAAIR,UAAU;oBACZD,aAAaW,KAAK,CAAC,AAAC,oBAA2C,OAAxBT,yBAAwB;gBACjE;gBAEA,OAAOD;YACT;;;YAEAK,KAAAA;mBAAAA,SAAAA,iBAAiBN,YAAY;gBAC3B,IAAII;gBAEJ,IAAMF,0BAA0B,IAAI,CAACX,MAAM,EAAG,GAAG;gBAEjDS,aAAaG,KAAK,CAAC,AAAC,kBAAyC,OAAxBD,yBAAwB;gBAE7DE,qBAAqB;gBAErB,IAAIA,oBAAoB;oBACtBJ,aAAaW,KAAK,CAAC,AAAC,oBAA2C,OAAxBT,yBAAwB;gBACjE;gBAEA,OAAOE;YACT;;;YAEAG,KAAAA;mBAAAA,SAAAA,kBAAkBP,YAAY;gBAC5B,IAAIY;gBAEJ,IAAMV,0BAA0B,IAAI,CAACX,MAAM,EAAG,GAAG;gBAEjDS,aAAaG,KAAK,CAAC,AAAC,kBAAyC,OAAxBD,yBAAwB;gBAE7DU,mCAAmC;gBAEnCZ,aAAaW,KAAK,CAAC,AAAC,QAA+B,OAAxBT,yBAAwB;gBAEnD,OAAOU;YACT;;;YAEAC,KAAAA;mBAAAA,SAAAA,cAAcC,QAAQ,EAAEC,aAAa,EAAEC,WAAW,EAAEhB,YAAY;gBAC9D,IAAIiB;gBAEJ,IAAMC,iBAAiBJ,SAASpB,SAAS,IACnCyB,qBAAqBL,SAASlB,aAAa,IAC3CM,0BAA0B,IAAI,CAACX,MAAM,EAAG,GAAG;gBAEjDS,aAAaG,KAAK,CAAC,AAAC,iBAAsDD,OAAtCgB,gBAAe,yBAA+C,OAAxBhB,yBAAwB;gBAElGe,kBAAkB/B,MAAM,IAAI,CAACO,UAAU,EAAE0B,oBAAoB,SAACC,WAAWC;oBACvE,IAAMC,gBAAgBF,UAAUzB,OAAO,IACjC4B,wBAAwBF,kBAAkB1B,OAAO,IACjD6B,QAAQF,eACRG,QAAQF,uBACRG,eAAeV,aACfW,gBAAgBC,cAAY,CAACC,eAAe,CAACH,eAC7CI,gBAAgB9B,cAChB+B,UAAUC,kBAAgB,CAACC,KAAK,CAACT,OAAOC,OAAOV,eAAeY,eAAeG;oBAEnF,IAAIC,SAAS;wBACX,OAAO;oBACT;gBACF;gBAEA,IAAId,iBAAiB;oBACnBjB,aAAaW,KAAK,CAAC,AAAC,mBAAwDT,OAAtCgB,gBAAe,yBAA+C,OAAxBhB,yBAAwB;gBACtG;gBAEA,OAAOe;YACT;;;;YAEOiB,KAAAA;mBAAP,SAAOA,kBAAkBZ,aAAa,EAAEN,WAAW;gBACjD,IAAImB,oBAAoB;gBAExB,IAAM3B,wBAAwBnB,2BAA2BiC;gBAEzD,IAAId,0BAA0B,MAAM;oBAClC,IAAM,AAAE4B,YAAcC,aAAI,CAAlBD,WACFE,iBAAiBnD,oBAAoBqB,wBACrCY,YAAYgB,UAAUF,iBAAiB,CAACZ,eAAeN,cACvDuB,kBAAkBnB,UAAU1B,SAAS,IACrCM,eAAe4B,cAAY,CAACC,eAAe,CAACb,cAC5CvB,aAAa6C,eAAeE,GAAG,CAAC,SAAClB;wBAC/B,IAAMF,YAAYgB,UAAUF,iBAAiB,CAACZ,eAAetB;wBAE7D,OAAOoB;oBACT,IACA5B,OAAOgB,uBACPjB,SAASgD,iBAAiB,GAAG;oBAEnCJ,oBAAoB,IArILrD,kBAqI2BS,QAAQC,MAAMC;gBAC1D;gBAEA,OAAO0C;YACT;;;YAEOM,KAAAA;mBAAP,SAAOA,0BAA0BjC,qBAAqB,EAAER,YAAY;gBAClE,IAAImC,oBAAoB;gBAExB,IAAI3B,0BAA0B,MAAM;oBAClC,IAAM,AAAE4B,YAAcC,aAAI,CAAlBD,WACFE,iBAAiBnD,oBAAoBqB,wBACrCf,aAAa6C,eAAeE,GAAG,CAAC,SAAClB;wBAC/B,IAAMF,YAAYgB,UAAUF,iBAAiB,CAACZ,eAAetB;wBAE7D,OAAOoB;oBACT,IACA5B,OAAOgB,uBACPjB,SAASmD,qBAAqBjD;oBAEpC0C,oBAAoB,IAzJLrD,kBAyJ2BS,QAAQC,MAAMC;gBAC1D;gBAEA,OAAO0C;YACT;;;WA7JmBrD;;AAgKrB,SAAS4D,qBAAqBjD,UAAU;IACtC,IAAMkD,kBAAkB5D,MAAMU,aACxBmD,gBAAgB3D,KAAKQ,aACrBoD,wBAAwBC,+BAA+BH,kBACvDI,sBAAsBH,cAAclD,SAAS,IAC7CH,SAAS,AAAC,IAAiCwD,OAA9BF,uBAAsB,UAA4B,OAApBE;IAEjD,OAAOxD;AACT;AAEA,SAASuD,+BAA+BrD,UAAU;IAChD,IAAMuD,mBAAmBvD,WAAWwD,MAAM,CAAC,SAACD,kBAAkB5B;QAC5D,IAAMmB,kBAAkBnB,UAAU1B,SAAS;QAE3CsD,mBAAmB,AAACA,qBAAqB,OACrB,AAAC,GAAuBT,OAArBS,kBAAiB,MAAoB,OAAhBT,mBACrBA,iBAAkB,GAAG;QAE5C,OAAOS;IACT,GAAG;IAEH,OAAOA;AACT"}

package/lib/assertion/type.js

@@ -74,13 +74,20 @@ var TypeAssertion = /*#__PURE__*/ function() {
         {
             key: "verify",
             value: function verify(assignments, stated, localContext) {
-                var verified;
+                var verified = false;
+                var typeAssertionString = this.string; ///
+                localContext.trace("Verifying the '$".concat(typeAssertionString, "' type assertion..."));
+                var verifiedWhenStated = false, verifiedWhenDerived = false;
                 if (stated) {
-                    var verifiedWhenStated = this.verifyWhenStated(assignments, localContext);
-                    verified = verifiedWhenStated; ///
+                    verifiedWhenStated = this.verifyWhenStated(assignments, localContext);
                 } else {
-                    var verifiedWhenDerived = this.verifyWhenDerived(localContext);
-                    verified = verifiedWhenDerived; ///
+                    verifiedWhenDerived = this.verifyWhenDerived(localContext);
+                }
+                if (verifiedWhenStated || verifiedWhenDerived) {
+                    verified = true;
+                }
+                if (verified) {
+                    localContext.debug("...verified the '$".concat(typeAssertionString, "' type assertion."));
                 }
                 return verified;
             }
@@ -181,4 +188,4 @@ function stringFromTermAndType(term, type) {
     return string;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/assertion/type.js"],"sourcesContent":["\"use strict\";\n\nimport shim from \"../shim\";\nimport Variable from \"../variable\";\nimport VariableAssignment from \"../assignment/variable\";\n\nimport { nodeQuery } from \"../utilities/query\";\nimport {objectType} from \"../type\";\n\nconst termNodeQuery = nodeQuery(\"/typeAssertion/term\"),\n      typeNodeQuery = nodeQuery(\"/typeAssertion/type\"),\n      variableNodeQuery = nodeQuery(\"/term/variable\");\n\nexport default class TypeAssertion {\n  constructor(string, term, type, variable) {\n    this.string = string;\n    this.term = term;\n    this.type = type;\n    this.variable = variable;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getTerm() {\n    return this.term;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  getVariable() {\n    return this.variable;\n  }\n\n  verify(assignments, stated, localContext) {\n    let verified;\n\n    if (stated) {\n      const verifiedWhenStated = this.verifyWhenStated(assignments, localContext);\n\n      verified = verifiedWhenStated;  ///\n    } else {\n      const verifiedWhenDerived = this.verifyWhenDerived(localContext);\n\n      verified = verifiedWhenDerived; ///\n    }\n\n    return verified;\n  }\n\n  verifyType(localContext) {\n    let typeVerified;\n\n    if (this.type === objectType) {\n      typeVerified = true;\n    } else {\n      const typeName = this.type.getName();\n\n      localContext.trace(`Verifying the '${typeName}' type...`);\n\n      const type = localContext.findTypeByTypeName(typeName);\n\n      if (type === null) {\n        localContext.debug(`The '${typeName}' type is missing.`);\n      } else {\n        this.type = type; ///\n\n        typeVerified = true;\n      }\n\n      if (typeVerified) {\n        localContext.debug(`...verified the '${typeName}' type.`);\n      }\n    }\n\n    return typeVerified;\n  }\n\n  verifyWhenStated(assignments, localContext) {\n    let verifiedWhenStated = false;\n\n    const typeAssertionString = this.string; ///\n\n    localContext.trace(`Verifying the '${typeAssertionString}' stated type assertion...`);\n\n    const typeVerified = this.verifyType(localContext);\n\n    if (typeVerified) {\n      const termVerified = this.term.verify(localContext, () => {\n        let verifiedAhead;\n\n        const termType = this.term.getType(),\n              typeEqualToOrSuperTypeOfTermType = this.type.isEqualToOrSubTypeOf(termType);\n\n        if (typeEqualToOrSuperTypeOfTermType) {\n          if (this.variable !== null) {\n            this.variable.setType(this.type);\n\n            const variableAssignment = VariableAssignment.fromVariable(this.variable),\n                  assignment = variableAssignment;  ///\n\n            assignments.push(assignment);\n          }\n\n          verifiedAhead = true;\n        }\n\n        return verifiedAhead;\n      });\n\n      verifiedWhenStated = termVerified; ///\n    }\n\n    if (verifiedWhenStated) {\n      localContext.debug(`...verified the '${typeAssertionString}' stated type assertion.`);\n    }\n\n    return verifiedWhenStated;\n  }\n\n  verifyWhenDerived(localContext) {\n    let verifiedWhenDerived = false;\n\n    const typeAssertionString = this.string; ///\n\n    localContext.trace(`Verifying the '${typeAssertionString}' derived type assertion...`);\n\n    const typeVerified = this.verifyType(localContext);\n\n    if (typeVerified) {\n      const termVerified = this.term.verify(localContext, () => {\n        let verifiedAhead;\n\n        const termType = this.term.getType(),\n              typeEqualToOrSuperTypeOfTermType = this.type.isEqualToOrSuperTypeOf(termType);\n\n        verifiedAhead = typeEqualToOrSuperTypeOfTermType; ///\n\n        return verifiedAhead;\n      });\n\n      verifiedWhenDerived = termVerified; ///\n    }\n\n    if (verifiedWhenDerived) {\n      localContext.debug(`...verified the '${typeAssertionString}' derived type assertion.`);\n    }\n\n    return verifiedWhenDerived;\n  }\n\n  static fromTypeAssertionNode(typeAssertionNode, localContext) {\n    let typeAssertion = null;\n\n    if (typeAssertionNode !== null) {\n      const { Term, Type } = shim,\n            termNode = termNodeQuery(typeAssertionNode),\n            typeNode = typeNodeQuery(typeAssertionNode),\n            variableNode = variableNodeQuery(termNode),\n            term = Term.fromTermNode(termNode, localContext),\n            type = Type.fromTypeNode(typeNode, localContext),\n            variable = Variable.fromVariableNode(variableNode, localContext),\n            string = stringFromTermAndType(term, type);\n\n      typeAssertion = new TypeAssertion(string, term, type, variable);\n    }\n\n    return typeAssertion;\n  }\n}\n\nfunction stringFromTermAndType(term, type) {\n  const termString = term.getString(),\n        typeName = type.getName(),\n        string = `${termString}:${typeName}`;\n\n  return string;\n}\n"],"names":["TypeAssertion","termNodeQuery","nodeQuery","typeNodeQuery","variableNodeQuery","string","term","type","variable","getString","getTerm","getType","getVariable","verify","assignments","stated","localContext","verified","verifiedWhenStated","verifyWhenStated","verifiedWhenDerived","verifyWhenDerived","verifyType","typeVerified","objectType","typeName","getName","trace","findTypeByTypeName","debug","typeAssertionString","termVerified","verifiedAhead","termType","typeEqualToOrSuperTypeOfTermType","isEqualToOrSubTypeOf","setType","variableAssignment","VariableAssignment","fromVariable","assignment","push","isEqualToOrSuperTypeOf","fromTypeAssertionNode","typeAssertionNode","typeAssertion","Term","shim","Type","termNode","typeNode","variableNode","fromTermNode","fromTypeNode","Variable","fromVariableNode","stringFromTermAndType","termString"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/assertion/type.js"],"sourcesContent":["\"use strict\";\n\nimport shim from \"../shim\";\nimport Variable from \"../variable\";\nimport VariableAssignment from \"../assignment/variable\";\n\nimport { nodeQuery } from \"../utilities/query\";\nimport { objectType } from \"../type\";\n\nconst termNodeQuery = nodeQuery(\"/typeAssertion/term\"),\n      typeNodeQuery = nodeQuery(\"/typeAssertion/type\"),\n      variableNodeQuery = nodeQuery(\"/term/variable\");\n\nexport default class TypeAssertion {\n  constructor(string, term, type, variable) {\n    this.string = string;\n    this.term = term;\n    this.type = type;\n    this.variable = variable;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getTerm() {\n    return this.term;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  getVariable() {\n    return this.variable;\n  }\n\n  verify(assignments, stated, localContext) {\n    let verified = false;\n\n    let typeAssertionString = this.string;  ///\n\n    localContext.trace(`Verifying the '$${typeAssertionString}' type assertion...`);\n\n    let verifiedWhenStated = false,\n        verifiedWhenDerived = false;\n\n    if (stated) {\n      verifiedWhenStated = this.verifyWhenStated(assignments, localContext);\n    } else {\n      verifiedWhenDerived = this.verifyWhenDerived(localContext);\n    }\n\n    if (verifiedWhenStated || verifiedWhenDerived) {\n      verified = true;\n    }\n\n    if (verified) {\n      localContext.debug(`...verified the '$${typeAssertionString}' type assertion.`);\n    }\n\n    return verified;\n  }\n\n  verifyType(localContext) {\n    let typeVerified;\n\n    if (this.type === objectType) {\n      typeVerified = true;\n    } else {\n      const typeName = this.type.getName();\n\n      localContext.trace(`Verifying the '${typeName}' type...`);\n\n      const type = localContext.findTypeByTypeName(typeName);\n\n      if (type === null) {\n        localContext.debug(`The '${typeName}' type is missing.`);\n      } else {\n        this.type = type; ///\n\n        typeVerified = true;\n      }\n\n      if (typeVerified) {\n        localContext.debug(`...verified the '${typeName}' type.`);\n      }\n    }\n\n    return typeVerified;\n  }\n\n  verifyWhenStated(assignments, localContext) {\n    let verifiedWhenStated = false;\n\n    const typeAssertionString = this.string; ///\n\n    localContext.trace(`Verifying the '${typeAssertionString}' stated type assertion...`);\n\n    const typeVerified = this.verifyType(localContext);\n\n    if (typeVerified) {\n      const termVerified = this.term.verify(localContext, () => {\n        let verifiedAhead;\n\n        const termType = this.term.getType(),\n              typeEqualToOrSuperTypeOfTermType = this.type.isEqualToOrSubTypeOf(termType);\n\n        if (typeEqualToOrSuperTypeOfTermType) {\n          if (this.variable !== null) {\n            this.variable.setType(this.type);\n\n            const variableAssignment = VariableAssignment.fromVariable(this.variable),\n                  assignment = variableAssignment;  ///\n\n            assignments.push(assignment);\n          }\n\n          verifiedAhead = true;\n        }\n\n        return verifiedAhead;\n      });\n\n      verifiedWhenStated = termVerified; ///\n    }\n\n    if (verifiedWhenStated) {\n      localContext.debug(`...verified the '${typeAssertionString}' stated type assertion.`);\n    }\n\n    return verifiedWhenStated;\n  }\n\n  verifyWhenDerived(localContext) {\n    let verifiedWhenDerived = false;\n\n    const typeAssertionString = this.string; ///\n\n    localContext.trace(`Verifying the '${typeAssertionString}' derived type assertion...`);\n\n    const typeVerified = this.verifyType(localContext);\n\n    if (typeVerified) {\n      const termVerified = this.term.verify(localContext, () => {\n        let verifiedAhead;\n\n        const termType = this.term.getType(),\n              typeEqualToOrSuperTypeOfTermType = this.type.isEqualToOrSuperTypeOf(termType);\n\n        verifiedAhead = typeEqualToOrSuperTypeOfTermType; ///\n\n        return verifiedAhead;\n      });\n\n      verifiedWhenDerived = termVerified; ///\n    }\n\n    if (verifiedWhenDerived) {\n      localContext.debug(`...verified the '${typeAssertionString}' derived type assertion.`);\n    }\n\n    return verifiedWhenDerived;\n  }\n\n  static fromTypeAssertionNode(typeAssertionNode, localContext) {\n    let typeAssertion = null;\n\n    if (typeAssertionNode !== null) {\n      const { Term, Type } = shim,\n            termNode = termNodeQuery(typeAssertionNode),\n            typeNode = typeNodeQuery(typeAssertionNode),\n            variableNode = variableNodeQuery(termNode),\n            term = Term.fromTermNode(termNode, localContext),\n            type = Type.fromTypeNode(typeNode, localContext),\n            variable = Variable.fromVariableNode(variableNode, localContext),\n            string = stringFromTermAndType(term, type);\n\n      typeAssertion = new TypeAssertion(string, term, type, variable);\n    }\n\n    return typeAssertion;\n  }\n}\n\nfunction stringFromTermAndType(term, type) {\n  const termString = term.getString(),\n        typeName = type.getName(),\n        string = `${termString}:${typeName}`;\n\n  return string;\n}\n"],"names":["TypeAssertion","termNodeQuery","nodeQuery","typeNodeQuery","variableNodeQuery","string","term","type","variable","getString","getTerm","getType","getVariable","verify","assignments","stated","localContext","verified","typeAssertionString","trace","verifiedWhenStated","verifiedWhenDerived","verifyWhenStated","verifyWhenDerived","debug","verifyType","typeVerified","objectType","typeName","getName","findTypeByTypeName","termVerified","verifiedAhead","termType","typeEqualToOrSuperTypeOfTermType","isEqualToOrSubTypeOf","setType","variableAssignment","VariableAssignment","fromVariable","assignment","push","isEqualToOrSuperTypeOf","fromTypeAssertionNode","typeAssertionNode","typeAssertion","Term","shim","Type","termNode","typeNode","variableNode","fromTermNode","fromTypeNode","Variable","fromVariableNode","stringFromTermAndType","termString"],"mappings":"AAAA;;;;;;;eAaqBA;;;2DAXJ;+DACI;gEACU;qBAEL;oBACC;;;;;;;;;;;;;;;;;;;;;;;;;AAE3B,IAAMC,gBAAgBC,IAAAA,gBAAS,EAAC,wBAC1BC,gBAAgBD,IAAAA,gBAAS,EAAC,wBAC1BE,oBAAoBF,IAAAA,gBAAS,EAAC;AAErB,IAAA,AAAMF,8BAAN;aAAMA,cACPK,MAAM,EAAEC,IAAI,EAAEC,IAAI,EAAEC,QAAQ;gCADrBR;QAEjB,IAAI,CAACK,MAAM,GAAGA;QACd,IAAI,CAACC,IAAI,GAAGA;QACZ,IAAI,CAACC,IAAI,GAAGA;QACZ,IAAI,CAACC,QAAQ,GAAGA;;kBALCR;;YAQnBS,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACJ,MAAM;YACpB;;;YAEAK,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACJ,IAAI;YAClB;;;YAEAK,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACJ,IAAI;YAClB;;;YAEAK,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACJ,QAAQ;YACtB;;;YAEAK,KAAAA;mBAAAA,SAAAA,OAAOC,WAAW,EAAEC,MAAM,EAAEC,YAAY;gBACtC,IAAIC,WAAW;gBAEf,IAAIC,sBAAsB,IAAI,CAACb,MAAM,EAAG,GAAG;gBAE3CW,aAAaG,KAAK,CAAC,AAAC,mBAAsC,OAApBD,qBAAoB;gBAE1D,IAAIE,qBAAqB,OACrBC,sBAAsB;gBAE1B,IAAIN,QAAQ;oBACVK,qBAAqB,IAAI,CAACE,gBAAgB,CAACR,aAAaE;gBAC1D,OAAO;oBACLK,sBAAsB,IAAI,CAACE,iBAAiB,CAACP;gBAC/C;gBAEA,IAAII,sBAAsBC,qBAAqB;oBAC7CJ,WAAW;gBACb;gBAEA,IAAIA,UAAU;oBACZD,aAAaQ,KAAK,CAAC,AAAC,qBAAwC,OAApBN,qBAAoB;gBAC9D;gBAEA,OAAOD;YACT;;;YAEAQ,KAAAA;mBAAAA,SAAAA,WAAWT,YAAY;gBACrB,IAAIU;gBAEJ,IAAI,IAAI,CAACnB,IAAI,KAAKoB,gBAAU,EAAE;oBAC5BD,eAAe;gBACjB,OAAO;oBACL,IAAME,WAAW,IAAI,CAACrB,IAAI,CAACsB,OAAO;oBAElCb,aAAaG,KAAK,CAAC,AAAC,kBAA0B,OAATS,UAAS;oBAE9C,IAAMrB,OAAOS,aAAac,kBAAkB,CAACF;oBAE7C,IAAIrB,SAAS,MAAM;wBACjBS,aAAaQ,KAAK,CAAC,AAAC,QAAgB,OAATI,UAAS;oBACtC,OAAO;wBACL,IAAI,CAACrB,IAAI,GAAGA,MAAM,GAAG;wBAErBmB,eAAe;oBACjB;oBAEA,IAAIA,cAAc;wBAChBV,aAAaQ,KAAK,CAAC,AAAC,oBAA4B,OAATI,UAAS;oBAClD;gBACF;gBAEA,OAAOF;YACT;;;YAEAJ,KAAAA;mBAAAA,SAAAA,iBAAiBR,WAAW,EAAEE,YAAY;;gBACxC,IAAII,qBAAqB;gBAEzB,IAAMF,sBAAsB,IAAI,CAACb,MAAM,EAAE,GAAG;gBAE5CW,aAAaG,KAAK,CAAC,AAAC,kBAAqC,OAApBD,qBAAoB;gBAEzD,IAAMQ,eAAe,IAAI,CAACD,UAAU,CAACT;gBAErC,IAAIU,cAAc;oBAChB,IAAMK,eAAe,IAAI,CAACzB,IAAI,CAACO,MAAM,CAACG,cAAc;wBAClD,IAAIgB;wBAEJ,IAAMC,WAAW,MAAK3B,IAAI,CAACK,OAAO,IAC5BuB,mCAAmC,MAAK3B,IAAI,CAAC4B,oBAAoB,CAACF;wBAExE,IAAIC,kCAAkC;4BACpC,IAAI,MAAK1B,QAAQ,KAAK,MAAM;gCAC1B,MAAKA,QAAQ,CAAC4B,OAAO,CAAC,MAAK7B,IAAI;gCAE/B,IAAM8B,qBAAqBC,kBAAkB,CAACC,YAAY,CAAC,MAAK/B,QAAQ,GAClEgC,aAAaH,oBAAqB,GAAG;gCAE3CvB,YAAY2B,IAAI,CAACD;4BACnB;4BAEAR,gBAAgB;wBAClB;wBAEA,OAAOA;oBACT;oBAEAZ,qBAAqBW,cAAc,GAAG;gBACxC;gBAEA,IAAIX,oBAAoB;oBACtBJ,aAAaQ,KAAK,CAAC,AAAC,oBAAuC,OAApBN,qBAAoB;gBAC7D;gBAEA,OAAOE;YACT;;;YAEAG,KAAAA;mBAAAA,SAAAA,kBAAkBP,YAAY;;gBAC5B,IAAIK,sBAAsB;gBAE1B,IAAMH,sBAAsB,IAAI,CAACb,MAAM,EAAE,GAAG;gBAE5CW,aAAaG,KAAK,CAAC,AAAC,kBAAqC,OAApBD,qBAAoB;gBAEzD,IAAMQ,eAAe,IAAI,CAACD,UAAU,CAACT;gBAErC,IAAIU,cAAc;oBAChB,IAAMK,eAAe,IAAI,CAACzB,IAAI,CAACO,MAAM,CAACG,cAAc;wBAClD,IAAIgB;wBAEJ,IAAMC,WAAW,MAAK3B,IAAI,CAACK,OAAO,IAC5BuB,mCAAmC,MAAK3B,IAAI,CAACmC,sBAAsB,CAACT;wBAE1ED,gBAAgBE,kCAAkC,GAAG;wBAErD,OAAOF;oBACT;oBAEAX,sBAAsBU,cAAc,GAAG;gBACzC;gBAEA,IAAIV,qBAAqB;oBACvBL,aAAaQ,KAAK,CAAC,AAAC,oBAAuC,OAApBN,qBAAoB;gBAC7D;gBAEA,OAAOG;YACT;;;;YAEOsB,KAAAA;mBAAP,SAAOA,sBAAsBC,iBAAiB,EAAE5B,YAAY;gBAC1D,IAAI6B,gBAAgB;gBAEpB,IAAID,sBAAsB,MAAM;oBAC9B,IAAQE,OAAeC,aAAI,CAAnBD,MAAME,OAASD,aAAI,CAAbC,MACRC,WAAWhD,cAAc2C,oBACzBM,WAAW/C,cAAcyC,oBACzBO,eAAe/C,kBAAkB6C,WACjC3C,OAAOwC,KAAKM,YAAY,CAACH,UAAUjC,eACnCT,OAAOyC,KAAKK,YAAY,CAACH,UAAUlC,eACnCR,WAAW8C,iBAAQ,CAACC,gBAAgB,CAACJ,cAAcnC,eACnDX,SAASmD,sBAAsBlD,MAAMC;oBAE3CsC,gBAAgB,IArKD7C,cAqKmBK,QAAQC,MAAMC,MAAMC;gBACxD;gBAEA,OAAOqC;YACT;;;WAzKmB7C;;AA4KrB,SAASwD,sBAAsBlD,IAAI,EAAEC,IAAI;IACvC,IAAMkD,aAAanD,KAAKG,SAAS,IAC3BmB,WAAWrB,KAAKsB,OAAO,IACvBxB,SAAS,AAAC,GAAgBuB,OAAd6B,YAAW,KAAY,OAAT7B;IAEhC,OAAOvB;AACT"}