occam-verify-cli 0.0.844 → 0.0.846

package/lib/verifier/nodes/statementAgainstCombinator.js

@@ -137,26 +137,26 @@ var StatementAgainstCombinatorNodesVerifier = /*#__PURE__*/ function(NodesVerifi
     _create_class(StatementAgainstCombinatorNodesVerifier, [
         {
             key: "verifyNonTerminalNode",
-            value: function verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead) {
+            value: function verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {
                 var nonTerminalNodeVerified = false;
                 var nonTerminalNode = nonTerminalNodeA, combinatorNonTerminalNode = nonTerminalNodeB, ruleName = nonTerminalNode.getRuleName(), combinatorRuleName = combinatorNonTerminalNode.getRuleName(); ///
                 if (ruleName === combinatorRuleName) {
                     switch(ruleName){
                         case _ruleNames.META_ARGUMENT_RULE_NAME:
                             {
-                                var metaArgumentNode = nonTerminalNode, combinatorMetaargumentNode = combinatorNonTerminalNode, metaArgumentNodeVerified = this.verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead);
+                                var metaArgumentNode = nonTerminalNode, combinatorMetaargumentNode = combinatorNonTerminalNode, metaArgumentNodeVerified = this.verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, localContext, verifyAhead);
                                 nonTerminalNodeVerified = metaArgumentNodeVerified; ///
                                 break;
                             }
                         case _ruleNames.ARGUMENT_RULE_NAME:
                             {
-                                var argumentNode = nonTerminalNode, constructorArgumentNode = combinatorNonTerminalNode, argumentNodeVerified = _termAgainstConstructor.default.verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead);
+                                var argumentNode = nonTerminalNode, constructorArgumentNode = combinatorNonTerminalNode, argumentNodeVerified = _termAgainstConstructor.default.verifyArgumentNode(argumentNode, constructorArgumentNode, localContext, verifyAhead);
                                 nonTerminalNodeVerified = argumentNodeVerified; ///
                                 break;
                             }
                         default:
                             {
-                                nonTerminalNodeVerified = _get(_get_prototype_of(StatementAgainstCombinatorNodesVerifier.prototype), "verifyNonTerminalNode", this).call(this, nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead);
+                                nonTerminalNodeVerified = _get(_get_prototype_of(StatementAgainstCombinatorNodesVerifier.prototype), "verifyNonTerminalNode", this).call(this, nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
                                 break;
                             }
                     }
@@ -166,20 +166,20 @@ var StatementAgainstCombinatorNodesVerifier = /*#__PURE__*/ function(NodesVerifi
         },
         {
             key: "verifyMetaargumentNode",
-            value: function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead) {
+            value: function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, localContext, verifyAhead) {
                 var metaArgumentNodeVerified = false;
-                var metaArgumentString = context.nodeAsString(metaArgumentNode);
+                var metaArgumentString = localContext.nodeAsString(metaArgumentNode);
                 var statementNode = statementNodeQuery(metaArgumentNode), combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
                 if (statementNode === null) {
-                    context.debug("Expected a statement but got a '".concat(metaArgumentString, "' meta-type."), metaArgumentNode);
+                    localContext.debug("Expected a statement but got a '".concat(metaArgumentString, "' meta-type."), metaArgumentNode);
                 } else {
                     if (combinatorMetaTYpeNode === null) {
-                        var combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
-                        context.debug("Expected a meta-type but got a '".concat(combinatorMetaargumentString, "' statement."), metaArgumentNode);
+                        var combinatorMetaargumentString = localContext.nodeAsString(combinatorMetaargumentNode);
+                        localContext.debug("Expected a meta-type but got a '".concat(combinatorMetaargumentString, "' statement."), metaArgumentNode);
                     } else {
                         var combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode), content = combinatorMetaTypeTerminalNode.getContent(), contentStatementMetaType = content === _metaTypes.STATEMENT_META_TYPE;
                         if (!contentStatementMetaType) {
-                            context.debug("Expected the meta-type of the combinator to be '".concat(_metaTypes.STATEMENT_META_TYPE, "' but got '").concat(content, "' instead."), metaArgumentNode);
+                            localContext.debug("Expected the meta-type of the combinator to be '".concat(_metaTypes.STATEMENT_META_TYPE, "' but got '").concat(content, "' instead."), metaArgumentNode);
                         } else {
                             var verifiedAhead = verifyAhead();
                             metaArgumentNodeVerified = verifiedAhead; ///
@@ -195,4 +195,4 @@ var StatementAgainstCombinatorNodesVerifier = /*#__PURE__*/ function(NodesVerifi
 var statementAgainstCombinatorNodesVerifier = new StatementAgainstCombinatorNodesVerifier();
 var _default = statementAgainstCombinatorNodesVerifier;
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verifier/nodes/statementAgainstCombinator.js"],"sourcesContent":["\"use strict\";\n\nimport NodesVerifier from \"../../verifier/nodes\";\nimport termAgainstConstructorNodesVerifier from \"../../verifier/nodes/termAgainstConstructor\";\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 StatementAgainstCombinatorNodesVerifier extends NodesVerifier {\n  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead) {\n    let nonTerminalNodeVerified = false;\n\n    const nonTerminalNode = nonTerminalNodeA, ///\n          combinatorNonTerminalNode = nonTerminalNodeB, ///\n          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 = termAgainstConstructorNodesVerifier.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 statementAgainstCombinatorNodesVerifier = new StatementAgainstCombinatorNodesVerifier();\n\nexport default statementAgainstCombinatorNodesVerifier;\n"],"names":["metaTypeNodeQuery","nodeQuery","statementNodeQuery","metaTypeTerminalNodeQuery","StatementAgainstCombinatorNodesVerifier","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","termAgainstConstructorNodesVerifier","verifyArgumentNode","metaArgumentString","nodeAsString","statementNode","combinatorMetaTYpeNode","debug","combinatorMetaargumentString","combinatorMetaTypeTerminalNode","content","getContent","contentStatementMetaType","STATEMENT_META_TYPE","verifiedAhead","NodesVerifier","statementAgainstCombinatorNodesVerifier"],"mappings":"AAAA;;;;+BA2FA;;;eAAA;;;4DAzF0B;6EACsB;qBAEtB;yBACU;yBACwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE5D,IAAMA,oBAAoBC,IAAAA,gBAAS,EAAC,4BAC9BC,qBAAqBD,IAAAA,gBAAS,EAAC,6BAC/BE,4BAA4BF,IAAAA,gBAAS,EAAC;AAE5C,IAAA,AAAMG,wDAAD,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,kBAC5BM,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,+BAAmC,CAACC,kBAAkB,CAACJ,cAAcC,yBAAyBf,SAASC;gCAEpIC,0BAA0Bc,sBAAsB,GAAG;gCAEnD;4BACF;wBAEA;4BAAS;gCACPd,0BAA0B,uBAhC9BN,oDAgCoCC,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;;;WAzEIf;EAAgDmC,cAAa;AA4EnE,IAAMC,0CAA0C,IAAIpC;IAEpD,WAAeoC"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verifier/nodes/statementAgainstCombinator.js"],"sourcesContent":["\"use strict\";\n\nimport NodesVerifier from \"../../verifier/nodes\";\nimport termAgainstConstructorNodesVerifier from \"../../verifier/nodes/termAgainstConstructor\";\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 StatementAgainstCombinatorNodesVerifier extends NodesVerifier {\n  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {\n    let nonTerminalNodeVerified = false;\n\n    const nonTerminalNode = nonTerminalNodeA, ///\n          combinatorNonTerminalNode = nonTerminalNodeB, ///\n          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, localContext, verifyAhead);\n\n          nonTerminalNodeVerified = metaArgumentNodeVerified; ///\n\n          break;\n        }\n\n        case ARGUMENT_RULE_NAME: {\n          const argumentNode = nonTerminalNode, ///\n                constructorArgumentNode = combinatorNonTerminalNode, ///\n                argumentNodeVerified = termAgainstConstructorNodesVerifier.verifyArgumentNode(argumentNode, constructorArgumentNode, localContext, verifyAhead);\n\n          nonTerminalNodeVerified = argumentNodeVerified; ///\n\n          break;\n        }\n\n        default: {\n          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);\n\n          break;\n        }\n      }\n    }\n\n    return nonTerminalNodeVerified;\n  }\n\n  verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, localContext, verifyAhead) {\n    let metaArgumentNodeVerified = false;\n\n    const metaArgumentString = localContext.nodeAsString(metaArgumentNode);\n\n    const statementNode = statementNodeQuery(metaArgumentNode),\n          combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);\n\n    if (statementNode === null) {\n      localContext.debug(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);\n    } else {\n      if (combinatorMetaTYpeNode === null) {\n        const combinatorMetaargumentString = localContext.nodeAsString(combinatorMetaargumentNode);\n\n        localContext.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          localContext.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 statementAgainstCombinatorNodesVerifier = new StatementAgainstCombinatorNodesVerifier();\n\nexport default statementAgainstCombinatorNodesVerifier;\n"],"names":["metaTypeNodeQuery","nodeQuery","statementNodeQuery","metaTypeTerminalNodeQuery","StatementAgainstCombinatorNodesVerifier","verifyNonTerminalNode","nonTerminalNodeA","nonTerminalNodeB","localContext","verifyAhead","nonTerminalNodeVerified","nonTerminalNode","combinatorNonTerminalNode","ruleName","getRuleName","combinatorRuleName","META_ARGUMENT_RULE_NAME","metaArgumentNode","combinatorMetaargumentNode","metaArgumentNodeVerified","verifyMetaargumentNode","ARGUMENT_RULE_NAME","argumentNode","constructorArgumentNode","argumentNodeVerified","termAgainstConstructorNodesVerifier","verifyArgumentNode","metaArgumentString","nodeAsString","statementNode","combinatorMetaTYpeNode","debug","combinatorMetaargumentString","combinatorMetaTypeTerminalNode","content","getContent","contentStatementMetaType","STATEMENT_META_TYPE","verifiedAhead","NodesVerifier","statementAgainstCombinatorNodesVerifier"],"mappings":"AAAA;;;;+BA2FA;;;eAAA;;;4DAzF0B;6EACsB;qBAEtB;yBACU;yBACwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE5D,IAAMA,oBAAoBC,IAAAA,gBAAS,EAAC,4BAC9BC,qBAAqBD,IAAAA,gBAAS,EAAC,6BAC/BE,4BAA4BF,IAAAA,gBAAS,EAAC;AAE5C,IAAA,AAAMG,wDAAD,AAAL;cAAMA;+BAAAA;aAAAA;gCAAAA;;;kBAAAA;;YACJC,KAAAA;mBAAAA,SAAAA,sBAAsBC,gBAAgB,EAAEC,gBAAgB,EAAEC,YAAY,EAAEC,WAAW;gBACjF,IAAIC,0BAA0B;gBAE9B,IAAMC,kBAAkBL,kBAClBM,4BAA4BL,kBAC5BM,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,cAAcC;gCAEzHC,0BAA0BS,0BAA0B,GAAG;gCAEvD;4BACF;wBAEA,KAAKE,6BAAkB;4BAAE;gCACvB,IAAMC,eAAeX,iBACfY,0BAA0BX,2BAC1BY,uBAAuBC,+BAAmC,CAACC,kBAAkB,CAACJ,cAAcC,yBAAyBf,cAAcC;gCAEzIC,0BAA0Bc,sBAAsB,GAAG;gCAEnD;4BACF;wBAEA;4BAAS;gCACPd,0BAA0B,uBAhC9BN,oDAgCoCC,yBAAN,IAAK,aAAuBC,kBAAkBC,kBAAkBC,cAAcC;gCAExG;4BACF;oBACF;gBACF;gBAEA,OAAOC;YACT;;;YAEAU,KAAAA;mBAAAA,SAAAA,uBAAuBH,gBAAgB,EAAEC,0BAA0B,EAAEV,YAAY,EAAEC,WAAW;gBAC5F,IAAIU,2BAA2B;gBAE/B,IAAMQ,qBAAqBnB,aAAaoB,YAAY,CAACX;gBAErD,IAAMY,gBAAgB3B,mBAAmBe,mBACnCa,yBAAyB9B,kBAAkBkB;gBAEjD,IAAIW,kBAAkB,MAAM;oBAC1BrB,aAAauB,KAAK,CAAC,AAAC,mCAAqD,OAAnBJ,oBAAmB,iBAAeV;gBAC1F,OAAO;oBACL,IAAIa,2BAA2B,MAAM;wBACnC,IAAME,+BAA+BxB,aAAaoB,YAAY,CAACV;wBAE/DV,aAAauB,KAAK,CAAC,AAAC,mCAA+D,OAA7BC,8BAA6B,iBAAef;oBACpG,OAAO;wBACL,IAAMgB,iCAAiC9B,0BAA0B2B,yBAC3DI,UAAUD,+BAA+BE,UAAU,IACnDC,2BAA4BF,YAAYG,8BAAmB;wBAEjE,IAAI,CAACD,0BAA0B;4BAC7B5B,aAAauB,KAAK,CAAC,AAAC,mDAAmFG,OAAjCG,8BAAmB,EAAC,eAAqB,OAARH,SAAQ,eAAajB;wBAC9H,OAAO;4BACL,IAAMqB,gBAAgB7B;4BAEtBU,2BAA2BmB,eAAe,GAAG;wBAC/C;oBACF;gBACF;gBAEA,OAAOnB;YACT;;;WAzEIf;EAAgDmC,cAAa;AA4EnE,IAAMC,0CAA0C,IAAIpC;IAEpD,WAAeoC"}

package/lib/verifier/nodes/substitution.js

@@ -0,0 +1,223 @@
+"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 _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 variableNodeQuery = (0, _query.nodeQuery)("/term/variable");
+var SubstitutionNodesVerifier = /*#__PURE__*/ function(NodesVerifier) {
+    _inherits(SubstitutionNodesVerifier, NodesVerifier);
+    var _super = _create_super(SubstitutionNodesVerifier);
+    function SubstitutionNodesVerifier() {
+        _class_call_check(this, SubstitutionNodesVerifier);
+        return _super.apply(this, arguments);
+    }
+    _create_class(SubstitutionNodesVerifier, [
+        {
+            key: "verifyNonTerminalNode",
+            value: function verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+                var nonTerminalNodeVerified = false;
+                var nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
+                if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+                    var ruleName = nonTerminalNodeARuleName; ///
+                    switch(ruleName){
+                        case _ruleNames.TERM_RULE_NAME:
+                            {
+                                var termNodeA = nonTerminalNodeA, termNodeB = nonTerminalNodeB, termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
+                                nonTerminalNodeVerified = termNodeVerified; ///
+                                break;
+                            }
+                        default:
+                            {
+                                nonTerminalNodeVerified = _get(_get_prototype_of(SubstitutionNodesVerifier.prototype), "verifyNonTerminalNode", this).call(this, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+                                break;
+                            }
+                    }
+                }
+                return nonTerminalNodeVerified;
+            }
+        },
+        {
+            key: "verifyTermNode",
+            value: function verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+                var termNodeVerified;
+                var variableNodeA = variableNodeQuery(termNodeA);
+                if (variableNodeA !== null) {
+                    var variableNodeVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
+                    termNodeVerified = variableNodeVerified; ///
+                } else {
+                    var nonTerminalNodeA = termNodeA, nonTerminalNodeB = termNodeB, nonTerminalNodeVerified = _get(_get_prototype_of(SubstitutionNodesVerifier.prototype), "verifyNonTerminalNode", this).call(this, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+                    termNodeVerified = nonTerminalNodeVerified; ///
+                }
+                return termNodeVerified;
+            }
+        },
+        {
+            key: "verifyVariableNode",
+            value: function verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+                var variableNodeVerified = false;
+                if (variableNodeVerified === false) {
+                    var variableNodeB = variableNodeQuery(termNodeB);
+                    if (variableNodeB !== null) {
+                        var variableNodeAMatchedVariableNodeB = variableNodeA.match(variableNodeB);
+                        if (variableNodeAMatchedVariableNodeB) {
+                            var verifiedAhead = verifyAhead();
+                            variableNodeVerified = verifiedAhead; ///
+                        }
+                    }
+                }
+                if (variableNodeVerified === false) {
+                    var variableNode = variableNodeA, substitution = substitutions.find(function(substitution) {
+                        var matches = substitution.matchVariableNode(variableNode);
+                        if (matches) {
+                            return true;
+                        }
+                    }) || null;
+                    if (substitution !== null) {
+                        var termNode = termNodeB, termNodeMatches = substitution.matchTermNode(termNode);
+                        if (termNodeMatches) {
+                            var verifiedAhead1 = verifyAhead();
+                            variableNodeVerified = verifiedAhead1; ///
+                        }
+                    } else {
+                        var verifiedAhead2;
+                        var termNode1 = termNodeB, termForVariableSubstitution = _termForVariable.default.fromVariableNodeAndTermNode(variableNode, termNode1), substitution1 = termForVariableSubstitution; ///
+                        substitutions.push(substitution1);
+                        verifiedAhead2 = verifyAhead();
+                        if (!verifiedAhead2) {
+                            substitutions.pop();
+                        }
+                        variableNodeVerified = verifiedAhead2; ///
+                    }
+                }
+                return variableNodeVerified;
+            }
+        }
+    ]);
+    return SubstitutionNodesVerifier;
+}(_nodes.default);
+var substitutionNodesVerifier = new SubstitutionNodesVerifier();
+var _default = substitutionNodesVerifier;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verifier/nodes/substitution.js"],"sourcesContent":["\"use strict\";\n\nimport NodesVerifier from \"../../verifier/nodes\";\n\nimport TermForVariableSubstitution from \"../../substitution/termForVariable\";\n\nimport { nodeQuery } from \"../../utilities/query\";\nimport { TERM_RULE_NAME } from \"../../ruleNames\";\n\nconst variableNodeQuery = nodeQuery(\"/term/variable\");\n\nclass SubstitutionNodesVerifier extends NodesVerifier {\n  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, 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 TERM_RULE_NAME: {\n          const termNodeA = nonTerminalNodeA, ///\n                termNodeB = nonTerminalNodeB, ///\n                termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);\n\n          nonTerminalNodeVerified = termNodeVerified; ///\n\n          break;\n        }\n\n        default: {\n          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);\n\n          break;\n        }\n      }\n    }\n\n    return nonTerminalNodeVerified;\n  }\n\n  verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {\n    let termNodeVerified;\n\n    const variableNodeA = variableNodeQuery(termNodeA);\n\n    if (variableNodeA !== null) {\n      const variableNodeVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);\n\n      termNodeVerified = variableNodeVerified; ///\n    } else {\n      const nonTerminalNodeA = termNodeA, ///\n            nonTerminalNodeB = termNodeB, ///\n            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);\n\n      termNodeVerified = nonTerminalNodeVerified; ///\n    }\n\n    return termNodeVerified;\n  }\n\n  verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {\n    let variableNodeVerified = false;\n\n    if (variableNodeVerified === false) {\n      const variableNodeB = variableNodeQuery(termNodeB);\n\n      if (variableNodeB !== null) {\n        const variableNodeAMatchedVariableNodeB = variableNodeA.match(variableNodeB);\n\n        if (variableNodeAMatchedVariableNodeB) {\n          const verifiedAhead = verifyAhead();\n\n          variableNodeVerified = verifiedAhead; ///\n        }\n      }\n    }\n\n    if (variableNodeVerified === false) {\n      const variableNode = variableNodeA,\n            substitution = substitutions.find((substitution) => {\n              const matches = substitution.matchVariableNode(variableNode);\n\n              if (matches) {\n                return true;\n              }\n            }) || null;\n\n      if (substitution !== null) {\n        const termNode = termNodeB, ///\n              termNodeMatches = substitution.matchTermNode(termNode);\n\n        if (termNodeMatches) {\n          const verifiedAhead = verifyAhead();\n\n          variableNodeVerified = verifiedAhead;  ///\n        }\n      } else {\n        let verifiedAhead;\n\n        const termNode = termNodeB, ///\n              termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),\n              substitution = termForVariableSubstitution; ///\n\n        substitutions.push(substitution);\n\n        verifiedAhead = verifyAhead();\n\n        if (!verifiedAhead) {\n          substitutions.pop();\n        }\n\n        variableNodeVerified = verifiedAhead; ///\n      }\n    }\n\n    return variableNodeVerified;\n  }\n}\n\nconst substitutionNodesVerifier = new SubstitutionNodesVerifier();\n\nexport default substitutionNodesVerifier;\n"],"names":["variableNodeQuery","nodeQuery","SubstitutionNodesVerifier","verifyNonTerminalNode","nonTerminalNodeA","nonTerminalNodeB","substitutions","localContextA","localContextB","verifyAhead","nonTerminalNodeVerified","nonTerminalNodeARuleName","getRuleName","nonTerminalNodeBRuleName","ruleName","TERM_RULE_NAME","termNodeA","termNodeB","termNodeVerified","verifyTermNode","variableNodeA","variableNodeVerified","verifyVariableNode","variableNodeB","variableNodeAMatchedVariableNodeB","match","verifiedAhead","variableNode","substitution","find","matches","matchVariableNode","termNode","termNodeMatches","matchTermNode","termForVariableSubstitution","TermForVariableSubstitution","fromVariableNodeAndTermNode","push","pop","NodesVerifier","substitutionNodesVerifier"],"mappings":"AAAA;;;;+BA4HA;;;eAAA;;;4DA1H0B;sEAEc;qBAEd;yBACK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE/B,IAAMA,oBAAoBC,IAAAA,gBAAS,EAAC;AAEpC,IAAA,AAAMC,0CAAD,AAAL;cAAMA;+BAAAA;aAAAA;gCAAAA;;;kBAAAA;;YACJC,KAAAA;mBAAAA,SAAAA,sBAAsBC,gBAAgB,EAAEC,gBAAgB,EAAEC,aAAa,EAAEC,aAAa,EAAEC,aAAa,EAAEC,WAAW;gBAChH,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,yBAAc;4BAAE;gCACnB,IAAMC,YAAYZ,kBACZa,YAAYZ,kBACZa,mBAAmB,IAAI,CAACC,cAAc,CAACH,WAAWC,WAAWX,eAAeC,eAAeC,eAAeC;gCAEhHC,0BAA0BQ,kBAAkB,GAAG;gCAE/C;4BACF;wBAEA;4BAAS;gCACPR,0BAA0B,uBAtB9BR,sCAsBoCC,yBAAN,IAAK,aAAuBC,kBAAkBC,kBAAkBC,eAAeC,eAAeC,eAAeC;gCAEvI;4BACF;oBACF;gBACF;gBAEA,OAAOC;YACT;;;YAEAS,KAAAA;mBAAAA,SAAAA,eAAeH,SAAS,EAAEC,SAAS,EAAEX,aAAa,EAAEC,aAAa,EAAEC,aAAa,EAAEC,WAAW;gBAC3F,IAAIS;gBAEJ,IAAME,gBAAgBpB,kBAAkBgB;gBAExC,IAAII,kBAAkB,MAAM;oBAC1B,IAAMC,uBAAuB,IAAI,CAACC,kBAAkB,CAACF,eAAeH,WAAWX,eAAeC,eAAeC,eAAeC;oBAE5HS,mBAAmBG,sBAAsB,GAAG;gBAC9C,OAAO;oBACL,IAAMjB,mBAAmBY,WACnBX,mBAAmBY,WACnBP,0BAA0B,uBA5ChCR,sCA4CsCC,yBAAN,IAAK,aAAuBC,kBAAkBC,kBAAkBC,eAAeC,eAAeC,eAAeC;oBAE7IS,mBAAmBR,yBAAyB,GAAG;gBACjD;gBAEA,OAAOQ;YACT;;;YAEAI,KAAAA;mBAAAA,SAAAA,mBAAmBF,aAAa,EAAEH,SAAS,EAAEX,aAAa,EAAEC,aAAa,EAAEC,aAAa,EAAEC,WAAW;gBACnG,IAAIY,uBAAuB;gBAE3B,IAAIA,yBAAyB,OAAO;oBAClC,IAAME,gBAAgBvB,kBAAkBiB;oBAExC,IAAIM,kBAAkB,MAAM;wBAC1B,IAAMC,oCAAoCJ,cAAcK,KAAK,CAACF;wBAE9D,IAAIC,mCAAmC;4BACrC,IAAME,gBAAgBjB;4BAEtBY,uBAAuBK,eAAe,GAAG;wBAC3C;oBACF;gBACF;gBAEA,IAAIL,yBAAyB,OAAO;oBAClC,IAAMM,eAAeP,eACfQ,eAAetB,cAAcuB,IAAI,CAAC,SAACD;wBACjC,IAAME,UAAUF,aAAaG,iBAAiB,CAACJ;wBAE/C,IAAIG,SAAS;4BACX,OAAO;wBACT;oBACF,MAAM;oBAEZ,IAAIF,iBAAiB,MAAM;wBACzB,IAAMI,WAAWf,WACXgB,kBAAkBL,aAAaM,aAAa,CAACF;wBAEnD,IAAIC,iBAAiB;4BACnB,IAAMP,iBAAgBjB;4BAEtBY,uBAAuBK,gBAAgB,GAAG;wBAC5C;oBACF,OAAO;wBACL,IAAIA;wBAEJ,IAAMM,YAAWf,WACXkB,8BAA8BC,wBAA2B,CAACC,2BAA2B,CAACV,cAAcK,YACpGJ,gBAAeO,6BAA6B,GAAG;wBAErD7B,cAAcgC,IAAI,CAACV;wBAEnBF,iBAAgBjB;wBAEhB,IAAI,CAACiB,gBAAe;4BAClBpB,cAAciC,GAAG;wBACnB;wBAEAlB,uBAAuBK,gBAAe,GAAG;oBAC3C;gBACF;gBAEA,OAAOL;YACT;;;WA5GInB;EAAkCsC,cAAa;AA+GrD,IAAMC,4BAA4B,IAAIvC;IAEtC,WAAeuC"}

package/lib/verifier/nodes/termAgainstConstructor.js

@@ -136,20 +136,20 @@ var TermAgainstConstructorNodesVerifier = /*#__PURE__*/ function(NodesVerifier)
     _create_class(TermAgainstConstructorNodesVerifier, [
         {
             key: "verifyNonTerminalNode",
-            value: function verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead) {
+            value: function verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {
                 var nonTerminalNodeVerified = false;
                 var nonTerminalNode = nonTerminalNodeA, constructorNonTerminalNode = nonTerminalNodeB, ruleName = nonTerminalNode.getRuleName(), constructorRuleName = constructorNonTerminalNode.getRuleName(); ///
                 if (ruleName === constructorRuleName) {
                     switch(ruleName){
                         case _ruleNames.ARGUMENT_RULE_NAME:
                             {
-                                var argumentNode = nonTerminalNode, constructorArgumentNode = constructorNonTerminalNode, argumentNodeVerified = this.verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead);
+                                var argumentNode = nonTerminalNode, constructorArgumentNode = constructorNonTerminalNode, argumentNodeVerified = this.verifyArgumentNode(argumentNode, constructorArgumentNode, localContext, verifyAhead);
                                 nonTerminalNodeVerified = argumentNodeVerified; ///
                                 break;
                             }
                         default:
                             {
-                                nonTerminalNodeVerified = _get(_get_prototype_of(TermAgainstConstructorNodesVerifier.prototype), "verifyNonTerminalNode", this).call(this, nonTerminalNode, constructorNonTerminalNode, context, verifyAhead);
+                                nonTerminalNodeVerified = _get(_get_prototype_of(TermAgainstConstructorNodesVerifier.prototype), "verifyNonTerminalNode", this).call(this, nonTerminalNode, constructorNonTerminalNode, localContext, verifyAhead);
                                 break;
                             }
                     }
@@ -159,27 +159,27 @@ var TermAgainstConstructorNodesVerifier = /*#__PURE__*/ function(NodesVerifier)
         },
         {
             key: "verifyArgumentNode",
-            value: function verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead) {
+            value: function verifyArgumentNode(argumentNode, constructorArgumentNode, localContext, verifyAhead) {
                 var argumentNodeVerified = false;
-                var argumentString = context.nodeAsString(argumentNode);
+                var argumentString = localContext.nodeAsString(argumentNode);
                 var typeNode = typeNodeQuery(argumentNode);
                 if (typeNode !== null) {
-                    context.debug("The '".concat(argumentString, "' argument should be a term, not a type."), argumentNode);
+                    localContext.debug("The '".concat(argumentString, "' argument should be a term, not a type."), argumentNode);
                 } else {
                     var termNode = termNodeQuery(argumentNode);
                     if (!argumentNodeVerified) {
                         var constructorTermNode = termNodeQuery(constructorArgumentNode);
                         if (constructorTermNode !== null) {
-                            var node = termNode, constructorNode = constructorTermNode, nodeVerified = this.verifyNode(node, constructorNode, context, verifyAhead);
+                            var node = termNode, constructorNode = constructorTermNode, nodeVerified = this.verifyNode(node, constructorNode, localContext, verifyAhead);
                             argumentNodeVerified = nodeVerified; ///
                         }
                     }
                     if (!argumentNodeVerified) {
                         var constructorTypeNode = typeNodeQuery(constructorArgumentNode);
                         if (constructorTypeNode !== null) {
-                            var verifyTerm = termAgainstConstructorNodesVerifier.verifyTerm, terms = [], termVerified = verifyTerm(termNode, terms, context, function() {
+                            var verifyTerm = termAgainstConstructorNodesVerifier.verifyTerm, terms = [], termVerified = verifyTerm(termNode, terms, localContext, function() {
                                 var verifiedAhead = false;
-                                var constructorTypeName = (0, _query.typeNameFromTypeNode)(constructorTypeNode), firstTerm = (0, _array.first)(terms), term = firstTerm, termType = term.getType(), constructorType = context.findTypeByTypeName(constructorTypeName), termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(constructorType);
+                                var constructorTypeName = (0, _query.typeNameFromTypeNode)(constructorTypeNode), firstTerm = (0, _array.first)(terms), term = firstTerm, termType = term.getType(), constructorType = localContext.findTypeByTypeName(constructorTypeName), termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(constructorType);
                                 if (termTypeEqualToOrSubTypeOfType) {
                                     verifiedAhead = verifyAhead();
                                 }
@@ -198,4 +198,4 @@ var TermAgainstConstructorNodesVerifier = /*#__PURE__*/ function(NodesVerifier)
 var termAgainstConstructorNodesVerifier = new TermAgainstConstructorNodesVerifier();
 var _default = termAgainstConstructorNodesVerifier;
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verifier/nodes/termAgainstConstructor.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 TermAgainstConstructorNodesVerifier extends NodesVerifier {\n  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead) {\n    let nonTerminalNodeVerified = false;\n\n    const nonTerminalNode = nonTerminalNodeA, ///\n          constructorNonTerminalNode = nonTerminalNodeB, ///\n          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 } = termAgainstConstructorNodesVerifier,\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 termAgainstConstructorNodesVerifier = new TermAgainstConstructorNodesVerifier();\n\nexport default termAgainstConstructorNodesVerifier;\n\n"],"names":["termNodeQuery","nodeQuery","typeNodeQuery","TermAgainstConstructorNodesVerifier","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","termAgainstConstructorNodesVerifier","terms","termVerified","verifiedAhead","constructorTypeName","typeNameFromTypeNode","firstTerm","first","term","termType","getType","constructorType","findTypeByTypeName","termTypeEqualToOrSubTypeOfType","isEqualToOrSubTypeOf","NodesVerifier"],"mappings":"AAAA;;;;+BAqGA;;;eAAA;;;4DAnG0B;qBAEJ;yBACa;qBACa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhD,IAAMA,gBAAgBC,IAAAA,gBAAS,EAAC,oBAC1BC,gBAAgBD,IAAAA,gBAAS,EAAC;AAEhC,IAAA,AAAME,oDAAD,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,kBAC7BM,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,uBAtB9BN,gDAsBoCC,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,oCAAfD,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;;;WArFIf;EAA4C4C,cAAa;AAwF/D,IAAMf,sCAAsC,IAAI7B;IAEhD,WAAe6B"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verifier/nodes/termAgainstConstructor.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 TermAgainstConstructorNodesVerifier extends NodesVerifier {\n  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {\n    let nonTerminalNodeVerified = false;\n\n    const nonTerminalNode = nonTerminalNodeA, ///\n          constructorNonTerminalNode = nonTerminalNodeB, ///\n          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, localContext, verifyAhead);\n\n          nonTerminalNodeVerified = argumentNodeVerified; ///\n\n          break;\n        }\n\n        default: {\n          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, localContext, verifyAhead);\n\n          break;\n        }\n      }\n    }\n\n    return nonTerminalNodeVerified;\n  }\n\n  verifyArgumentNode(argumentNode, constructorArgumentNode, localContext, verifyAhead) {\n    let argumentNodeVerified = false;\n\n    const argumentString = localContext.nodeAsString(argumentNode);\n\n    const typeNode = typeNodeQuery(argumentNode);\n\n    if (typeNode !== null) {\n      localContext.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, localContext, verifyAhead);\n\n          argumentNodeVerified = nodeVerified;  ///\n        }\n      }\n\n      if (!argumentNodeVerified) {\n        const constructorTypeNode = typeNodeQuery(constructorArgumentNode);\n\n        if (constructorTypeNode !== null) {\n          const { verifyTerm } = termAgainstConstructorNodesVerifier,\n                terms = [],\n                termVerified = verifyTerm(termNode, terms, localContext, () => {\n                  let verifiedAhead = false;\n\n                  const constructorTypeName = typeNameFromTypeNode(constructorTypeNode),\n                        firstTerm = first(terms),\n                        term = firstTerm, ///\n                        termType = term.getType(),\n                        constructorType = localContext.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 termAgainstConstructorNodesVerifier = new TermAgainstConstructorNodesVerifier();\n\nexport default termAgainstConstructorNodesVerifier;\n\n"],"names":["termNodeQuery","nodeQuery","typeNodeQuery","TermAgainstConstructorNodesVerifier","verifyNonTerminalNode","nonTerminalNodeA","nonTerminalNodeB","localContext","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","termAgainstConstructorNodesVerifier","terms","termVerified","verifiedAhead","constructorTypeName","typeNameFromTypeNode","firstTerm","first","term","termType","getType","constructorType","findTypeByTypeName","termTypeEqualToOrSubTypeOfType","isEqualToOrSubTypeOf","NodesVerifier"],"mappings":"AAAA;;;;+BAqGA;;;eAAA;;;4DAnG0B;qBAEJ;yBACa;qBACa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhD,IAAMA,gBAAgBC,IAAAA,gBAAS,EAAC,oBAC1BC,gBAAgBD,IAAAA,gBAAS,EAAC;AAEhC,IAAA,AAAME,oDAAD,AAAL;cAAMA;+BAAAA;aAAAA;gCAAAA;;;kBAAAA;;YACJC,KAAAA;mBAAAA,SAAAA,sBAAsBC,gBAAgB,EAAEC,gBAAgB,EAAEC,YAAY,EAAEC,WAAW;gBACjF,IAAIC,0BAA0B;gBAE9B,IAAMC,kBAAkBL,kBAClBM,6BAA6BL,kBAC7BM,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,cAAcC;gCAE1GC,0BAA0BS,sBAAsB,GAAG;gCAEnD;4BACF;wBAEA;4BAAS;gCACPT,0BAA0B,uBAtB9BN,gDAsBoCC,yBAAN,IAAK,aAAuBM,iBAAiBC,4BAA4BJ,cAAcC;gCAEjH;4BACF;oBACF;gBACF;gBAEA,OAAOC;YACT;;;YAEAU,KAAAA;mBAAAA,SAAAA,mBAAmBH,YAAY,EAAEC,uBAAuB,EAAEV,YAAY,EAAEC,WAAW;gBACjF,IAAIU,uBAAuB;gBAE3B,IAAME,iBAAiBb,aAAac,YAAY,CAACL;gBAEjD,IAAMM,WAAWpB,cAAcc;gBAE/B,IAAIM,aAAa,MAAM;oBACrBf,aAAagB,KAAK,CAAC,AAAC,QAAsB,OAAfH,gBAAe,6CAA2CJ;gBACvF,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,cAAcC;4BAE1EU,uBAAuBU,cAAe,GAAG;wBAC3C;oBACF;oBAEA,IAAI,CAACV,sBAAsB;wBACzB,IAAMY,sBAAsB5B,cAAce;wBAE1C,IAAIa,wBAAwB,MAAM;4BAChC,IAAM,AAAEC,aAAeC,oCAAfD,YACFE,QAAQ,EAAE,EACVC,eAAeH,WAAWP,UAAUS,OAAO1B,cAAc;gCACvD,IAAI4B,gBAAgB;gCAEpB,IAAMC,sBAAsBC,IAAAA,2BAAoB,EAACP,sBAC3CQ,YAAYC,IAAAA,YAAK,EAACN,QAClBO,OAAOF,WACPG,WAAWD,KAAKE,OAAO,IACvBC,kBAAkBpC,aAAaqC,kBAAkB,CAACR,sBAClDS,iCAAiCJ,SAASK,oBAAoB,CAACH;gCAErE,IAAIE,gCAAgC;oCAClCV,gBAAgB3B;gCAClB;gCAEA,OAAO2B;4BACT;4BAENjB,uBAAuBgB,cAAe,GAAG;wBAC3C;oBACF;gBACF;gBAEA,OAAOhB;YACT;;;WArFIf;EAA4C4C,cAAa;AAwF/D,IAAMf,sCAAsC,IAAI7B;IAEhD,WAAe6B"}

package/lib/verify/containment.js

@@ -11,24 +11,43 @@ Object.defineProperty(exports, "default", {
 var _array = require("../utilities/array");
 var _constants = require("../constants");
 var _query = require("../utilities/query");
-var variableNodesQuery = (0, _query.nodesQuery)("/metaArgument//variable"), containmentVariableNodeQuery = (0, _query.nodeQuery)("/argument/term/variable!");
-function verifyContainment(argumentNode, containmentNode, metaArgumentNode, context) {
+var termNodeQuery = (0, _query.nodeQuery)("/argument/term!"), variableNodeQuery = (0, _query.nodeQuery)("/argument/term/variable!"), metaArgumentTermNodesQuery = (0, _query.nodesQuery)("/metaArgument//term"), metaArgumentVariableNodesQuery = (0, _query.nodesQuery)("/metaArgument//variable");
+function verifyContainment(argumentNode, containmentNode, metaArgumentNode, localContext) {
     var containmentVerified = false;
-    var containmentVariableNode = containmentVariableNodeQuery(argumentNode);
-    if (containmentVariableNode !== null) {
-        var contained = containedFromContainmentNode(containmentNode), variableNodes = variableNodesQuery(metaArgumentNode), containmentVariableNodeMatchesStatementVariableNode = variableNodes.some(function(statementVariableNode) {
-            var containmentVariableNodeMatchesStatementVariableNode = containmentVariableNode.match(statementVariableNode);
-            if (containmentVariableNodeMatchesStatementVariableNode) {
+    var contained = containedFromContainmentNode(containmentNode), termNode = termNodeQuery(argumentNode), variableNode = variableNodeQuery(argumentNode);
+    if (false) {
+    ///
+    } else if (variableNode !== null) {
+        var metaArgumentVariableNodes = metaArgumentVariableNodesQuery(metaArgumentNode), variableNodeMatchesMetaArgumentVariableNode = metaArgumentVariableNodes.some(function(metaArgumentVariableNode) {
+            var variableNodeMatchesMetaArgumentVariableNode = variableNode.match(metaArgumentVariableNode);
+            if (variableNodeMatchesMetaArgumentVariableNode) {
                 return true;
             }
         });
         if (contained) {
-            if (containmentVariableNodeMatchesStatementVariableNode) {
+            if (variableNodeMatchesMetaArgumentVariableNode) {
                 containmentVerified = true;
             }
         }
         if (!contained) {
-            if (!containmentVariableNodeMatchesStatementVariableNode) {
+            if (!variableNodeMatchesMetaArgumentVariableNode) {
+                containmentVerified = true;
+            }
+        }
+    } else if (termNode !== null) {
+        var metaArgumentTermNodes = metaArgumentTermNodesQuery(metaArgumentNode), termNodeMatchesMetaArgumentTermNode = metaArgumentTermNodes.some(function(metaArgumentTermNode) {
+            var termNodeMatchesMetaArgumentTermNode = termNode.match(metaArgumentTermNode);
+            if (termNodeMatchesMetaArgumentTermNode) {
+                return true;
+            }
+        });
+        if (contained) {
+            if (termNodeMatchesMetaArgumentTermNode) {
+                containmentVerified = true;
+            }
+        }
+        if (!contained) {
+            if (!termNodeMatchesMetaArgumentTermNode) {
                 containmentVerified = true;
             }
         }
@@ -40,4 +59,4 @@ function containedFromContainmentNode(containmentNode) {
     return contained;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/verify/defining.js

@@ -18,15 +18,15 @@ function _interop_require_default(obj) {
     };
 }
 var termNodeQuery = (0, _query.nodeQuery)("/argument/term!"), variableNodeQuery = (0, _query.nodeQuery)("/argument/term/variable!");
-function verifyDefining(argumentNode, definingNode, context) {
+function verifyDefining(argumentNode, definingNode, localContext) {
     var definingVerified = false;
     var defined = definedFromDefiningNode(definingNode), termNode = termNodeQuery(argumentNode), variableNode = variableNodeQuery(argumentNode);
     if (false) {
     ///
     } else if (variableNode !== null) {
-        var variable = context.findVariableByVariableNode(variableNode);
+        var variable = localContext.findVariableByVariableNode(variableNode);
         if (variable !== null) {
-            var variableDefined = context.isVariableDefined(variable);
+            var variableDefined = localContext.isVariableDefined(variable);
             if (defined) {
                 if (variableDefined) {
                     definingVerified = true;
@@ -39,9 +39,9 @@ function verifyDefining(argumentNode, definingNode, context) {
             }
         }
     } else if (termNode !== null) {
-        var terms = [], termVerified = (0, _term.default)(termNode, terms, context, function() {
+        var terms = [], termVerified = (0, _term.default)(termNode, terms, localContext, function() {
             var verifiedAhead;
-            var firstTerm = (0, _array.first)(terms), term = firstTerm, termGrounded = context.isTermGrounded(term);
+            var firstTerm = (0, _array.first)(terms), term = firstTerm, termGrounded = localContext.isTermGrounded(term);
             if (defined) {
                 if (termGrounded) {
                     verifiedAhead = true;
@@ -63,4 +63,4 @@ function definedFromDefiningNode(definingNode) {
     return defined;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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