occam-verify-cli 0.0.932 → 0.0.934

package/lib/supposition.js

@@ -9,7 +9,7 @@ Object.defineProperty(exports, "default", {
     }
 });
 var _local = /*#__PURE__*/ _interop_require_default(require("./context/local"));
-var _metaLevel = /*#__PURE__*/ _interop_require_default(require("./verifier/nodes/metaLevel"));
+var _metaLevel = /*#__PURE__*/ _interop_require_default(require("./unifier/metaLevel"));
 var _array = require("./utilities/array");
 var _string = require("./utilities/string");
 var _query = require("./utilities/query");
@@ -81,11 +81,11 @@ var Supposition = /*#__PURE__*/ function() {
             value: function matchStatementNode(statementNode, substitutions, fileContext, localContext) {
                 var matchesStatementNode = false;
                 if (this.statementNode !== null) {
-                    var fileContextA = fileContext, nonTerminalNodeA = this.statementNode, nonTerminalNodeB = statementNode, localContextA = _local.default.fromFileContext(fileContextA), localContextB = localContext, nonTerminalNodeVerified = _metaLevel.default.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, function() {
+                    var fileContextA = fileContext, nonTerminalNodeA = this.statementNode, nonTerminalNodeB = statementNode, localContextA = _local.default.fromFileContext(fileContextA), localContextB = localContext, nonTerminalNodeUnified = _metaLevel.default.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, function() {
                         var verifiedAhead = true;
                         return verifiedAhead;
                     });
-                    matchesStatementNode = nonTerminalNodeVerified; ///
+                    matchesStatementNode = nonTerminalNodeUnified; ///
                 }
                 return matchesStatementNode;
             }
@@ -101,11 +101,11 @@ var Supposition = /*#__PURE__*/ function() {
                             subproofLastProofStepStatementNode
                         ]), subproofAssertionStatementNodes = subproofAssertionStatementNodesQuery(subproofAssertionNode);
                         matchesSubproofNode = (0, _array.match)(subproofAssertionStatementNodes, subproofStatementNodes, function(subproofAssertionStatementNode, subproofStatementNode) {
-                            var fileContextA = fileContext, nonTerminalNodeA = subproofAssertionStatementNode, nonTerminalNodeB = subproofStatementNode, localContextA = _local.default.fromFileContext(fileContextA), localContextB = localContext, nonTerminalNodeVerified = _metaLevel.default.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, function() {
+                            var fileContextA = fileContext, nonTerminalNodeA = subproofAssertionStatementNode, nonTerminalNodeB = subproofStatementNode, localContextA = _local.default.fromFileContext(fileContextA), localContextB = localContext, nonTerminalNodeUnified = _metaLevel.default.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, function() {
                                 var verifiedAhead = true;
                                 return verifiedAhead;
                             });
-                            if (nonTerminalNodeVerified) {
+                            if (nonTerminalNodeUnified) {
                                 return true;
                             }
                         });
@@ -142,4 +142,4 @@ var Supposition = /*#__PURE__*/ function() {
     return Supposition;
 }();
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/supposition.js"],"sourcesContent":["\"use strict\";\n\nimport LocalContext from \"./context/local\";\nimport metaLevelNodesVerifier from \"./verifier/nodes/metaLevel\";\n\nimport { match } from \"./utilities/array\";\nimport { nodeAsString } from \"./utilities/string\";\nimport { nodeQuery, nodesQuery } from \"./utilities/query\";\nimport { statementNodeFromStatementString } from \"./utilities/node\";\n\nconst subproofAssertionNodeQuery = nodeQuery(\"/statement/subproofAssertion!\"),\n      subproofAssertionStatementNodesQuery = nodesQuery(\"/subproofAssertion/statement\"),\n      subproofSuppositionStatementNodesQuery = nodesQuery(\"/subproof/supposition/unqualifiedStatement/statement!\"),\n      subproofLastProofStepStatementNodeQuery = nodeQuery(\"/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!\");\n\nexport default class Supposition {\n  constructor(statementNode) {\n    this.statementNode = statementNode;\n  }\n\n  getStatementNode() {\n    return this.statementNode;\n  }\n\n  matchStatementNode(statementNode, substitutions, fileContext, localContext) {\n    let matchesStatementNode = false;\n\n    if (this.statementNode !== null) {\n      const fileContextA = fileContext, ///\n            nonTerminalNodeA = this.statementNode,  ///\n            nonTerminalNodeB = statementNode,  ///\n            localContextA = LocalContext.fromFileContext(fileContextA),\n            localContextB = localContext,  ///\n            nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {\n              const verifiedAhead = true;\n\n              return verifiedAhead;\n            });\n\n      matchesStatementNode = nonTerminalNodeVerified; ///\n    }\n\n    return matchesStatementNode;\n  }\n\n  matchSubproofNode(subproofNode, substitutions, fileContext, localContext) {\n    let matchesSubproofNode = false;\n\n    if (this.statementNode !== null) {\n      const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);\n\n      if (subproofAssertionNode !== null) {\n        const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),\n              subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),\n              subproofStatementNodes = [\n                ...subproofSuppositionStatementNodes,\n                subproofLastProofStepStatementNode\n              ],\n              subproofAssertionStatementNodes = subproofAssertionStatementNodesQuery(subproofAssertionNode);\n\n        matchesSubproofNode = match(subproofAssertionStatementNodes, subproofStatementNodes, (subproofAssertionStatementNode, subproofStatementNode) => {\n          const fileContextA = fileContext, ///\n                nonTerminalNodeA = subproofAssertionStatementNode,  ///\n                nonTerminalNodeB = subproofStatementNode, ///\n                localContextA = LocalContext.fromFileContext(fileContextA),\n                localContextB = localContext,  ///\n                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {\n                  const verifiedAhead = true;\n\n                  return verifiedAhead;\n                });\n\n          if (nonTerminalNodeVerified) {\n            return true;\n          }\n        });\n      }\n    }\n\n    return matchesSubproofNode;\n  }\n\n  toJSON(tokens) {\n    const statementString = nodeAsString(this.statementNode, tokens),\n          statement = statementString, ///\n          json = {\n            statement\n          };\n\n    return json;\n  }\n\n  static fromStatementNode(statementNode) {\n    const supposition = new Supposition(statementNode);\n\n    return supposition;\n  }\n\n  static fromJSONAndFileContext(json, fileContext) {\n    const { statement } = json,\n          statementString = statement,  ///\n          lexer = fileContext.getLexer(),\n          parser = fileContext.getParser(),\n          statementNode = statementNodeFromStatementString(statementString, lexer, parser),\n          supposition = new Supposition(statementNode);\n\n    return supposition;\n  }\n}\n"],"names":["Supposition","subproofAssertionNodeQuery","nodeQuery","subproofAssertionStatementNodesQuery","nodesQuery","subproofSuppositionStatementNodesQuery","subproofLastProofStepStatementNodeQuery","statementNode","getStatementNode","matchStatementNode","substitutions","fileContext","localContext","matchesStatementNode","fileContextA","nonTerminalNodeA","nonTerminalNodeB","localContextA","LocalContext","fromFileContext","localContextB","nonTerminalNodeVerified","metaLevelNodesVerifier","verifyNonTerminalNode","verifiedAhead","matchSubproofNode","subproofNode","matchesSubproofNode","subproofAssertionNode","subproofSuppositionStatementNodes","subproofLastProofStepStatementNode","subproofStatementNodes","subproofAssertionStatementNodes","match","subproofAssertionStatementNode","subproofStatementNode","toJSON","tokens","statementString","nodeAsString","statement","json","fromStatementNode","supposition","fromJSONAndFileContext","lexer","getLexer","parser","getParser","statementNodeFromStatementString"],"mappings":"AAAA;;;;;;;eAeqBA;;;4DAbI;gEACU;qBAEb;sBACO;qBACS;oBACW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjD,IAAMC,6BAA6BC,IAAAA,gBAAS,EAAC,kCACvCC,uCAAuCC,IAAAA,iBAAU,EAAC,iCAClDC,yCAAyCD,IAAAA,iBAAU,EAAC,0DACpDE,0CAA0CJ,IAAAA,gBAAS,EAAC;AAE3C,IAAA,AAAMF,4BAAD,AAAL;aAAMA,YACPO,aAAa;gCADNP;QAEjB,IAAI,CAACO,aAAa,GAAGA;;kBAFJP;;YAKnBQ,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACD,aAAa;YAC3B;;;YAEAE,KAAAA;mBAAAA,SAAAA,mBAAmBF,aAAa,EAAEG,aAAa,EAAEC,WAAW,EAAEC,YAAY;gBACxE,IAAIC,uBAAuB;gBAE3B,IAAI,IAAI,CAACN,aAAa,KAAK,MAAM;oBAC/B,IAAMO,eAAeH,aACfI,mBAAmB,IAAI,CAACR,aAAa,EACrCS,mBAAmBT,eACnBU,gBAAgBC,cAAY,CAACC,eAAe,CAACL,eAC7CM,gBAAgBR,cAChBS,0BAA0BC,kBAAsB,CAACC,qBAAqB,CAACR,kBAAkBC,kBAAkBN,eAAeO,eAAeG,eAAe;wBACtJ,IAAMI,gBAAgB;wBAEtB,OAAOA;oBACT;oBAENX,uBAAuBQ,yBAAyB,GAAG;gBACrD;gBAEA,OAAOR;YACT;;;YAEAY,KAAAA;mBAAAA,SAAAA,kBAAkBC,YAAY,EAAEhB,aAAa,EAAEC,WAAW,EAAEC,YAAY;gBACtE,IAAIe,sBAAsB;gBAE1B,IAAI,IAAI,CAACpB,aAAa,KAAK,MAAM;oBAC/B,IAAMqB,wBAAwB3B,2BAA2B,IAAI,CAACM,aAAa;oBAE3E,IAAIqB,0BAA0B,MAAM;wBAClC,IAAMC,oCAAoCxB,uCAAuCqB,eAC3EI,qCAAqCxB,wCAAwCoB,eAC7EK,yBAAyB,AACvB,qBAAGF,0CADoB;4BAEvBC;yBACD,GACDE,kCAAkC7B,qCAAqCyB;wBAE7ED,sBAAsBM,IAAAA,YAAK,EAACD,iCAAiCD,wBAAwB,SAACG,gCAAgCC;4BACpH,IAAMrB,eAAeH,aACfI,mBAAmBmB,gCACnBlB,mBAAmBmB,uBACnBlB,gBAAgBC,cAAY,CAACC,eAAe,CAACL,eAC7CM,gBAAgBR,cAChBS,0BAA0BC,kBAAsB,CAACC,qBAAqB,CAACR,kBAAkBC,kBAAkBN,eAAeO,eAAeG,eAAe;gCACtJ,IAAMI,gBAAgB;gCAEtB,OAAOA;4BACT;4BAEN,IAAIH,yBAAyB;gCAC3B,OAAO;4BACT;wBACF;oBACF;gBACF;gBAEA,OAAOM;YACT;;;YAEAS,KAAAA;mBAAAA,SAAAA,OAAOC,MAAM;gBACX,IAAMC,kBAAkBC,IAAAA,oBAAY,EAAC,IAAI,CAAChC,aAAa,EAAE8B,SACnDG,YAAYF,iBACZG,OAAO;oBACLD,WAAAA;gBACF;gBAEN,OAAOC;YACT;;;;YAEOC,KAAAA;mBAAP,SAAOA,kBAAkBnC,aAAa;gBACpC,IAAMoC,cAAc,IA9EH3C,YA8EmBO;gBAEpC,OAAOoC;YACT;;;YAEOC,KAAAA;mBAAP,SAAOA,uBAAuBH,IAAI,EAAE9B,WAAW;gBAC7C,IAAM,AAAE6B,YAAcC,KAAdD,WACFF,kBAAkBE,WAClBK,QAAQlC,YAAYmC,QAAQ,IAC5BC,SAASpC,YAAYqC,SAAS,IAC9BzC,gBAAgB0C,IAAAA,sCAAgC,EAACX,iBAAiBO,OAAOE,SACzEJ,cAAc,IAzFH3C,YAyFmBO;gBAEpC,OAAOoC;YACT;;;WA5FmB3C"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/supposition.js"],"sourcesContent":["\"use strict\";\n\nimport LocalContext from \"./context/local\";\nimport metaLevelUnifier from \"./unifier/metaLevel\";\n\nimport { match } from \"./utilities/array\";\nimport { nodeAsString } from \"./utilities/string\";\nimport { nodeQuery, nodesQuery } from \"./utilities/query\";\nimport { statementNodeFromStatementString } from \"./utilities/node\";\n\nconst subproofAssertionNodeQuery = nodeQuery(\"/statement/subproofAssertion!\"),\n      subproofAssertionStatementNodesQuery = nodesQuery(\"/subproofAssertion/statement\"),\n      subproofSuppositionStatementNodesQuery = nodesQuery(\"/subproof/supposition/unqualifiedStatement/statement!\"),\n      subproofLastProofStepStatementNodeQuery = nodeQuery(\"/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!\");\n\nexport default class Supposition {\n  constructor(statementNode) {\n    this.statementNode = statementNode;\n  }\n\n  getStatementNode() {\n    return this.statementNode;\n  }\n\n  matchStatementNode(statementNode, substitutions, fileContext, localContext) {\n    let matchesStatementNode = false;\n\n    if (this.statementNode !== null) {\n      const fileContextA = fileContext, ///\n            nonTerminalNodeA = this.statementNode,  ///\n            nonTerminalNodeB = statementNode,  ///\n            localContextA = LocalContext.fromFileContext(fileContextA),\n            localContextB = localContext,  ///\n            nonTerminalNodeUnified = metaLevelUnifier.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {\n              const verifiedAhead = true;\n\n              return verifiedAhead;\n            });\n\n      matchesStatementNode = nonTerminalNodeUnified; ///\n    }\n\n    return matchesStatementNode;\n  }\n\n  matchSubproofNode(subproofNode, substitutions, fileContext, localContext) {\n    let matchesSubproofNode = false;\n\n    if (this.statementNode !== null) {\n      const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);\n\n      if (subproofAssertionNode !== null) {\n        const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),\n              subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),\n              subproofStatementNodes = [\n                ...subproofSuppositionStatementNodes,\n                subproofLastProofStepStatementNode\n              ],\n              subproofAssertionStatementNodes = subproofAssertionStatementNodesQuery(subproofAssertionNode);\n\n        matchesSubproofNode = match(subproofAssertionStatementNodes, subproofStatementNodes, (subproofAssertionStatementNode, subproofStatementNode) => {\n          const fileContextA = fileContext, ///\n                nonTerminalNodeA = subproofAssertionStatementNode,  ///\n                nonTerminalNodeB = subproofStatementNode, ///\n                localContextA = LocalContext.fromFileContext(fileContextA),\n                localContextB = localContext,  ///\n                nonTerminalNodeUnified = metaLevelUnifier.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {\n                  const verifiedAhead = true;\n\n                  return verifiedAhead;\n                });\n\n          if (nonTerminalNodeUnified) {\n            return true;\n          }\n        });\n      }\n    }\n\n    return matchesSubproofNode;\n  }\n\n  toJSON(tokens) {\n    const statementString = nodeAsString(this.statementNode, tokens),\n          statement = statementString, ///\n          json = {\n            statement\n          };\n\n    return json;\n  }\n\n  static fromStatementNode(statementNode) {\n    const supposition = new Supposition(statementNode);\n\n    return supposition;\n  }\n\n  static fromJSONAndFileContext(json, fileContext) {\n    const { statement } = json,\n          statementString = statement,  ///\n          lexer = fileContext.getLexer(),\n          parser = fileContext.getParser(),\n          statementNode = statementNodeFromStatementString(statementString, lexer, parser),\n          supposition = new Supposition(statementNode);\n\n    return supposition;\n  }\n}\n"],"names":["Supposition","subproofAssertionNodeQuery","nodeQuery","subproofAssertionStatementNodesQuery","nodesQuery","subproofSuppositionStatementNodesQuery","subproofLastProofStepStatementNodeQuery","statementNode","getStatementNode","matchStatementNode","substitutions","fileContext","localContext","matchesStatementNode","fileContextA","nonTerminalNodeA","nonTerminalNodeB","localContextA","LocalContext","fromFileContext","localContextB","nonTerminalNodeUnified","metaLevelUnifier","unifyNonTerminalNode","verifiedAhead","matchSubproofNode","subproofNode","matchesSubproofNode","subproofAssertionNode","subproofSuppositionStatementNodes","subproofLastProofStepStatementNode","subproofStatementNodes","subproofAssertionStatementNodes","match","subproofAssertionStatementNode","subproofStatementNode","toJSON","tokens","statementString","nodeAsString","statement","json","fromStatementNode","supposition","fromJSONAndFileContext","lexer","getLexer","parser","getParser","statementNodeFromStatementString"],"mappings":"AAAA;;;;;;;eAeqBA;;;4DAbI;gEACI;qBAEP;sBACO;qBACS;oBACW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjD,IAAMC,6BAA6BC,IAAAA,gBAAS,EAAC,kCACvCC,uCAAuCC,IAAAA,iBAAU,EAAC,iCAClDC,yCAAyCD,IAAAA,iBAAU,EAAC,0DACpDE,0CAA0CJ,IAAAA,gBAAS,EAAC;AAE3C,IAAA,AAAMF,4BAAD,AAAL;aAAMA,YACPO,aAAa;gCADNP;QAEjB,IAAI,CAACO,aAAa,GAAGA;;kBAFJP;;YAKnBQ,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACD,aAAa;YAC3B;;;YAEAE,KAAAA;mBAAAA,SAAAA,mBAAmBF,aAAa,EAAEG,aAAa,EAAEC,WAAW,EAAEC,YAAY;gBACxE,IAAIC,uBAAuB;gBAE3B,IAAI,IAAI,CAACN,aAAa,KAAK,MAAM;oBAC/B,IAAMO,eAAeH,aACfI,mBAAmB,IAAI,CAACR,aAAa,EACrCS,mBAAmBT,eACnBU,gBAAgBC,cAAY,CAACC,eAAe,CAACL,eAC7CM,gBAAgBR,cAChBS,yBAAyBC,kBAAgB,CAACC,oBAAoB,CAACR,kBAAkBC,kBAAkBN,eAAeO,eAAeG,eAAe;wBAC9I,IAAMI,gBAAgB;wBAEtB,OAAOA;oBACT;oBAENX,uBAAuBQ,wBAAwB,GAAG;gBACpD;gBAEA,OAAOR;YACT;;;YAEAY,KAAAA;mBAAAA,SAAAA,kBAAkBC,YAAY,EAAEhB,aAAa,EAAEC,WAAW,EAAEC,YAAY;gBACtE,IAAIe,sBAAsB;gBAE1B,IAAI,IAAI,CAACpB,aAAa,KAAK,MAAM;oBAC/B,IAAMqB,wBAAwB3B,2BAA2B,IAAI,CAACM,aAAa;oBAE3E,IAAIqB,0BAA0B,MAAM;wBAClC,IAAMC,oCAAoCxB,uCAAuCqB,eAC3EI,qCAAqCxB,wCAAwCoB,eAC7EK,yBAAyB,AACvB,qBAAGF,0CADoB;4BAEvBC;yBACD,GACDE,kCAAkC7B,qCAAqCyB;wBAE7ED,sBAAsBM,IAAAA,YAAK,EAACD,iCAAiCD,wBAAwB,SAACG,gCAAgCC;4BACpH,IAAMrB,eAAeH,aACfI,mBAAmBmB,gCACnBlB,mBAAmBmB,uBACnBlB,gBAAgBC,cAAY,CAACC,eAAe,CAACL,eAC7CM,gBAAgBR,cAChBS,yBAAyBC,kBAAgB,CAACC,oBAAoB,CAACR,kBAAkBC,kBAAkBN,eAAeO,eAAeG,eAAe;gCAC9I,IAAMI,gBAAgB;gCAEtB,OAAOA;4BACT;4BAEN,IAAIH,wBAAwB;gCAC1B,OAAO;4BACT;wBACF;oBACF;gBACF;gBAEA,OAAOM;YACT;;;YAEAS,KAAAA;mBAAAA,SAAAA,OAAOC,MAAM;gBACX,IAAMC,kBAAkBC,IAAAA,oBAAY,EAAC,IAAI,CAAChC,aAAa,EAAE8B,SACnDG,YAAYF,iBACZG,OAAO;oBACLD,WAAAA;gBACF;gBAEN,OAAOC;YACT;;;;YAEOC,KAAAA;mBAAP,SAAOA,kBAAkBnC,aAAa;gBACpC,IAAMoC,cAAc,IA9EH3C,YA8EmBO;gBAEpC,OAAOoC;YACT;;;YAEOC,KAAAA;mBAAP,SAAOA,uBAAuBH,IAAI,EAAE9B,WAAW;gBAC7C,IAAM,AAAE6B,YAAcC,KAAdD,WACFF,kBAAkBE,WAClBK,QAAQlC,YAAYmC,QAAQ,IAC5BC,SAASpC,YAAYqC,SAAS,IAC9BzC,gBAAgB0C,IAAAA,sCAAgC,EAACX,iBAAiBO,OAAOE,SACzEJ,cAAc,IAzFH3C,YAyFmBO;gBAEpC,OAAOoC;YACT;;;WA5FmB3C"}

package/lib/unifier/equality.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _unifier = /*#__PURE__*/ _interop_require_wildcard(require("../unifier"));
+var _termAgainstTerm = /*#__PURE__*/ _interop_require_default(require("../unify/termAgainstTerm"));
+var _query = require("../utilities/query");
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _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 _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+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() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+var termNodeQuery = (0, _query.nodeQuery)("/term!"), nonTerminalNodeQuery = (0, _query.nodeQuery)("/*");
+var EqualityUnifier = /*#__PURE__*/ function(Unifier) {
+    _inherits(EqualityUnifier, Unifier);
+    function EqualityUnifier() {
+        _class_call_check(this, EqualityUnifier);
+        return _call_super(this, EqualityUnifier, arguments);
+    }
+    _create_class(EqualityUnifier, [
+        {
+            key: "unifyNonTerminalNode",
+            value: function unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead) {
+                var _this = this;
+                var nonTerminalNodUnified;
+                var nodeQueryMaps = [
+                    {
+                        nodeQueryA: termNodeQuery,
+                        nodeQueryB: termNodeQuery,
+                        unify: function(nodeA, nodeB, localContext, unifyAhead) {
+                            var nonTerminalNodUnified;
+                            var termNodeA = nodeA, termNodeB = nodeB, termNodUnifiedAgainstTermNode = _this.unifyTermNodeAgainstTermNode(termNodeA, termNodeB, localContext, unifyAhead);
+                            nonTerminalNodUnified = termNodUnifiedAgainstTermNode; ///
+                            return nonTerminalNodUnified;
+                        }
+                    },
+                    {
+                        nodeQueryA: nonTerminalNodeQuery,
+                        nodeQueryB: nonTerminalNodeQuery,
+                        unify: function(nodeA, nodeB, localContext, unifyAhead) {
+                            var nonTerminalNodUnified;
+                            var _$nonTerminalNodeA = nodeA, _$nonTerminalNodeB = nodeB; ///
+                            nonTerminalNodUnified = _get(_get_prototype_of(EqualityUnifier.prototype), "unifyNonTerminalNode", _this).call(_this, _$nonTerminalNodeA, _$nonTerminalNodeB, localContext, unifyAhead);
+                            return nonTerminalNodUnified;
+                        }
+                    }
+                ];
+                var nodesVerified = (0, _unifier.unify)(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead);
+                nonTerminalNodUnified = nodesVerified; ///
+                return nonTerminalNodUnified;
+            }
+        },
+        {
+            key: "unifyTermNodeAgainstTermNode",
+            value: function unifyTermNodeAgainstTermNode(termNodeA, termNodeB, localContext, unifyAhead) {
+                var termNodUnifiedAgainstTermNode;
+                var termVerifiedAgainstTerm = (0, _termAgainstTerm.default)(termNodeA, termNodeB, localContext, unifyAhead);
+                if (termVerifiedAgainstTerm) {
+                    termNodUnifiedAgainstTermNode = true;
+                } else {
+                    var nonTerminalNodeA = termNodeA, nonTerminalNodeB = termNodeB, nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(), nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(), childNodesA = nonTerminalNodeAChildNodes, childNodesB = nonTerminalNodeBChildNodes, childNodesVerified = this.unifyChildNodes(childNodesA, childNodesB, localContext, unifyAhead);
+                    termNodUnifiedAgainstTermNode = childNodesVerified; ///
+                }
+                return termNodUnifiedAgainstTermNode;
+            }
+        }
+    ]);
+    return EqualityUnifier;
+}(_unifier.default);
+var equalityUnifier = new EqualityUnifier();
+var _default = equalityUnifier;
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/unifier/metaLevel.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _shim = /*#__PURE__*/ _interop_require_default(require("../shim"));
+var _unifier = /*#__PURE__*/ _interop_require_wildcard(require("../unifier"));
+var _variableAgainstTerm = /*#__PURE__*/ _interop_require_default(require("../unify/variableAgainstTerm"));
+var _metavariableAgainstStatement = /*#__PURE__*/ _interop_require_default(require("../unify/metavariableAgainstStatement"));
+var _query = require("../utilities/query");
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _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 _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+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() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+var termNodeQuery = (0, _query.nodeQuery)("/term!"), statementNodeQuery = (0, _query.nodeQuery)("/statement!"), nonTerminalNodeQuery = (0, _query.nodeQuery)("/*"), termVariableNodeQuery = (0, _query.nodeQuery)("/term/variable!"), statementSubstitutionNodeQuery = (0, _query.nodeQuery)("/statement/substitution!"), statementMetavariableNodeQuery = (0, _query.nodeQuery)("/statement/metavariable!");
+var MetaLevelUnifier = /*#__PURE__*/ function(Unifier) {
+    _inherits(MetaLevelUnifier, Unifier);
+    function MetaLevelUnifier() {
+        _class_call_check(this, MetaLevelUnifier);
+        return _call_super(this, MetaLevelUnifier, arguments);
+    }
+    _create_class(MetaLevelUnifier, [
+        {
+            key: "unifyNonTerminalNode",
+            value: function unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, unifyAhead) {
+                var _this = this;
+                var nonTerminalNodeUnified;
+                var nodeQueryMaps = [
+                    {
+                        nodeQueryA: statementMetavariableNodeQuery,
+                        nodeQueryB: statementNodeQuery,
+                        unify: function(nodeA, nodeB, substitutions, localContextA, localContextB, unifyAhead) {
+                            var nonTerminalNodeUnified;
+                            var statementNodeA = nonTerminalNodeA, statementNodeB = nodeB, statementMetavariableNodeA = nodeA, statementSubstitutionNodeA = statementSubstitutionNodeQuery(statementNodeA), metavariableNodeUnifiedAgainstStatementNode = _this.unifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementSubstitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, unifyAhead);
+                            nonTerminalNodeUnified = metavariableNodeUnifiedAgainstStatementNode; ///
+                            return nonTerminalNodeUnified;
+                        }
+                    },
+                    {
+                        nodeQueryA: termVariableNodeQuery,
+                        nodeQueryB: termNodeQuery,
+                        unify: function(nodeA, nodeB, substitutions, localContextA, localContextB, unifyAhead) {
+                            var nonTerminalNodeUnified;
+                            var termNodeB = nodeB, termVariableNodeA = nodeA, termVariableNodeUnifiedAgainstTermNode = _this.unifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, unifyAhead);
+                            nonTerminalNodeUnified = termVariableNodeUnifiedAgainstTermNode; ///
+                            return nonTerminalNodeUnified;
+                        }
+                    },
+                    {
+                        nodeQueryA: nonTerminalNodeQuery,
+                        nodeQueryB: nonTerminalNodeQuery,
+                        unify: function(nodeA, nodeB, substitutions, localContextA, localContextB, unifyAhead) {
+                            var nonTerminalNodeUnified;
+                            var _$nonTerminalNodeA = nodeA, _$nonTerminalNodeB = nodeB; ///
+                            nonTerminalNodeUnified = _get(_get_prototype_of(MetaLevelUnifier.prototype), "unifyNonTerminalNode", _this).call(_this, _$nonTerminalNodeA, _$nonTerminalNodeB, substitutions, localContextA, localContextB, unifyAhead);
+                            return nonTerminalNodeUnified;
+                        }
+                    }
+                ];
+                var nodesUnified = (0, _unifier.unify)(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, unifyAhead);
+                nonTerminalNodeUnified = nodesUnified; ///
+                return nonTerminalNodeUnified;
+            }
+        },
+        {
+            key: "unifyStatementMetavariableNodeAgainstStatementNode",
+            value: function unifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementSubstitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, unifyAhead) {
+                var metavariableNodeUnifiedAgainstStatementNode;
+                var substitutionNode = statementSubstitutionNodeA, metavariableNodeA = statementMetavariableNodeA, metavariableUnifiedAgainstStatement = (0, _metavariableAgainstStatement.default)(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, unifyAhead);
+                metavariableNodeUnifiedAgainstStatementNode = metavariableUnifiedAgainstStatement; ///
+                return metavariableNodeUnifiedAgainstStatementNode;
+            }
+        },
+        {
+            key: "unifyTermVariableNodeAgainstTermNode",
+            value: function unifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, unifyAhead) {
+                var termVariableNodeUnifiedAgainstTermNode;
+                var variableNodeA = termVariableNodeA, termUnifiedAgainstVariable = (0, _variableAgainstTerm.default)(variableNodeA, termNodeB, substitutions, localContextA, localContextB, unifyAhead);
+                termVariableNodeUnifiedAgainstTermNode = termUnifiedAgainstVariable; ///
+                return termVariableNodeUnifiedAgainstTermNode;
+            }
+        }
+    ]);
+    return MetaLevelUnifier;
+}(_unifier.default);
+var metaLevelUnifier = new MetaLevelUnifier();
+Object.assign(_shim.default, {
+    metaLevelUnifier: metaLevelUnifier
+});
+var _default = metaLevelUnifier;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/unifier/metaLevel.js"],"sourcesContent":["\"use strict\";\n\nimport shim from \"../shim\";\nimport Unifier from \"../unifier\";\nimport unifyVariableAgainstTerm from \"../unify/variableAgainstTerm\";\nimport unifyMetavariableAgainstStatement from \"../unify/metavariableAgainstStatement\";\n\nimport { unify } from \"../unifier\";\nimport { nodeQuery } from \"../utilities/query\";\n\nconst termNodeQuery = nodeQuery(\"/term!\"),\n      statementNodeQuery = nodeQuery(\"/statement!\"),\n      nonTerminalNodeQuery = nodeQuery(\"/*\"),\n      termVariableNodeQuery = nodeQuery(\"/term/variable!\"),\n      statementSubstitutionNodeQuery = nodeQuery(\"/statement/substitution!\"),\n      statementMetavariableNodeQuery = nodeQuery(\"/statement/metavariable!\");\n\nclass MetaLevelUnifier extends Unifier {\n  unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, unifyAhead) {\n    let nonTerminalNodeUnified;\n\n    const nodeQueryMaps = [\n      {\n        nodeQueryA: statementMetavariableNodeQuery,\n        nodeQueryB: statementNodeQuery,\n        unify: (nodeA, nodeB, substitutions, localContextA, localContextB, unifyAhead) => {\n          let nonTerminalNodeUnified;\n\n          const statementNodeA = nonTerminalNodeA,  ///\n                statementNodeB = nodeB, ///\n                statementMetavariableNodeA = nodeA, ///\n                statementSubstitutionNodeA = statementSubstitutionNodeQuery(statementNodeA),\n                metavariableNodeUnifiedAgainstStatementNode =\n\n                  this.unifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementSubstitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, unifyAhead);\n\n          nonTerminalNodeUnified = metavariableNodeUnifiedAgainstStatementNode;  ///\n\n          return nonTerminalNodeUnified;\n        }\n      },\n      {\n        nodeQueryA: termVariableNodeQuery,\n        nodeQueryB: termNodeQuery,\n        unify: (nodeA, nodeB, substitutions, localContextA, localContextB, unifyAhead) => {\n          let nonTerminalNodeUnified;\n\n          const termNodeB = nodeB,  ///\n                termVariableNodeA = nodeA,  ///\n                termVariableNodeUnifiedAgainstTermNode =\n\n                  this.unifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, unifyAhead);\n\n          nonTerminalNodeUnified = termVariableNodeUnifiedAgainstTermNode;  ///\n\n          return nonTerminalNodeUnified;\n        }\n      },\n      {\n        nodeQueryA: nonTerminalNodeQuery,\n        nodeQueryB: nonTerminalNodeQuery,\n        unify: (nodeA, nodeB, substitutions, localContextA, localContextB, unifyAhead) => {\n          let nonTerminalNodeUnified;\n\n          const nonTerminalNodeA = nodeA, ///\n                nonTerminalNodeB = nodeB; ///\n\n          nonTerminalNodeUnified =\n\n            super.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, unifyAhead);\n\n          return nonTerminalNodeUnified;\n        }\n      }\n    ];\n\n    const nodesUnified = unify(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, unifyAhead);\n\n    nonTerminalNodeUnified = nodesUnified;  ///\n\n    return nonTerminalNodeUnified;\n  }\n\n  unifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementSubstitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, unifyAhead) {\n    let metavariableNodeUnifiedAgainstStatementNode;\n\n    const substitutionNode = statementSubstitutionNodeA,  ///\n          metavariableNodeA = statementMetavariableNodeA, ///\n          metavariableUnifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, unifyAhead);\n\n    metavariableNodeUnifiedAgainstStatementNode = metavariableUnifiedAgainstStatement;  ///\n\n    return metavariableNodeUnifiedAgainstStatementNode;\n  }\n\n  unifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, unifyAhead) {\n    let termVariableNodeUnifiedAgainstTermNode;\n\n    const variableNodeA = termVariableNodeA, ///\n          termUnifiedAgainstVariable = unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, unifyAhead);\n\n    termVariableNodeUnifiedAgainstTermNode = termUnifiedAgainstVariable;  ///\n\n    return termVariableNodeUnifiedAgainstTermNode;\n  }\n}\n\nconst metaLevelUnifier = new MetaLevelUnifier();\n\nObject.assign(shim, {\n  metaLevelUnifier\n});\n\nexport default metaLevelUnifier;\n"],"names":["termNodeQuery","nodeQuery","statementNodeQuery","nonTerminalNodeQuery","termVariableNodeQuery","statementSubstitutionNodeQuery","statementMetavariableNodeQuery","MetaLevelUnifier","unifyNonTerminalNode","nonTerminalNodeA","nonTerminalNodeB","substitutions","localContextA","localContextB","unifyAhead","nonTerminalNodeUnified","nodeQueryMaps","nodeQueryA","nodeQueryB","unify","nodeA","nodeB","statementNodeA","statementNodeB","statementMetavariableNodeA","statementSubstitutionNodeA","metavariableNodeUnifiedAgainstStatementNode","unifyStatementMetavariableNodeAgainstStatementNode","termNodeB","termVariableNodeA","termVariableNodeUnifiedAgainstTermNode","unifyTermVariableNodeAgainstTermNode","nodesUnified","substitutionNode","metavariableNodeA","metavariableUnifiedAgainstStatement","unifyMetavariableAgainstStatement","variableNodeA","termUnifiedAgainstVariable","unifyVariableAgainstTerm","Unifier","metaLevelUnifier","Object","assign","shim"],"mappings":"AAAA;;;;+BAiHA;;;eAAA;;;2DA/GiB;+DACG;0EACiB;mFACS;qBAGpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE1B,IAAMA,gBAAgBC,IAAAA,gBAAS,EAAC,WAC1BC,qBAAqBD,IAAAA,gBAAS,EAAC,gBAC/BE,uBAAuBF,IAAAA,gBAAS,EAAC,OACjCG,wBAAwBH,IAAAA,gBAAS,EAAC,oBAClCI,iCAAiCJ,IAAAA,gBAAS,EAAC,6BAC3CK,iCAAiCL,IAAAA,gBAAS,EAAC;AAEjD,IAAA,AAAMM,iCAAD,AAAL;cAAMA;aAAAA;gCAAAA;iCAAAA;;kBAAAA;;YACJC,KAAAA;mBAAAA,SAAAA,qBAAqBC,gBAAgB,EAAEC,gBAAgB,EAAEC,aAAa,EAAEC,aAAa,EAAEC,aAAa,EAAEC,UAAU;;gBAC9G,IAAIC;gBAEJ,IAAMC,gBAAgB;oBACpB;wBACEC,YAAYX;wBACZY,YAAYhB;wBACZiB,OAAO,SAACC,OAAOC,OAAOV,eAAeC,eAAeC,eAAeC;4BACjE,IAAIC;4BAEJ,IAAMO,iBAAiBb,kBACjBc,iBAAiBF,OACjBG,6BAA6BJ,OAC7BK,6BAA6BpB,+BAA+BiB,iBAC5DI,8CAEE,MAAKC,kDAAkD,CAACH,4BAA4BC,4BAA4BF,gBAAgBZ,eAAeC,eAAeC,eAAeC;4BAErLC,yBAAyBW,6CAA8C,GAAG;4BAE1E,OAAOX;wBACT;oBACF;oBACA;wBACEE,YAAYb;wBACZc,YAAYlB;wBACZmB,OAAO,SAACC,OAAOC,OAAOV,eAAeC,eAAeC,eAAeC;4BACjE,IAAIC;4BAEJ,IAAMa,YAAYP,OACZQ,oBAAoBT,OACpBU,yCAEE,MAAKC,oCAAoC,CAACF,mBAAmBD,WAAWjB,eAAeC,eAAeC,eAAeC;4BAE7HC,yBAAyBe,wCAAyC,GAAG;4BAErE,OAAOf;wBACT;oBACF;oBACA;wBACEE,YAAYd;wBACZe,YAAYf;wBACZgB,OAAO,SAACC,OAAOC,OAAOV,eAAeC,eAAeC,eAAeC;4BACjE,IAAIC;4BAEJ,IAAMN,qBAAmBW,OACnBV,qBAAmBW,OAAO,GAAG;4BAEnCN,yBAEE,uBApDNR,6BAoDYC,2CAAqBC,oBAAkBC,oBAAkBC,eAAeC,eAAeC,eAAeC;4BAE9G,OAAOC;wBACT;oBACF;iBACD;gBAED,IAAMiB,eAAeb,IAAAA,cAAK,EAACH,eAAeP,kBAAkBC,kBAAkBC,eAAeC,eAAeC,eAAeC;gBAE3HC,yBAAyBiB,cAAe,GAAG;gBAE3C,OAAOjB;YACT;;;YAEAY,KAAAA;mBAAAA,SAAAA,mDAAmDH,0BAA0B,EAAEC,0BAA0B,EAAEF,cAAc,EAAEZ,aAAa,EAAEC,aAAa,EAAEC,aAAa,EAAEC,UAAU;gBAChL,IAAIY;gBAEJ,IAAMO,mBAAmBR,4BACnBS,oBAAoBV,4BACpBW,sCAAsCC,IAAAA,qCAAiC,EAACF,mBAAmBX,gBAAgBU,kBAAkBtB,eAAeC,eAAeC,eAAeC;gBAEhLY,8CAA8CS,qCAAsC,GAAG;gBAEvF,OAAOT;YACT;;;YAEAK,KAAAA;mBAAAA,SAAAA,qCAAqCF,iBAAiB,EAAED,SAAS,EAAEjB,aAAa,EAAEC,aAAa,EAAEC,aAAa,EAAEC,UAAU;gBACxH,IAAIgB;gBAEJ,IAAMO,gBAAgBR,mBAChBS,6BAA6BC,IAAAA,4BAAwB,EAACF,eAAeT,WAAWjB,eAAeC,eAAeC,eAAeC;gBAEnIgB,yCAAyCQ,4BAA6B,GAAG;gBAEzE,OAAOR;YACT;;;WAvFIvB;EAAyBiC,gBAAO;AA0FtC,IAAMC,mBAAmB,IAAIlC;AAE7BmC,OAAOC,MAAM,CAACC,aAAI,EAAE;IAClBH,kBAAAA;AACF;IAEA,WAAeA"}