occam-verify-cli 0.0.1111 → 0.0.1114

package/lib/dom/statement.js

@@ -0,0 +1,379 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _necessary = require("necessary");
+var _dom = /*#__PURE__*/ _interop_require_wildcard(require("../dom"));
+var _verify = /*#__PURE__*/ _interop_require_default(require("../mixins/statement/verify"));
+var _combinator = /*#__PURE__*/ _interop_require_default(require("../verifier/combinator"));
+var _statement = /*#__PURE__*/ _interop_require_default(require("../nodeAndTokens/statement"));
+var _unification = require("../utilities/unification");
+var _query = require("../utilities/query");
+var _metaTypeNames = require("../metaTypeNames");
+var _verification = require("../utilities/verification");
+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 _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _Statement;
+var match = _necessary.arrayUtilities.match, backwardsSome = _necessary.arrayUtilities.backwardsSome;
+var statementNodeQuery = (0, _query.nodeQuery)("/*/statement"), statementTermNodesQuery = (0, _query.nodesQuery)("/statement//term"), statementFrameNodesQuery = (0, _query.nodesQuery)("/statement//frame");
+var _default = (0, _dom.domAssigned)((_Statement = /*#__PURE__*/ function() {
+    function Statement(string, node, tokens) {
+        _class_call_check(this, Statement);
+        this.string = string;
+        this.node = node;
+        this.tokens = tokens;
+    }
+    _create_class(Statement, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getTokens",
+            value: function getTokens() {
+                return this.tokens;
+            }
+        },
+        {
+            key: "isEqualTo",
+            value: function isEqualTo(statement) {
+                var statementString = statement.getString(), equalTo = statementString === this.string;
+                return equalTo;
+            }
+        },
+        {
+            key: "isTermContained",
+            value: function isTermContained(term, context) {
+                var termContained;
+                var termString = term.getString(), statementString = this.string; ///
+                context.trace("Is the '".concat(termString, "' term contained in the '").concat(statementString, "' statement..."));
+                var termNode = term.getNode(), statementNode = this.node, statementTermNodes = statementTermNodesQuery(statementNode);
+                termContained = statementTermNodes.some(function(statementTermNode) {
+                    var termNodeMatchesStatementVariableNode = termNode.match(statementTermNode);
+                    if (termNodeMatchesStatementVariableNode) {
+                        return true;
+                    }
+                });
+                if (termContained) {
+                    context.debug("...the '".concat(termString, "' term is contained in the '").concat(statementString, "' statement."));
+                }
+                return termContained;
+            }
+        },
+        {
+            key: "isFrameContained",
+            value: function isFrameContained(frame, context) {
+                var frameContained;
+                var frameString = frame.getString(), statementString = this.string; ///
+                context.trace("Is the '".concat(frameString, "' frame contained in the '").concat(statementString, "' statement..."));
+                var frameNode = frame.getNode(), statementNode = this.node, statementFrameNodes = statementFrameNodesQuery(statementNode);
+                frameContained = statementFrameNodes.some(function(statementFrameNode) {
+                    var frameNodeMatchesStatementMetavariableNode = frameNode.match(statementFrameNode);
+                    if (frameNodeMatchesStatementMetavariableNode) {
+                        return true;
+                    }
+                });
+                if (frameContained) {
+                    context.debug("...the '".concat(frameString, "' frame is contained in the '").concat(statementString, "' statement."));
+                }
+                return frameContained;
+            }
+        },
+        {
+            key: "matchStatementNode",
+            value: function matchStatementNode(statementNode) {
+                var statementNodeMatches = this.node.match(statementNode);
+                return statementNodeMatches;
+            }
+        },
+        {
+            key: "unifySubproof",
+            value: function unifySubproof(subproof, substitutions, generalContext, specificContext) {
+                var subproofUnified = false;
+                var context = specificContext, statement = this, subproofAssertion = (0, _verification.subproofAssertionFromStatement)(statement, context);
+                if (subproofAssertion !== null) {
+                    var subproofString = subproof.getString(), subproofAssertionString = subproofAssertion.getString();
+                    specificContext.trace("Unifying the '".concat(subproofString, "' subproof with the '").concat(subproofAssertionString, "' subproof assertion..."));
+                    var subproofStatements = subproof.getStatements(), subproofAssertionStatements = subproofAssertion.getStatements();
+                    subproofUnified = match(subproofAssertionStatements, subproofStatements, function(subproofAssertionStatement, subproofStatement) {
+                        var generalStatement = subproofAssertionStatement, specificStatement = subproofStatement, statementUnified = (0, _unification.unifyStatement)(generalStatement, specificStatement, substitutions, generalContext, specificContext);
+                        if (statementUnified) {
+                            return true;
+                        }
+                    });
+                    if (subproofUnified) {
+                        specificContext.debug("...unified the '".concat(subproofString, "' subproof with the '").concat(subproofAssertionString, "' subproof assertion."));
+                    }
+                }
+                return subproofUnified;
+            }
+        },
+        {
+            key: "unifyStatement",
+            value: function unifyStatement(statement, substitutions, generalContext, specificContext) {
+                var statementUnified;
+                var generalStatement = this, specificStatement = statement, generalStatementString = generalStatement.getString(), specificStatementString = specificStatement.getString();
+                specificContext.trace("Unifying the '".concat(specificStatementString, "' statement with the '").concat(generalStatementString, "' statement..."));
+                statementUnified = (0, _unification.unifyStatement)(generalStatement, specificStatement, substitutions, generalContext, specificContext);
+                if (statementUnified) {
+                    specificContext.debug("...unified the '".concat(specificStatementString, "' statement with the '").concat(generalStatementString, "' statement."));
+                }
+                return statementUnified;
+            }
+        },
+        {
+            key: "unifyIndependently",
+            value: function unifyIndependently(substitutions, generalContext, specificContext) {
+                var unifiedIndependently = false;
+                var context = specificContext, statement = this; ///
+                var definedAssertion = (0, _verification.definedAssertionFromStatement)(statement, context), containedAssertion = (0, _verification.containedAssertionFromStatement)(statement, context);
+                if (definedAssertion !== null || containedAssertion !== null) {
+                    var statementString = this.string;
+                    specificContext.trace("Unifying the '".concat(statementString, "' statement independently..."));
+                    if (definedAssertion !== null) {
+                        var definedAssertionUnifiedIndependently = definedAssertion.unifyIndependently(substitutions, context);
+                        unifiedIndependently = definedAssertionUnifiedIndependently; ///
+                    }
+                    if (containedAssertion !== null) {
+                        var containedAssertionUnifiedIndependently = containedAssertion.unifyIndependently(substitutions, context);
+                        unifiedIndependently = containedAssertionUnifiedIndependently; ///
+                    }
+                    if (unifiedIndependently) {
+                        specificContext.debug("...unified the '".concat(statementString, "' statement independently."));
+                    }
+                }
+                return unifiedIndependently;
+            }
+        },
+        {
+            key: "unifyWithProofSteps",
+            value: function unifyWithProofSteps(proofSteps, context) {
+                var _this = this;
+                var unifiedWithProofSteps;
+                unifiedWithProofSteps = backwardsSome(proofSteps, function(proofStep) {
+                    var statement = _this, statementUnified = proofStep.unifyStatement(statement, context);
+                    if (statementUnified) {
+                        return true;
+                    }
+                });
+                return unifiedWithProofSteps;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, context) {
+                var _this = this;
+                var verified;
+                verified = _verify.default.some(function(verifyMixin) {
+                    var statement = _this, verified = verifyMixin(statement, assignments, stated, context);
+                    if (verified) {
+                        return true;
+                    }
+                });
+                return verified;
+            }
+        },
+        {
+            key: "verifyWhenDeclared",
+            value: function verifyWhenDeclared(fileContext) {
+                var verifiedWhenDeclared;
+                var statementNode = this.node, statementString = this.string; ///
+                fileContext.trace("Verifying the '".concat(statementString, "' statement when declared..."));
+                verifiedWhenDeclared = _combinator.default.verifyStatement(statementNode, fileContext);
+                if (verifiedWhenDeclared) {
+                    fileContext.debug("...verified the '".concat(statementString, "' statement when declared."));
+                }
+                return verifiedWhenDeclared;
+            }
+        },
+        {
+            key: "verifyGivenMetaType",
+            value: function verifyGivenMetaType(metaType, assignments, stated, context) {
+                var verifiedGivenMetaType = false;
+                var metaTypeString = metaType.getString(), statementString = this.string; ///
+                context.trace("Verifying the '".concat(statementString, "' statement given the '").concat(metaTypeString, "' meta-type..."));
+                var metaTypeName = metaType.getName();
+                if (metaTypeName === _metaTypeNames.STATEMENT_META_TYPE_NAME) {
+                    var verified = this.verify(assignments, stated, context);
+                    verifiedGivenMetaType = verified; ///
+                }
+                if (verifiedGivenMetaType) {
+                    context.debug("...verified the '".concat(statementString, "' statement given the '").concat(metaTypeString, "' meta-type."));
+                }
+                return verifiedGivenMetaType;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var string = this.string, json = {
+                    string: string
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(json, fileContext) {
+                var string = json.string, context = fileContext, statementNodeAndTokens = _statement.default.fromString(string, context), node = statementNodeAndTokens.getNode(), tokens = statementNodeAndTokens.getTokens(), statement = new Statement(string, node, tokens);
+                return statement;
+            }
+        },
+        {
+            key: "fromPremiseNode",
+            value: function fromPremiseNode(premiseNode, fileContext) {
+                var node = premiseNode, statement = statementFromNode(node, fileContext);
+                return statement;
+            }
+        },
+        {
+            key: "fromProofStepNode",
+            value: function fromProofStepNode(proofStepNode, fileContext) {
+                var node = proofStepNode, statement = statementFromNode(node, fileContext);
+                return statement;
+            }
+        },
+        {
+            key: "fromStatementNode",
+            value: function fromStatementNode(statementNode, context) {
+                var statement = null;
+                if (statementNode !== null) {
+                    var node = statementNode, tokens = context.nodeAsTokens(node), string = context.tokensAsString(tokens);
+                    statement = new Statement(string, node, tokens);
+                }
+                return statement;
+            }
+        },
+        {
+            key: "fromConclusionNode",
+            value: function fromConclusionNode(conclusionNode, fileContext) {
+                var node = conclusionNode, statement = statementFromNode(node, fileContext);
+                return statement;
+            }
+        },
+        {
+            key: "fromConsequentNode",
+            value: function fromConsequentNode(consequentNode, fileContext) {
+                var node = consequentNode, statement = statementFromNode(node, fileContext);
+                return statement;
+            }
+        },
+        {
+            key: "fromSuppositionNode",
+            value: function fromSuppositionNode(suppositionNode, fileContext) {
+                var node = suppositionNode, statement = statementFromNode(node, fileContext);
+                return statement;
+            }
+        },
+        {
+            key: "fromContainedAssertionNode",
+            value: function fromContainedAssertionNode(containedAssertionNode, context) {
+                var statementNode = statementNodeQuery(containedAssertionNode), node = statementNode, tokens = context.nodeAsTokens(node), string = context.tokensAsString(tokens), statement = new Statement(string, node, tokens);
+                return statement;
+            }
+        }
+    ]);
+    return Statement;
+}(), _define_property(_Statement, "name", "Statement"), _Statement));
+function statementFromNode(node, fileContext) {
+    var statement = null;
+    var statementNode = statementNodeQuery(node);
+    if (statementNode !== null) {
+        var Statement = _dom.default.Statement, _$node = statementNode, tokens = fileContext.nodeAsTokens(_$node), string = fileContext.tokensAsString(tokens);
+        statement = new Statement(string, _$node, tokens);
+    }
+    return statement;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/dom/statement.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport dom from \"../dom\";\nimport verifyMixins from \"../mixins/statement/verify\";\nimport combinatorVerifier from \"../verifier/combinator\";\nimport StatementNodeAndTokens from \"../nodeAndTokens/statement\";\n\nimport { domAssigned } from \"../dom\";\nimport { unifyStatement } from \"../utilities/unification\";\nimport { nodeQuery, nodesQuery } from \"../utilities/query\";\nimport { STATEMENT_META_TYPE_NAME } from \"../metaTypeNames\";\nimport { definedAssertionFromStatement, subproofAssertionFromStatement, containedAssertionFromStatement } from \"../utilities/verification\";\n\nconst { match, backwardsSome } = arrayUtilities;\n\nconst statementNodeQuery = nodeQuery(\"/*/statement\"),\n      statementTermNodesQuery = nodesQuery(\"/statement//term\"),\n      statementFrameNodesQuery = nodesQuery(\"/statement//frame\");\n\nexport default domAssigned(class Statement {\n  constructor(string, node, tokens) {\n    this.string = string;\n    this.node = node;\n    this.tokens = tokens;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getTokens() {\n    return this.tokens;\n  }\n\n  isEqualTo(statement) {\n    const statementString = statement.getString(),\n          equalTo = (statementString === this.string);\n\n    return equalTo;\n  }\n\n  isTermContained(term, context) {\n    let termContained;\n\n    const termString = term.getString(),\n          statementString = this.string;  ///\n\n    context.trace(`Is the '${termString}' term contained in the '${statementString}' statement...`);\n\n    const termNode = term.getNode(),\n          statementNode = this.node,\n          statementTermNodes = statementTermNodesQuery(statementNode);\n\n    termContained = statementTermNodes.some((statementTermNode) => {  ///\n      const termNodeMatchesStatementVariableNode = termNode.match(statementTermNode);\n\n      if (termNodeMatchesStatementVariableNode) {\n        return true;\n      }\n    });\n\n    if (termContained) {\n      context.debug(`...the '${termString}' term is contained in the '${statementString}' statement.`);\n    }\n\n    return termContained;\n  }\n\n  isFrameContained(frame, context) {\n    let frameContained;\n\n    const frameString = frame.getString(),\n          statementString = this.string;  ///\n\n    context.trace(`Is the '${frameString}' frame contained in the '${statementString}' statement...`);\n\n    const frameNode = frame.getNode(),\n          statementNode = this.node,\n          statementFrameNodes = statementFrameNodesQuery(statementNode);\n\n    frameContained = statementFrameNodes.some((statementFrameNode) => {  ///\n      const frameNodeMatchesStatementMetavariableNode = frameNode.match(statementFrameNode);\n\n      if (frameNodeMatchesStatementMetavariableNode) {\n        return true;\n      }\n    });\n\n    if (frameContained) {\n      context.debug(`...the '${frameString}' frame is contained in the '${statementString}' statement.`);\n    }\n\n    return frameContained;\n  }\n\n  matchStatementNode(statementNode) {\n    const statementNodeMatches = this.node.match(statementNode);\n\n    return statementNodeMatches;\n  }\n\n  unifySubproof(subproof, substitutions, generalContext, specificContext) {\n    let subproofUnified = false;\n\n    const context = specificContext,  ///\n          statement = this, ///\n          subproofAssertion = subproofAssertionFromStatement(statement, context);\n\n    if (subproofAssertion !== null) {\n      const subproofString = subproof.getString(),\n            subproofAssertionString = subproofAssertion.getString();\n\n      specificContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);\n\n      const subproofStatements = subproof.getStatements(),\n            subproofAssertionStatements = subproofAssertion.getStatements();\n\n      subproofUnified = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {\n        const generalStatement = subproofAssertionStatement,  ///\n              specificStatement = subproofStatement,  ///\n              statementUnified = unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext);\n\n        if (statementUnified) {\n          return true;\n        }\n      });\n\n      if (subproofUnified) {\n        specificContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);\n      }\n    }\n\n    return subproofUnified;\n  }\n\n  unifyStatement(statement, substitutions, generalContext, specificContext) {\n    let statementUnified;\n\n    const generalStatement = this,  ///\n          specificStatement = statement, ///\n          generalStatementString = generalStatement.getString(),\n          specificStatementString = specificStatement.getString();\n\n    specificContext.trace(`Unifying the '${specificStatementString}' statement with the '${generalStatementString}' statement...`);\n\n    statementUnified = unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext);\n\n    if (statementUnified) {\n      specificContext.debug(`...unified the '${specificStatementString}' statement with the '${generalStatementString}' statement.`);\n    }\n\n    return statementUnified;\n  }\n\n  unifyIndependently(substitutions, generalContext, specificContext) {\n    let unifiedIndependently = false;\n\n    const context = specificContext,  ///\n          statement = this; ///\n\n    const definedAssertion = definedAssertionFromStatement(statement, context),\n          containedAssertion = containedAssertionFromStatement(statement, context);\n\n    if ((definedAssertion !== null) || (containedAssertion !== null)) {\n      const statementString = this.string;\n\n      specificContext.trace(`Unifying the '${statementString}' statement independently...`);\n\n      if (definedAssertion !== null) {\n        const definedAssertionUnifiedIndependently = definedAssertion.unifyIndependently(substitutions, context);\n\n        unifiedIndependently = definedAssertionUnifiedIndependently; ///\n      }\n\n      if (containedAssertion !== null) {\n        const containedAssertionUnifiedIndependently = containedAssertion.unifyIndependently(substitutions, context);\n\n        unifiedIndependently = containedAssertionUnifiedIndependently; ///\n      }\n\n      if (unifiedIndependently) {\n        specificContext.debug(`...unified the '${statementString}' statement independently.`);\n      }\n    }\n\n    return unifiedIndependently;\n  }\n\n  unifyWithProofSteps(proofSteps, context) {\n    let unifiedWithProofSteps;\n\n    unifiedWithProofSteps = backwardsSome(proofSteps, (proofStep) => {\n      const statement = this, ///\n            statementUnified =proofStep.unifyStatement(statement, context);\n\n      if (statementUnified) {\n        return true;\n      }\n    });\n\n    return unifiedWithProofSteps;\n  }\n\n  verify(assignments, stated, context) {\n    let verified;\n\n    verified = verifyMixins.some((verifyMixin) => {\n      const statement = this, ///\n            verified = verifyMixin(statement, assignments, stated, context);\n\n      if (verified) {\n        return true;\n      }\n    });\n\n    return verified;\n  }\n\n  verifyWhenDeclared(fileContext) {\n    let verifiedWhenDeclared;\n\n    const statementNode = this.node,  ///\n          statementString = this.string;  ///\n\n    fileContext.trace(`Verifying the '${statementString}' statement when declared...`);\n\n    verifiedWhenDeclared = combinatorVerifier.verifyStatement(statementNode, fileContext);\n\n    if (verifiedWhenDeclared) {\n      fileContext.debug(`...verified the '${statementString}' statement when declared.`);\n    }\n\n    return verifiedWhenDeclared;\n  }\n\n  verifyGivenMetaType(metaType, assignments, stated, context) {\n    let verifiedGivenMetaType = false;\n\n    const metaTypeString = metaType.getString(),\n          statementString = this.string;  ///\n\n    context.trace(`Verifying the '${statementString}' statement given the '${metaTypeString}' meta-type...`);\n\n    const metaTypeName = metaType.getName();\n\n    if (metaTypeName === STATEMENT_META_TYPE_NAME) {\n      const verified = this.verify(assignments, stated, context)\n\n      verifiedGivenMetaType = verified; ///\n    }\n\n    if (verifiedGivenMetaType) {\n      context.debug(`...verified the '${statementString}' statement given the '${metaTypeString}' meta-type.`);\n    }\n\n    return verifiedGivenMetaType;\n  }\n\n  toJSON() {\n    const string = this.string, ///\n          json = {\n            string\n          };\n\n    return json;\n  }\n\n  static name = \"Statement\";\n\n  static fromJSON(json, fileContext) {\n    const { string } = json,\n          context = fileContext,  ///\n          statementNodeAndTokens = StatementNodeAndTokens.fromString(string, context),\n          node = statementNodeAndTokens.getNode(),\n          tokens = statementNodeAndTokens.getTokens(),\n          statement = new Statement(string, node, tokens);\n\n    return statement;\n  }\n\n  static fromPremiseNode(premiseNode, fileContext) {\n    const node = premiseNode, ///\n          statement = statementFromNode(node, fileContext);\n\n    return statement;\n  }\n\n  static fromProofStepNode(proofStepNode, fileContext) {\n    const node = proofStepNode, ///\n          statement = statementFromNode(node, fileContext);\n\n    return statement;\n  }\n\n  static fromStatementNode(statementNode, context) {\n    let statement = null;\n\n    if (statementNode !== null) {\n      const node = statementNode, ///\n            tokens = context.nodeAsTokens(node),\n            string = context.tokensAsString(tokens);\n\n      statement = new Statement(string, node, tokens);\n    }\n\n    return statement;\n  }\n\n  static fromConclusionNode(conclusionNode, fileContext) {\n    const node = conclusionNode, ///\n          statement = statementFromNode(node, fileContext);\n\n    return statement;\n  }\n\n  static fromConsequentNode(consequentNode, fileContext) {\n    const node = consequentNode, ///\n          statement = statementFromNode(node, fileContext);\n\n    return statement;\n  }\n\n  static fromSuppositionNode(suppositionNode, fileContext) {\n    const node = suppositionNode, ///\n          statement = statementFromNode(node, fileContext);\n\n    return statement;\n  }\n\n  static fromContainedAssertionNode(containedAssertionNode, context) {\n    const statementNode = statementNodeQuery(containedAssertionNode),\n          node = statementNode, ///\n          tokens = context.nodeAsTokens(node),\n          string = context.tokensAsString(tokens),\n          statement = new Statement(string, node, tokens);\n\n    return statement;\n  }\n});\n\nfunction statementFromNode(node, fileContext) {\n  let statement = null;\n\n  const statementNode = statementNodeQuery(node);\n\n  if (statementNode !== null) {\n    const { Statement } = dom,\n          node = statementNode, ///\n          tokens = fileContext.nodeAsTokens(node),\n          string = fileContext.tokensAsString(tokens);\n\n    statement = new Statement(string, node, tokens);\n  }\n\n  return statement;\n}"],"names":["match","arrayUtilities","backwardsSome","statementNodeQuery","nodeQuery","statementTermNodesQuery","nodesQuery","statementFrameNodesQuery","domAssigned","Statement","string","node","tokens","getString","getNode","getTokens","isEqualTo","statement","statementString","equalTo","isTermContained","term","context","termContained","termString","trace","termNode","statementNode","statementTermNodes","some","statementTermNode","termNodeMatchesStatementVariableNode","debug","isFrameContained","frame","frameContained","frameString","frameNode","statementFrameNodes","statementFrameNode","frameNodeMatchesStatementMetavariableNode","matchStatementNode","statementNodeMatches","unifySubproof","subproof","substitutions","generalContext","specificContext","subproofUnified","subproofAssertion","subproofAssertionFromStatement","subproofString","subproofAssertionString","subproofStatements","getStatements","subproofAssertionStatements","subproofAssertionStatement","subproofStatement","generalStatement","specificStatement","statementUnified","unifyStatement","generalStatementString","specificStatementString","unifyIndependently","unifiedIndependently","definedAssertion","definedAssertionFromStatement","containedAssertion","containedAssertionFromStatement","definedAssertionUnifiedIndependently","containedAssertionUnifiedIndependently","unifyWithProofSteps","proofSteps","unifiedWithProofSteps","proofStep","verify","assignments","stated","verified","verifyMixins","verifyMixin","verifyWhenDeclared","fileContext","verifiedWhenDeclared","combinatorVerifier","verifyStatement","verifyGivenMetaType","metaType","verifiedGivenMetaType","metaTypeString","metaTypeName","getName","STATEMENT_META_TYPE_NAME","toJSON","json","fromJSON","statementNodeAndTokens","StatementNodeAndTokens","fromString","fromPremiseNode","premiseNode","statementFromNode","fromProofStepNode","proofStepNode","fromStatementNode","nodeAsTokens","tokensAsString","fromConclusionNode","conclusionNode","fromConsequentNode","consequentNode","fromSuppositionNode","suppositionNode","fromContainedAssertionNode","containedAssertionNode","name","dom"],"mappings":"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"}

package/lib/dom/subDerivation.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _necessary = require("necessary");
+var _dom = /*#__PURE__*/ _interop_require_wildcard(require("../dom"));
+var _query = require("../utilities/query");
+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 _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _SubDerivation;
+var last = _necessary.arrayUtilities.last;
+var proofStepNodesQuery = (0, _query.nodesQuery)("/subDerivation/proofStep|lastProofStep");
+var _default = (0, _dom.domAssigned)((_SubDerivation = /*#__PURE__*/ function() {
+    function SubDerivation(proofSteps) {
+        _class_call_check(this, SubDerivation);
+        this.proofSteps = proofSteps;
+    }
+    _create_class(SubDerivation, [
+        {
+            key: "getProofSteps",
+            value: function getProofSteps() {
+                return this.proofSteps;
+            }
+        },
+        {
+            key: "getLastProofStep",
+            value: function getLastProofStep() {
+                var lastProofStep = last(this.proofSteps);
+                return lastProofStep;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(substitutions, context) {
+                var verified;
+                verified = this.proofSteps.every(function(proofStep) {
+                    var proofStepVerifiedAndUnified = proofStep.verifyAndUnify(substitutions, context);
+                    if (proofStepVerifiedAndUnified) {
+                        return true;
+                    }
+                });
+                return verified;
+            }
+        }
+    ], [
+        {
+            key: "fromSubDerivationNode",
+            value: function fromSubDerivationNode(subDerivationNode, fileContext) {
+                var ProofStep = _dom.default.ProofStep, proofStepNodes = proofStepNodesQuery(subDerivationNode), proofSteps = proofStepNodes.map(function(proofStepNode) {
+                    var proofStep = ProofStep.fromProofStepNode(proofStepNode, fileContext);
+                    return proofStep;
+                }), subDerivation = new SubDerivation(proofSteps);
+                return subDerivation;
+            }
+        }
+    ]);
+    return SubDerivation;
+}(), _define_property(_SubDerivation, "name", "SubDerivation"), _SubDerivation));
+
+//# sourceMappingURL=data:application/json;base64,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