occam-verify-cli 1.0.383 → 1.0.386

package/lib/ontology/derivation.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _necessary = require("necessary");
+var _ontology = /*#__PURE__*/ _interop_require_wildcard(require("../ontology"));
+var _assignments = require("../utilities/assignments");
+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 _Derivation;
+var last = _necessary.arrayUtilities.last;
+var _default = (0, _ontology.define)((_Derivation = /*#__PURE__*/ function() {
+    function Derivation(stepsOrSubproofs) {
+        _class_call_check(this, Derivation);
+        this.stepsOrSubproofs = stepsOrSubproofs;
+    }
+    _create_class(Derivation, [
+        {
+            key: "getStepsOrSubproofs",
+            value: function getStepsOrSubproofs() {
+                return this.stepsOrSubproofs;
+            }
+        },
+        {
+            key: "getLastStep",
+            value: function getLastStep() {
+                var lastStepOrSubproof = last(this.stepsOrSubproofs), lastStep = lastStepOrSubproof; ///
+                return lastStep;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(substitutions, context) {
+                var verifies;
+                verifies = this.stepsOrSubproofs.every(function(stepOrSubproof) {
+                    var assignments = [], stepOrSubproofVerifies = stepOrSubproof.verify(substitutions, assignments, context);
+                    if (stepOrSubproofVerifies) {
+                        var stepOrSubproofUnifies = stepOrSubproof.unify(substitutions, context);
+                        if (stepOrSubproofUnifies) {
+                            var assignmentsAssigned = (0, _assignments.assignAssignments)(assignments, context);
+                            if (assignmentsAssigned) {
+                                context.addStepOrSubproof(stepOrSubproof);
+                                return true;
+                            }
+                        }
+                    }
+                });
+                return verifies;
+            }
+        }
+    ], [
+        {
+            key: "fromDerivationNode",
+            value: function fromDerivationNode(derivationNode, context) {
+                var stepsOrSubproofs = stepsOrSubproofsFromDerivationNode(derivationNode, context), derivation = new Derivation(stepsOrSubproofs);
+                return derivation;
+            }
+        }
+    ]);
+    return Derivation;
+}(), _define_property(_Derivation, "name", "Derivation"), _Derivation));
+function stepsOrSubproofsFromDerivationNode(derivationNode, context) {
+    var Step = _ontology.default.Step, Subproof = _ontology.default.Subproof, stepOrSubproofNodes = derivationNode.getStepOrSubproofNodes(), stepsOrSubproofs = stepOrSubproofNodes.map(function(stepOrSubproofNode) {
+        var stepOrSubproof;
+        var step = Step.fromStepOrSubproofNode(stepOrSubproofNode, context), subproof = Subproof.fromStepOrSubproofNode(stepOrSubproofNode, context);
+        if (false) {
+        ///
+        } else if (step !== null) {
+            stepOrSubproof = step; ///
+        } else if (subproof !== null) {
+            stepOrSubproof = subproof; ///
+        }
+        return stepOrSubproof;
+    });
+    return stepsOrSubproofs;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/ontology/equality.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _ontology = /*#__PURE__*/ _interop_require_wildcard(require("../ontology"));
+var _equantional = /*#__PURE__*/ _interop_require_default(require("../unifier/equantional"));
+var _equality = /*#__PURE__*/ _interop_require_default(require("../assignment/equality"));
+var _variable = /*#__PURE__*/ _interop_require_default(require("../assignment/variable"));
+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 _Equality;
+var _default = (0, _ontology.define)((_Equality = /*#__PURE__*/ function() {
+    function Equality(string, leftTerm, rightTerm) {
+        _class_call_check(this, Equality);
+        this.string = string;
+        this.leftTerm = leftTerm;
+        this.rightTerm = rightTerm;
+    }
+    _create_class(Equality, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getLeftTerm",
+            value: function getLeftTerm() {
+                return this.leftTerm;
+            }
+        },
+        {
+            key: "getRightTerm",
+            value: function getRightTerm() {
+                return this.rightTerm;
+            }
+        },
+        {
+            key: "getType",
+            value: function getType() {
+                var type;
+                var leftTermType = this.leftTerm.getType(), rightTermType = this.rightTerm.getType(), leftTermTypeEqualToOrSubTypeOfRightTermType = leftTermType.isEqualToOrSubTypeOf(rightTermType), rightTermTypeEqualToOrSubTypeOfLeftTermType = rightTermType.isEqualToOrSubTypeOf(leftTermType);
+                if (leftTermTypeEqualToOrSubTypeOfRightTermType) {
+                    type = leftTermType; ///
+                }
+                if (rightTermTypeEqualToOrSubTypeOfLeftTermType) {
+                    type = rightTermType; ///
+                }
+                return type;
+            }
+        },
+        {
+            key: "getTerms",
+            value: function getTerms() {
+                var terms = [
+                    this.leftTerm,
+                    this.rightTerm
+                ];
+                return terms;
+            }
+        },
+        {
+            key: "isReflexive",
+            value: function isReflexive() {
+                var leftTermString = this.leftTerm.getString(), rightTermString = this.rightTerm.getString(), reflexive = leftTermString === rightTermString;
+                return reflexive;
+            }
+        },
+        {
+            key: "isEqual",
+            value: function isEqual(context) {
+                var equal = false;
+                var leftTermNode = this.leftTerm.getNode(), rightTermNode = this.rightTerm.getNode(), termsEquates = _equantional.default.equateTerms(leftTermNode, rightTermNode, context);
+                if (termsEquates) {
+                    equal = true;
+                }
+                return equal;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, context) {
+                var verifies = false;
+                var equalityString = this.string; ///
+                context.trace("Verifying the '".concat(equalityString, "' equality..."));
+                var termsVerify = this.verifyTerms(context);
+                if (termsVerify) {
+                    var verifiesWhenStated = false, verifiesWhenDerived = false;
+                    if (stated) {
+                        verifiesWhenStated = this.verifyWhenStated(assignments, context);
+                    } else {
+                        verifiesWhenDerived = this.verifyWhenDerived(context);
+                    }
+                    if (verifiesWhenStated || verifiesWhenDerived) {
+                        verifies = true;
+                    }
+                }
+                if (verifies) {
+                    this.assign(assignments, context);
+                }
+                if (verifies) {
+                    context.debug("...verified the '".concat(equalityString, "' equality."));
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifyTerms",
+            value: function verifyTerms(context) {
+                var _this = this;
+                var termsVerify;
+                var equalityString = this.string; ///
+                context.trace("Verifying the '".concat(equalityString, "' equality's terms..."));
+                var leftTermVerifies = this.leftTerm.verify(context, function() {
+                    var verifiesAhead;
+                    var rightTermVerifies = _this.rightTerm.verify(context, function() {
+                        var verifiesAhead;
+                        var leftTermType = _this.leftTerm.getType(), rightTermType = _this.rightTerm.getType(), leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
+                        verifiesAhead = leftTermTypeComparableToRightTermType; ///
+                        return verifiesAhead;
+                    });
+                    verifiesAhead = rightTermVerifies; ///
+                    return verifiesAhead;
+                });
+                termsVerify = leftTermVerifies; ///
+                if (termsVerify) {
+                    context.debug("...verified the '".concat(equalityString, "' equality's terms."));
+                }
+                return termsVerify;
+            }
+        },
+        {
+            key: "verifyWhenStated",
+            value: function verifyWhenStated(assignments, context) {
+                var verifiesWhenStated;
+                var equalityString = this.string; ///
+                context.trace("Verifying the '".concat(equalityString, "' stated equality..."));
+                verifiesWhenStated = true;
+                if (verifiesWhenStated) {
+                    context.debug("...verified the '".concat(equalityString, "' stated equality."));
+                }
+                return verifiesWhenStated;
+            }
+        },
+        {
+            key: "verifyWhenDerived",
+            value: function verifyWhenDerived(context) {
+                var verifiesWhenDerived;
+                var equalityString = this.string; ///
+                context.trace("Verifying the '".concat(equalityString, "' derived equality..."));
+                verifiesWhenDerived = true; ///
+                if (verifiesWhenDerived) {
+                    context.debug("...verified the '".concat(equalityString, "' derived equality."));
+                }
+                return verifiesWhenDerived;
+            }
+        },
+        {
+            key: "assign",
+            value: function assign(assignments, context) {
+                if (assignments === null) {
+                    return;
+                }
+                var Variable = _ontology.default.Variable, type = this.getType(), leftTermNode = this.leftTerm.getNode(), rightTermNode = this.rightTerm.getNode(), leftTermNodeSingularVariableNode = leftTermNode.getSingularVariableNode(), rightTermNodeSingularVariableNode = rightTermNode.getSingularVariableNode(), leftVariableNode = leftTermNodeSingularVariableNode, rightVariableNode = rightTermNodeSingularVariableNode; ///
+                var assignment;
+                if (leftVariableNode !== null) {
+                    var leftVariable = Variable.fromVariableNodeAndType(leftVariableNode, type, context), leftVariableAssignment = _variable.default.fromVariable(leftVariable);
+                    assignment = leftVariableAssignment; ///
+                    assignments.push(assignment);
+                }
+                if (rightVariableNode !== null) {
+                    var rightVariable = Variable.fromVariableNodeAndType(rightVariableNode, type, context), rightVariableAssignment = _variable.default.fromVariable(rightVariable);
+                    assignment = rightVariableAssignment; ///
+                    assignments.push(assignment);
+                }
+                var equality = this, equalityAssignment = _equality.default.fromEquality(equality);
+                assignment = equalityAssignment; ///
+                assignments.push(assignment);
+            }
+        }
+    ], [
+        {
+            key: "fromStatementNode",
+            value: function fromStatementNode(statementNode, context) {
+                var equality = null;
+                var equalityNode = statementNode.getEqualityNode();
+                if (equalityNode !== null) {
+                    var node = equalityNode, string = context.nodeAsString(node), leftTerm = leftTermFromEqualityNode(equalityNode, context), rightTerm = rightTermFromEqualityNode(equalityNode, context);
+                    equality = new Equality(string, leftTerm, rightTerm);
+                }
+                return equality;
+            }
+        }
+    ]);
+    return Equality;
+}(), _define_property(_Equality, "name", "Equality"), _Equality));
+function leftTermFromEqualityNode(equalityNode, context) {
+    var Term = _ontology.default.Term, leftTermNode = equalityNode.getLeftTermNode(), leftTerm = Term.fromTermNode(leftTermNode, context);
+    return leftTerm;
+}
+function rightTermFromEqualityNode(equalityNode, context) {
+    var Term = _ontology.default.Term, rightTermNode = equalityNode.getRightTermNode(), rightTerm = Term.fromTermNode(rightTermNode, context);
+    return rightTerm;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/ontology/equality.js"],"sourcesContent":["\"use strict\";\n\nimport ontology from \"../ontology\";\nimport equationalUnifier from \"../unifier/equantional\";\nimport EqualityAssignment from \"../assignment/equality\";\nimport VariableAssignment from \"../assignment/variable\";\n\nimport { define } from \"../ontology\";\n\nexport default define(class Equality {\n  constructor(string, leftTerm, rightTerm) {\n    this.string = string;\n    this.leftTerm = leftTerm;\n    this.rightTerm = rightTerm;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getLeftTerm() {\n    return this.leftTerm;\n  }\n\n  getRightTerm() {\n    return this.rightTerm;\n  }\n\n  getType() {\n    let type;\n\n    const leftTermType = this.leftTerm.getType(),\n          rightTermType = this.rightTerm.getType(),\n          leftTermTypeEqualToOrSubTypeOfRightTermType = leftTermType.isEqualToOrSubTypeOf(rightTermType),\n          rightTermTypeEqualToOrSubTypeOfLeftTermType = rightTermType.isEqualToOrSubTypeOf(leftTermType);\n\n    if (leftTermTypeEqualToOrSubTypeOfRightTermType) {\n      type = leftTermType;  ///\n    }\n\n    if (rightTermTypeEqualToOrSubTypeOfLeftTermType) {\n      type = rightTermType; ///\n    }\n\n    return type;\n  }\n\n  getTerms() {\n    const terms = [\n      this.leftTerm,\n      this.rightTerm\n    ];\n\n    return terms;\n  }\n\n  isReflexive() {\n    const leftTermString = this.leftTerm.getString(),\n          rightTermString = this.rightTerm.getString(),\n          reflexive = (leftTermString === rightTermString);\n\n    return reflexive;\n  }\n\n  isEqual(context) {\n    let equal = false;\n\n    const leftTermNode = this.leftTerm.getNode(),\n          rightTermNode = this.rightTerm.getNode(),\n          termsEquates = equationalUnifier.equateTerms(leftTermNode, rightTermNode, context);\n\n    if (termsEquates) {\n      equal = true;\n    }\n\n    return equal;\n  }\n\n  verify(assignments, stated, context) {\n    let verifies = false;\n\n    const equalityString = this.string; ///\n\n    context.trace(`Verifying the '${equalityString}' equality...`);\n\n    const termsVerify = this.verifyTerms(context);\n\n    if (termsVerify) {\n      let verifiesWhenStated = false,\n          verifiesWhenDerived = false;\n\n      if (stated) {\n        verifiesWhenStated = this.verifyWhenStated(assignments, context);\n      } else {\n        verifiesWhenDerived = this.verifyWhenDerived(context);\n      }\n\n      if (verifiesWhenStated || verifiesWhenDerived) {\n        verifies = true;\n      }\n    }\n\n    if (verifies) {\n\n        this.assign(assignments, context);\n\n    }\n\n    if (verifies) {\n      context.debug(`...verified the '${equalityString}' equality.`);\n    }\n\n    return verifies;\n  }\n\n  verifyTerms(context) {\n    let termsVerify;\n\n    const equalityString = this.string; ///\n\n    context.trace(`Verifying the '${equalityString}' equality's terms...`);\n\n    const leftTermVerifies = this.leftTerm.verify(context, () => {\n      let verifiesAhead;\n\n      const rightTermVerifies = this.rightTerm.verify(context, () => {\n        let verifiesAhead;\n\n        const leftTermType = this.leftTerm.getType(),\n              rightTermType = this.rightTerm.getType(),\n              leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);\n\n        verifiesAhead = leftTermTypeComparableToRightTermType;  ///\n\n        return verifiesAhead;\n      });\n\n      verifiesAhead = rightTermVerifies; ///\n\n      return verifiesAhead;\n    });\n\n    termsVerify = leftTermVerifies; ///\n\n    if (termsVerify) {\n      context.debug(`...verified the '${equalityString}' equality's terms.`);\n    }\n\n    return termsVerify;\n  }\n\n  verifyWhenStated(assignments, context) {\n    let verifiesWhenStated;\n\n    const equalityString = this.string; ///\n\n    context.trace(`Verifying the '${equalityString}' stated equality...`);\n\n    verifiesWhenStated = true;\n\n    if (verifiesWhenStated) {\n      context.debug(`...verified the '${equalityString}' stated equality.`);\n    }\n\n    return verifiesWhenStated;\n  }\n\n  verifyWhenDerived(context) {\n    let verifiesWhenDerived;\n\n    const equalityString = this.string; ///\n\n    context.trace(`Verifying the '${equalityString}' derived equality...`);\n\n    verifiesWhenDerived = true;  ///\n\n    if (verifiesWhenDerived) {\n      context.debug(`...verified the '${equalityString}' derived equality.`);\n    }\n\n    return verifiesWhenDerived;\n  }\n\n  assign(assignments, context) {\n    if (assignments === null) {\n      return;\n    }\n\n    const { Variable } = ontology,\n          type = this.getType(),\n          leftTermNode = this.leftTerm.getNode(),\n          rightTermNode = this.rightTerm.getNode(),\n          leftTermNodeSingularVariableNode = leftTermNode.getSingularVariableNode(),\n          rightTermNodeSingularVariableNode = rightTermNode.getSingularVariableNode(),\n          leftVariableNode = leftTermNodeSingularVariableNode,  ///\n          rightVariableNode = rightTermNodeSingularVariableNode;  ///\n\n    let assignment;\n\n    if (leftVariableNode !== null) {\n      const leftVariable = Variable.fromVariableNodeAndType(leftVariableNode, type, context),\n            leftVariableAssignment = VariableAssignment.fromVariable(leftVariable);\n\n      assignment = leftVariableAssignment;  ///\n\n      assignments.push(assignment);\n    }\n\n    if (rightVariableNode !== null) {\n      const rightVariable = Variable.fromVariableNodeAndType(rightVariableNode, type, context),\n            rightVariableAssignment = VariableAssignment.fromVariable(rightVariable);\n\n      assignment = rightVariableAssignment;  ///\n\n      assignments.push(assignment);\n    }\n\n    const equality = this,  //\n          equalityAssignment = EqualityAssignment.fromEquality(equality);\n\n    assignment = equalityAssignment; ///\n\n    assignments.push(assignment);\n  }\n\n  static name = \"Equality\";\n\n  static fromStatementNode(statementNode, context) {\n    let equality = null;\n\n    const equalityNode = statementNode.getEqualityNode();\n\n    if (equalityNode !== null) {\n      const node = equalityNode,  ///\n            string = context.nodeAsString(node),\n            leftTerm = leftTermFromEqualityNode(equalityNode, context),\n            rightTerm = rightTermFromEqualityNode(equalityNode, context);\n\n      equality = new Equality(string, leftTerm, rightTerm);\n    }\n\n    return equality;\n  }\n});\n\nfunction leftTermFromEqualityNode(equalityNode, context) {\n  const { Term } = ontology,\n        leftTermNode = equalityNode.getLeftTermNode(),\n        leftTerm = Term.fromTermNode(leftTermNode, context);\n\n  return leftTerm;\n}\n\nfunction rightTermFromEqualityNode(equalityNode, context) {\n  const { Term } = ontology,\n        rightTermNode = equalityNode.getRightTermNode(),\n        rightTerm = Term.fromTermNode(rightTermNode, context);\n\n  return rightTerm;\n}\n"],"names":["define","Equality","string","leftTerm","rightTerm","getString","getLeftTerm","getRightTerm","getType","type","leftTermType","rightTermType","leftTermTypeEqualToOrSubTypeOfRightTermType","isEqualToOrSubTypeOf","rightTermTypeEqualToOrSubTypeOfLeftTermType","getTerms","terms","isReflexive","leftTermString","rightTermString","reflexive","isEqual","context","equal","leftTermNode","getNode","rightTermNode","termsEquates","equationalUnifier","equateTerms","verify","assignments","stated","verifies","equalityString","trace","termsVerify","verifyTerms","verifiesWhenStated","verifiesWhenDerived","verifyWhenStated","verifyWhenDerived","assign","debug","leftTermVerifies","verifiesAhead","rightTermVerifies","leftTermTypeComparableToRightTermType","isComparableTo","Variable","ontology","leftTermNodeSingularVariableNode","getSingularVariableNode","rightTermNodeSingularVariableNode","leftVariableNode","rightVariableNode","assignment","leftVariable","fromVariableNodeAndType","leftVariableAssignment","VariableAssignment","fromVariable","push","rightVariable","rightVariableAssignment","equality","equalityAssignment","EqualityAssignment","fromEquality","fromStatementNode","statementNode","equalityNode","getEqualityNode","node","nodeAsString","leftTermFromEqualityNode","rightTermFromEqualityNode","name","Term","getLeftTermNode","fromTermNode","getRightTermNode"],"mappings":"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"}

package/lib/{dom → ontology}/error.js

@@ -8,7 +8,7 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
-var _dom = require("../dom");
+var _ontology = require("../ontology");
 function _class_call_check(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
@@ -42,7 +42,7 @@ function _define_property(obj, key, value) {
     return obj;
 }
 var _Error;
-var _default = (0, _dom.domAssigned)((_Error = /*#__PURE__*/ function() {
+var _default = (0, _ontology.define)((_Error = /*#__PURE__*/ function() {
     function Error(context, node, string) {
         _class_call_check(this, Error);
         this.context = context;
@@ -89,4 +89,4 @@ var _default = (0, _dom.domAssigned)((_Error = /*#__PURE__*/ function() {
     return Error;
 }(), _define_property(_Error, "name", "Error"), _Error));
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vbnRvbG9neS9lcnJvci5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuaW1wb3J0IHsgZGVmaW5lIH0gZnJvbSBcIi4uL29udG9sb2d5XCI7XG5cbmV4cG9ydCBkZWZhdWx0IGRlZmluZShjbGFzcyBFcnJvciB7XG4gIGNvbnN0cnVjdG9yKGNvbnRleHQsIG5vZGUsIHN0cmluZykge1xuICAgIHRoaXMuY29udGV4dCA9IGNvbnRleHQ7XG4gICAgdGhpcy5ub2RlID0gbm9kZTtcbiAgICB0aGlzLnN0cmluZyA9IHN0cmluZztcbiAgfVxuXG4gIGdldENvbnRleHQoKSB7XG4gICAgcmV0dXJuIHRoaXMuY29udGV4dDtcbiAgfVxuXG4gIGdldE5vZGUoKSB7XG4gICAgcmV0dXJuIHRoaXMubm9kZTtcbiAgfVxuXG4gIGdldFN0cmluZygpIHtcbiAgICByZXR1cm4gdGhpcy5zdHJpbmc7XG4gIH1cblxuICB2ZXJpZnkoKSB7XG4gICAgbGV0IHZlcmlmaWVzID0gZmFsc2U7XG5cbiAgICBjb25zdCBlcnJvclN0cmluZyA9IHRoaXMuc3RyaW5nOyAgLy8vXG5cbiAgICB0aGlzLmNvbnRleHQud2FybmluZyhgVGhlICcke2Vycm9yU3RyaW5nfScgZXJyb3IgY2Fubm90IGJlIHZlcmlmaWVkLmAsIHRoaXMubm9kZSk7XG5cbiAgICByZXR1cm4gdmVyaWZpZXM7XG4gIH1cblxuICBzdGF0aWMgbmFtZSA9IFwiRXJyb3JcIjtcblxuICBzdGF0aWMgZnJvbUVycm9yTm9kZShlcnJvck5vZGUsIGNvbnRleHQpIHtcbiAgICBjb25zdCBub2RlID0gZXJyb3JOb2RlLCAvLy9cbiAgICAgICAgICBzdHJpbmcgPSBjb250ZXh0Lm5vZGVBc1N0cmluZyhub2RlKSxcbiAgICAgICAgICBlcnJvciA9IG5ldyBFcnJvcihjb250ZXh0LCBub2RlLCBzdHJpbmcpO1xuXG4gICAgcmV0dXJuIGVycm9yO1xuICB9XG59KTtcbiJdLCJuYW1lcyI6WyJkZWZpbmUiLCJFcnJvciIsImNvbnRleHQiLCJub2RlIiwic3RyaW5nIiwiZ2V0Q29udGV4dCIsImdldE5vZGUiLCJnZXRTdHJpbmciLCJ2ZXJpZnkiLCJ2ZXJpZmllcyIsImVycm9yU3RyaW5nIiwid2FybmluZyIsImZyb21FcnJvck5vZGUiLCJlcnJvck5vZGUiLCJub2RlQXNTdHJpbmciLCJlcnJvciIsIm5hbWUiXSwibWFwcGluZ3MiOiJBQUFBOzs7OytCQUlBOzs7ZUFBQTs7O3dCQUZ1Qjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztJQUV2QixXQUFlQSxJQUFBQSxnQkFBTSwwQkFBQzthQUFNQyxNQUNkQyxPQUFPLEVBQUVDLElBQUksRUFBRUMsTUFBTTtnQ0FEUEg7UUFFeEIsSUFBSSxDQUFDQyxPQUFPLEdBQUdBO1FBQ2YsSUFBSSxDQUFDQyxJQUFJLEdBQUdBO1FBQ1osSUFBSSxDQUFDQyxNQUFNLEdBQUdBOzs7O1lBR2hCQyxLQUFBQTttQkFBQUEsU0FBQUE7Z0JBQ0UsT0FBTyxJQUFJLENBQUNILE9BQU87WUFDckI7OztZQUVBSSxLQUFBQTttQkFBQUEsU0FBQUE7Z0JBQ0UsT0FBTyxJQUFJLENBQUNILElBQUk7WUFDbEI7OztZQUVBSSxLQUFBQTttQkFBQUEsU0FBQUE7Z0JBQ0UsT0FBTyxJQUFJLENBQUNILE1BQU07WUFDcEI7OztZQUVBSSxLQUFBQTttQkFBQUEsU0FBQUE7Z0JBQ0UsSUFBSUMsV0FBVztnQkFFZixJQUFNQyxjQUFjLElBQUksQ0FBQ04sTUFBTSxFQUFHLEdBQUc7Z0JBRXJDLElBQUksQ0FBQ0YsT0FBTyxDQUFDUyxPQUFPLENBQUMsQUFBQyxRQUFtQixPQUFaRCxhQUFZLGdDQUE4QixJQUFJLENBQUNQLElBQUk7Z0JBRWhGLE9BQU9NO1lBQ1Q7Ozs7WUFJT0csS0FBQUE7bUJBQVAsU0FBT0EsY0FBY0MsU0FBUyxFQUFFWCxPQUFPO2dCQUNyQyxJQUFNQyxPQUFPVSxXQUNQVCxTQUFTRixRQUFRWSxZQUFZLENBQUNYLE9BQzlCWSxRQUFRLElBQUlkLE1BQU1DLFNBQVNDLE1BQU1DO2dCQUV2QyxPQUFPVztZQUNUOzs7O0tBUkEseUJBQU9DLFFBQU8ifQ==