occam-verify-cli 1.0.405 → 1.0.415

package/lib/process/verify.js

@@ -0,0 +1,612 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get default () {
+        return Pass;
+    },
+    get verifyFile () {
+        return verifyFile;
+    },
+    get verifyStatement () {
+        return verifyStatement;
+    },
+    get verifyTerm () {
+        return verifyTerm;
+    }
+});
+var _query = require("../utilities/query");
+var _pass = require("../utilities/pass");
+var _statement = /*#__PURE__*/ _interop_require_default(require("../ontology/statement"));
+var _ontology = /*#__PURE__*/ _interop_require_default(require("../ontology"));
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+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 _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+var nonTerminalNodeQuery = (0, _query.nodeQuery)("/*");
+var termNodeQuery = (0, _query.nodeQuery)("/term"), typeNodeQuery = (0, _query.nodeQuery)("/type"), statementNodeQuery = (0, _query.nodeQuery)("/statement");
+var errorNodeQuery = (0, _query.nodeQuery)("/error"), ruleNodeQuery = (0, _query.nodeQuery)("/rule"), axiomNodeQuery = (0, _query.nodeQuery)("/axiom"), lemmaNodeQuery = (0, _query.nodeQuery)("/lemma"), sectionNodeQuery = (0, _query.nodeQuery)("/section"), theoremNodeQuery = (0, _query.nodeQuery)("/theorem"), metaLemmaNodeQuery = (0, _query.nodeQuery)("/metaLemma"), conjectureNodeQuery = (0, _query.nodeQuery)("/conjecture"), metatheoremNodeQuery = (0, _query.nodeQuery)("/metatheorem"), variableDeclarationNodeQuery = (0, _query.nodeQuery)("/variableDeclaration"), combinatorDeclarationNodeQuery = (0, _query.nodeQuery)("/combinatorDeclaration"), simpleTypeDeclarationNodeQuery = (0, _query.nodeQuery)("/simpleTypeDeclaration"), typePrefixDeclarationNodeQuery = (0, _query.nodeQuery)("/typePrefixDeclaration"), constructorDeclarationNodeQuery = (0, _query.nodeQuery)("/constructorDeclaration"), complexTypeDeclarationNodeQuery = (0, _query.nodeQuery)("/complexTypeDeclaration"), metavariableDeclarationNodeQuery = (0, _query.nodeQuery)("/metavariableDeclaration");
+var Pass = /*#__PURE__*/ function() {
+    function Pass() {
+        _class_call_check(this, Pass);
+    }
+    _create_class(Pass, [
+        {
+            key: "run",
+            value: function run(node) {
+                for(var _len = arguments.length, remainingArguments = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+                    remainingArguments[_key - 1] = arguments[_key];
+                }
+                var success;
+                var visited = this.visitNode.apply(this, [
+                    node
+                ].concat(_to_consumable_array(remainingArguments)));
+                success = visited; ///
+                return success;
+            }
+        },
+        {
+            key: "descend",
+            value: function descend(childNodes) {
+                var _this = this;
+                for(var _len = arguments.length, remainingArguments = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+                    remainingArguments[_key - 1] = arguments[_key];
+                }
+                var descendedAhead = false;
+                var lastRemainingArgumentFunction = (0, _pass.isLastRemainingArgumentFunction)(remainingArguments);
+                if (lastRemainingArgumentFunction) {
+                    var index = 0;
+                    descendedAhead = this.descendAhead.apply(this, [
+                        index,
+                        childNodes
+                    ].concat(_to_consumable_array(remainingArguments))); ///
+                } else {
+                    var visited = childNodes.every(function(childNode) {
+                        var node = childNode, visited = _this.visitNode.apply(_this, [
+                            node
+                        ].concat(_to_consumable_array(remainingArguments)));
+                        if (visited) {
+                            return true;
+                        }
+                    });
+                    if (visited) {
+                        descendedAhead = true;
+                    }
+                }
+                return descendedAhead;
+            }
+        },
+        {
+            key: "descendAhead",
+            value: function descendAhead(index, childNodes) {
+                var _this = this;
+                for(var _len = arguments.length, remainingArguments = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+                    remainingArguments[_key - 2] = arguments[_key];
+                }
+                var descendedAhead = false;
+                var descendAhead = remainingArguments.pop(), childNodesLength = childNodes.length;
+                if (index === childNodesLength) {
+                    descendedAhead = descendAhead();
+                } else {
+                    var childNode = childNodes[index], node = childNode, visited = this.visitNode.apply(this, [
+                        node
+                    ].concat(_to_consumable_array(remainingArguments), [
+                        function() {
+                            remainingArguments.push(descendAhead);
+                            var aheadIndex = index + 1, descendedAhead = _this.descendAhead.apply(_this, [
+                                aheadIndex,
+                                childNodes
+                            ].concat(_to_consumable_array(remainingArguments)));
+                            return descendedAhead;
+                        }
+                    ]));
+                    if (visited) {
+                        descendedAhead = true;
+                    }
+                }
+                return descendedAhead;
+            }
+        },
+        {
+            key: "visitNode",
+            value: function visitNode(node) {
+                for(var _len = arguments.length, remainingArguments = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+                    remainingArguments[_key - 1] = arguments[_key];
+                }
+                var visited;
+                var nodeTerminalNode = node.isTerminalNode();
+                if (nodeTerminalNode) {
+                    var terminalNode = node; ///
+                    visited = this.visitTerminalNode.apply(this, [
+                        terminalNode
+                    ].concat(_to_consumable_array(remainingArguments)));
+                } else {
+                    var nonTerminalNode = node; ///
+                    visited = this.visitNonTerminalNode.apply(this, [
+                        nonTerminalNode
+                    ].concat(_to_consumable_array(remainingArguments)));
+                }
+                return visited;
+            }
+        },
+        {
+            key: "visitTerminalNode",
+            value: function visitTerminalNode(terminalNode) {
+                for(var _len = arguments.length, remainingArguments = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+                    remainingArguments[_key - 1] = arguments[_key];
+                }
+                var visited = false;
+                var lastRemainingArgumentFunction = (0, _pass.isLastRemainingArgumentFunction)(remainingArguments);
+                if (lastRemainingArgumentFunction) {
+                    var descendAhead = remainingArguments.pop(), descendedAhead = descendAhead();
+                    if (descendedAhead) {
+                        visited = true;
+                    }
+                    remainingArguments.push(descendAhead);
+                } else {
+                    visited = true;
+                }
+                return visited;
+            }
+        },
+        {
+            key: "visitNonTerminalNode",
+            value: function visitNonTerminalNode(nonTerminalNode) {
+                for(var _len = arguments.length, remainingArguments = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+                    remainingArguments[_key - 1] = arguments[_key];
+                }
+                var _this = this;
+                var visited = false;
+                var maps = this.constructor.maps;
+                maps = _to_consumable_array(maps).concat([
+                    {
+                        nodeQuery: nonTerminalNodeQuery,
+                        run: function(node) {
+                            for(var _len = arguments.length, remainingArguments = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+                                remainingArguments[_key - 1] = arguments[_key];
+                            }
+                            var visited = false;
+                            var childNodes = nonTerminalNode.getChildNodes(), descended = _this.descend.apply(_this, [
+                                childNodes
+                            ].concat(_to_consumable_array(remainingArguments)));
+                            if (descended) {
+                                visited = true;
+                            }
+                            return visited;
+                        }
+                    }
+                ]);
+                maps.some(function(map) {
+                    var _$nodeQuery = map.nodeQuery, run = map.run;
+                    var node = _$nodeQuery(nonTerminalNode);
+                    if (node !== null) {
+                        var success = run.apply(void 0, [
+                            node
+                        ].concat(_to_consumable_array(remainingArguments)));
+                        visited = success;
+                        return true;
+                    }
+                });
+                return visited;
+            }
+        }
+    ]);
+    return Pass;
+}();
+var TopLevelPass = /*#__PURE__*/ function(Pass) {
+    _inherits(TopLevelPass, Pass);
+    function TopLevelPass() {
+        _class_call_check(this, TopLevelPass);
+        return _call_super(this, TopLevelPass, arguments);
+    }
+    return TopLevelPass;
+}(Pass);
+_define_property(TopLevelPass, "maps", [
+    {
+        nodeQuery: errorNodeQuery,
+        run: function(errorNode, context) {
+            var success = false;
+            var Error = _ontology.default.Error, error = Error.fromErrorNode(errorNode, context), errorVerifies = error.verify();
+            if (errorVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: ruleNodeQuery,
+        run: function(ruleNode, context) {
+            var success = false;
+            var Rule = _ontology.default.Rule, rule = Rule.fromRuleNode(ruleNode, context), ruleVerifies = rule.verify();
+            if (ruleVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: axiomNodeQuery,
+        run: function(axiomNode, context) {
+            var success = false;
+            var Axiom = _ontology.default.Axiom, axiom = Axiom.fromAxiomNode(axiomNode, context), axiomVerifies = axiom.verify();
+            if (axiomVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: lemmaNodeQuery,
+        run: function(lemmaNode, context) {
+            var success = false;
+            var Lemma = _ontology.default.Lemma, lemma = Lemma.fromLemmaNode(lemmaNode, context), lemmaVerifies = lemma.verify();
+            if (lemmaVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: sectionNodeQuery,
+        run: function(sectionNode, context) {
+            var success = false;
+            var Section = _ontology.default.Section, section = Section.fromSectionNode(sectionNode, context), sectionVerifies = section.verify();
+            if (sectionVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: theoremNodeQuery,
+        run: function(theoremNode, context) {
+            var success = false;
+            var Theorem = _ontology.default.Theorem, theorem = Theorem.fromTheoremNode(theoremNode, context), theoremVerifies = theorem.verify();
+            if (theoremVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: metaLemmaNodeQuery,
+        run: function(metaLemmaNode, context) {
+            var success = false;
+            var MetaLemma = _ontology.default.MetaLemma, metaLemma = MetaLemma.fromMetaLemmaNode(metaLemmaNode, context), metaLemmaVerifies = metaLemma.verify();
+            if (metaLemmaVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: conjectureNodeQuery,
+        run: function(conjectureNode, context) {
+            var success = false;
+            var Conjecture = _ontology.default.Conjecture, conjecture = Conjecture.fromConjectureNode(conjectureNode, context), conjectureVerifies = conjecture.verify();
+            if (conjectureVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: metatheoremNodeQuery,
+        run: function(metatheoremNode, context) {
+            var success = false;
+            var Metatheorem = _ontology.default.Metatheorem, metatheorem = Metatheorem.fromMetatheoremNode(metatheoremNode, context), metatheoremVerifies = metatheorem.verify();
+            if (metatheoremVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: variableDeclarationNodeQuery,
+        run: function(variableDeclarationNode, context) {
+            var success = false;
+            var VariableDeclaration = _ontology.default.VariableDeclaration, variableDeclaration = VariableDeclaration.fromVariableDeclarationNode(variableDeclarationNode, context), variableDeclarationVerifies = variableDeclaration.verify();
+            if (variableDeclarationVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: simpleTypeDeclarationNodeQuery,
+        run: function(simpleTypeDeclarationNode, context) {
+            var success = false;
+            var SimpleTypeDeclaration = _ontology.default.SimpleTypeDeclaration, simpleTypeDeclaration = SimpleTypeDeclaration.fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context), simpleTypeDeclarationVerifies = simpleTypeDeclaration.verify();
+            if (simpleTypeDeclarationVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: typePrefixDeclarationNodeQuery,
+        run: function(typePrefixDeclarationNode, context) {
+            var success = false;
+            var TypePrefixDeclaration = _ontology.default.TypePrefixDeclaration, typePrefixDeclaration = TypePrefixDeclaration.fromTypePrefixDeclarationNode(typePrefixDeclarationNode, context), typePrefixDeclarationVerifies = typePrefixDeclaration.verify();
+            if (typePrefixDeclarationVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: combinatorDeclarationNodeQuery,
+        run: function(combinatorDeclarationNode, context) {
+            var success = false;
+            var CombinatorDeclaration = _ontology.default.CombinatorDeclaration, combinatorDeclaration = CombinatorDeclaration.fromCombinatorDeclarationNode(combinatorDeclarationNode, context), combinatorDeclarationVerifies = combinatorDeclaration.verify();
+            if (combinatorDeclarationVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: constructorDeclarationNodeQuery,
+        run: function(constructorDeclarationNode, context) {
+            var success = false;
+            var ConstructorDeclaration = _ontology.default.ConstructorDeclaration, constructorDeclaration = ConstructorDeclaration.fromConstructorDeclarationNode(constructorDeclarationNode, context), constructorDeclarationVerifies = constructorDeclaration.verify();
+            if (constructorDeclarationVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: complexTypeDeclarationNodeQuery,
+        run: function(complexTypeDeclarationNode, context) {
+            var success = false;
+            var ComplexTypeDeclaration = _ontology.default.ComplexTypeDeclaration, complexTypeDeclaration = ComplexTypeDeclaration.fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context), complexTypeDeclarationVerifies = complexTypeDeclaration.verify();
+            if (complexTypeDeclarationVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: metavariableDeclarationNodeQuery,
+        run: function(metavariableDeclarationNode, context) {
+            var success = false;
+            var MetavariableDeclaration = _ontology.default.MetavariableDeclaration, metavariableDeclaration = MetavariableDeclaration.fromMetavariableDeclarationNode(metavariableDeclarationNode, context), metavariableDeclarationVerifies = metavariableDeclaration.verify();
+            if (metavariableDeclarationVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    }
+]);
+var CombinatorPass = /*#__PURE__*/ function(Pass) {
+    _inherits(CombinatorPass, Pass);
+    function CombinatorPass() {
+        _class_call_check(this, CombinatorPass);
+        return _call_super(this, CombinatorPass, arguments);
+    }
+    return CombinatorPass;
+}(Pass);
+_define_property(CombinatorPass, "maps", [
+    {
+        nodeQuery: statementNodeQuery,
+        run: function(statementNode, context) {
+            var success = false;
+            var Statement = _ontology.default.Statement, statement = Statement.fromStatementNode(statementNode, context), assignments = null, stated = false, statementVerifies = statement.verify(assignments, stated, context);
+            if (statementVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: termNodeQuery,
+        run: function(termNode, context) {
+            var success = false;
+            var Term = _ontology.default.Term, term = Term.fromTermNode(termNode, context), termVerifies = term.verify(context, function() {
+                var verifiesAhead = true;
+                return verifiesAhead;
+            });
+            if (termVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: typeNodeQuery,
+        run: function(typeNode, context) {
+            var success = false;
+            var nominalTypeName = typeNode.getNominalTypeName(), typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
+            if (typePresent) {
+                success = true;
+            }
+            return success;
+        }
+    }
+]);
+var ConstructorPass = /*#__PURE__*/ function(Pass) {
+    _inherits(ConstructorPass, Pass);
+    function ConstructorPass() {
+        _class_call_check(this, ConstructorPass);
+        return _call_super(this, ConstructorPass, arguments);
+    }
+    return ConstructorPass;
+}(Pass);
+_define_property(ConstructorPass, "maps", [
+    {
+        nodeQuery: termNodeQuery,
+        run: function(termNode, context, verifyAhead) {
+            var success = false;
+            var Term = _ontology.default.Term, term = Term.fromTermNode(termNode, context), termVerifies = term.verify(context, verifyAhead);
+            if (termVerifies) {
+                success = true;
+            }
+            return success;
+        }
+    },
+    {
+        nodeQuery: typeNodeQuery,
+        run: function(typeNode, context, verifyAhead) {
+            var success = false;
+            var nominalTypeName = typeNode.getNominalTypeName(), typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
+            if (typePresent) {
+                var verifiesAhead = verifyAhead();
+                if (verifiesAhead) {
+                    success = true;
+                }
+            } else {
+                var typeString = nominalTypeName; ///
+                context.debug("The '".concat(typeString, "' type is not present."));
+                success = false;
+            }
+            return success;
+        }
+    }
+]);
+var topLevelPass = new TopLevelPass(), combinatorPass = new CombinatorPass(), constructorPass = new ConstructorPass();
+function verifyFile(fileNode, context) {
+    var fileVerifies = false;
+    var node = fileNode, sucess = topLevelPass.run(node, context);
+    if (sucess) {
+        fileVerifies = true;
+    }
+    return fileVerifies;
+}
+function verifyTerm(termNode, context) {
+    var termVerifies = false;
+    var node = termNode, sucess = constructorPass.run(node, context);
+    if (sucess) {
+        termVerifies = true;
+    }
+    return termVerifies;
+}
+function verifyStatement(statementNode, context) {
+    var statementVerifies = false;
+    var node = statementNode, sucess = combinatorPass.run(node, context);
+    if (sucess) {
+        statementVerifies = true;
+    }
+    return statementVerifies;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/process/verify.js"],"sourcesContent":["\"use strict\";\n\nimport { nodeQuery } from \"../utilities/query\";\nimport { isLastRemainingArgumentFunction } from \"../utilities/pass\";\nimport statement from \"../ontology/statement\";\nimport ontology from \"../ontology\";\n\nconst nonTerminalNodeQuery = nodeQuery(\"/*\");\n\nconst termNodeQuery = nodeQuery(\"/term\"),\n      typeNodeQuery = nodeQuery(\"/type\"),\n      statementNodeQuery = nodeQuery(\"/statement\");\n\nconst errorNodeQuery = nodeQuery(\"/error\"),\n      ruleNodeQuery = nodeQuery(\"/rule\"),\n      axiomNodeQuery = nodeQuery(\"/axiom\"),\n      lemmaNodeQuery = nodeQuery(\"/lemma\"),\n      sectionNodeQuery = nodeQuery(\"/section\"),\n      theoremNodeQuery = nodeQuery(\"/theorem\"),\n      metaLemmaNodeQuery = nodeQuery(\"/metaLemma\"),\n      conjectureNodeQuery = nodeQuery(\"/conjecture\"),\n      metatheoremNodeQuery = nodeQuery(\"/metatheorem\"),\n      variableDeclarationNodeQuery = nodeQuery(\"/variableDeclaration\"),\n      combinatorDeclarationNodeQuery = nodeQuery(\"/combinatorDeclaration\"),\n      simpleTypeDeclarationNodeQuery = nodeQuery(\"/simpleTypeDeclaration\"),\n      typePrefixDeclarationNodeQuery = nodeQuery(\"/typePrefixDeclaration\"),\n      constructorDeclarationNodeQuery = nodeQuery(\"/constructorDeclaration\"),\n      complexTypeDeclarationNodeQuery = nodeQuery(\"/complexTypeDeclaration\"),\n      metavariableDeclarationNodeQuery = nodeQuery(\"/metavariableDeclaration\");\n\nexport default class Pass {\n  run(node, ...remainingArguments) {\n    let success;\n\n    const visited = this.visitNode(node, ...remainingArguments);\n\n    success = visited;  ///\n\n    return success;\n  }\n\n  descend(childNodes, ...remainingArguments) {\n    let descendedAhead = false;\n\n    const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);\n\n    if (lastRemainingArgumentFunction) {\n      const index = 0;\n\n      descendedAhead = this.descendAhead(index, childNodes, ...remainingArguments); ///\n    } else {\n      const visited = childNodes.every((childNode) => {\n        const node = childNode, ///\n              visited = this.visitNode(node, ...remainingArguments);\n\n        if (visited) {\n          return true;\n        }\n      });\n\n      if (visited) {\n        descendedAhead = true;\n      }\n    }\n\n    return descendedAhead;\n  }\n\n  descendAhead(index, childNodes, ...remainingArguments) {\n    let descendedAhead = false;\n\n    const descendAhead = remainingArguments.pop(), ///\n          childNodesLength = childNodes.length;\n\n    if (index === childNodesLength) {\n      descendedAhead = descendAhead();\n    } else {\n      const childNode = childNodes[index],\n            node = childNode, ///\n            visited = this.visitNode(node, ...remainingArguments, () => {\n              remainingArguments.push(descendAhead);\n\n              const aheadIndex = index + 1,\n                    descendedAhead = this.descendAhead(aheadIndex, childNodes, ...remainingArguments);\n\n              return descendedAhead;\n            });\n\n      if (visited) {\n        descendedAhead = true;\n      }\n    }\n\n    return descendedAhead;\n  }\n\n  visitNode(node, ...remainingArguments) {\n    let visited;\n\n    const nodeTerminalNode = node.isTerminalNode();\n\n    if (nodeTerminalNode) {\n      const terminalNode = node;  ///\n\n      visited = this.visitTerminalNode(terminalNode, ...remainingArguments);\n    } else {\n      const nonTerminalNode = node;  ///\n\n      visited = this.visitNonTerminalNode(nonTerminalNode, ...remainingArguments);\n    }\n\n    return visited;\n  }\n\n  visitTerminalNode(terminalNode, ...remainingArguments) {\n    let visited = false;\n\n    const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);\n\n    if (lastRemainingArgumentFunction) {\n      const descendAhead = remainingArguments.pop(), ///\n            descendedAhead = descendAhead();\n\n      if (descendedAhead) {\n        visited = true;\n      }\n\n      remainingArguments.push(descendAhead);\n    } else {\n      visited = true;\n    }\n\n    return visited;\n  }\n\n  visitNonTerminalNode(nonTerminalNode, ...remainingArguments) {\n    let visited = false;\n\n    let { maps } = this.constructor;\n\n    maps = [ ///\n      ...maps,\n      {\n        nodeQuery: nonTerminalNodeQuery,\n        run: (node, ...remainingArguments) => {\n          let visited = false;\n\n          const childNodes = nonTerminalNode.getChildNodes(), ///\n                descended = this.descend(childNodes, ...remainingArguments);\n\n          if (descended) {\n            visited = true;\n          }\n\n          return visited;\n        }\n      }\n    ]\n\n    maps.some((map) => {\n      const { nodeQuery, run } = map;\n\n      const node = nodeQuery(nonTerminalNode);\n\n      if (node !== null) {\n        const success = run(node, ...remainingArguments);\n\n        visited = success;\n\n        return true;\n      }\n    });\n\n    return visited;\n  }\n}\n\nclass TopLevelPass extends Pass {\n  static maps = [\n    {\n      nodeQuery: errorNodeQuery,\n      run: (errorNode, context) => {\n        let success = false;\n\n        const { Error } = ontology,\n              error = Error.fromErrorNode(errorNode, context),\n              errorVerifies = error.verify();\n\n        if (errorVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: ruleNodeQuery,\n      run: (ruleNode, context) => {\n        let success = false;\n\n        const { Rule } = ontology,\n              rule = Rule.fromRuleNode(ruleNode, context),\n              ruleVerifies = rule.verify();\n\n        if (ruleVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: axiomNodeQuery,\n      run: (axiomNode, context) => {\n        let success = false;\n\n        const { Axiom } = ontology,\n              axiom = Axiom.fromAxiomNode(axiomNode, context),\n              axiomVerifies = axiom.verify();\n\n        if (axiomVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: lemmaNodeQuery,\n      run: (lemmaNode, context) => {\n        let success = false;\n\n        const { Lemma } = ontology,\n              lemma = Lemma.fromLemmaNode(lemmaNode, context),\n              lemmaVerifies = lemma.verify();\n\n        if (lemmaVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: sectionNodeQuery,\n      run: (sectionNode, context) => {\n        let success = false;\n\n        const { Section } = ontology,\n              section = Section.fromSectionNode(sectionNode, context),\n              sectionVerifies = section.verify();\n\n        if (sectionVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: theoremNodeQuery,\n      run: (theoremNode, context) => {\n        let success = false;\n\n        const { Theorem } = ontology,\n              theorem = Theorem.fromTheoremNode(theoremNode, context),\n              theoremVerifies = theorem.verify();\n\n        if (theoremVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: metaLemmaNodeQuery,\n      run: (metaLemmaNode, context) => {\n        let success = false;\n\n        const { MetaLemma } = ontology,\n              metaLemma = MetaLemma.fromMetaLemmaNode(metaLemmaNode, context),\n              metaLemmaVerifies = metaLemma.verify();\n\n        if (metaLemmaVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: conjectureNodeQuery,\n      run: (conjectureNode, context) => {\n        let success = false;\n\n        const { Conjecture } = ontology,\n              conjecture = Conjecture.fromConjectureNode(conjectureNode, context),\n              conjectureVerifies = conjecture.verify();\n\n        if (conjectureVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: metatheoremNodeQuery,\n      run: (metatheoremNode, context) => {\n        let success = false;\n\n        const { Metatheorem } = ontology,\n              metatheorem = Metatheorem.fromMetatheoremNode(metatheoremNode, context),\n              metatheoremVerifies = metatheorem.verify();\n\n        if (metatheoremVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: variableDeclarationNodeQuery,\n      run: (variableDeclarationNode, context) => {\n        let success = false;\n\n        const { VariableDeclaration } = ontology,\n              variableDeclaration = VariableDeclaration.fromVariableDeclarationNode(variableDeclarationNode, context),\n              variableDeclarationVerifies = variableDeclaration.verify();\n\n        if (variableDeclarationVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: simpleTypeDeclarationNodeQuery,\n      run: (simpleTypeDeclarationNode, context) => {\n        let success = false;\n\n        const { SimpleTypeDeclaration } = ontology,\n              simpleTypeDeclaration = SimpleTypeDeclaration.fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),\n              simpleTypeDeclarationVerifies = simpleTypeDeclaration.verify();\n\n        if (simpleTypeDeclarationVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: typePrefixDeclarationNodeQuery,\n      run: (typePrefixDeclarationNode, context) => {\n        let success = false;\n\n        const { TypePrefixDeclaration } = ontology,\n              typePrefixDeclaration = TypePrefixDeclaration.fromTypePrefixDeclarationNode(typePrefixDeclarationNode, context),\n              typePrefixDeclarationVerifies = typePrefixDeclaration.verify();\n\n        if (typePrefixDeclarationVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: combinatorDeclarationNodeQuery,\n      run: (combinatorDeclarationNode, context) => {\n        let success = false;\n\n        const { CombinatorDeclaration } = ontology,\n              combinatorDeclaration = CombinatorDeclaration.fromCombinatorDeclarationNode(combinatorDeclarationNode, context),\n              combinatorDeclarationVerifies = combinatorDeclaration.verify();\n\n        if (combinatorDeclarationVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: constructorDeclarationNodeQuery,\n      run: (constructorDeclarationNode, context) => {\n        let success = false;\n\n        const { ConstructorDeclaration } = ontology,\n              constructorDeclaration = ConstructorDeclaration.fromConstructorDeclarationNode(constructorDeclarationNode, context),\n              constructorDeclarationVerifies = constructorDeclaration.verify();\n\n        if (constructorDeclarationVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: complexTypeDeclarationNodeQuery,\n      run: (complexTypeDeclarationNode, context) => {\n        let success = false;\n\n        const { ComplexTypeDeclaration } = ontology,\n              complexTypeDeclaration = ComplexTypeDeclaration.fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),\n              complexTypeDeclarationVerifies = complexTypeDeclaration.verify();\n\n        if (complexTypeDeclarationVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: metavariableDeclarationNodeQuery,\n      run: (metavariableDeclarationNode, context) => {\n        let success = false;\n\n        const { MetavariableDeclaration } = ontology,\n              metavariableDeclaration = MetavariableDeclaration.fromMetavariableDeclarationNode(metavariableDeclarationNode, context),\n              metavariableDeclarationVerifies = metavariableDeclaration.verify();\n\n        if (metavariableDeclarationVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    }\n  ];\n}\n\nclass CombinatorPass extends Pass {\n  static maps = [\n    {\n      nodeQuery: statementNodeQuery,\n      run: (statementNode, context) => {\n        let success = false;\n\n        const { Statement } = ontology,\n              statement = Statement.fromStatementNode(statementNode, context),\n              assignments = null,\n              stated = false,\n              statementVerifies = statement.verify(assignments, stated, context);\n\n        if (statementVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: termNodeQuery,\n      run: (termNode, context) => {\n        let success = false;\n\n        const { Term } = ontology,\n              term = Term.fromTermNode(termNode, context),\n              termVerifies = term.verify(context, () => {\n                const verifiesAhead = true;\n\n                return verifiesAhead;\n              });\n\n        if (termVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: typeNodeQuery,\n      run: (typeNode, context) => {\n        let success = false;\n\n        const nominalTypeName = typeNode.getNominalTypeName(),\n              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);\n\n        if (typePresent) {\n          success = true;\n        }\n\n        return success;\n      }\n    }\n  ];\n}\n\nclass ConstructorPass extends Pass {\n  static maps = [\n    {\n      nodeQuery: termNodeQuery,\n      run: (termNode, context, verifyAhead) => {\n        let success = false;\n\n        const { Term } = ontology,\n              term = Term.fromTermNode(termNode, context),\n              termVerifies = term.verify(context, verifyAhead);\n\n        if (termVerifies) {\n          success = true;\n        }\n\n        return success;\n      }\n    },\n    {\n      nodeQuery: typeNodeQuery,\n      run: (typeNode, context, verifyAhead) => {\n        let success = false;\n\n        const nominalTypeName = typeNode.getNominalTypeName(),\n              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);\n\n        if (typePresent) {\n          const verifiesAhead = verifyAhead();\n\n          if (verifiesAhead) {\n            success = true;\n          }\n        } else {\n          const typeString = nominalTypeName; ///\n\n          context.debug(`The '${typeString}' type is not present.`);\n\n          success = false;\n        }\n\n        return success;\n      }\n    }\n  ];\n}\n\nconst topLevelPass = new TopLevelPass(),\n      combinatorPass = new CombinatorPass(),\n      constructorPass = new ConstructorPass();\n\nexport function verifyFile(fileNode, context) {\n  let fileVerifies = false;\n\n  const node = fileNode, ///\n        sucess = topLevelPass.run(node, context);\n\n  if (sucess) {\n    fileVerifies = true;\n  }\n\n  return fileVerifies;\n}\n\nexport function verifyTerm(termNode, context) {\n  let termVerifies = false;\n\n  const node = termNode, ///\n        sucess = constructorPass.run(node, context);\n\n  if (sucess) {\n    termVerifies = true;\n  }\n\n  return termVerifies;\n}\n\nexport function verifyStatement(statementNode, context) {\n  let statementVerifies = false;\n\n  const node = statementNode, ///\n        sucess = combinatorPass.run(node, context);\n\n  if (sucess) {\n    statementVerifies = true;\n  }\n\n  return statementVerifies;\n}\n"],"names":["Pass","verifyFile","verifyStatement","verifyTerm","nonTerminalNodeQuery","nodeQuery","termNodeQuery","typeNodeQuery","statementNodeQuery","errorNodeQuery","ruleNodeQuery","axiomNodeQuery","lemmaNodeQuery","sectionNodeQuery","theoremNodeQuery","metaLemmaNodeQuery","conjectureNodeQuery","metatheoremNodeQuery","variableDeclarationNodeQuery","combinatorDeclarationNodeQuery","simpleTypeDeclarationNodeQuery","typePrefixDeclarationNodeQuery","constructorDeclarationNodeQuery","complexTypeDeclarationNodeQuery","metavariableDeclarationNodeQuery","run","node","remainingArguments","success","visited","visitNode","descend","childNodes","descendedAhead","lastRemainingArgumentFunction","isLastRemainingArgumentFunction","index","descendAhead","every","childNode","pop","childNodesLength","length","push","aheadIndex","nodeTerminalNode","isTerminalNode","terminalNode","visitTerminalNode","nonTerminalNode","visitNonTerminalNode","maps","getChildNodes","descended","some","map","TopLevelPass","errorNode","context","Error","ontology","error","fromErrorNode","errorVerifies","verify","ruleNode","Rule","rule","fromRuleNode","ruleVerifies","axiomNode","Axiom","axiom","fromAxiomNode","axiomVerifies","lemmaNode","Lemma","lemma","fromLemmaNode","lemmaVerifies","sectionNode","Section","section","fromSectionNode","sectionVerifies","theoremNode","Theorem","theorem","fromTheoremNode","theoremVerifies","metaLemmaNode","MetaLemma","metaLemma","fromMetaLemmaNode","metaLemmaVerifies","conjectureNode","Conjecture","conjecture","fromConjectureNode","conjectureVerifies","metatheoremNode","Metatheorem","metatheorem","fromMetatheoremNode","metatheoremVerifies","variableDeclarationNode","VariableDeclaration","variableDeclaration","fromVariableDeclarationNode","variableDeclarationVerifies","simpleTypeDeclarationNode","SimpleTypeDeclaration","simpleTypeDeclaration","fromSimpleTypeDeclarationNode","simpleTypeDeclarationVerifies","typePrefixDeclarationNode","TypePrefixDeclaration","typePrefixDeclaration","fromTypePrefixDeclarationNode","typePrefixDeclarationVerifies","combinatorDeclarationNode","CombinatorDeclaration","combinatorDeclaration","fromCombinatorDeclarationNode","combinatorDeclarationVerifies","constructorDeclarationNode","ConstructorDeclaration","constructorDeclaration","fromConstructorDeclarationNode","constructorDeclarationVerifies","complexTypeDeclarationNode","ComplexTypeDeclaration","complexTypeDeclaration","fromComplexTypeDeclarationNode","complexTypeDeclarationVerifies","metavariableDeclarationNode","MetavariableDeclaration","metavariableDeclaration","fromMetavariableDeclarationNode","metavariableDeclarationVerifies","CombinatorPass","statementNode","Statement","statement","fromStatementNode","assignments","stated","statementVerifies","termNode","Term","term","fromTermNode","termVerifies","verifiesAhead","typeNode","nominalTypeName","getNominalTypeName","typePresent","isTypePresentByNominalTypeName","ConstructorPass","verifyAhead","typeString","debug","topLevelPass","combinatorPass","constructorPass","fileNode","fileVerifies","sucess"],"mappings":"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"}