occam-verify-cli 0.0.1111 → 0.0.1112

package/lib/dom/assertion/subproof.js

@@ -0,0 +1,210 @@
+"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 _unification = require("../../utilities/unification");
+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 _SubproofAssertion;
+var front = _necessary.arrayUtilities.front, last = _necessary.arrayUtilities.last, match = _necessary.arrayUtilities.match;
+var statementNodesQuery = (0, _query.nodesQuery)("/subproofAssertion/statement"), subproofAssertionNodeQuery = (0, _query.nodeQuery)("/statement/subproofAssertion");
+var _default = (0, _dom.domAssigned)((_SubproofAssertion = /*#__PURE__*/ function() {
+    function SubproofAssertion(string, node, statements) {
+        _class_call_check(this, SubproofAssertion);
+        this.string = string;
+        this.node = node;
+        this.statements = statements;
+    }
+    _create_class(SubproofAssertion, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getStatements",
+            value: function getStatements() {
+                return this.statements;
+            }
+        },
+        {
+            key: "unifySubproof",
+            value: function unifySubproof(subproof, substitutions, generalContext, specificContext) {
+                var subproofUnified;
+                var subproofString = subproof.getString(), subproofAssertionString = this.string; ///
+                specificContext.trace("Unifying the '".concat(subproofString, "' subproof with the '").concat(subproofAssertionString, "' subproof assertion..."));
+                var subproofStatements = subproof.getStatements(), subproofAssertionStatements = this.statements; ///
+                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: "verify",
+            value: function verify(assignments, stated, context) {
+                var verified;
+                var subproofAssertionString = this.string; ///
+                context.trace("Verifying the '".concat(subproofAssertionString, "' subproof assertion..."));
+                var statementsVerified = this.verifyStatements(assignments, stated, context);
+                verified = statementsVerified; ///
+                if (verified) {
+                    context.debug("...verified the '".concat(subproofAssertionString, "' subproof assertion."));
+                }
+                return verified;
+            }
+        },
+        {
+            key: "verifyStatements",
+            value: function verifyStatements(assignments, stated, context) {
+                stated = true; ///
+                assignments = null; ///
+                var statementsVerified = this.statements.map(function(statement) {
+                    var statementVerified = statement.verify(assignments, stated, context);
+                    if (statementVerified) {
+                        return true;
+                    }
+                });
+                return statementsVerified;
+            }
+        }
+    ], [
+        {
+            key: "fromStatementNode",
+            value: function fromStatementNode(statementNode, context) {
+                var subproofAssertion = null;
+                var subproofAssertionNode = subproofAssertionNodeQuery(statementNode);
+                if (subproofAssertionNode !== null) {
+                    var Statement = _dom.default.Statement, statementNodes = statementNodesQuery(subproofAssertionNode), statement = Statement.fromStatementNode(statementNode, context), statementString = statement.getString(), statements = statementNodes.map(function(statementNode) {
+                        var statement = Statement.fromStatementNode(statementNode, context);
+                        return statement;
+                    }), node = subproofAssertionNode, string = statementString; ///
+                    subproofAssertion = new SubproofAssertion(string, node, statements);
+                }
+                return subproofAssertion;
+            }
+        },
+        {
+            key: "fromSubproofAssertionNode",
+            value: function fromSubproofAssertionNode(subproofAssertionNode, context) {
+                var subproofAssertion = null;
+                if (subproofAssertionNode !== null) {
+                    var Statement = _dom.default.Statement, statementNodes = statementNodesQuery(subproofAssertionNode), statements = statementNodes.map(function(statementNode) {
+                        var statement = Statement.fromStatementNode(statementNode, context);
+                        return statement;
+                    }), node = subproofAssertionNode, string = stringFromStatements(statements);
+                    subproofAssertion = new SubproofAssertion(string, node, statements);
+                }
+                return subproofAssertion;
+            }
+        }
+    ]);
+    return SubproofAssertion;
+}(), _define_property(_SubproofAssertion, "name", "SubproofAssertion"), _SubproofAssertion));
+function stringFromStatements(statements) {
+    var frontStatements = front(statements), lastStatement = last(statements), frontStatementsString = statementsStringFromStatements(frontStatements), lastStatementString = lastStatement.getString(), string = "[".concat(frontStatementsString, "] ... ").concat(lastStatementString);
+    return string;
+}
+function statementsStringFromStatements(statements) {
+    var statementsString = statements.reduce(function(statementsString, statement) {
+        var statementString = statement.getString();
+        statementsString = statementsString !== null ? "".concat(statementsString, ", ").concat(statementString) : statementString; ///
+        return statementsString;
+    }, null);
+    return statementsString;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/dom/assertion/subproof.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport dom from \"../../dom\";\n\nimport { domAssigned } from \"../../dom\";\nimport { unifyStatement } from \"../../utilities/unification\";\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 domAssigned(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  unifySubproof(subproof, substitutions, generalContext, specificContext) {\n    let subproofUnified;\n\n    const subproofString = subproof.getString(),\n          subproofAssertionString = this.string;  ///\n\n    specificContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);\n\n    const subproofStatements = subproof.getStatements(),\n          subproofAssertionStatements = this.statements;  ///\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    return subproofUnified;\n  }\n\n  verify(assignments, stated, context) {\n    let verified;\n\n    const subproofAssertionString = this.string;  ///\n\n    context.trace(`Verifying the '${subproofAssertionString}' subproof assertion...`);\n\n    const statementsVerified = this.verifyStatements(assignments, stated, context);\n\n    verified = statementsVerified;  ///\n\n    if (verified) {\n      context.debug(`...verified the '${subproofAssertionString}' subproof assertion.`);\n    }\n\n    return verified;\n  }\n\n  verifyStatements(assignments, stated, context) {\n    stated = true;  ///\n\n    assignments = null; ///\n\n    const statementsVerified = this.statements.map((statement) => {\n      const statementVerified = statement.verify(assignments, stated, context);\n\n      if (statementVerified) {\n        return true;\n      }\n    });\n\n    return statementsVerified;\n  }\n\n  static name = \"SubproofAssertion\";\n\n  static fromStatementNode(statementNode, context) {\n    let subproofAssertion = null;\n\n    const subproofAssertionNode = subproofAssertionNodeQuery(statementNode);\n\n    if (subproofAssertionNode !== null) {\n      const { Statement } = dom,\n            statementNodes = statementNodesQuery(subproofAssertionNode),\n            statement = Statement.fromStatementNode(statementNode, context),\n            statementString = statement.getString(),\n            statements = statementNodes.map((statementNode) => {\n              const statement = Statement.fromStatementNode(statementNode, context);\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, context) {\n    let subproofAssertion = null;\n\n    if (subproofAssertionNode !== null) {\n      const { Statement } = dom,\n            statementNodes = statementNodesQuery(subproofAssertionNode),\n            statements = statementNodes.map((statementNode) => {\n              const statement = Statement.fromStatementNode(statementNode, context);\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}\n"],"names":["front","arrayUtilities","last","match","statementNodesQuery","nodesQuery","subproofAssertionNodeQuery","nodeQuery","domAssigned","SubproofAssertion","string","node","statements","getString","getNode","getStatements","unifySubproof","subproof","substitutions","generalContext","specificContext","subproofUnified","subproofString","subproofAssertionString","trace","subproofStatements","subproofAssertionStatements","subproofAssertionStatement","subproofStatement","generalStatement","specificStatement","statementUnified","unifyStatement","debug","verify","assignments","stated","context","verified","statementsVerified","verifyStatements","map","statement","statementVerified","fromStatementNode","statementNode","subproofAssertion","subproofAssertionNode","Statement","dom","statementNodes","statementString","fromSubproofAssertionNode","stringFromStatements","name","frontStatements","lastStatement","frontStatementsString","statementsStringFromStatements","lastStatementString","statementsString","reduce"],"mappings":"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"}

package/lib/dom/assertion/type.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _dom = /*#__PURE__*/ _interop_require_wildcard(require("../../dom"));
+var _variable = /*#__PURE__*/ _interop_require_default(require("../../assignment/variable"));
+var _query = require("../../utilities/query");
+var _type = require("../../dom/type");
+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 _TypeAssertion;
+var termNodeQuery = (0, _query.nodeQuery)("/typeAssertion/term"), typeNodeQuery = (0, _query.nodeQuery)("/typeAssertion/type"), variableNodeQuery = (0, _query.nodeQuery)("/term/variable!"), typeAssertionNodeQuery = (0, _query.nodeQuery)("/statement/typeAssertion");
+var _default = (0, _dom.domAssigned)((_TypeAssertion = /*#__PURE__*/ function() {
+    function TypeAssertion(string, term, type) {
+        _class_call_check(this, TypeAssertion);
+        this.string = string;
+        this.term = term;
+        this.type = type;
+    }
+    _create_class(TypeAssertion, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getTerm",
+            value: function getTerm() {
+                return this.term;
+            }
+        },
+        {
+            key: "getType",
+            value: function getType() {
+                return this.type;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, context) {
+                var verified = false;
+                var typeAssertionString = this.string; ///
+                context.trace("Verifying the '".concat(typeAssertionString, "' type assertion..."));
+                var typeVerified = this.verifyType(context);
+                if (typeVerified) {
+                    var verifiedWhenStated = false, verifiedWhenDerived = false;
+                    if (stated) {
+                        verifiedWhenStated = this.verifyWhenStated(assignments, context);
+                    } else {
+                        verifiedWhenDerived = this.verifyWhenDerived(context);
+                    }
+                    if (verifiedWhenStated || verifiedWhenDerived) {
+                        verified = true;
+                    }
+                }
+                if (verified) {
+                    context.debug("...verified the '".concat(typeAssertionString, "' type assertion."));
+                }
+                return verified;
+            }
+        },
+        {
+            key: "verifyType",
+            value: function verifyType(context) {
+                var typeVerified;
+                if (this.type === _type.objectType) {
+                    typeVerified = true;
+                } else {
+                    var typeName = this.type.getName();
+                    context.trace("Verifying the '".concat(typeName, "' type..."));
+                    var type = context.findTypeByTypeName(typeName);
+                    if (type !== null) {
+                        this.type = type;
+                        typeVerified = true;
+                    } else {
+                        context.debug("The '".concat(typeName, "' type is missing."));
+                    }
+                    if (typeVerified) {
+                        context.debug("...verified the '".concat(typeName, "' type."));
+                    }
+                }
+                return typeVerified;
+            }
+        },
+        {
+            key: "verifyWhenStated",
+            value: function verifyWhenStated(assignments, context) {
+                var _this = this;
+                var verifiedWhenStated = false;
+                var typeAssertionString = this.string; ///
+                context.trace("Verifying the '".concat(typeAssertionString, "' stated type assertion..."));
+                var termVerified = this.term.verify(context, function() {
+                    var verifiedAhead;
+                    var termType = _this.term.getType(), typeEqualToOrSubTypeOfTermType = _this.type.isEqualToOrSubTypeOf(termType);
+                    if (typeEqualToOrSubTypeOfTermType) {
+                        verifiedAhead = true;
+                    }
+                    return verifiedAhead;
+                });
+                if (termVerified) {
+                    if (assignments !== null) {
+                        var Variable = _dom.default.Variable, termNode = this.term.getNode(), variableNode = variableNodeQuery(termNode), variable = Variable.fromVariableNodeAndType(variableNode, this.type, context);
+                        if (variable !== null) {
+                            var variableAssignment = _variable.default.fromVariable(variable), assignment = variableAssignment; ///
+                            assignments.push(assignment);
+                        }
+                    }
+                    verifiedWhenStated = true;
+                }
+                if (verifiedWhenStated) {
+                    context.debug("...verified the '".concat(typeAssertionString, "' stated type assertion."));
+                }
+                return verifiedWhenStated;
+            }
+        },
+        {
+            key: "verifyWhenDerived",
+            value: function verifyWhenDerived(context) {
+                var _this = this;
+                var verifiedWhenDerived;
+                var typeAssertionString = this.string; ///
+                context.trace("Verifying the '".concat(typeAssertionString, "' derived type assertion..."));
+                var termVerified = this.term.verify(context, function() {
+                    var verifiedAhead;
+                    var termType = _this.term.getType(), typeEqualToOrSuperTypeOfTermType = _this.type.isEqualToOrSuperTypeOf(termType);
+                    verifiedAhead = typeEqualToOrSuperTypeOfTermType; ///
+                    return verifiedAhead;
+                });
+                verifiedWhenDerived = termVerified; ///
+                if (verifiedWhenDerived) {
+                    context.debug("...verified the '".concat(typeAssertionString, "' derived type assertion."));
+                }
+                return verifiedWhenDerived;
+            }
+        }
+    ], [
+        {
+            key: "fromStatementNode",
+            value: function fromStatementNode(statementNode, context) {
+                var typeAssertion = null;
+                var typeAssertionNode = typeAssertionNodeQuery(statementNode);
+                if (typeAssertionNode !== null) {
+                    var Term = _dom.default.Term, Type = _dom.default.Type, termNode = termNodeQuery(typeAssertionNode), typeNode = typeNodeQuery(typeAssertionNode), term = Term.fromTermNode(termNode, context), type = Type.fromTypeNode(typeNode, context), string = stringFromTermAndType(term, type);
+                    typeAssertion = new TypeAssertion(string, term, type);
+                }
+                return typeAssertion;
+            }
+        }
+    ]);
+    return TypeAssertion;
+}(), _define_property(_TypeAssertion, "name", "TypeAssertion"), _TypeAssertion));
+function stringFromTermAndType(term, type) {
+    var termString = term.getString(), typeName = type.getName(), string = "".concat(termString, ":").concat(typeName);
+    return string;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/dom/assertion/type.js"],"sourcesContent":["\"use strict\";\n\nimport dom from \"../../dom\";\nimport VariableAssignment from \"../../assignment/variable\";\n\nimport { nodeQuery } from \"../../utilities/query\";\nimport { objectType } from \"../../dom/type\";\nimport { domAssigned } from \"../../dom\";\n\nconst termNodeQuery = nodeQuery(\"/typeAssertion/term\"),\n      typeNodeQuery = nodeQuery(\"/typeAssertion/type\"),\n      variableNodeQuery = nodeQuery(\"/term/variable!\"),\n      typeAssertionNodeQuery = nodeQuery(\"/statement/typeAssertion\");\n\nexport default domAssigned(class TypeAssertion {\n  constructor(string, term, type) {\n    this.string = string;\n    this.term = term;\n    this.type = type;\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  verify(assignments, stated, context) {\n    let verified = false;\n\n    let typeAssertionString = this.string;  ///\n\n    context.trace(`Verifying the '${typeAssertionString}' type assertion...`);\n\n    const typeVerified = this.verifyType(context);\n\n    if (typeVerified) {\n      let verifiedWhenStated = false,\n          verifiedWhenDerived = false;\n\n      if (stated) {\n        verifiedWhenStated = this.verifyWhenStated(assignments, context);\n      } else {\n        verifiedWhenDerived = this.verifyWhenDerived(context);\n      }\n\n      if (verifiedWhenStated || verifiedWhenDerived) {\n        verified = true;\n      }\n    }\n\n    if (verified) {\n      context.debug(`...verified the '${typeAssertionString}' type assertion.`);\n    }\n\n    return verified;\n  }\n\n  verifyType(context) {\n    let typeVerified;\n\n    if (this.type === objectType) {\n      typeVerified = true;\n    } else {\n      const typeName = this.type.getName();\n\n      context.trace(`Verifying the '${typeName}' type...`);\n\n      const type = context.findTypeByTypeName(typeName);\n\n      if (type !== null) {\n        this.type = type;\n\n        typeVerified = true;\n      } else {\n        context.debug(`The '${typeName}' type is missing.`);\n      }\n\n      if (typeVerified) {\n        context.debug(`...verified the '${typeName}' type.`);\n      }\n    }\n\n    return typeVerified;\n  }\n\n  verifyWhenStated(assignments, context) {\n    let verifiedWhenStated = false;\n\n    const typeAssertionString = this.string; ///\n\n    context.trace(`Verifying the '${typeAssertionString}' stated type assertion...`);\n\n    const termVerified = this.term.verify(context, () => {\n      let verifiedAhead;\n\n      const termType = this.term.getType(),\n            typeEqualToOrSubTypeOfTermType = this.type.isEqualToOrSubTypeOf(termType);\n\n      if (typeEqualToOrSubTypeOfTermType) {\n        verifiedAhead = true;\n      }\n\n      return verifiedAhead;\n    });\n\n    if (termVerified) {\n      if (assignments !== null) {\n        const { Variable } = dom,\n              termNode = this.term.getNode(),\n              variableNode = variableNodeQuery(termNode),\n              variable = Variable.fromVariableNodeAndType(variableNode, this.type, context);\n\n        if (variable !== null) {\n          const variableAssignment = VariableAssignment.fromVariable(variable),\n                assignment = variableAssignment;  ///\n\n          assignments.push(assignment);\n        }\n      }\n\n      verifiedWhenStated = true;\n    }\n\n    if (verifiedWhenStated) {\n      context.debug(`...verified the '${typeAssertionString}' stated type assertion.`);\n    }\n\n    return verifiedWhenStated;\n  }\n\n  verifyWhenDerived(context) {\n    let verifiedWhenDerived;\n\n    const typeAssertionString = this.string; ///\n\n    context.trace(`Verifying the '${typeAssertionString}' derived type assertion...`);\n\n    const termVerified = this.term.verify(context, () => {\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    if (verifiedWhenDerived) {\n      context.debug(`...verified the '${typeAssertionString}' derived type assertion.`);\n    }\n\n    return verifiedWhenDerived;\n  }\n\n  static name = \"TypeAssertion\";\n\n  static fromStatementNode(statementNode, context) {\n    let typeAssertion = null;\n\n    const typeAssertionNode = typeAssertionNodeQuery(statementNode);\n\n    if (typeAssertionNode !== null) {\n      const { Term, Type } = dom,\n            termNode = termNodeQuery(typeAssertionNode),\n            typeNode = typeNodeQuery(typeAssertionNode),\n            term = Term.fromTermNode(termNode, context),\n            type = Type.fromTypeNode(typeNode, context),\n            string = stringFromTermAndType(term, type);\n\n      typeAssertion = new TypeAssertion(string, term, type);\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":["termNodeQuery","nodeQuery","typeNodeQuery","variableNodeQuery","typeAssertionNodeQuery","domAssigned","TypeAssertion","string","term","type","getString","getTerm","getType","verify","assignments","stated","context","verified","typeAssertionString","trace","typeVerified","verifyType","verifiedWhenStated","verifiedWhenDerived","verifyWhenStated","verifyWhenDerived","debug","objectType","typeName","getName","findTypeByTypeName","termVerified","verifiedAhead","termType","typeEqualToOrSubTypeOfTermType","isEqualToOrSubTypeOf","Variable","dom","termNode","getNode","variableNode","variable","fromVariableNodeAndType","variableAssignment","VariableAssignment","fromVariable","assignment","push","typeEqualToOrSuperTypeOfTermType","isEqualToOrSuperTypeOf","fromStatementNode","statementNode","typeAssertion","typeAssertionNode","Term","Type","typeNode","fromTermNode","fromTypeNode","stringFromTermAndType","name","termString"],"mappings":"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"}

package/lib/{axiom.js → dom/axiom.js}

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
-var _shim = /*#__PURE__*/ _interop_require_default(require("./shim"));
 var _topLevelAssertion = /*#__PURE__*/ _interop_require_default(require("./topLevelAssertion"));
+var _dom = require("../dom");
 function _assert_this_initialized(self) {
     if (self === void 0) {
         throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
@@ -39,6 +39,19 @@ function _create_class(Constructor, protoProps, staticProps) {
     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 _get(target, property, receiver) {
     if (typeof Reflect !== "undefined" && Reflect.get) {
         _get = Reflect.get;
@@ -111,7 +124,8 @@ function _is_native_reflect_construct() {
         return !!result;
     })();
 }
-var Axiom = /*#__PURE__*/ function(TopLevelAssertion) {
+var _Axiom;
+var _default = (0, _dom.domAssigned)((_Axiom = /*#__PURE__*/ function(TopLevelAssertion) {
     _inherits(Axiom, TopLevelAssertion);
     function Axiom() {
         _class_call_check(this, Axiom);
@@ -148,10 +162,6 @@ var Axiom = /*#__PURE__*/ function(TopLevelAssertion) {
         }
     ]);
     return Axiom;
-}(_topLevelAssertion.default);
-Object.assign(_shim.default, {
-    Axiom: Axiom
-});
-var _default = Axiom;
+}(_topLevelAssertion.default), _define_property(_Axiom, "name", "TopLevelAssertion"), _Axiom));
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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