occam-verify-cli 0.0.682 → 0.0.684

package/lib/context/local.js

@@ -0,0 +1,330 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _variable = /*#__PURE__*/ _interop_require_default(require("../variable"));
+var _equality = /*#__PURE__*/ _interop_require_default(require("../equality"));
+var _collection = /*#__PURE__*/ _interop_require_default(require("../collection"));
+var _file = /*#__PURE__*/ _interop_require_default(require("../mixins/file"));
+var _logging = /*#__PURE__*/ _interop_require_default(require("../mixins/logging"));
+var _array = require("../utilities/array");
+var _collection1 = require("../utilities/collection");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _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 _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var LocalContext = /*#__PURE__*/ function() {
+    function LocalContext(context, variables, proofSteps, collections) {
+        _class_call_check(this, LocalContext);
+        this.context = context;
+        this.variables = variables;
+        this.proofSteps = proofSteps;
+        this.collections = collections;
+    }
+    _create_class(LocalContext, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
+        {
+            key: "getVariables",
+            value: function getVariables() {
+                var variables = this.context.getVariables();
+                variables = _to_consumable_array(variables).concat(_to_consumable_array(this.variables));
+                return variables;
+            }
+        },
+        {
+            key: "getProofSteps",
+            value: function getProofSteps() {
+                var proofSteps = this.context.getProofSteps();
+                proofSteps = _to_consumable_array(proofSteps).concat(_to_consumable_array(this.proofSteps));
+                return proofSteps;
+            }
+        },
+        {
+            key: "getCollections",
+            value: function getCollections() {
+                var collections = this.context.getCollections();
+                var collectionsA = collections, collectionsB = this.collections;
+                collections = (0, _collection1.mergeCollections)(collectionsA, collectionsB); ///
+                return collections;
+            }
+        },
+        {
+            key: "getEqualities",
+            value: function getEqualities() {
+                var equalities = this.context.getEqualities();
+                this.proofSteps.forEach(function(proofStep) {
+                    var equality = _equality.default.fromProofStep(proofStep);
+                    if (equality !== null) {
+                        equalities.push(equality);
+                    }
+                });
+                return equalities;
+            }
+        },
+        {
+            key: "getLastProofStep",
+            value: function getLastProofStep() {
+                var lastProofStep = null;
+                var proofStepsLength = this.proofSteps.length;
+                if (proofStepsLength > 0) {
+                    lastProofStep = (0, _array.last)(this.proofSteps);
+                }
+                return lastProofStep;
+            }
+        },
+        {
+            key: "getMetavariables",
+            value: function getMetavariables() {
+                return this.context.getMetavariables();
+            }
+        },
+        {
+            key: "addEquality",
+            value: function addEquality(equality) {
+                var equalityReflexive = equality.isReflexive();
+                if (equalityReflexive) {
+                ///
+                } else {
+                    var leftTerm = equality.getLeftTerm(), rightTerm = equality.getRightTerm(), leftCollection = this.findCollectionByTerm(leftTerm), rightCollection = this.findCollectionByTerm(rightTerm);
+                    if (false) {
+                    ///
+                    } else if (leftCollection === null && rightCollection === null) {
+                        var collection = _collection.default.fromEquality(equality);
+                        this.addCollection(collection);
+                    } else if (leftCollection !== null && rightCollection === null) {
+                        var term = rightTerm, collection1 = leftCollection; ///
+                        collection1.addTerm(term);
+                    } else if (leftCollection === null && rightCollection !== null) {
+                        var term1 = leftTerm, collection2 = rightCollection; ///
+                        collection2.addTerm(term1);
+                    } else if (leftCollection !== null && rightCollection !== null) {
+                        debugger;
+                    }
+                }
+            }
+        },
+        {
+            key: "addVariable",
+            value: function addVariable(variable) {
+                var variableName = variable.getName();
+                (0, _array.filter)(this.variables, function(variable) {
+                    var name = variable.getName(), nameVariableName = name === variableName;
+                    if (!nameVariableName) {
+                        return true;
+                    }
+                });
+                this.variables.push(variable);
+            }
+        },
+        {
+            key: "addProofStep",
+            value: function addProofStep(proofStep) {
+                this.proofSteps.push(proofStep);
+            }
+        },
+        {
+            key: "addCollection",
+            value: function addCollection(collection) {
+                this.collections.push(collection);
+            }
+        },
+        {
+            key: "matchStatement",
+            value: function matchStatement(statementNode) {
+                var statementMatches = false;
+                if (!statementMatches) {
+                    var proofStepMatchesStatement = this.proofSteps.some(function(proofStep) {
+                        var proofStepMatchesStatement = proofStep.match(statementNode);
+                        if (proofStepMatchesStatement) {
+                            return true;
+                        }
+                    });
+                    statementMatches = proofStepMatchesStatement; ///
+                }
+                if (!statementMatches) {
+                    statementMatches = this.context.matchStatement(statementNode);
+                }
+                return statementMatches;
+            }
+        },
+        {
+            key: "findCollectionByType",
+            value: function findCollectionByType(type) {
+                var collections = this.getCollections(), collection = (0, _collection1.findCollectionByType)(collections, type);
+                return collection;
+            }
+        },
+        {
+            key: "findCollectionByTerm",
+            value: function findCollectionByTerm(term) {
+                var collections = this.getCollections(), collection = (0, _collection1.findCollectionByTerm)(collections, term);
+                return collection;
+            }
+        },
+        {
+            key: "findCollectionByTerms",
+            value: function findCollectionByTerms(terms) {
+                var collections = this.getCollections(), collection = (0, _collection1.findCollectionByTerms)(collections, terms);
+                return collection;
+            }
+        },
+        {
+            key: "findVariableByVariableName",
+            value: function findVariableByVariableName(variableName) {
+                var name = variableName, variables = this.getVariables(), variable = variables.find(function(variable) {
+                    var matches = variable.matchName(name);
+                    if (matches) {
+                        return true;
+                    }
+                }) || null;
+                return variable;
+            }
+        },
+        {
+            key: "isVariablePresentByVariableName",
+            value: function isVariablePresentByVariableName(variableName) {
+                var variable = this.findVariableByVariableName(variableName), variablePresent = variable !== null;
+                return variablePresent;
+            }
+        },
+        {
+            key: "isEqualityEqual",
+            value: function isEqualityEqual(equality) {
+                var equalityEqual;
+                var equalityReflexive = equality.isReflexive();
+                if (equalityReflexive) {
+                    equalityEqual = true;
+                } else {
+                    var leftTerm = equality.getLeftTerm(), rightTerm = equality.getRightTerm(), terms = [
+                        leftTerm,
+                        rightTerm
+                    ], termsEqual = this.areTermsEqual(terms);
+                    equalityEqual = termsEqual; ///
+                }
+                return equalityEqual;
+            }
+        },
+        {
+            key: "areTermsEqual",
+            value: function areTermsEqual(terms) {
+                var collection = this.findCollectionByTerms(terms), termsEqual = collection !== null;
+                return termsEqual;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON(tokens) {
+                var variables = this.variables.map(function(variable) {
+                    var variableJSON = variable.toJSON(tokens);
+                    variable = variableJSON;
+                    return variable;
+                }), json = {
+                    variables: variables
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromFileContext",
+            value: function fromFileContext(fileContext) {
+                var context = fileContext, variables = [], proofSteps = [], collections = [], localContext = new LocalContext(context, variables, proofSteps, collections);
+                return localContext;
+            }
+        },
+        {
+            key: "fromLocalContext",
+            value: function fromLocalContext(localContext) {
+                var context = localContext, variables = [], proofSteps = [], collections = [];
+                localContext = new LocalContext(context, variables, proofSteps, collections);
+                return localContext;
+            }
+        },
+        {
+            key: "fromJSONAndFileContext",
+            value: function fromJSONAndFileContext(json, fileContext) {
+                var variables = json.variables;
+                var variablesJSON = variables;
+                variables = variablesJSON.map(function(variableJSON) {
+                    var _$json = variableJSON, variable = _variable.default.fromJSONAndFileContext(_$json, fileContext);
+                    return variable;
+                });
+                var context = fileContext, proofSteps = [], collections = [], localContext = new LocalContext(context, variables, proofSteps, collections);
+                return localContext;
+            }
+        },
+        {
+            key: "fromLocalContextAndAssignments",
+            value: function fromLocalContextAndAssignments(localContext, assignments) {
+                var context = localContext, variables = assignments.map(function(assignment) {
+                    var variable = assignment.getVariable();
+                    return variable;
+                }), proofSteps = [], collections = [];
+                localContext = new LocalContext(context, variables, proofSteps, collections);
+                return localContext;
+            }
+        }
+    ]);
+    return LocalContext;
+}();
+Object.assign(LocalContext.prototype, _file.default);
+Object.assign(LocalContext.prototype, _logging.default);
+var _default = LocalContext;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/local.js"],"sourcesContent":["\"use strict\";\n\nimport Variable from \"../variable\";\nimport Equality from \"../equality\";\nimport Collection from \"../collection\";\nimport fileMixins from \"../mixins/file\";\nimport loggingMixins from \"../mixins/logging\";\n\nimport { last, filter } from \"../utilities/array\";\nimport { mergeCollections, findCollectionByType, findCollectionByTerm, findCollectionByTerms } from \"../utilities/collection\";\n\nclass LocalContext {\n  constructor(context, variables, proofSteps, collections) {\n    this.context = context;\n    this.variables = variables;\n    this.proofSteps = proofSteps;\n    this.collections = collections;\n  }\n\n  getContext() {\n    return this.context;\n  }\n\n  getVariables() {\n    let variables = this.context.getVariables();\n\n    variables = [ ///\n      ...variables,\n      ...this.variables\n    ];\n\n    return variables;\n  }\n\n  getProofSteps() {\n    let proofSteps = this.context.getProofSteps();\n\n    proofSteps = [  ///\n      ...proofSteps,\n      ...this.proofSteps\n    ];\n\n    return proofSteps;\n  }\n\n  getCollections() {\n    let collections = this.context.getCollections();\n\n    const collectionsA = collections, ///\n          collectionsB = this.collections;\n\n    collections = mergeCollections(collectionsA, collectionsB); ///\n\n    return collections;\n  }\n\n  getEqualities() {\n    const equalities = this.context.getEqualities();\n\n    this.proofSteps.forEach((proofStep) => {\n      const equality = Equality.fromProofStep(proofStep);\n\n      if (equality !== null) {\n        equalities.push(equality);\n      }\n    });\n\n    return equalities;\n  }\n\n  getLastProofStep() {\n    let lastProofStep = null;\n\n    const proofStepsLength = this.proofSteps.length;\n\n    if (proofStepsLength > 0) {\n      lastProofStep = last(this.proofSteps);\n    }\n\n    return lastProofStep;\n  }\n\n  getMetavariables() { return this.context.getMetavariables(); }\n\n  addEquality(equality) {\n    const equalityReflexive = equality.isReflexive();\n\n    if (equalityReflexive) {\n      ///\n    } else {\n      const leftTerm = equality.getLeftTerm(),\n            rightTerm = equality.getRightTerm(),\n            leftCollection = this.findCollectionByTerm(leftTerm),\n            rightCollection = this.findCollectionByTerm(rightTerm);\n\n      if (false) {\n        ///\n      } else if ((leftCollection === null) && (rightCollection === null)) {\n        const collection = Collection.fromEquality(equality);\n\n        this.addCollection(collection);\n      } else if ((leftCollection !== null) && (rightCollection === null)) {\n        const term = rightTerm, ///\n              collection = leftCollection;  ///\n\n        collection.addTerm(term);\n      } else if ((leftCollection === null) && (rightCollection !== null)) {\n        const term = leftTerm, ///\n              collection = rightCollection;  ///\n\n        collection.addTerm(term);\n      } else if ((leftCollection !== null) && (rightCollection !== null)) {\n\n        debugger\n\n      }\n    }\n  }\n\n  addVariable(variable) {\n    const variableName = variable.getName();\n\n    filter(this.variables, (variable) => {\n      const name = variable.getName(),\n            nameVariableName = (name === variableName);\n\n      if (!nameVariableName) {\n        return true;\n      }\n    });\n\n    this.variables.push(variable);\n  }\n\n  addProofStep(proofStep) {\n    this.proofSteps.push(proofStep);\n  }\n\n  addCollection(collection) {\n    this.collections.push(collection);\n  }\n\n  matchStatement(statementNode) {\n    let statementMatches = false;\n\n    if (!statementMatches) {\n      const proofStepMatchesStatement = this.proofSteps.some((proofStep) => {\n        const proofStepMatchesStatement = proofStep.match(statementNode);\n\n        if (proofStepMatchesStatement) {\n          return true;\n        }\n      });\n\n      statementMatches = proofStepMatchesStatement; ///\n    }\n\n    if (!statementMatches) {\n      statementMatches = this.context.matchStatement(statementNode);\n    }\n\n    return statementMatches;\n  }\n\n  findCollectionByType(type) {\n    const collections = this.getCollections(),\n          collection = findCollectionByType(collections, type);\n\n    return collection;\n  }\n\n  findCollectionByTerm(term) {\n    const collections = this.getCollections(),\n          collection = findCollectionByTerm(collections, term);\n\n    return collection;\n  }\n\n  findCollectionByTerms(terms) {\n    const collections = this.getCollections(),\n          collection = findCollectionByTerms(collections, terms);\n\n    return collection;\n  }\n\n  findVariableByVariableName(variableName) {\n    const name = variableName,  ///\n          variables = this.getVariables(),\n          variable = variables.find((variable) => {\n            const matches = variable.matchName(name);\n\n            if (matches) {\n              return true;\n            }\n          }) || null;\n\n    return variable;\n  }\n\n  isVariablePresentByVariableName(variableName) {\n    const variable = this.findVariableByVariableName(variableName),\n          variablePresent = (variable !== null);\n\n    return variablePresent;\n  }\n\n  isEqualityEqual(equality) {\n    let equalityEqual;\n\n    const equalityReflexive = equality.isReflexive();\n\n    if (equalityReflexive) {\n      equalityEqual = true;\n    } else {\n      const leftTerm = equality.getLeftTerm(),\n            rightTerm = equality.getRightTerm(),\n            terms = [\n              leftTerm,\n              rightTerm\n            ],\n            termsEqual = this.areTermsEqual(terms);\n\n      equalityEqual = termsEqual; ///\n    }\n\n    return equalityEqual;\n  }\n\n  areTermsEqual(terms) {\n    const collection = this.findCollectionByTerms(terms),\n          termsEqual = (collection !== null);\n\n    return termsEqual;\n  }\n\n  toJSON(tokens) {\n    const variables = this.variables.map((variable) => {\n            const variableJSON = variable.toJSON(tokens);\n\n            variable = variableJSON;\n\n            return variable;\n          }),\n          json = {\n            variables\n          };\n\n    return json;\n  }\n\n  static fromFileContext(fileContext) {\n    const context = fileContext,  ///\n          variables = [],\n          proofSteps = [],\n          collections = [],\n          localContext = new LocalContext(context, variables, proofSteps, collections);\n\n    return localContext;\n  }\n\n  static fromLocalContext(localContext) {\n    const context = localContext,  ///\n          variables = [],\n          proofSteps = [],\n          collections = [];\n\n    localContext = new LocalContext(context, variables, proofSteps, collections);\n\n    return localContext;\n  }\n\n  static fromJSONAndFileContext(json, fileContext) {\n    let { variables } = json;\n\n    const variablesJSON = variables;\n\n    variables = variablesJSON.map((variableJSON) => {\n      const json = variableJSON,  ///\n            variable = Variable.fromJSONAndFileContext(json, fileContext);\n\n      return variable;\n    });\n\n    const context = fileContext,  ///\n          proofSteps = [],\n          collections = [],\n          localContext = new LocalContext(context, variables, proofSteps, collections);\n\n    return localContext;\n  }\n\n  static fromLocalContextAndAssignments(localContext, assignments) {\n    const context = localContext,  ///\n          variables = assignments.map((assignment) => {\n            const variable = assignment.getVariable();\n\n            return variable;\n          }),\n          proofSteps = [],\n          collections = [];\n\n    localContext = new LocalContext(context, variables, proofSteps, collections);\n\n    return localContext;\n  }\n}\n\nObject.assign(LocalContext.prototype, fileMixins);\nObject.assign(LocalContext.prototype, loggingMixins);\n\nexport default LocalContext;\n"],"names":["LocalContext","context","variables","proofSteps","collections","getContext","getVariables","getProofSteps","getCollections","collectionsA","collectionsB","mergeCollections","getEqualities","equalities","forEach","proofStep","equality","Equality","fromProofStep","push","getLastProofStep","lastProofStep","proofStepsLength","length","last","getMetavariables","addEquality","equalityReflexive","isReflexive","leftTerm","getLeftTerm","rightTerm","getRightTerm","leftCollection","findCollectionByTerm","rightCollection","collection","Collection","fromEquality","addCollection","term","addTerm","addVariable","variable","variableName","getName","filter","name","nameVariableName","addProofStep","matchStatement","statementNode","statementMatches","proofStepMatchesStatement","some","match","findCollectionByType","type","findCollectionByTerms","terms","findVariableByVariableName","find","matches","matchName","isVariablePresentByVariableName","variablePresent","isEqualityEqual","equalityEqual","termsEqual","areTermsEqual","toJSON","tokens","map","variableJSON","json","fromFileContext","fileContext","localContext","fromLocalContext","fromJSONAndFileContext","variablesJSON","Variable","fromLocalContextAndAssignments","assignments","assignment","getVariable","Object","assign","prototype","fileMixins","loggingMixins"],"mappings":"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"}

package/lib/context/localMeta.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _file = /*#__PURE__*/ _interop_require_default(require("../mixins/file"));
+var _logging = /*#__PURE__*/ _interop_require_default(require("../mixins/logging"));
+var _array = require("../utilities/array");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _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 _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var LocalMetaContext = /*#__PURE__*/ function() {
+    function LocalMetaContext(context, metavariables, metaproofSteps) {
+        _class_call_check(this, LocalMetaContext);
+        this.context = context;
+        this.metavariables = metavariables;
+        this.metaproofSteps = metaproofSteps;
+    }
+    _create_class(LocalMetaContext, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
+        {
+            key: "getMetavariables",
+            value: function getMetavariables() {
+                var metavariables = this.context.getMetavariables();
+                metavariables = _to_consumable_array(metavariables).concat([
+                    this.metavariables
+                ]);
+                return metavariables;
+            }
+        },
+        {
+            key: "getMetaproofSteps",
+            value: function getMetaproofSteps() {
+                var metaproofSteps = this.context.getMetaproofSteps();
+                metaproofSteps = _to_consumable_array(metaproofSteps).concat(_to_consumable_array(this.metaproofSteps));
+                return metaproofSteps;
+            }
+        },
+        {
+            key: "getVariables",
+            value: function getVariables() {
+                return this.context.getVariables();
+            }
+        },
+        {
+            key: "getLastMetaproofStep",
+            value: function getLastMetaproofStep() {
+                var lastMetaproofStep = null;
+                var metaproofStepsLength = this.metaproofSteps.length;
+                if (metaproofStepsLength > 0) {
+                    lastMetaproofStep = (0, _array.last)(this.metaproofSteps);
+                }
+                return lastMetaproofStep;
+            }
+        },
+        {
+            key: "addMetavariable",
+            value: function addMetavariable(metavariable) {
+                var metavariableName = metavariable.getName();
+                (0, _array.filter)(this.metavariables, function(metavariable) {
+                    var name = metavariable.getName(), nameMetavariableName = name === metavariableName;
+                    if (!nameMetavariableName) {
+                        return true;
+                    }
+                });
+                this.metavariables.push(metavariable);
+            }
+        },
+        {
+            key: "addMetaproofStep",
+            value: function addMetaproofStep(metaproofStep) {
+                this.metaproofSteps.push(metaproofStep);
+            }
+        },
+        {
+            key: "matchMetastatement",
+            value: function matchMetastatement(metastatementNode) {
+                var metastatementMatches = false;
+                if (!metastatementMatches) {
+                    var proofStepMatchesMetastatement = this.metaproofSteps.some(function(metaproofStep) {
+                        var proofStepMatchesMetastatement = metaproofStep.match(metastatementNode);
+                        if (proofStepMatchesMetastatement) {
+                            return true;
+                        }
+                    });
+                    metastatementMatches = proofStepMatchesMetastatement; ///
+                }
+                if (!metastatementMatches) {
+                    metastatementMatches = this.context.matchMetastatement(metastatementNode);
+                }
+                return metastatementMatches;
+            }
+        },
+        {
+            key: "findMetavariableByMetavariableName",
+            value: function findMetavariableByMetavariableName(metavariableName) {
+                var name = metavariableName, metavariables = this.getMetavariables(), metavariable = metavariables.find(function(metavariable) {
+                    var matches = metavariable.matchName(name);
+                    if (matches) {
+                        return true;
+                    }
+                }) || null;
+                return metavariable;
+            }
+        },
+        {
+            key: "isMetavariablePresentByMetavariableName",
+            value: function isMetavariablePresentByMetavariableName(metavariableName) {
+                var metavariable = this.findMetavariableByMetavariableName(metavariableName), metavariablePresent = metavariable !== null;
+                return metavariablePresent;
+            }
+        }
+    ], [
+        {
+            key: "fromFileContext",
+            value: function fromFileContext(fileContext) {
+                var context = fileContext, metavariables = [], metaproofSteps = [], localMetaContext = new LocalMetaContext(context, metavariables, metaproofSteps);
+                return localMetaContext;
+            }
+        },
+        {
+            key: "fromLocalMetaContext",
+            value: function fromLocalMetaContext(localMetaContext) {
+                var context = localMetaContext, metavariables = [], metaproofSteps = [];
+                localMetaContext = new LocalMetaContext(context, metavariables, metaproofSteps); ///
+                return localMetaContext;
+            }
+        }
+    ]);
+    return LocalMetaContext;
+}();
+Object.assign(LocalMetaContext.prototype, _file.default);
+Object.assign(LocalMetaContext.prototype, _logging.default);
+var _default = LocalMetaContext;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/localMeta.js"],"sourcesContent":["\"use strict\";\n\nimport fileMixins from \"../mixins/file\";\nimport loggingMixins from \"../mixins/logging\";\n\nimport { last, filter } from \"../utilities/array\";\n\nclass LocalMetaContext {\n  constructor(context, metavariables, metaproofSteps) {\n    this.context = context;\n    this.metavariables = metavariables;\n    this.metaproofSteps = metaproofSteps;\n  }\n\n  getContext() {\n    return this.context;\n  }\n\n  getMetavariables() {\n    let metavariables = this.context.getMetavariables();\n\n    metavariables = [ ///\n      ...metavariables,\n      this.metavariables\n    ]\n\n    return metavariables;\n  }\n\n  getMetaproofSteps() {\n    let metaproofSteps = this.context.getMetaproofSteps();\n\n    metaproofSteps = [  ///\n      ...metaproofSteps,\n      ...this.metaproofSteps\n    ];\n\n    return metaproofSteps;\n  }\n\n  getVariables() { return this.context.getVariables(); }\n\n  getLastMetaproofStep() {\n    let lastMetaproofStep = null;\n\n    const metaproofStepsLength = this.metaproofSteps.length;\n\n    if (metaproofStepsLength > 0) {\n      lastMetaproofStep = last(this.metaproofSteps);\n    }\n\n    return lastMetaproofStep;\n  }\n\n  addMetavariable(metavariable) {\n    const metavariableName = metavariable.getName();\n\n    filter(this.metavariables, (metavariable) => {\n      const name = metavariable.getName(),\n            nameMetavariableName = (name === metavariableName);\n\n      if (!nameMetavariableName) {\n        return true;\n      }\n    });\n\n    this.metavariables.push(metavariable);\n  }\n\n  addMetaproofStep(metaproofStep) {\n    this.metaproofSteps.push(metaproofStep);\n  }\n\n  matchMetastatement(metastatementNode) {\n    let metastatementMatches = false;\n\n    if (!metastatementMatches) {\n      const proofStepMatchesMetastatement = this.metaproofSteps.some((metaproofStep) => {\n        const proofStepMatchesMetastatement = metaproofStep.match(metastatementNode);\n\n        if (proofStepMatchesMetastatement) {\n          return true;\n        }\n      });\n\n      metastatementMatches = proofStepMatchesMetastatement; ///\n    }\n\n    if (!metastatementMatches) {\n      metastatementMatches = this.context.matchMetastatement(metastatementNode);\n    }\n\n    return metastatementMatches;\n  }\n\n  findMetavariableByMetavariableName(metavariableName) {\n    const name = metavariableName,  ///\n          metavariables = this.getMetavariables(),\n          metavariable = metavariables.find((metavariable) => {\n            const matches = metavariable.matchName(name);\n\n            if (matches) {\n              return true;\n            }\n          }) || null;\n\n    return metavariable;\n  }\n\n  isMetavariablePresentByMetavariableName(metavariableName) {\n    const metavariable = this.findMetavariableByMetavariableName(metavariableName),\n          metavariablePresent = (metavariable !== null);\n\n    return metavariablePresent;\n  }\n\n  static fromFileContext(fileContext) {\n    const context = fileContext,  ///\n          metavariables = [],\n          metaproofSteps = [],\n          localMetaContext = new LocalMetaContext(context, metavariables, metaproofSteps);\n\n    return localMetaContext;\n  }\n\n  static fromLocalMetaContext(localMetaContext) {\n    const context = localMetaContext,  ///\n          metavariables = [],\n          metaproofSteps = [];\n\n    localMetaContext = new LocalMetaContext(context, metavariables, metaproofSteps);  ///\n\n    return localMetaContext;\n  }\n}\n\nObject.assign(LocalMetaContext.prototype, fileMixins);\nObject.assign(LocalMetaContext.prototype, loggingMixins);\n\nexport default LocalMetaContext;"],"names":["LocalMetaContext","context","metavariables","metaproofSteps","getContext","getMetavariables","getMetaproofSteps","getVariables","getLastMetaproofStep","lastMetaproofStep","metaproofStepsLength","length","last","addMetavariable","metavariable","metavariableName","getName","filter","name","nameMetavariableName","push","addMetaproofStep","metaproofStep","matchMetastatement","metastatementNode","metastatementMatches","proofStepMatchesMetastatement","some","match","findMetavariableByMetavariableName","find","matches","matchName","isMetavariablePresentByMetavariableName","metavariablePresent","fromFileContext","fileContext","localMetaContext","fromLocalMetaContext","Object","assign","prototype","fileMixins","loggingMixins"],"mappings":"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"}