occam-verify-cli 1.0.382 → 1.0.385

package/lib/ontology/assertion/defined.js

@@ -0,0 +1,290 @@
+"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 _local = /*#__PURE__*/ _interop_require_default(require("../../context/local"));
+var _substitutions = require("../../utilities/substitutions");
+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 _DefinedAssertion;
+var _default = (0, _ontology.define)((_DefinedAssertion = /*#__PURE__*/ function() {
+    function DefinedAssertion(string, node, tokens, term, frame, negated) {
+        _class_call_check(this, DefinedAssertion);
+        this.string = string;
+        this.node = node;
+        this.tokens = tokens;
+        this.term = term;
+        this.frame = frame;
+        this.negated = negated;
+    }
+    _create_class(DefinedAssertion, [
+        {
+            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: "getTerm",
+            value: function getTerm() {
+                return this.term;
+            }
+        },
+        {
+            key: "getFrame",
+            value: function getFrame() {
+                return this.frame;
+            }
+        },
+        {
+            key: "isNegated",
+            value: function isNegated() {
+                return this.negated;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, context) {
+                var verifies = false;
+                var definedAssertionString = this.string; ///
+                context.trace("Verifying the '".concat(definedAssertionString, "' defined assertion..."));
+                var termVerifies = this.verifyTerm(assignments, stated, context), frameVerifies = this.verifyFrame(assignments, stated, context);
+                if (termVerifies || frameVerifies) {
+                    var verifiesWhenStated = false, verifiesWhenDerived = false;
+                    if (stated) {
+                        verifiesWhenStated = this.verifyWhenStated(assignments, context);
+                    } else {
+                        verifiesWhenDerived = this.verifyWhenDerived(context);
+                    }
+                    if (verifiesWhenStated || verifiesWhenDerived) {
+                        verifies = true;
+                    }
+                }
+                if (verifies) {
+                    context.debug("...verified the '".concat(definedAssertionString, "' defined assertion."));
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifyTerm",
+            value: function verifyTerm(assignments, stated, context) {
+                var termVerifies = false;
+                if (this.term !== null) {
+                    var termString = this.term.getString(); ///
+                    context.trace("Verifying the '".concat(termString, "' term..."));
+                    var termSimple = this.term.isSimple();
+                    if (!termSimple) {
+                        context.debug("The '".concat(termString, "' term is not simple."));
+                    } else {
+                        termVerifies = this.term.verify(context, function() {
+                            var verifiesAhead = true;
+                            return verifiesAhead;
+                        });
+                        if (termVerifies) {
+                            context.debug("...verified the '".concat(termString, "' term."));
+                        }
+                    }
+                }
+                return termVerifies;
+            }
+        },
+        {
+            key: "verifyFrame",
+            value: function verifyFrame(assignments, stated, context) {
+                var frameVerifies = false;
+                if (this.frame !== null) {
+                    var frameString = this.frame.getString(); ///
+                    context.trace("Verifying the '".concat(frameString, "' frame..."));
+                    var frameSimple = this.frame.isSimple();
+                    if (!frameSimple) {
+                        context.debug("The '".concat(frameString, "' frame is not simple."));
+                    } else {
+                        stated = true; ///
+                        assignments = null; ///
+                        frameVerifies = this.frame.verify(assignments, stated, context);
+                        if (frameVerifies) {
+                            context.debug("...verified the '".concat(frameString, "' frame."));
+                        }
+                    }
+                }
+                return frameVerifies;
+            }
+        },
+        {
+            key: "verifyWhenStated",
+            value: function verifyWhenStated(assignments, context) {
+                var verifiesWhenStated;
+                var definedAssertionString = this.string; ///
+                context.trace("Verifying the '".concat(definedAssertionString, "' stated defined assertion..."));
+                verifiesWhenStated = true;
+                if (verifiesWhenStated) {
+                    context.debug("...verified the '".concat(definedAssertionString, "' stated defined assertion."));
+                }
+                return verifiesWhenStated;
+            }
+        },
+        {
+            key: "verifyWhenDerived",
+            value: function verifyWhenDerived1(context) {
+                var verifiesWhenDerived;
+                var definedAssertionString = this.string; ///
+                context.trace("Verifying the '".concat(definedAssertionString, "' derived defined assertion..."));
+                verifiesWhenDerived = verifyWhenDerived(this.term, this.frame, this.negated, context);
+                if (verifiesWhenDerived) {
+                    context.debug("...verified the '".concat(definedAssertionString, "' derived defined assertion."));
+                }
+                return verifiesWhenDerived;
+            }
+        },
+        {
+            key: "unifyIndependently",
+            value: function unifyIndependently(substitutions, context) {
+                var unifiesIndependently;
+                var definedAssertionString = this.string; ///
+                context.trace("Unifying the '".concat(definedAssertionString, "' defined assertion independently..."));
+                var localContext = _local.default.fromContextAndTokens(context, this.tokens);
+                context = localContext; ///
+                var term = (0, _substitutions.termFromTermAndSubstitutions)(this.term, substitutions, context), frame = (0, _substitutions.frameFromFrameAndSubstitutions)(this.frame, substitutions, context), verifiesWhenDerived = verifyWhenDerived(term, frame, this.negated, context);
+                unifiesIndependently = verifiesWhenDerived; ///
+                if (unifiesIndependently) {
+                    context.debug("...unified the '".concat(definedAssertionString, "' defined assertion independently."));
+                }
+                return unifiesIndependently;
+            }
+        }
+    ], [
+        {
+            key: "fromStatementNode",
+            value: function fromStatementNode(statementNode, context) {
+                var definedAssertion = null;
+                var definedAssertionNode = statementNode.getDefinedAssertionNode();
+                if (definedAssertionNode !== null) {
+                    var Term = _ontology.default.Term, Frame = _ontology.default.Frame, node = definedAssertionNode, string = context.nodeAsString(node), tokens = context.nodeAsTokens(node), negated = definedAssertionNode.isNegated(), term = Term.fromDefinedAssertionNode(definedAssertionNode, context), frame = Frame.fromDefinedAssertionNode(definedAssertionNode, context);
+                    definedAssertion = new DefinedAssertion(string, node, tokens, term, frame, negated);
+                }
+                return definedAssertion;
+            }
+        }
+    ]);
+    return DefinedAssertion;
+}(), _define_property(_DefinedAssertion, "name", "DefinedAssertion"), _DefinedAssertion));
+function verifyWhenDerived(term, frame, negated, context) {
+    var verifiesWhenDerived = false;
+    if (term !== null) {
+        var Variable = _ontology.default.Variable, termNode = term.getNode(), variable = Variable.fromTermNode(termNode, context), generalContext = context, variableDefined = generalContext.isVariableDefined(variable);
+        if (!negated && variableDefined) {
+            verifiesWhenDerived = true;
+        }
+        if (negated && !variableDefined) {
+            verifiesWhenDerived = true;
+        }
+    }
+    if (frame !== null) {
+        var Metavariable = _ontology.default.Metavariable, frameNode = frame.getNode(), metavariable = Metavariable.fromFrameNode(frameNode, context), metavariableDefined = context.isMetavariableDefined(metavariable);
+        if (!negated && metavariableDefined) {
+            verifiesWhenDerived = true;
+        }
+        if (negated && !metavariableDefined) {
+            verifiesWhenDerived = true;
+        }
+    }
+    return verifiesWhenDerived;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/ontology/assertion/defined.js"],"sourcesContent":["\"use strict\";\n\nimport ontology from \"../../ontology\";\nimport LocalContext from \"../../context/local\";\n\nimport { define } from \"../../ontology\";\nimport { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions } from \"../../utilities/substitutions\";\n\nexport default define(class DefinedAssertion {\n  constructor(string, node, tokens, term, frame, negated) {\n    this.string = string;\n    this.node = node;\n    this.tokens = tokens;\n    this.term = term;\n    this.frame= frame;\n    this.negated = negated;\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  getTerm() {\n    return this.term;\n  }\n\n  getFrame() {\n    return this.frame;\n  }\n\n  isNegated() {\n    return this.negated;\n  }\n\n  verify(assignments, stated, context) {\n    let verifies = false;\n\n    const definedAssertionString = this.string; ///\n\n    context.trace(`Verifying the '${definedAssertionString}' defined assertion...`);\n\n    const termVerifies = this.verifyTerm(assignments, stated, context),\n          frameVerifies = this.verifyFrame(assignments, stated, context);\n\n    if (termVerifies || frameVerifies) {\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      context.debug(`...verified the '${definedAssertionString}' defined assertion.`);\n    }\n\n    return verifies;\n  }\n\n  verifyTerm(assignments, stated, context) {\n    let termVerifies = false;\n\n    if (this.term !== null) {\n      const termString = this.term.getString(); ///\n\n      context.trace(`Verifying the '${termString}' term...`);\n\n      const termSimple = this.term.isSimple();\n\n      if (!termSimple) {\n        context.debug(`The '${termString}' term is not simple.`);\n      } else {\n        termVerifies = this.term.verify(context, () => {\n          const verifiesAhead = true;\n\n          return verifiesAhead;\n        });\n\n        if (termVerifies) {\n          context.debug(`...verified the '${termString}' term.`);\n        }\n      }\n    }\n\n    return termVerifies;\n  }\n\n  verifyFrame(assignments, stated, context) {\n    let frameVerifies = false;\n\n    if (this.frame !== null) {\n      const frameString = this.frame.getString(); ///\n\n      context.trace(`Verifying the '${frameString}' frame...`);\n\n      const frameSimple = this.frame.isSimple();\n\n      if (!frameSimple) {\n        context.debug(`The '${frameString}' frame is not simple.`);\n      } else {\n        stated = true;  ///\n\n        assignments = null; ///\n\n        frameVerifies = this.frame.verify(assignments, stated, context);\n\n        if (frameVerifies) {\n          context.debug(`...verified the '${frameString}' frame.`);\n        }\n      }\n    }\n\n    return frameVerifies;\n  }\n\n  verifyWhenStated(assignments, context) {\n    let verifiesWhenStated;\n\n    const definedAssertionString = this.string; ///\n\n    context.trace(`Verifying the '${definedAssertionString}' stated defined assertion...`);\n\n    verifiesWhenStated = true;\n\n    if (verifiesWhenStated) {\n      context.debug(`...verified the '${definedAssertionString}' stated defined assertion.`);\n    }\n\n    return verifiesWhenStated;\n  }\n\n  verifyWhenDerived(context) {\n    let verifiesWhenDerived;\n\n    const definedAssertionString = this.string; ///\n\n    context.trace(`Verifying the '${definedAssertionString}' derived defined assertion...`);\n\n    verifiesWhenDerived = verifyWhenDerived(this.term, this.frame, this.negated, context);\n\n    if (verifiesWhenDerived) {\n      context.debug(`...verified the '${definedAssertionString}' derived defined assertion.`);\n    }\n\n    return verifiesWhenDerived;\n  }\n\n  unifyIndependently(substitutions, context) {\n    let unifiesIndependently;\n\n    const definedAssertionString = this.string; ///\n\n    context.trace(`Unifying the '${definedAssertionString}' defined assertion independently...`);\n\n    const localContext = LocalContext.fromContextAndTokens(context, this.tokens);\n\n    context = localContext; ///\n\n    const term = termFromTermAndSubstitutions(this.term, substitutions, context),\n          frame = frameFromFrameAndSubstitutions(this.frame, substitutions, context),\n          verifiesWhenDerived = verifyWhenDerived(term, frame, this.negated, context);\n\n    unifiesIndependently = verifiesWhenDerived; ///\n\n    if (unifiesIndependently) {\n      context.debug(`...unified the '${definedAssertionString}' defined assertion independently.`);\n    }\n\n    return unifiesIndependently;\n  }\n\n  static name = \"DefinedAssertion\";\n\n  static fromStatementNode(statementNode, context) {\n    let definedAssertion = null;\n\n    const definedAssertionNode = statementNode.getDefinedAssertionNode();\n\n    if (definedAssertionNode !== null) {\n      const { Term, Frame } = ontology,\n            node = definedAssertionNode,  ///\n            string = context.nodeAsString(node),\n            tokens = context.nodeAsTokens(node),\n            negated = definedAssertionNode.isNegated(),\n            term = Term.fromDefinedAssertionNode(definedAssertionNode, context),\n            frame = Frame.fromDefinedAssertionNode(definedAssertionNode, context);\n\n      definedAssertion = new DefinedAssertion(string, node, tokens, term, frame, negated);\n    }\n\n    return definedAssertion;\n  }\n});\n\nfunction verifyWhenDerived(term, frame, negated, context) {\n  let verifiesWhenDerived = false;\n\n  if (term !== null) {\n    const { Variable } = ontology,\n          termNode = term.getNode(),\n          variable = Variable.fromTermNode(termNode, context),\n          generalContext = context, ///\n          variableDefined = generalContext.isVariableDefined(variable);\n\n    if (!negated && variableDefined) {\n      verifiesWhenDerived = true;\n    }\n\n    if (negated && !variableDefined) {\n      verifiesWhenDerived = true;\n    }\n  }\n\n  if (frame!== null) {\n    const { Metavariable } = ontology,\n          frameNode = frame.getNode(),\n          metavariable = Metavariable.fromFrameNode(frameNode, context),\n          metavariableDefined = context.isMetavariableDefined(metavariable);\n\n    if (!negated && metavariableDefined) {\n      verifiesWhenDerived = true;\n    }\n\n    if (negated && !metavariableDefined) {\n      verifiesWhenDerived = true;\n    }\n  }\n\n  return verifiesWhenDerived;\n}\n"],"names":["define","DefinedAssertion","string","node","tokens","term","frame","negated","getString","getNode","getTokens","getTerm","getFrame","isNegated","verify","assignments","stated","context","verifies","definedAssertionString","trace","termVerifies","verifyTerm","frameVerifies","verifyFrame","verifiesWhenStated","verifiesWhenDerived","verifyWhenStated","verifyWhenDerived","debug","termString","termSimple","isSimple","verifiesAhead","frameString","frameSimple","unifyIndependently","substitutions","unifiesIndependently","localContext","LocalContext","fromContextAndTokens","termFromTermAndSubstitutions","frameFromFrameAndSubstitutions","fromStatementNode","statementNode","definedAssertion","definedAssertionNode","getDefinedAssertionNode","Term","ontology","Frame","nodeAsString","nodeAsTokens","fromDefinedAssertionNode","name","Variable","termNode","variable","fromTermNode","generalContext","variableDefined","isVariableDefined","Metavariable","frameNode","metavariable","fromFrameNode","metavariableDefined","isMetavariableDefined"],"mappings":"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"}

package/lib/ontology/assertion/property.js

@@ -0,0 +1,271 @@
+"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 _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 _PropertyAssertion;
+var _default = (0, _ontology.define)((_PropertyAssertion = /*#__PURE__*/ function() {
+    function PropertyAssertion(string, node, tokens, term, propertyRelation) {
+        _class_call_check(this, PropertyAssertion);
+        this.string = string;
+        this.node = node;
+        this.tokens = tokens;
+        this.term = term;
+        this.propertyRelation = propertyRelation;
+    }
+    _create_class(PropertyAssertion, [
+        {
+            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: "getTerm",
+            value: function getTerm() {
+                return this.term;
+            }
+        },
+        {
+            key: "getPropertyRelation",
+            value: function getPropertyRelation() {
+                return this.propertyRelation;
+            }
+        },
+        {
+            key: "matchTermAndPropertyRelation",
+            value: function matchTermAndPropertyRelation(term, propertyRelation, context) {
+                var propertyMatchesTermAndPropertyRelation = false;
+                var termString = term.getString(), propertyRelationString = propertyRelation.getString(), propertyAssertionString = this.getString();
+                context.trace("Matching the '".concat(termString, "' term and '").concat(propertyRelationString, "' property relation against the '").concat(propertyAssertionString, "' property assertion..."));
+                var termA = term, termB = this.term, termAEqualToTermB = termA.isEqualTo(termB);
+                if (termAEqualToTermB) {
+                    var propertyRelationEqualToPropertyRelation = this.propertyRelation.isEqualTo(propertyRelation);
+                    propertyMatchesTermAndPropertyRelation = propertyRelationEqualToPropertyRelation; ///
+                }
+                if (propertyMatchesTermAndPropertyRelation) {
+                    context.debug("...matched the '".concat(termString, "' term and '").concat(propertyRelationString, "' property relation against the '").concat(propertyAssertionString, "' property assertion."));
+                }
+                return propertyMatchesTermAndPropertyRelation;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, context) {
+                var verifies = false;
+                var propertyAssertionString = this.string; ///
+                context.trace("Verifying the '".concat(propertyAssertionString, "' property assertion..."));
+                var termVerifies = this.verifyTerm(assignments, stated, context);
+                if (termVerifies) {
+                    var propertyRelationVerifies = this.verifyPropertyRelation(assignments, stated, context);
+                    if (propertyRelationVerifies) {
+                        var verifiesWhenStated = false, verifiesWhenDerived = false;
+                        if (stated) {
+                            verifiesWhenStated = this.verifyWhenStated(assignments, context);
+                        } else {
+                            verifiesWhenDerived = this.verifyWhenDerived(context);
+                        }
+                        if (verifiesWhenStated || verifiesWhenDerived) {
+                            verifies = true;
+                        }
+                    }
+                }
+                if (verifies) {
+                    if (stated) {
+                        this.assign(assignments, context);
+                    }
+                }
+                if (verifies) {
+                    context.debug("...verified the '".concat(propertyAssertionString, "' property assertion."));
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifyTerm",
+            value: function verifyTerm(assignments, stated, context) {
+                var termVerifies;
+                var termString = this.term.getString();
+                context.trace("Verifying the '".concat(termString, "' term..."));
+                termVerifies = this.term.verify(context, function() {
+                    var verifiesAhead = true;
+                    return verifiesAhead;
+                });
+                if (termVerifies) {
+                    context.debug("...verified the '".concat(termString, "' term."));
+                }
+                return termVerifies;
+            }
+        },
+        {
+            key: "verifyPropertyRelation",
+            value: function verifyPropertyRelation(assignments, stated, context) {
+                var propertyRelationVerifies;
+                var propertyRelationString = this.propertyRelation.getString();
+                context.trace("Verifying the '".concat(propertyRelationString, "' property relation..."));
+                propertyRelationVerifies = this.propertyRelation.verify(context);
+                if (propertyRelationVerifies) {
+                    context.debug("...verified the '".concat(propertyRelationString, "' property relation."));
+                }
+                return propertyRelationVerifies;
+            }
+        },
+        {
+            key: "verifyWhenStated",
+            value: function verifyWhenStated(assignments, context) {
+                var verifiesWhenStated = false;
+                var propertyAssertionString = this.string; ///
+                context.trace("Verifying the '".concat(propertyAssertionString, "' stated property assertion..."));
+                verifiesWhenStated = true;
+                if (verifiesWhenStated) {
+                    context.debug("...verified the '".concat(propertyAssertionString, "' stated property assertion."));
+                }
+                return verifiesWhenStated;
+            }
+        },
+        {
+            key: "verifyWhenDerived",
+            value: function verifyWhenDerived(context) {
+                var verifiesWhenDerived;
+                var propertyAssertionString = this.string; ///
+                context.trace("Verifying the '".concat(propertyAssertionString, "' derived property assertion..."));
+                verifiesWhenDerived = true;
+                if (verifiesWhenDerived) {
+                    context.debug("...verified the '".concat(propertyAssertionString, "' derived property assertion."));
+                }
+                return verifiesWhenDerived;
+            }
+        },
+        {
+            key: "assign",
+            value: function assign(assignments, context) {
+                if (assignments === null) {
+                    return;
+                }
+                var variable;
+                var Variable = _ontology.default.Variable, termNode = this.term.getNode();
+                variable = Variable.fromTermNode(termNode, context);
+                if (variable !== null) {
+                    var variableIdentifier = variable.getIdentifier();
+                    variable = context.findVariableByVariableIdentifier(variableIdentifier);
+                    variable = Variable.fromVariableAndPropertyRelation(variable, this.propertyRelation);
+                    var variableAssignment = _variable.default.fromVariable(variable), assignment = variableAssignment; ///
+                    assignments.push(assignment);
+                }
+            }
+        }
+    ], [
+        {
+            key: "fromStatementNode",
+            value: function fromStatementNode(statementNode, context) {
+                var propertyAssertion = null;
+                var propertyAssertionNode = statementNode.getPropertyAssertionNode();
+                if (propertyAssertionNode !== null) {
+                    var Term = _ontology.default.Term, PropertyRelation = _ontology.default.PropertyRelation, node = propertyAssertionNode, string = context.nodeAsString(node), tokens = context.nodeAsTokens(node), term = Term.fromPropertyAssertionNode(propertyAssertionNode, context), propertyRelation = PropertyRelation.fromPropertyAssertionNode(propertyAssertionNode, context);
+                    propertyAssertion = new PropertyAssertion(string, node, tokens, term, propertyRelation);
+                }
+                return propertyAssertion;
+            }
+        }
+    ]);
+    return PropertyAssertion;
+}(), _define_property(_PropertyAssertion, "name", "PropertyAssertion"), _PropertyAssertion));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/ontology/assertion/property.js"],"sourcesContent":["\"use strict\";\n\nimport ontology from \"../../ontology\";\n\nimport VariableAssignment from \"../../assignment/variable\";\n\nimport { define } from \"../../ontology\";\n\nexport default define(class PropertyAssertion {\n  constructor(string, node, tokens, term, propertyRelation) {\n    this.string = string;\n    this.node = node;\n    this.tokens = tokens;\n    this.term = term;\n    this.propertyRelation = propertyRelation;\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  getTerm() {\n    return this.term;\n  }\n\n  getPropertyRelation() {\n    return this.propertyRelation;\n  }\n\n  matchTermAndPropertyRelation(term, propertyRelation, context) {\n    let propertyMatchesTermAndPropertyRelation = false;\n\n    const termString = term.getString(),\n          propertyRelationString = propertyRelation.getString(),\n          propertyAssertionString = this.getString();\n\n    context.trace(`Matching the '${termString}' term and '${propertyRelationString}' property relation against the '${propertyAssertionString}' property assertion...`);\n\n    const termA = term,\n          termB = this.term, ///\n          termAEqualToTermB = termA.isEqualTo(termB);\n\n    if (termAEqualToTermB) {\n      const propertyRelationEqualToPropertyRelation = this.propertyRelation.isEqualTo(propertyRelation);\n\n      propertyMatchesTermAndPropertyRelation = propertyRelationEqualToPropertyRelation;  ///\n    }\n\n    if (propertyMatchesTermAndPropertyRelation) {\n      context.debug(`...matched the '${termString}' term and '${propertyRelationString}' property relation against the '${propertyAssertionString}' property assertion.`);\n    }\n\n    return propertyMatchesTermAndPropertyRelation;\n  }\n\n  verify(assignments, stated, context) {\n    let verifies = false;\n\n    const propertyAssertionString = this.string; ///\n\n    context.trace(`Verifying the '${propertyAssertionString}' property assertion...`);\n\n    const termVerifies = this.verifyTerm(assignments, stated, context);\n\n    if (termVerifies) {\n      const propertyRelationVerifies = this.verifyPropertyRelation(assignments, stated, context);\n\n      if (propertyRelationVerifies) {\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\n    if (verifies) {\n      if (stated) {\n        this.assign(assignments, context);\n      }\n    }\n\n    if (verifies) {\n      context.debug(`...verified the '${propertyAssertionString}' property assertion.`);\n    }\n\n    return verifies;\n  }\n\n  verifyTerm(assignments, stated, context) {\n    let termVerifies;\n\n    const termString = this.term.getString();\n\n    context.trace(`Verifying the '${termString}' term...`);\n\n    termVerifies = this.term.verify(context, () => {\n      const verifiesAhead = true;\n\n      return verifiesAhead;\n    });\n\n    if (termVerifies) {\n      context.debug(`...verified the '${termString}' term.`);\n    }\n\n    return termVerifies;\n  }\n\n  verifyPropertyRelation(assignments, stated, context) {\n    let propertyRelationVerifies;\n\n    const propertyRelationString = this.propertyRelation.getString();\n\n    context.trace(`Verifying the '${propertyRelationString}' property relation...`);\n\n    propertyRelationVerifies = this.propertyRelation.verify(context);\n\n    if (propertyRelationVerifies) {\n      context.debug(`...verified the '${propertyRelationString}' property relation.`);\n    }\n\n    return propertyRelationVerifies;\n  }\n\n  verifyWhenStated(assignments, context) {\n    let verifiesWhenStated = false;\n\n    const propertyAssertionString = this.string; ///\n\n    context.trace(`Verifying the '${propertyAssertionString}' stated property assertion...`);\n\n    verifiesWhenStated = true;\n\n    if (verifiesWhenStated) {\n      context.debug(`...verified the '${propertyAssertionString}' stated property assertion.`);\n    }\n\n    return verifiesWhenStated;\n  }\n\n  verifyWhenDerived(context) {\n    let verifiesWhenDerived;\n\n    const propertyAssertionString = this.string; ///\n\n    context.trace(`Verifying the '${propertyAssertionString}' derived property assertion...`);\n\n    verifiesWhenDerived = true;\n\n    if (verifiesWhenDerived) {\n      context.debug(`...verified the '${propertyAssertionString}' derived property assertion.`);\n    }\n\n    return verifiesWhenDerived;\n  }\n\n  assign(assignments, context) {\n    if (assignments === null) {\n      return;\n    }\n\n    let variable;\n\n    const { Variable } = ontology,\n          termNode = this.term.getNode();\n\n    variable = Variable.fromTermNode(termNode, context);\n\n    if (variable !== null) {\n      const variableIdentifier = variable.getIdentifier();\n\n      variable = context.findVariableByVariableIdentifier(variableIdentifier);\n\n      variable = Variable.fromVariableAndPropertyRelation(variable, this.propertyRelation);\n\n      const variableAssignment = VariableAssignment.fromVariable(variable),\n            assignment = variableAssignment;  ///\n\n      assignments.push(assignment);\n    }\n  }\n\n  static name = \"PropertyAssertion\";\n\n  static fromStatementNode(statementNode, context) {\n    let propertyAssertion = null;\n\n    const propertyAssertionNode = statementNode.getPropertyAssertionNode();\n\n    if (propertyAssertionNode !== null) {\n      const { Term, PropertyRelation } = ontology,\n            node = propertyAssertionNode,  ///\n            string = context.nodeAsString(node),\n            tokens = context.nodeAsTokens(node),\n            term = Term.fromPropertyAssertionNode(propertyAssertionNode, context),\n            propertyRelation = PropertyRelation.fromPropertyAssertionNode(propertyAssertionNode, context);\n\n      propertyAssertion = new PropertyAssertion(string, node, tokens, term, propertyRelation);\n    }\n\n    return propertyAssertion;\n  }\n});\n"],"names":["define","PropertyAssertion","string","node","tokens","term","propertyRelation","getString","getNode","getTokens","getTerm","getPropertyRelation","matchTermAndPropertyRelation","context","propertyMatchesTermAndPropertyRelation","termString","propertyRelationString","propertyAssertionString","trace","termA","termB","termAEqualToTermB","isEqualTo","propertyRelationEqualToPropertyRelation","debug","verify","assignments","stated","verifies","termVerifies","verifyTerm","propertyRelationVerifies","verifyPropertyRelation","verifiesWhenStated","verifiesWhenDerived","verifyWhenStated","verifyWhenDerived","assign","verifiesAhead","variable","Variable","ontology","termNode","fromTermNode","variableIdentifier","getIdentifier","findVariableByVariableIdentifier","fromVariableAndPropertyRelation","variableAssignment","VariableAssignment","fromVariable","assignment","push","fromStatementNode","statementNode","propertyAssertion","propertyAssertionNode","getPropertyAssertionNode","Term","PropertyRelation","nodeAsString","nodeAsTokens","fromPropertyAssertionNode","name"],"mappings":"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"}