occam-verify-cli 0.0.834 → 0.0.835

package/lib/verifier/nodes/metaLevel.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _nodes = /*#__PURE__*/ _interop_require_default(require("../../verifier/nodes"));
+var _metastatementForMetavariable = /*#__PURE__*/ _interop_require_default(require("../../substitution/metastatementForMetavariable"));
+var _query = require("../../utilities/query");
+var _ruleNames = require("../../ruleNames");
+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 _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 _get(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+        _get = Reflect.get;
+    } else {
+        _get = function get(target, property, receiver) {
+            var base = _super_prop_base(target, property);
+            if (!base) return;
+            var desc = Object.getOwnPropertyDescriptor(base, property);
+            if (desc.get) {
+                return desc.get.call(receiver || target);
+            }
+            return desc.value;
+        };
+    }
+    return _get(target, property, receiver || target);
+}
+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 _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 _super_prop_base(object, property) {
+    while(!Object.prototype.hasOwnProperty.call(object, property)){
+        object = _get_prototype_of(object);
+        if (object === null) break;
+    }
+    return object;
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+var metavariableNodeQuery = (0, _query.nodeQuery)('/metastatement/metavariable!');
+var MetaLevelNodesVerifier = /*#__PURE__*/ function(NodesVerifier) {
+    _inherits(MetaLevelNodesVerifier, NodesVerifier);
+    var _super = _create_super(MetaLevelNodesVerifier);
+    function MetaLevelNodesVerifier() {
+        _class_call_check(this, MetaLevelNodesVerifier);
+        return _super.apply(this, arguments);
+    }
+    _create_class(MetaLevelNodesVerifier, [
+        {
+            key: "verifyNonTerminalNode",
+            value: function verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
+                var nonTerminalNodeVerified = false;
+                var nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
+                if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+                    var ruleName = nonTerminalNodeARuleName; ///
+                    switch(ruleName){
+                        case _ruleNames.METASTATEMENT_RULE_NAME:
+                            {
+                                var metastatementNodeA = nonTerminalNodeA, metastatementNodeB = nonTerminalNodeB, metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+                                if (metastatementNodeVerified) {
+                                    nonTerminalNodeVerified = true; ///
+                                } else {
+                                    nonTerminalNodeVerified = _get(_get_prototype_of(MetaLevelNodesVerifier.prototype), "verifyNonTerminalNode", this).call(this, nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+                                }
+                                break;
+                            }
+                        default:
+                            {
+                                nonTerminalNodeVerified = _get(_get_prototype_of(MetaLevelNodesVerifier.prototype), "verifyNonTerminalNode", this).call(this, nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+                                break;
+                            }
+                    }
+                }
+                return nonTerminalNodeVerified;
+            }
+        },
+        {
+            key: "verifyMetastatementNode",
+            value: function verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
+                var metastatementNodeVerified = false;
+                var metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
+                if (metavariableNodeA !== null) {
+                    var metaVariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+                    metastatementNodeVerified = metaVariableNodeVerified; ///
+                }
+                return metastatementNodeVerified;
+            }
+        },
+        {
+            key: "verifyMetavariableNode",
+            value: function verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
+                var metavariableNodeVerified;
+                var substitution = substitutions.find(function(substitution) {
+                    var substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
+                    if (substitutionMatchesMetavariableNodeA) {
+                        return true;
+                    }
+                }) || null;
+                if (substitution !== null) {
+                    var metastatementNode = metastatementNodeB, metastatementNodeMatches = substitution.matchMetastatementNode(metastatementNode);
+                    metavariableNodeVerified = metastatementNodeMatches; ///
+                } else {
+                    var metavariableNode = metavariableNodeA, metastatementNode1 = metastatementNodeB, metastatementForMetavariableSubstitution = _metastatementForMetavariable.default.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode1), substitution1 = metastatementForMetavariableSubstitution; ///
+                    substitutions.push(substitution1);
+                    metavariableNodeVerified = true;
+                }
+                return metavariableNodeVerified;
+            }
+        }
+    ]);
+    return MetaLevelNodesVerifier;
+}(_nodes.default);
+var metaLevelNodesVerifier = new MetaLevelNodesVerifier();
+var _default = metaLevelNodesVerifier;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verifier/nodes/metaLevel.js"],"sourcesContent":["\"use strict\";\n\nimport NodesVerifier from \"../../verifier/nodes\";\nimport MetastatementForMetavariableSubstitution from \"../../substitution/metastatementForMetavariable\";\n\nimport { nodeQuery } from \"../../utilities/query\";\nimport { METASTATEMENT_RULE_NAME } from \"../../ruleNames\";\n\nconst metavariableNodeQuery = nodeQuery('/metastatement/metavariable!');\n\nclass MetaLevelNodesVerifier extends NodesVerifier {\n  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {\n    let nonTerminalNodeVerified = false;\n\n    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),\n          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();\n\n    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {\n      const ruleName = nonTerminalNodeARuleName;  ///\n\n      switch (ruleName) {\n        case METASTATEMENT_RULE_NAME: {\n          const metastatementNodeA = nonTerminalNodeA,  ///\n                metastatementNodeB = nonTerminalNodeB,  ///\n                metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);\n\n          if (metastatementNodeVerified) {\n            nonTerminalNodeVerified = true;  ///\n          } else {\n            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);\n          }\n\n          break;\n        }\n\n        default: {\n          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);\n\n          break;\n        }\n      }\n    }\n\n    return nonTerminalNodeVerified;\n  }\n\n  verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {\n    let metastatementNodeVerified = false;\n\n    const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);\n\n    if (metavariableNodeA !== null) {\n      const metaVariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);\n\n      metastatementNodeVerified = metaVariableNodeVerified; ///\n    }\n\n    return metastatementNodeVerified;\n  }\n\n  verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {\n    let metavariableNodeVerified;\n\n    const substitution = substitutions.find((substitution) => {\n            const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);\n\n            if (substitutionMatchesMetavariableNodeA) {\n              return true;\n            }\n          }) || null;\n\n    if (substitution !== null) {\n      const metastatementNode = metastatementNodeB, ///\n            metastatementNodeMatches = substitution.matchMetastatementNode(metastatementNode);\n\n      metavariableNodeVerified = metastatementNodeMatches;  ///\n    } else {\n      const metavariableNode = metavariableNodeA, ///\n            metastatementNode = metastatementNodeB, ///\n            metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode),\n            substitution = metastatementForMetavariableSubstitution;  ///\n\n      substitutions.push(substitution);\n\n      metavariableNodeVerified = true;\n    }\n\n    return metavariableNodeVerified;\n  }\n}\n\nconst metaLevelNodesVerifier = new MetaLevelNodesVerifier();\n\nexport default metaLevelNodesVerifier;\n"],"names":["metavariableNodeQuery","nodeQuery","MetaLevelNodesVerifier","verifyNonTerminalNode","nonTerminalNodeA","nonTerminalNodeB","substitutions","fileContextA","localMetaContextB","verifyAhead","nonTerminalNodeVerified","nonTerminalNodeARuleName","getRuleName","nonTerminalNodeBRuleName","ruleName","METASTATEMENT_RULE_NAME","metastatementNodeA","metastatementNodeB","metastatementNodeVerified","verifyMetastatementNode","metavariableNodeA","metaVariableNodeVerified","verifyMetavariableNode","metavariableNodeVerified","substitution","find","substitutionMatchesMetavariableNodeA","matchMetavariableNode","metastatementNode","metastatementNodeMatches","matchMetastatementNode","metavariableNode","metastatementForMetavariableSubstitution","MetastatementForMetavariableSubstitution","fromMetavariableNodeAndMetastatementNode","push","NodesVerifier","metaLevelNodesVerifier"],"mappings":"AAAA;;;;+BA6FA;;;eAAA;;;4DA3F0B;mFAC2B;qBAE3B;yBACc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAExC,IAAMA,wBAAwBC,IAAAA,gBAAS,EAAC;AAExC,IAAA,AAAMC,uCAAD,AAAL;cAAMA;+BAAAA;aAAAA;gCAAAA;;;kBAAAA;;YACJC,KAAAA;mBAAAA,SAAAA,sBAAsBC,gBAAgB,EAAEC,gBAAgB,EAAEC,aAAa,EAAEC,YAAY,EAAEC,iBAAiB,EAAEC,WAAW;gBACnH,IAAIC,0BAA0B;gBAE9B,IAAMC,2BAA2BP,iBAAiBQ,WAAW,IACvDC,2BAA2BR,iBAAiBO,WAAW;gBAE7D,IAAID,6BAA6BE,0BAA0B;oBACzD,IAAMC,WAAWH,0BAA2B,GAAG;oBAE/C,OAAQG;wBACN,KAAKC,kCAAuB;4BAAE;gCAC5B,IAAMC,qBAAqBZ,kBACrBa,qBAAqBZ,kBACrBa,4BAA4B,IAAI,CAACC,uBAAuB,CAACH,oBAAoBC,oBAAoBX,eAAeC,cAAcC,mBAAmBC;gCAEvJ,IAAIS,2BAA2B;oCAC7BR,0BAA0B,MAAO,GAAG;gCACtC,OAAO;oCACLA,0BAA0B,uBAnBhCR,mCAmBsCC,yBAAN,IAAK,aAAuBC,kBAAkBC,kBAAkBC,eAAeC,cAAcC,mBAAmBC;gCAC5I;gCAEA;4BACF;wBAEA;4BAAS;gCACPC,0BAA0B,uBA1B9BR,mCA0BoCC,yBAAN,IAAK,aAAuBC,kBAAkBC,kBAAkBC,eAAeC,cAAcC,mBAAmBC;gCAE1I;4BACF;oBACF;gBACF;gBAEA,OAAOC;YACT;;;YAEAS,KAAAA;mBAAAA,SAAAA,wBAAwBH,kBAAkB,EAAEC,kBAAkB,EAAEX,aAAa,EAAEC,YAAY,EAAEC,iBAAiB,EAAEC,WAAW;gBACzH,IAAIS,4BAA4B;gBAEhC,IAAME,oBAAoBpB,sBAAsBgB;gBAEhD,IAAII,sBAAsB,MAAM;oBAC9B,IAAMC,2BAA2B,IAAI,CAACC,sBAAsB,CAACF,mBAAmBH,oBAAoBX,eAAeC,cAAcC,mBAAmBC;oBAEpJS,4BAA4BG,0BAA0B,GAAG;gBAC3D;gBAEA,OAAOH;YACT;;;YAEAI,KAAAA;mBAAAA,SAAAA,uBAAuBF,iBAAiB,EAAEH,kBAAkB,EAAEX,aAAa,EAAEC,YAAY,EAAEC,iBAAiB,EAAEC,WAAW;gBACvH,IAAIc;gBAEJ,IAAMC,eAAelB,cAAcmB,IAAI,CAAC,SAACD;oBACjC,IAAME,uCAAuCF,aAAaG,qBAAqB,CAACP;oBAEhF,IAAIM,sCAAsC;wBACxC,OAAO;oBACT;gBACF,MAAM;gBAEZ,IAAIF,iBAAiB,MAAM;oBACzB,IAAMI,oBAAoBX,oBACpBY,2BAA2BL,aAAaM,sBAAsB,CAACF;oBAErEL,2BAA2BM,0BAA2B,GAAG;gBAC3D,OAAO;oBACL,IAAME,mBAAmBX,mBACnBQ,qBAAoBX,oBACpBe,2CAA2CC,qCAAwC,CAACC,wCAAwC,CAACH,kBAAkBH,qBAC/IJ,gBAAeQ,0CAA2C,GAAG;oBAEnE1B,cAAc6B,IAAI,CAACX;oBAEnBD,2BAA2B;gBAC7B;gBAEA,OAAOA;YACT;;;WA9EIrB;EAA+BkC,cAAa;AAiFlD,IAAMC,yBAAyB,IAAInC;IAEnC,WAAemC"}

package/lib/verifier/nodes/metaLevelToIntrinsicLevel.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _nodes = /*#__PURE__*/ _interop_require_default(require("../../verifier/nodes"));
+var _termForVariable = /*#__PURE__*/ _interop_require_default(require("../../substitution/termForVariable"));
+var _statementForMetavariable = /*#__PURE__*/ _interop_require_default(require("../../substitution/statementForMetavariable"));
+var _query = require("../../utilities/query");
+var _ruleNames = require("../../ruleNames");
+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 _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 _get(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+        _get = Reflect.get;
+    } else {
+        _get = function get(target, property, receiver) {
+            var base = _super_prop_base(target, property);
+            if (!base) return;
+            var desc = Object.getOwnPropertyDescriptor(base, property);
+            if (desc.get) {
+                return desc.get.call(receiver || target);
+            }
+            return desc.value;
+        };
+    }
+    return _get(target, property, receiver || target);
+}
+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 _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 _super_prop_base(object, property) {
+    while(!Object.prototype.hasOwnProperty.call(object, property)){
+        object = _get_prototype_of(object);
+        if (object === null) break;
+    }
+    return object;
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+var metavariableNodeQuery = (0, _query.nodeQuery)('/metastatement/metavariable!'), metaArgumentChildNodeNodeQuery = (0, _query.nodeQuery)('/metaArgument/*!');
+var MetaLevelToIntrinsicLevelNodesVerifier = /*#__PURE__*/ function(NodesVerifier) {
+    _inherits(MetaLevelToIntrinsicLevelNodesVerifier, NodesVerifier);
+    var _super = _create_super(MetaLevelToIntrinsicLevelNodesVerifier);
+    function MetaLevelToIntrinsicLevelNodesVerifier() {
+        _class_call_check(this, MetaLevelToIntrinsicLevelNodesVerifier);
+        return _super.apply(this, arguments);
+    }
+    _create_class(MetaLevelToIntrinsicLevelNodesVerifier, [
+        {
+            key: "verifyNonTerminalNode",
+            value: function verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContext) {
+                var nonTerminalNodeVerified = false;
+                var nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(), nonTerminalNodeBRuleNameMetaArgumentRuleName = nonTerminalNodeBRuleName === _ruleNames.META_ARGUMENT_RULE_NAME;
+                if (nonTerminalNodeBRuleNameMetaArgumentRuleName) {
+                    var metaArgumentNodeB = nonTerminalNodeB, metaArgumentChildNodeB = metaArgumentChildNodeNodeQuery(metaArgumentNodeB);
+                    nonTerminalNodeB = metaArgumentChildNodeB; ///
+                    nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContext);
+                } else {
+                    var nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), nonTerminalNodeBRuleName1 = nonTerminalNodeB.getRuleName(), nonTerminalNodeARuleNameMetastatementRuleName = nonTerminalNodeARuleName === _ruleNames.METASTATEMENT_RULE_NAME, nonTerminalNodeBRuleNameStatementRuleName = nonTerminalNodeBRuleName1 === _ruleNames.STATEMENT_RULE_NAME;
+                    if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameStatementRuleName) {
+                        var metastatementNodeA = nonTerminalNodeA, statementNodeB = nonTerminalNodeB, statementNodeVerified = this.verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, fileContextA, localContext);
+                        if (statementNodeVerified) {
+                            nonTerminalNodeVerified = true; ///
+                        } else {
+                            var nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(), nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(), childNodesA = nonTerminalNodeAChildNodes, childNodesB = nonTerminalNodeBChildNodes, childNodesVerified = this.verifyChildNodes(childNodesA, childNodesB, substitutions, fileContextA, localContext);
+                            nonTerminalNodeVerified = childNodesVerified; ///
+                        }
+                    } else if (nonTerminalNodeBRuleName1 === nonTerminalNodeARuleName) {
+                        nonTerminalNodeVerified = _get(_get_prototype_of(MetaLevelToIntrinsicLevelNodesVerifier.prototype), "verifyNonTerminalNode", this).call(this, nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContext);
+                    }
+                }
+                return nonTerminalNodeVerified;
+            }
+        },
+        {
+            key: "verifyStatementNode",
+            value: function verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, fileContextA, localContext) {
+                var statementNodeVerified = false;
+                var metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
+                if (metavariableNodeA !== null) {
+                    var metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, localContext);
+                    statementNodeVerified = metavariableNodeVerified; ///
+                }
+                return statementNodeVerified;
+            }
+        },
+        {
+            key: "verifyMetavariableNode",
+            value: function verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, localContext) {
+                var metavariableNodeVerified;
+                var substitution = substitutions.find(function(substitution) {
+                    var substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
+                    if (substitutionMatchesMetavariableNodeA) {
+                        return true;
+                    }
+                }) || null;
+                if (substitution !== null) {
+                    var statementNode = statementNodeB, statementNodeMatches = substitution.matchStatementNode(statementNode);
+                    metavariableNodeVerified = statementNodeMatches; ///
+                } else {
+                    var metavariableNode = metavariableNodeA, statementNode1 = statementNodeB, statementForMetavariableSubstitution = _statementForMetavariable.default.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode1), substitution1 = statementForMetavariableSubstitution; ///
+                    substitutions.push(substitution1);
+                    metavariableNodeVerified = true;
+                }
+                return metavariableNodeVerified;
+            }
+        }
+    ]);
+    return MetaLevelToIntrinsicLevelNodesVerifier;
+}(_nodes.default);
+var metaLevelToIntrinsicLevelNodesVerifier = new MetaLevelToIntrinsicLevelNodesVerifier();
+var _default = metaLevelToIntrinsicLevelNodesVerifier;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verifier/nodes/metaLevelToIntrinsicLevel.js"],"sourcesContent":["\"use strict\";\n\nimport NodesVerifier from \"../../verifier/nodes\";\nimport TermForVariableSubstitution from \"../../substitution/termForVariable\";\nimport StatementForMetavariableSubstitution from \"../../substitution/statementForMetavariable\";\n\nimport { nodeQuery } from \"../../utilities/query\";\nimport { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from \"../../ruleNames\";\n\nconst metavariableNodeQuery = nodeQuery('/metastatement/metavariable!'),\n      metaArgumentChildNodeNodeQuery = nodeQuery('/metaArgument/*!');\n\nclass MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {\n  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContext) {\n    let nonTerminalNodeVerified = false;\n\n    const nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),\n          nonTerminalNodeBRuleNameMetaArgumentRuleName = (nonTerminalNodeBRuleName === META_ARGUMENT_RULE_NAME);\n\n    if (nonTerminalNodeBRuleNameMetaArgumentRuleName) {\n      const metaArgumentNodeB = nonTerminalNodeB, ///\n            metaArgumentChildNodeB = metaArgumentChildNodeNodeQuery(metaArgumentNodeB);\n\n      nonTerminalNodeB = metaArgumentChildNodeB;  ///\n\n      nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContext);\n    } else {\n      const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),\n            nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),\n            nonTerminalNodeARuleNameMetastatementRuleName = (nonTerminalNodeARuleName === METASTATEMENT_RULE_NAME),\n            nonTerminalNodeBRuleNameStatementRuleName = (nonTerminalNodeBRuleName === STATEMENT_RULE_NAME);\n\n      if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameStatementRuleName) {\n        const metastatementNodeA = nonTerminalNodeA,  ///\n              statementNodeB = nonTerminalNodeB,  ///\n              statementNodeVerified = this.verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, fileContextA, localContext);\n\n        if (statementNodeVerified) {\n          nonTerminalNodeVerified = true;  ///\n        } else {\n          const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),\n                nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),\n                childNodesA = nonTerminalNodeAChildNodes, ///\n                childNodesB = nonTerminalNodeBChildNodes, ///\n                childNodesVerified = this.verifyChildNodes(childNodesA, childNodesB, substitutions, fileContextA, localContext);\n\n          nonTerminalNodeVerified = childNodesVerified;  ///\n        }\n      } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {\n        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContext);\n      }\n    }\n\n    return nonTerminalNodeVerified;\n  }\n\n  verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, fileContextA, localContext) {\n    let statementNodeVerified = false;\n\n    const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);\n\n    if (metavariableNodeA !== null) {\n      const metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, localContext);\n\n      statementNodeVerified = metavariableNodeVerified; ///\n    }\n\n    return statementNodeVerified;\n  }\n\n  verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, localContext) {\n    let metavariableNodeVerified;\n\n    const substitution = substitutions.find((substitution) => {\n            const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);\n\n            if (substitutionMatchesMetavariableNodeA) {\n              return true;\n            }\n          }) || null;\n\n    if (substitution !== null) {\n      const statementNode = statementNodeB, ///\n            statementNodeMatches = substitution.matchStatementNode(statementNode);\n\n      metavariableNodeVerified = statementNodeMatches;  ///\n    } else {\n      const metavariableNode = metavariableNodeA, ///\n            statementNode = statementNodeB, ///\n            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode),\n            substitution = statementForMetavariableSubstitution;  ///\n\n      substitutions.push(substitution);\n\n      metavariableNodeVerified = true;\n    }\n\n    return metavariableNodeVerified;\n  }\n}\n\nconst metaLevelToIntrinsicLevelNodesVerifier = new MetaLevelToIntrinsicLevelNodesVerifier();\n\nexport default metaLevelToIntrinsicLevelNodesVerifier;\n"],"names":["metavariableNodeQuery","nodeQuery","metaArgumentChildNodeNodeQuery","MetaLevelToIntrinsicLevelNodesVerifier","verifyNonTerminalNode","nonTerminalNodeA","nonTerminalNodeB","substitutions","fileContextA","localContext","nonTerminalNodeVerified","nonTerminalNodeBRuleName","getRuleName","nonTerminalNodeBRuleNameMetaArgumentRuleName","META_ARGUMENT_RULE_NAME","metaArgumentNodeB","metaArgumentChildNodeB","nonTerminalNodeARuleName","nonTerminalNodeARuleNameMetastatementRuleName","METASTATEMENT_RULE_NAME","nonTerminalNodeBRuleNameStatementRuleName","STATEMENT_RULE_NAME","metastatementNodeA","statementNodeB","statementNodeVerified","verifyStatementNode","nonTerminalNodeAChildNodes","getChildNodes","nonTerminalNodeBChildNodes","childNodesA","childNodesB","childNodesVerified","verifyChildNodes","metavariableNodeA","metavariableNodeVerified","verifyMetavariableNode","substitution","find","substitutionMatchesMetavariableNodeA","matchMetavariableNode","statementNode","statementNodeMatches","matchStatementNode","metavariableNode","statementForMetavariableSubstitution","StatementForMetavariableSubstitution","fromMetavariableNodeAndStatementNode","push","NodesVerifier","metaLevelToIntrinsicLevelNodesVerifier"],"mappings":"AAAA;;;;+BAuGA;;;eAAA;;;4DArG0B;sEACc;+EACS;qBAEvB;yBAC4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEtF,IAAMA,wBAAwBC,IAAAA,gBAAS,EAAC,iCAClCC,iCAAiCD,IAAAA,gBAAS,EAAC;AAEjD,IAAA,AAAME,uDAAD,AAAL;cAAMA;+BAAAA;aAAAA;gCAAAA;;;kBAAAA;;YACJC,KAAAA;mBAAAA,SAAAA,sBAAsBC,gBAAgB,EAAEC,gBAAgB,EAAEC,aAAa,EAAEC,YAAY,EAAEC,YAAY;gBACjG,IAAIC,0BAA0B;gBAE9B,IAAMC,2BAA2BL,iBAAiBM,WAAW,IACvDC,+CAAgDF,6BAA6BG,kCAAuB;gBAE1G,IAAID,8CAA8C;oBAChD,IAAME,oBAAoBT,kBACpBU,yBAAyBd,+BAA+Ba;oBAE9DT,mBAAmBU,wBAAyB,GAAG;oBAE/CN,0BAA0B,IAAI,CAACN,qBAAqB,CAACC,kBAAkBC,kBAAkBC,eAAeC,cAAcC;gBACxH,OAAO;oBACL,IAAMQ,2BAA2BZ,iBAAiBO,WAAW,IACvDD,4BAA2BL,iBAAiBM,WAAW,IACvDM,gDAAiDD,6BAA6BE,kCAAuB,EACrGC,4CAA6CT,8BAA6BU,8BAAmB;oBAEnG,IAAIH,iDAAiDE,2CAA2C;wBAC9F,IAAME,qBAAqBjB,kBACrBkB,iBAAiBjB,kBACjBkB,wBAAwB,IAAI,CAACC,mBAAmB,CAACH,oBAAoBC,gBAAgBhB,eAAeC,cAAcC;wBAExH,IAAIe,uBAAuB;4BACzBd,0BAA0B,MAAO,GAAG;wBACtC,OAAO;4BACL,IAAMgB,6BAA6BrB,iBAAiBsB,aAAa,IAC3DC,6BAA6BtB,iBAAiBqB,aAAa,IAC3DE,cAAcH,4BACdI,cAAcF,4BACdG,qBAAqB,IAAI,CAACC,gBAAgB,CAACH,aAAaC,aAAavB,eAAeC,cAAcC;4BAExGC,0BAA0BqB,oBAAqB,GAAG;wBACpD;oBACF,OAAO,IAAIpB,8BAA6BM,0BAA0B;wBAChEP,0BAA0B,uBArC5BP,mDAqCkCC,yBAAN,IAAK,aAAuBC,kBAAkBC,kBAAkBC,eAAeC,cAAcC;oBACzH;gBACF;gBAEA,OAAOC;YACT;;;YAEAe,KAAAA;mBAAAA,SAAAA,oBAAoBH,kBAAkB,EAAEC,cAAc,EAAEhB,aAAa,EAAEC,YAAY,EAAEC,YAAY;gBAC/F,IAAIe,wBAAwB;gBAE5B,IAAMS,oBAAoBjC,sBAAsBsB;gBAEhD,IAAIW,sBAAsB,MAAM;oBAC9B,IAAMC,2BAA2B,IAAI,CAACC,sBAAsB,CAACF,mBAAmBV,gBAAgBhB,eAAeC,cAAcC;oBAE7He,wBAAwBU,0BAA0B,GAAG;gBACvD;gBAEA,OAAOV;YACT;;;YAEAW,KAAAA;mBAAAA,SAAAA,uBAAuBF,iBAAiB,EAAEV,cAAc,EAAEhB,aAAa,EAAEC,YAAY,EAAEC,YAAY;gBACjG,IAAIyB;gBAEJ,IAAME,eAAe7B,cAAc8B,IAAI,CAAC,SAACD;oBACjC,IAAME,uCAAuCF,aAAaG,qBAAqB,CAACN;oBAEhF,IAAIK,sCAAsC;wBACxC,OAAO;oBACT;gBACF,MAAM;gBAEZ,IAAIF,iBAAiB,MAAM;oBACzB,IAAMI,gBAAgBjB,gBAChBkB,uBAAuBL,aAAaM,kBAAkB,CAACF;oBAE7DN,2BAA2BO,sBAAuB,GAAG;gBACvD,OAAO;oBACL,IAAME,mBAAmBV,mBACnBO,iBAAgBjB,gBAChBqB,uCAAuCC,iCAAoC,CAACC,oCAAoC,CAACH,kBAAkBH,iBACnIJ,gBAAeQ,sCAAuC,GAAG;oBAE/DrC,cAAcwC,IAAI,CAACX;oBAEnBF,2BAA2B;gBAC7B;gBAEA,OAAOA;YACT;;;WAtFI/B;EAA+C6C,cAAa;AAyFlE,IAAMC,yCAAyC,IAAI9C;IAEnD,WAAe8C"}

package/lib/verifier/nodes/statement.js

@@ -143,18 +143,18 @@ var StatementNodesVerifier = /*#__PURE__*/ function(NodesVerifier) {
                 var ruleName = nonTerminalNode.getRuleName(), combinatorRuleName = combinatorNonTerminalNode.getRuleName(); ///
                 if (ruleName === combinatorRuleName) {
                     switch(ruleName){
-                        case _ruleNames.ARGUMENT_RULE_NAME:
-                            {
-                                var argumentNode = nonTerminalNode, constructorArgumentNode = combinatorNonTerminalNode, argumentNodeVerified = _term.default.verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead);
-                                nonTerminalNodeVerified = argumentNodeVerified; ///
-                                break;
-                            }
                         case _ruleNames.META_ARGUMENT_RULE_NAME:
                             {
                                 var metaArgumentNode = nonTerminalNode, combinatorMetaargumentNode = combinatorNonTerminalNode, metaArgumentNodeVerified = this.verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead);
                                 nonTerminalNodeVerified = metaArgumentNodeVerified; ///
                                 break;
                             }
+                        case _ruleNames.ARGUMENT_RULE_NAME:
+                            {
+                                var argumentNode = nonTerminalNode, constructorArgumentNode = combinatorNonTerminalNode, argumentNodeVerified = _term.default.verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead);
+                                nonTerminalNodeVerified = argumentNodeVerified; ///
+                                break;
+                            }
                         default:
                             {
                                 nonTerminalNodeVerified = _get(_get_prototype_of(StatementNodesVerifier.prototype), "verifyNonTerminalNode", this).call(this, nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead);
@@ -196,4 +196,4 @@ var StatementNodesVerifier = /*#__PURE__*/ function(NodesVerifier) {
 var statementNodesVerifier = new StatementNodesVerifier();
 var _default = statementNodesVerifier;
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verifier/nodes/statement.js"],"sourcesContent":["\"use strict\";\n\nimport NodesVerifier from \"../../verifier/nodes\";\nimport termNodesVerifier from \"../../verifier/nodes/term\";\n\nimport { nodeQuery } from \"../../utilities/query\";\nimport { STATEMENT_META_TYPE } from \"../../metaTypes\";\nimport { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from \"../../ruleNames\";\n\nconst metaTypeNodeQuery = nodeQuery(\"/metaArgument/metaType!\"),\n      statementNodeQuery = nodeQuery(\"/metaArgument/statement!\"),\n      metaTypeTerminalNodeQuery = nodeQuery(\"/metaType/@meta-type\");\n\nclass StatementNodesVerifier extends NodesVerifier {\n  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead) {\n    let nonTerminalNodeVerified = false;\n\n    const nonTerminalNode = nonTerminalNodeA, ///\n          combinatorNonTerminalNode = nonTerminalNodeB; ///\n\n    const ruleName = nonTerminalNode.getRuleName(), ///\n          combinatorRuleName = combinatorNonTerminalNode.getRuleName(); ///\n\n    if (ruleName === combinatorRuleName) {\n      switch (ruleName) {\n        case ARGUMENT_RULE_NAME: {\n          const argumentNode = nonTerminalNode, ///\n                constructorArgumentNode = combinatorNonTerminalNode, ///\n                argumentNodeVerified = termNodesVerifier.verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead);\n\n          nonTerminalNodeVerified = argumentNodeVerified; ///\n\n          break;\n        }\n\n        case META_ARGUMENT_RULE_NAME: {\n          const metaArgumentNode = nonTerminalNode, ///\n                combinatorMetaargumentNode = combinatorNonTerminalNode, ///\n                metaArgumentNodeVerified = this.verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead);\n\n          nonTerminalNodeVerified = metaArgumentNodeVerified; ///\n\n          break;\n        }\n\n        default: {\n          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead);\n\n          break;\n        }\n      }\n    }\n\n    return nonTerminalNodeVerified;\n  }\n\n  verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead) {\n    let metaArgumentNodeVerified = false;\n\n    const metaArgumentString = context.nodeAsString(metaArgumentNode);\n\n    const statementNode = statementNodeQuery(metaArgumentNode),\n          combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);\n\n    if (statementNode === null) {\n      context.debug(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);\n    } else {\n      if (combinatorMetaTYpeNode === null) {\n        const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);\n\n        context.debug(`Expected a meta-type but got a '${combinatorMetaargumentString}' statement.`, metaArgumentNode);\n      } else {\n        const combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode),\n              content = combinatorMetaTypeTerminalNode.getContent(),\n              contentStatementMetaType = (content === STATEMENT_META_TYPE);\n\n        if (!contentStatementMetaType) {\n          context.debug(`Expected the meta-type of the combinator to be '${STATEMENT_META_TYPE}' but got '${content}' instead.`, metaArgumentNode);\n        } else {\n          const verifiedAhead = verifyAhead();\n\n          metaArgumentNodeVerified = verifiedAhead; ///\n        }\n      }\n    }\n\n    return metaArgumentNodeVerified;\n  }\n}\n\nconst statementNodesVerifier = new StatementNodesVerifier();\n\nexport default statementNodesVerifier;\n"],"names":["metaTypeNodeQuery","nodeQuery","statementNodeQuery","metaTypeTerminalNodeQuery","StatementNodesVerifier","verifyNonTerminalNode","nonTerminalNodeA","nonTerminalNodeB","context","verifyAhead","nonTerminalNodeVerified","nonTerminalNode","combinatorNonTerminalNode","ruleName","getRuleName","combinatorRuleName","ARGUMENT_RULE_NAME","argumentNode","constructorArgumentNode","argumentNodeVerified","termNodesVerifier","verifyArgumentNode","META_ARGUMENT_RULE_NAME","metaArgumentNode","combinatorMetaargumentNode","metaArgumentNodeVerified","verifyMetaargumentNode","metaArgumentString","nodeAsString","statementNode","combinatorMetaTYpeNode","debug","combinatorMetaargumentString","combinatorMetaTypeTerminalNode","content","getContent","contentStatementMetaType","STATEMENT_META_TYPE","verifiedAhead","NodesVerifier","statementNodesVerifier"],"mappings":"AAAA;;;;+BA4FA;;;eAAA;;;4DA1F0B;2DACI;qBAEJ;yBACU;yBACwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE5D,IAAMA,oBAAoBC,IAAAA,gBAAS,EAAC,4BAC9BC,qBAAqBD,IAAAA,gBAAS,EAAC,6BAC/BE,4BAA4BF,IAAAA,gBAAS,EAAC;AAE5C,IAAA,AAAMG,uCAAD,AAAL;cAAMA;+BAAAA;aAAAA;gCAAAA;;;kBAAAA;;YACJC,KAAAA;mBAAAA,SAAAA,sBAAsBC,gBAAgB,EAAEC,gBAAgB,EAAEC,OAAO,EAAEC,WAAW;gBAC5E,IAAIC,0BAA0B;gBAE9B,IAAMC,kBAAkBL,kBAClBM,4BAA4BL,kBAAkB,GAAG;gBAEvD,IAAMM,WAAWF,gBAAgBG,WAAW,IACtCC,qBAAqBH,0BAA0BE,WAAW,IAAI,GAAG;gBAEvE,IAAID,aAAaE,oBAAoB;oBACnC,OAAQF;wBACN,KAAKG,6BAAkB;4BAAE;gCACvB,IAAMC,eAAeN,iBACfO,0BAA0BN,2BAC1BO,uBAAuBC,aAAiB,CAACC,kBAAkB,CAACJ,cAAcC,yBAAyBV,SAASC;gCAElHC,0BAA0BS,sBAAsB,GAAG;gCAEnD;4BACF;wBAEA,KAAKG,kCAAuB;4BAAE;gCAC5B,IAAMC,mBAAmBZ,iBACnBa,6BAA6BZ,2BAC7Ba,2BAA2B,IAAI,CAACC,sBAAsB,CAACH,kBAAkBC,4BAA4BhB,SAASC;gCAEpHC,0BAA0Be,0BAA0B,GAAG;gCAEvD;4BACF;wBAEA;4BAAS;gCACPf,0BAA0B,uBAjC9BN,mCAiCoCC,yBAAN,IAAK,aAAuBC,kBAAkBC,kBAAkBC,SAASC;gCAEnG;4BACF;oBACF;gBACF;gBAEA,OAAOC;YACT;;;YAEAgB,KAAAA;mBAAAA,SAAAA,uBAAuBH,gBAAgB,EAAEC,0BAA0B,EAAEhB,OAAO,EAAEC,WAAW;gBACvF,IAAIgB,2BAA2B;gBAE/B,IAAME,qBAAqBnB,QAAQoB,YAAY,CAACL;gBAEhD,IAAMM,gBAAgB3B,mBAAmBqB,mBACnCO,yBAAyB9B,kBAAkBwB;gBAEjD,IAAIK,kBAAkB,MAAM;oBAC1BrB,QAAQuB,KAAK,CAAC,AAAC,mCAAqD,OAAnBJ,oBAAmB,iBAAeJ;gBACrF,OAAO;oBACL,IAAIO,2BAA2B,MAAM;wBACnC,IAAME,+BAA+BxB,QAAQoB,YAAY,CAACJ;wBAE1DhB,QAAQuB,KAAK,CAAC,AAAC,mCAA+D,OAA7BC,8BAA6B,iBAAeT;oBAC/F,OAAO;wBACL,IAAMU,iCAAiC9B,0BAA0B2B,yBAC3DI,UAAUD,+BAA+BE,UAAU,IACnDC,2BAA4BF,YAAYG,8BAAmB;wBAEjE,IAAI,CAACD,0BAA0B;4BAC7B5B,QAAQuB,KAAK,CAAC,AAAC,mDAAmFG,OAAjCG,8BAAmB,EAAC,eAAqB,OAARH,SAAQ,eAAaX;wBACzH,OAAO;4BACL,IAAMe,gBAAgB7B;4BAEtBgB,2BAA2Ba,eAAe,GAAG;wBAC/C;oBACF;gBACF;gBAEA,OAAOb;YACT;;;WA1EIrB;EAA+BmC,cAAa;AA6ElD,IAAMC,yBAAyB,IAAIpC;IAEnC,WAAeoC"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verifier/nodes/statement.js"],"sourcesContent":["\"use strict\";\n\nimport NodesVerifier from \"../../verifier/nodes\";\nimport termNodesVerifier from \"../../verifier/nodes/term\";\n\nimport { nodeQuery } from \"../../utilities/query\";\nimport { STATEMENT_META_TYPE } from \"../../metaTypes\";\nimport { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from \"../../ruleNames\";\n\nconst metaTypeNodeQuery = nodeQuery(\"/metaArgument/metaType!\"),\n      statementNodeQuery = nodeQuery(\"/metaArgument/statement!\"),\n      metaTypeTerminalNodeQuery = nodeQuery(\"/metaType/@meta-type\");\n\nclass StatementNodesVerifier extends NodesVerifier {\n  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead) {\n    let nonTerminalNodeVerified = false;\n\n    const nonTerminalNode = nonTerminalNodeA, ///\n          combinatorNonTerminalNode = nonTerminalNodeB; ///\n\n    const ruleName = nonTerminalNode.getRuleName(), ///\n          combinatorRuleName = combinatorNonTerminalNode.getRuleName(); ///\n\n    if (ruleName === combinatorRuleName) {\n      switch (ruleName) {\n        case META_ARGUMENT_RULE_NAME: {\n          const metaArgumentNode = nonTerminalNode, ///\n                combinatorMetaargumentNode = combinatorNonTerminalNode, ///\n                metaArgumentNodeVerified = this.verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead);\n\n          nonTerminalNodeVerified = metaArgumentNodeVerified; ///\n\n          break;\n        }\n\n        case ARGUMENT_RULE_NAME: {\n          const argumentNode = nonTerminalNode, ///\n                constructorArgumentNode = combinatorNonTerminalNode, ///\n                argumentNodeVerified = termNodesVerifier.verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead);\n\n          nonTerminalNodeVerified = argumentNodeVerified; ///\n\n          break;\n        }\n\n        default: {\n          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead);\n\n          break;\n        }\n      }\n    }\n\n    return nonTerminalNodeVerified;\n  }\n\n  verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead) {\n    let metaArgumentNodeVerified = false;\n\n    const metaArgumentString = context.nodeAsString(metaArgumentNode);\n\n    const statementNode = statementNodeQuery(metaArgumentNode),\n          combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);\n\n    if (statementNode === null) {\n      context.debug(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);\n    } else {\n      if (combinatorMetaTYpeNode === null) {\n        const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);\n\n        context.debug(`Expected a meta-type but got a '${combinatorMetaargumentString}' statement.`, metaArgumentNode);\n      } else {\n        const combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode),\n              content = combinatorMetaTypeTerminalNode.getContent(),\n              contentStatementMetaType = (content === STATEMENT_META_TYPE);\n\n        if (!contentStatementMetaType) {\n          context.debug(`Expected the meta-type of the combinator to be '${STATEMENT_META_TYPE}' but got '${content}' instead.`, metaArgumentNode);\n        } else {\n          const verifiedAhead = verifyAhead();\n\n          metaArgumentNodeVerified = verifiedAhead; ///\n        }\n      }\n    }\n\n    return metaArgumentNodeVerified;\n  }\n}\n\nconst statementNodesVerifier = new StatementNodesVerifier();\n\nexport default statementNodesVerifier;\n"],"names":["metaTypeNodeQuery","nodeQuery","statementNodeQuery","metaTypeTerminalNodeQuery","StatementNodesVerifier","verifyNonTerminalNode","nonTerminalNodeA","nonTerminalNodeB","context","verifyAhead","nonTerminalNodeVerified","nonTerminalNode","combinatorNonTerminalNode","ruleName","getRuleName","combinatorRuleName","META_ARGUMENT_RULE_NAME","metaArgumentNode","combinatorMetaargumentNode","metaArgumentNodeVerified","verifyMetaargumentNode","ARGUMENT_RULE_NAME","argumentNode","constructorArgumentNode","argumentNodeVerified","termNodesVerifier","verifyArgumentNode","metaArgumentString","nodeAsString","statementNode","combinatorMetaTYpeNode","debug","combinatorMetaargumentString","combinatorMetaTypeTerminalNode","content","getContent","contentStatementMetaType","STATEMENT_META_TYPE","verifiedAhead","NodesVerifier","statementNodesVerifier"],"mappings":"AAAA;;;;+BA4FA;;;eAAA;;;4DA1F0B;2DACI;qBAEJ;yBACU;yBACwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE5D,IAAMA,oBAAoBC,IAAAA,gBAAS,EAAC,4BAC9BC,qBAAqBD,IAAAA,gBAAS,EAAC,6BAC/BE,4BAA4BF,IAAAA,gBAAS,EAAC;AAE5C,IAAA,AAAMG,uCAAD,AAAL;cAAMA;+BAAAA;aAAAA;gCAAAA;;;kBAAAA;;YACJC,KAAAA;mBAAAA,SAAAA,sBAAsBC,gBAAgB,EAAEC,gBAAgB,EAAEC,OAAO,EAAEC,WAAW;gBAC5E,IAAIC,0BAA0B;gBAE9B,IAAMC,kBAAkBL,kBAClBM,4BAA4BL,kBAAkB,GAAG;gBAEvD,IAAMM,WAAWF,gBAAgBG,WAAW,IACtCC,qBAAqBH,0BAA0BE,WAAW,IAAI,GAAG;gBAEvE,IAAID,aAAaE,oBAAoB;oBACnC,OAAQF;wBACN,KAAKG,kCAAuB;4BAAE;gCAC5B,IAAMC,mBAAmBN,iBACnBO,6BAA6BN,2BAC7BO,2BAA2B,IAAI,CAACC,sBAAsB,CAACH,kBAAkBC,4BAA4BV,SAASC;gCAEpHC,0BAA0BS,0BAA0B,GAAG;gCAEvD;4BACF;wBAEA,KAAKE,6BAAkB;4BAAE;gCACvB,IAAMC,eAAeX,iBACfY,0BAA0BX,2BAC1BY,uBAAuBC,aAAiB,CAACC,kBAAkB,CAACJ,cAAcC,yBAAyBf,SAASC;gCAElHC,0BAA0Bc,sBAAsB,GAAG;gCAEnD;4BACF;wBAEA;4BAAS;gCACPd,0BAA0B,uBAjC9BN,mCAiCoCC,yBAAN,IAAK,aAAuBC,kBAAkBC,kBAAkBC,SAASC;gCAEnG;4BACF;oBACF;gBACF;gBAEA,OAAOC;YACT;;;YAEAU,KAAAA;mBAAAA,SAAAA,uBAAuBH,gBAAgB,EAAEC,0BAA0B,EAAEV,OAAO,EAAEC,WAAW;gBACvF,IAAIU,2BAA2B;gBAE/B,IAAMQ,qBAAqBnB,QAAQoB,YAAY,CAACX;gBAEhD,IAAMY,gBAAgB3B,mBAAmBe,mBACnCa,yBAAyB9B,kBAAkBkB;gBAEjD,IAAIW,kBAAkB,MAAM;oBAC1BrB,QAAQuB,KAAK,CAAC,AAAC,mCAAqD,OAAnBJ,oBAAmB,iBAAeV;gBACrF,OAAO;oBACL,IAAIa,2BAA2B,MAAM;wBACnC,IAAME,+BAA+BxB,QAAQoB,YAAY,CAACV;wBAE1DV,QAAQuB,KAAK,CAAC,AAAC,mCAA+D,OAA7BC,8BAA6B,iBAAef;oBAC/F,OAAO;wBACL,IAAMgB,iCAAiC9B,0BAA0B2B,yBAC3DI,UAAUD,+BAA+BE,UAAU,IACnDC,2BAA4BF,YAAYG,8BAAmB;wBAEjE,IAAI,CAACD,0BAA0B;4BAC7B5B,QAAQuB,KAAK,CAAC,AAAC,mDAAmFG,OAAjCG,8BAAmB,EAAC,eAAqB,OAARH,SAAQ,eAAajB;wBACzH,OAAO;4BACL,IAAMqB,gBAAgB7B;4BAEtBU,2BAA2BmB,eAAe,GAAG;wBAC/C;oBACF;gBACF;gBAEA,OAAOnB;YACT;;;WA1EIf;EAA+BmC,cAAa;AA6ElD,IAAMC,yBAAyB,IAAIpC;IAEnC,WAAeoC"}

package/lib/verifier/nodes/term.js

@@ -136,8 +136,9 @@ var TermNodesVerifier = /*#__PURE__*/ function(NodesVerifier) {
     _create_class(TermNodesVerifier, [
         {
             key: "verifyNonTerminalNode",
-            value: function verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context, verifyAhead) {
+            value: function verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead) {
                 var nonTerminalNodeVerified = false;
+                var nonTerminalNode = nonTerminalNodeA, constructorNonTerminalNode = nonTerminalNodeB; ///
                 var ruleName = nonTerminalNode.getRuleName(), constructorRuleName = constructorNonTerminalNode.getRuleName(); ///
                 if (ruleName === constructorRuleName) {
                     switch(ruleName){
@@ -198,4 +199,4 @@ var TermNodesVerifier = /*#__PURE__*/ function(NodesVerifier) {
 var termNodesVerifier = new TermNodesVerifier();
 var _default = termNodesVerifier;
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verifier/nodes/term.js"],"sourcesContent":["\"use strict\";\n\nimport NodesVerifier from \"../../verifier/nodes\";\n\nimport { first } from \"../../utilities/array\";\nimport { ARGUMENT_RULE_NAME } from \"../../ruleNames\";\nimport { nodeQuery, typeNameFromTypeNode } from \"../../utilities/query\";\n\nconst termNodeQuery = nodeQuery(\"/argument/term!\"),\n      typeNodeQuery = nodeQuery(\"/argument/type!\");\n\nclass TermNodesVerifier extends NodesVerifier {\n  verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context, verifyAhead) {\n    let nonTerminalNodeVerified = false;\n\n    const ruleName = nonTerminalNode.getRuleName(), ///\n          constructorRuleName = constructorNonTerminalNode.getRuleName(); ///\n\n    if (ruleName === constructorRuleName) {\n      switch (ruleName) {\n        case ARGUMENT_RULE_NAME: {\n          const argumentNode = nonTerminalNode, ///\n                constructorArgumentNode = constructorNonTerminalNode, ///\n                argumentNodeVerified = this.verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead);\n\n          nonTerminalNodeVerified = argumentNodeVerified; ///\n\n          break;\n        }\n\n        default: {\n          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context, verifyAhead);\n\n          break;\n        }\n      }\n    }\n\n    return nonTerminalNodeVerified;\n  }\n\n  verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead) {\n    let argumentNodeVerified = false;\n\n    const argumentString = context.nodeAsString(argumentNode);\n\n    const typeNode = typeNodeQuery(argumentNode);\n\n    if (typeNode !== null) {\n      context.debug(`The '${argumentString}' argument should be a term, not a type.`, argumentNode);\n    } else {\n      const termNode = termNodeQuery(argumentNode);\n\n      if (!argumentNodeVerified) {\n        const constructorTermNode = termNodeQuery(constructorArgumentNode);\n\n        if (constructorTermNode !== null) {\n          const node = termNode,  ///\n                constructorNode = constructorTermNode,  ///\n                nodeVerified = this.verifyNode(node, constructorNode, context, verifyAhead);\n\n          argumentNodeVerified = nodeVerified;  ///\n        }\n      }\n\n      if (!argumentNodeVerified) {\n        const constructorTypeNode = typeNodeQuery(constructorArgumentNode);\n\n        if (constructorTypeNode !== null) {\n          const { verifyTerm } = termNodesVerifier,\n                terms = [],\n                termVerified = verifyTerm(termNode, terms, context, () => {\n                  let verifiedAhead = false;\n\n                  const constructorTypeName = typeNameFromTypeNode(constructorTypeNode),\n                        firstTerm = first(terms),\n                        term = firstTerm, ///\n                        termType = term.getType(),\n                        constructorType = context.findTypeByTypeName(constructorTypeName),\n                        termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(constructorType);\n\n                  if (termTypeEqualToOrSubTypeOfType) {\n                    verifiedAhead = verifyAhead();\n                  }\n\n                  return verifiedAhead;\n                });\n\n          argumentNodeVerified = termVerified;  ///\n        }\n      }\n    }\n\n    return argumentNodeVerified;\n  }\n}\n\nconst termNodesVerifier = new TermNodesVerifier();\n\nexport default termNodesVerifier;\n\n"],"names":["termNodeQuery","nodeQuery","typeNodeQuery","TermNodesVerifier","verifyNonTerminalNode","nonTerminalNode","constructorNonTerminalNode","context","verifyAhead","nonTerminalNodeVerified","ruleName","getRuleName","constructorRuleName","ARGUMENT_RULE_NAME","argumentNode","constructorArgumentNode","argumentNodeVerified","verifyArgumentNode","argumentString","nodeAsString","typeNode","debug","termNode","constructorTermNode","node","constructorNode","nodeVerified","verifyNode","constructorTypeNode","verifyTerm","termNodesVerifier","terms","termVerified","verifiedAhead","constructorTypeName","typeNameFromTypeNode","firstTerm","first","term","termType","getType","constructorType","findTypeByTypeName","termTypeEqualToOrSubTypeOfType","isEqualToOrSubTypeOf","NodesVerifier"],"mappings":"AAAA;;;;+BAmGA;;;eAAA;;;4DAjG0B;qBAEJ;yBACa;qBACa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhD,IAAMA,gBAAgBC,IAAAA,gBAAS,EAAC,oBAC1BC,gBAAgBD,IAAAA,gBAAS,EAAC;AAEhC,IAAA,AAAME,kCAAD,AAAL;cAAMA;+BAAAA;aAAAA;gCAAAA;;;kBAAAA;;YACJC,KAAAA;mBAAAA,SAAAA,sBAAsBC,eAAe,EAAEC,0BAA0B,EAAEC,OAAO,EAAEC,WAAW;gBACrF,IAAIC,0BAA0B;gBAE9B,IAAMC,WAAWL,gBAAgBM,WAAW,IACtCC,sBAAsBN,2BAA2BK,WAAW,IAAI,GAAG;gBAEzE,IAAID,aAAaE,qBAAqB;oBACpC,OAAQF;wBACN,KAAKG,6BAAkB;4BAAE;gCACvB,IAAMC,eAAeT,iBACfU,0BAA0BT,4BAC1BU,uBAAuB,IAAI,CAACC,kBAAkB,CAACH,cAAcC,yBAAyBR,SAASC;gCAErGC,0BAA0BO,sBAAsB,GAAG;gCAEnD;4BACF;wBAEA;4BAAS;gCACPP,0BAA0B,uBApB9BN,8BAoBoCC,yBAAN,IAAK,aAAuBC,iBAAiBC,4BAA4BC,SAASC;gCAE5G;4BACF;oBACF;gBACF;gBAEA,OAAOC;YACT;;;YAEAQ,KAAAA;mBAAAA,SAAAA,mBAAmBH,YAAY,EAAEC,uBAAuB,EAAER,OAAO,EAAEC,WAAW;gBAC5E,IAAIQ,uBAAuB;gBAE3B,IAAME,iBAAiBX,QAAQY,YAAY,CAACL;gBAE5C,IAAMM,WAAWlB,cAAcY;gBAE/B,IAAIM,aAAa,MAAM;oBACrBb,QAAQc,KAAK,CAAC,AAAC,QAAsB,OAAfH,gBAAe,6CAA2CJ;gBAClF,OAAO;oBACL,IAAMQ,WAAWtB,cAAcc;oBAE/B,IAAI,CAACE,sBAAsB;wBACzB,IAAMO,sBAAsBvB,cAAce;wBAE1C,IAAIQ,wBAAwB,MAAM;4BAChC,IAAMC,OAAOF,UACPG,kBAAkBF,qBAClBG,eAAe,IAAI,CAACC,UAAU,CAACH,MAAMC,iBAAiBlB,SAASC;4BAErEQ,uBAAuBU,cAAe,GAAG;wBAC3C;oBACF;oBAEA,IAAI,CAACV,sBAAsB;wBACzB,IAAMY,sBAAsB1B,cAAca;wBAE1C,IAAIa,wBAAwB,MAAM;4BAChC,IAAM,AAAEC,aAAeC,kBAAfD,YACFE,QAAQ,EAAE,EACVC,eAAeH,WAAWP,UAAUS,OAAOxB,SAAS;gCAClD,IAAI0B,gBAAgB;gCAEpB,IAAMC,sBAAsBC,IAAAA,2BAAoB,EAACP,sBAC3CQ,YAAYC,IAAAA,YAAK,EAACN,QAClBO,OAAOF,WACPG,WAAWD,KAAKE,OAAO,IACvBC,kBAAkBlC,QAAQmC,kBAAkB,CAACR,sBAC7CS,iCAAiCJ,SAASK,oBAAoB,CAACH;gCAErE,IAAIE,gCAAgC;oCAClCV,gBAAgBzB;gCAClB;gCAEA,OAAOyB;4BACT;4BAENjB,uBAAuBgB,cAAe,GAAG;wBAC3C;oBACF;gBACF;gBAEA,OAAOhB;YACT;;;WAnFIb;EAA0B0C,cAAa;AAsF7C,IAAMf,oBAAoB,IAAI3B;IAE9B,WAAe2B"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verifier/nodes/term.js"],"sourcesContent":["\"use strict\";\n\nimport NodesVerifier from \"../../verifier/nodes\";\n\nimport { first } from \"../../utilities/array\";\nimport { ARGUMENT_RULE_NAME } from \"../../ruleNames\";\nimport { nodeQuery, typeNameFromTypeNode } from \"../../utilities/query\";\n\nconst termNodeQuery = nodeQuery(\"/argument/term!\"),\n      typeNodeQuery = nodeQuery(\"/argument/type!\");\n\nclass TermNodesVerifier extends NodesVerifier {\n  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead) {\n    let nonTerminalNodeVerified = false;\n\n    const nonTerminalNode = nonTerminalNodeA, ///\n          constructorNonTerminalNode = nonTerminalNodeB; ///\n\n    const ruleName = nonTerminalNode.getRuleName(), ///\n          constructorRuleName = constructorNonTerminalNode.getRuleName(); ///\n\n    if (ruleName === constructorRuleName) {\n      switch (ruleName) {\n        case ARGUMENT_RULE_NAME: {\n          const argumentNode = nonTerminalNode, ///\n                constructorArgumentNode = constructorNonTerminalNode, ///\n                argumentNodeVerified = this.verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead);\n\n          nonTerminalNodeVerified = argumentNodeVerified; ///\n\n          break;\n        }\n\n        default: {\n          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context, verifyAhead);\n\n          break;\n        }\n      }\n    }\n\n    return nonTerminalNodeVerified;\n  }\n\n  verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead) {\n    let argumentNodeVerified = false;\n\n    const argumentString = context.nodeAsString(argumentNode);\n\n    const typeNode = typeNodeQuery(argumentNode);\n\n    if (typeNode !== null) {\n      context.debug(`The '${argumentString}' argument should be a term, not a type.`, argumentNode);\n    } else {\n      const termNode = termNodeQuery(argumentNode);\n\n      if (!argumentNodeVerified) {\n        const constructorTermNode = termNodeQuery(constructorArgumentNode);\n\n        if (constructorTermNode !== null) {\n          const node = termNode,  ///\n                constructorNode = constructorTermNode,  ///\n                nodeVerified = this.verifyNode(node, constructorNode, context, verifyAhead);\n\n          argumentNodeVerified = nodeVerified;  ///\n        }\n      }\n\n      if (!argumentNodeVerified) {\n        const constructorTypeNode = typeNodeQuery(constructorArgumentNode);\n\n        if (constructorTypeNode !== null) {\n          const { verifyTerm } = termNodesVerifier,\n                terms = [],\n                termVerified = verifyTerm(termNode, terms, context, () => {\n                  let verifiedAhead = false;\n\n                  const constructorTypeName = typeNameFromTypeNode(constructorTypeNode),\n                        firstTerm = first(terms),\n                        term = firstTerm, ///\n                        termType = term.getType(),\n                        constructorType = context.findTypeByTypeName(constructorTypeName),\n                        termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(constructorType);\n\n                  if (termTypeEqualToOrSubTypeOfType) {\n                    verifiedAhead = verifyAhead();\n                  }\n\n                  return verifiedAhead;\n                });\n\n          argumentNodeVerified = termVerified;  ///\n        }\n      }\n    }\n\n    return argumentNodeVerified;\n  }\n}\n\nconst termNodesVerifier = new TermNodesVerifier();\n\nexport default termNodesVerifier;\n\n"],"names":["termNodeQuery","nodeQuery","typeNodeQuery","TermNodesVerifier","verifyNonTerminalNode","nonTerminalNodeA","nonTerminalNodeB","context","verifyAhead","nonTerminalNodeVerified","nonTerminalNode","constructorNonTerminalNode","ruleName","getRuleName","constructorRuleName","ARGUMENT_RULE_NAME","argumentNode","constructorArgumentNode","argumentNodeVerified","verifyArgumentNode","argumentString","nodeAsString","typeNode","debug","termNode","constructorTermNode","node","constructorNode","nodeVerified","verifyNode","constructorTypeNode","verifyTerm","termNodesVerifier","terms","termVerified","verifiedAhead","constructorTypeName","typeNameFromTypeNode","firstTerm","first","term","termType","getType","constructorType","findTypeByTypeName","termTypeEqualToOrSubTypeOfType","isEqualToOrSubTypeOf","NodesVerifier"],"mappings":"AAAA;;;;+BAsGA;;;eAAA;;;4DApG0B;qBAEJ;yBACa;qBACa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhD,IAAMA,gBAAgBC,IAAAA,gBAAS,EAAC,oBAC1BC,gBAAgBD,IAAAA,gBAAS,EAAC;AAEhC,IAAA,AAAME,kCAAD,AAAL;cAAMA;+BAAAA;aAAAA;gCAAAA;;;kBAAAA;;YACJC,KAAAA;mBAAAA,SAAAA,sBAAsBC,gBAAgB,EAAEC,gBAAgB,EAAEC,OAAO,EAAEC,WAAW;gBAC5E,IAAIC,0BAA0B;gBAE9B,IAAMC,kBAAkBL,kBAClBM,6BAA6BL,kBAAkB,GAAG;gBAExD,IAAMM,WAAWF,gBAAgBG,WAAW,IACtCC,sBAAsBH,2BAA2BE,WAAW,IAAI,GAAG;gBAEzE,IAAID,aAAaE,qBAAqB;oBACpC,OAAQF;wBACN,KAAKG,6BAAkB;4BAAE;gCACvB,IAAMC,eAAeN,iBACfO,0BAA0BN,4BAC1BO,uBAAuB,IAAI,CAACC,kBAAkB,CAACH,cAAcC,yBAAyBV,SAASC;gCAErGC,0BAA0BS,sBAAsB,GAAG;gCAEnD;4BACF;wBAEA;4BAAS;gCACPT,0BAA0B,uBAvB9BN,8BAuBoCC,yBAAN,IAAK,aAAuBM,iBAAiBC,4BAA4BJ,SAASC;gCAE5G;4BACF;oBACF;gBACF;gBAEA,OAAOC;YACT;;;YAEAU,KAAAA;mBAAAA,SAAAA,mBAAmBH,YAAY,EAAEC,uBAAuB,EAAEV,OAAO,EAAEC,WAAW;gBAC5E,IAAIU,uBAAuB;gBAE3B,IAAME,iBAAiBb,QAAQc,YAAY,CAACL;gBAE5C,IAAMM,WAAWpB,cAAcc;gBAE/B,IAAIM,aAAa,MAAM;oBACrBf,QAAQgB,KAAK,CAAC,AAAC,QAAsB,OAAfH,gBAAe,6CAA2CJ;gBAClF,OAAO;oBACL,IAAMQ,WAAWxB,cAAcgB;oBAE/B,IAAI,CAACE,sBAAsB;wBACzB,IAAMO,sBAAsBzB,cAAciB;wBAE1C,IAAIQ,wBAAwB,MAAM;4BAChC,IAAMC,OAAOF,UACPG,kBAAkBF,qBAClBG,eAAe,IAAI,CAACC,UAAU,CAACH,MAAMC,iBAAiBpB,SAASC;4BAErEU,uBAAuBU,cAAe,GAAG;wBAC3C;oBACF;oBAEA,IAAI,CAACV,sBAAsB;wBACzB,IAAMY,sBAAsB5B,cAAce;wBAE1C,IAAIa,wBAAwB,MAAM;4BAChC,IAAM,AAAEC,aAAeC,kBAAfD,YACFE,QAAQ,EAAE,EACVC,eAAeH,WAAWP,UAAUS,OAAO1B,SAAS;gCAClD,IAAI4B,gBAAgB;gCAEpB,IAAMC,sBAAsBC,IAAAA,2BAAoB,EAACP,sBAC3CQ,YAAYC,IAAAA,YAAK,EAACN,QAClBO,OAAOF,WACPG,WAAWD,KAAKE,OAAO,IACvBC,kBAAkBpC,QAAQqC,kBAAkB,CAACR,sBAC7CS,iCAAiCJ,SAASK,oBAAoB,CAACH;gCAErE,IAAIE,gCAAgC;oCAClCV,gBAAgB3B;gCAClB;gCAEA,OAAO2B;4BACT;4BAENjB,uBAAuBgB,cAAe,GAAG;wBAC3C;oBACF;gBACF;gBAEA,OAAOhB;YACT;;;WAtFIf;EAA0B4C,cAAa;AAyF7C,IAAMf,oBAAoB,IAAI7B;IAE9B,WAAe6B"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.834",
+  "version": "0.0.835",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,7 +12,7 @@
   "dependencies": {
     "argumentative": "^2.0.28",
     "necessary": "^14.0.1",
-    "occam-custom-grammars": "^5.0.732",
+    "occam-custom-grammars": "^5.0.734",
     "occam-entities": "^1.0.125",
     "occam-file-system": "^6.0.167",
     "occam-grammar-utilities": "^8.0.201",

package/src/conclusion.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import statementForMetavariableNodesVerifier from "./verifier/nodes/statementForMetavariable";
-import metastatementForMetavariableNodesVerifier from "./verifier/nodes/metastatementForMetavariable";
+import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
+import metaLevelToIntrinsicLevelNodesVerifier from "./verifier/nodes/metaLevelToIntrinsicLevel";
 
 import { nodeAsString } from "./utilities/string";
 import { metastatementNodeFromMetastatementString } from "./utilities/node";
@@ -20,7 +20,7 @@ export default class Conclusion {
           nonTerminalNodeB = statementNode,  ///
           fileContextA = fileContext, ///
           localContextB = statementLocalContext,  ///
-          nonTerminalNodeVerified = statementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
+          nonTerminalNodeVerified = metaLevelToIntrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
             const verifyAhead = true;
 
             return verifyAhead;
@@ -35,7 +35,7 @@ export default class Conclusion {
           nonTerminalNodeB = metastatementNode,  ///
           fileContextA = fileContext, ///
           localMetaContextB = metastatementLocalMetaContext,  ///
-          nonTerminalNodeVerified = metastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, () => {
+          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/consequent.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import termForVariableNodesVerifier from "./verifier/nodes/termForVariable";
+import intrinsicLevelNodesVerifier from "./verifier/nodes/intrinsicLevel";
 
 import { nodeAsString } from "./utilities/string";
 import { statementNodeFromStatementString } from "./utilities/node";
@@ -19,7 +19,7 @@ export default class Consequent {
           nonTerminalNodeB = statementNode,  ///
           localContextA = localContext, ///
           localContextB = statementLocalContext, ///
-          nonTerminalNodeVerified = termForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+          nonTerminalNodeVerified = intrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;