occam-verify-cli 1.0.448 → 1.0.472

package/lib/context/scoped.js

@@ -0,0 +1,322 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _necessary = require("necessary");
+var _occamfurtle = require("occam-furtle");
+var _elements = /*#__PURE__*/ _interop_require_default(require("../elements"));
+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 last = _necessary.arrayUtilities.last, chainContext = _occamfurtle.contextUtilities.chainContext;
+var ScopedContext = /*#__PURE__*/ function() {
+    function ScopedContext(context, variables, judgements, equivalences, subproofOrProofAssertions) {
+        _class_call_check(this, ScopedContext);
+        this.context = context;
+        this.variables = variables;
+        this.judgements = judgements;
+        this.equivalences = equivalences;
+        this.subproofOrProofAssertions = subproofOrProofAssertions;
+        return chainContext(this);
+    }
+    _create_class(ScopedContext, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
+        {
+            key: "getVariables",
+            value: function getVariables() {
+                var nested = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var variables;
+                if (nested) {
+                    variables = this.context.getVariables();
+                    variables = _to_consumable_array(this.variables).concat(_to_consumable_array(variables));
+                } else {
+                    variables = this.variables;
+                }
+                return variables;
+            }
+        },
+        {
+            key: "getJudgements",
+            value: function getJudgements() {
+                var judgements = this.context.getJudgements();
+                judgements = _to_consumable_array(this.judgements).concat(_to_consumable_array(judgements));
+                return judgements;
+            }
+        },
+        {
+            key: "getEquivalences",
+            value: function getEquivalences() {
+                var equivalences = this.context.getEquivalences();
+                var context = this; ///
+                equivalences = this.equivalences.mergedWith(equivalences, context); ///
+                return equivalences;
+            }
+        },
+        {
+            key: "getProofAssertions",
+            value: function getProofAssertions() {
+                var subproofOrProofAssertions = this.getSubproofOrProofAssertions(), proofAssertions = subproofOrProofAssertions.filter(function(subproofOrProofAssertion) {
+                    var subproofOrProofAssertionproofAssertion = subproofOrProofAssertion.isProofAssertion();
+                    if (subproofOrProofAssertionproofAssertion) {
+                        return true;
+                    }
+                });
+                return proofAssertions;
+            }
+        },
+        {
+            key: "getLastProofAssertion",
+            value: function getLastProofAssertion() {
+                var lastProofAssertion = null;
+                var proofAssertions = this.getProofAssertions(), proofAssertionsLength = proofAssertions.length;
+                if (proofAssertionsLength > 0) {
+                    lastProofAssertion = last(proofAssertions);
+                }
+                return lastProofAssertion;
+            }
+        },
+        {
+            key: "getSubproofOrProofAssertions",
+            value: function getSubproofOrProofAssertions() {
+                var subproofOrProofAssertions = this.context.getSubproofOrProofAssertions();
+                subproofOrProofAssertions = _to_consumable_array(subproofOrProofAssertions).concat(_to_consumable_array(this.subproofOrProofAssertions));
+                return subproofOrProofAssertions;
+            }
+        },
+        {
+            key: "addEquality",
+            value: function addEquality(equality) {
+                var equalityAdded;
+                var equalityReflexive = equality.isReflexive();
+                if (!equalityReflexive) {
+                    var Equivalence = _elements.default.Equivalence, equivalence = Equivalence.fromEquality(equality), context = this; ///
+                    this.equivalences = this.equivalences.mergedWithEquivalence(equivalence, context);
+                }
+                equalityAdded = true;
+                if (equalityAdded) {
+                    var context1 = this, equalityString = equality.getString();
+                    context1.trace("Added the '".concat(equalityString, "' equality."));
+                }
+                return equalityAdded;
+            }
+        },
+        {
+            key: "addVariable",
+            value: function addVariable(variable) {
+                var nested = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+                var variableAdded = false;
+                var variableIdentifier = variable.getIdentifier(), variablePresent = this.isVariablePresentByVariableIdentifier(variableIdentifier, nested);
+                if (!variablePresent) {
+                    this.variables.push(variable);
+                    variableAdded = true;
+                }
+                if (variableAdded) {
+                    var context = this, variableString = variable.getString();
+                    context.trace("Added the '".concat(variableString, "' variable."));
+                }
+                return variableAdded;
+            }
+        },
+        {
+            key: "addJudgement",
+            value: function addJudgement(judgement) {
+                var judgementAdded = false;
+                var metavariable = judgement.getMetavariable(), judgementPresent = this.isJudgementPresentByMetavariable(metavariable);
+                if (!judgementPresent) {
+                    this.judgements.push(judgement);
+                    judgementAdded = true;
+                }
+                if (judgementAdded) {
+                    var context = this, judgementString = judgement.getString();
+                    context.trace("Added the '".concat(judgementString, "' judgement."));
+                }
+                return judgementAdded;
+            }
+        },
+        {
+            key: "addSubproofOrProofAssertion",
+            value: function addSubproofOrProofAssertion(subproofOrProofAssertion) {
+                this.subproofOrProofAssertions.push(subproofOrProofAssertion);
+            }
+        },
+        {
+            key: "findEquivalenceByTerm",
+            value: function findEquivalenceByTerm(term) {
+                return this.equivalences.findEquivalenceByTerm(term);
+            }
+        },
+        {
+            key: "findJudgementByMetavariable",
+            value: function findJudgementByMetavariable(metavariable) {
+                var judgements = this.getJudgements(), judgement = judgements.find(function(judgement) {
+                    var judgementSingular = judgement.isSingular();
+                    if (judgementSingular) {
+                        var judgementMetavariable = judgement.getMetavariable(), judgementMetavariableEqualToMetavariable = judgementMetavariable.isEqualTo(metavariable);
+                        if (judgementMetavariableEqualToMetavariable) {
+                            return true;
+                        }
+                    }
+                }) || null;
+                return judgement;
+            }
+        },
+        {
+            key: "findVariableByVariableIdentifier",
+            value: function findVariableByVariableIdentifier(variableIdentifier) {
+                var nested = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+                var variables = this.getVariables(nested), variable = variables.find(function(variable) {
+                    var variableComparesToVariableIdentifier = variable.compareVariableIdentifier(variableIdentifier);
+                    if (variableComparesToVariableIdentifier) {
+                        return true;
+                    }
+                }) || null;
+                return variable;
+            }
+        },
+        {
+            key: "isTermGrounded",
+            value: function isTermGrounded(term) {
+                var context = this, equivalences = this.getEquivalences(), groundedTerms = [], definedVariables = [];
+                equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
+                var termMatchesGroundedTerm = groundedTerms.some(function(groundedTerm) {
+                    var groundedTermNode = groundedTerm.getNode(), groundedTermNodeMatches = term.matchNode(groundedTermNode);
+                    if (groundedTermNodeMatches) {
+                        return true;
+                    }
+                }), termGrounded = termMatchesGroundedTerm; ///
+                return termGrounded;
+            }
+        },
+        {
+            key: "isVariableDefined",
+            value: function isVariableDefined(variable) {
+                var context = this, equivalences = this.getEquivalences(), groundedTerms = [], definedVariables = [];
+                equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
+                var variableMatchesDefinedVariable = definedVariables.some(function(definedVariable) {
+                    var definedVariableEqualToVariable = definedVariable.isEqualTo(variable);
+                    if (definedVariableEqualToVariable === variable) {
+                        return true;
+                    }
+                }), variableDefined = variableMatchesDefinedVariable; ///
+                return variableDefined;
+            }
+        },
+        {
+            key: "isMetavariableDefined",
+            value: function isMetavariableDefined(metavariable) {
+                var judgementPresent = this.isJudgementPresentByMetavariable(metavariable), metavariableDefined = judgementPresent; ///
+                return metavariableDefined;
+            }
+        },
+        {
+            key: "isJudgementPresentByMetavariable",
+            value: function isJudgementPresentByMetavariable(metavariable) {
+                var judgement = this.findJudgementByMetavariable(metavariable), judgementPresent = judgement !== null;
+                return judgementPresent;
+            }
+        },
+        {
+            key: "isVariablePresentByVariableIdentifier",
+            value: function isVariablePresentByVariableIdentifier(variableIdentifier) {
+                var nested = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+                var variable = this.findVariableByVariableIdentifier(variableIdentifier, nested), variablePresent = variable !== null;
+                return variablePresent;
+            }
+        },
+        {
+            key: "compareTermAndPropertyRelation",
+            value: function compareTermAndPropertyRelation(term, propertyRelation) {
+                var context = this, proofAssertions = this.getProofAssertions(), comparesToTermAndPropertyRelation = proofAssertions.some(function(proofAssertion) {
+                    var comparesToTermAndPropertyRelation = proofAssertion.compareTermAndPropertyRelation(term, propertyRelation, context);
+                    if (comparesToTermAndPropertyRelation) {
+                        return true;
+                    }
+                });
+                return comparesToTermAndPropertyRelation;
+            }
+        },
+        {
+            key: "getFileContext",
+            value: function getFileContext() {
+                return this.context.getFileContext();
+            }
+        },
+        {
+            key: "getDepth",
+            value: function getDepth() {
+                var depth = this.context.getDepth();
+                depth++;
+                return depth;
+            }
+        }
+    ], [
+        {
+            key: "fromNothing",
+            value: function fromNothing(context) {
+                var Equivalences = _elements.default.Equivalences, variables = [], judgements = [], equivalences = Equivalences.fromNothing(context), subproofOrProofAssertions = [], scopedContext = new ScopedContext(context, variables, judgements, equivalences, subproofOrProofAssertions);
+                return scopedContext;
+            }
+        }
+    ]);
+    return ScopedContext;
+}();
+var _default = ScopedContext;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/scoped.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\nimport { contextUtilities } from \"occam-furtle\";\n\nimport elements from \"../elements\";\n\nconst { last } = arrayUtilities,\n      { chainContext } = contextUtilities;\n\nclass ScopedContext {\n  constructor(context, variables, judgements, equivalences, subproofOrProofAssertions) {\n    this.context = context;\n    this.variables = variables;\n    this.judgements = judgements;\n    this.equivalences = equivalences;\n    this.subproofOrProofAssertions = subproofOrProofAssertions;\n\n    return chainContext(this);\n  }\n\n  getContext() {\n    return this.context;\n  }\n\n  getVariables(nested = true) {\n    let variables;\n\n    if (nested) {\n      variables = this.context.getVariables();\n\n      variables = [\n        ...this.variables,\n        ...variables\n      ];\n    } else {\n      variables = this.variables;\n    }\n\n    return variables;\n  }\n\n  getJudgements() {\n    let judgements = this.context.getJudgements();\n\n    judgements = [ ///\n      ...this.judgements,\n      ...judgements\n    ]\n\n    return judgements;\n  }\n\n  getEquivalences() {\n    let equivalences = this.context.getEquivalences();\n\n    const context = this; ///\n\n    equivalences = this.equivalences.mergedWith(equivalences, context);  ///\n\n    return equivalences;\n  }\n\n  getProofAssertions() {\n    const subproofOrProofAssertions = this.getSubproofOrProofAssertions(),\n          proofAssertions = subproofOrProofAssertions.filter((subproofOrProofAssertion) => {\n            const subproofOrProofAssertionproofAssertion = subproofOrProofAssertion.isProofAssertion();\n\n            if (subproofOrProofAssertionproofAssertion) {\n              return true;\n            }\n          });\n\n    return proofAssertions;\n  }\n\n  getLastProofAssertion() {\n    let lastProofAssertion = null;\n\n    const proofAssertions = this.getProofAssertions(),\n          proofAssertionsLength = proofAssertions.length;\n\n    if (proofAssertionsLength > 0) {\n      lastProofAssertion = last(proofAssertions);\n    }\n\n    return lastProofAssertion;\n  }\n\n  getSubproofOrProofAssertions() {\n    let subproofOrProofAssertions = this.context.getSubproofOrProofAssertions();\n\n    subproofOrProofAssertions = [  ///\n      ...subproofOrProofAssertions,\n      ...this.subproofOrProofAssertions\n    ];\n\n    return subproofOrProofAssertions;\n  }\n\n  addEquality(equality) {\n    let equalityAdded;\n\n    const equalityReflexive = equality.isReflexive();\n\n    if (!equalityReflexive) {\n      const { Equivalence } = elements,\n            equivalence = Equivalence.fromEquality(equality),\n            context = this; ///\n\n      this.equivalences = this.equivalences.mergedWithEquivalence(equivalence, context);\n    }\n\n    equalityAdded = true;\n\n    if (equalityAdded) {\n      const context = this, ///\n            equalityString = equality.getString();\n\n      context.trace(`Added the '${equalityString}' equality.`)\n    }\n\n    return equalityAdded;\n  }\n\n  addVariable(variable, nested = true) {\n    let variableAdded = false;\n\n    const variableIdentifier = variable.getIdentifier(),\n          variablePresent = this.isVariablePresentByVariableIdentifier(variableIdentifier, nested);\n\n    if (!variablePresent) {\n      this.variables.push(variable);\n\n      variableAdded = true;\n    }\n\n    if (variableAdded) {\n      const context = this,\n            variableString = variable.getString();\n\n      context.trace(`Added the '${variableString}' variable.`)\n    }\n\n    return variableAdded;\n  }\n\n  addJudgement(judgement) {\n    let judgementAdded = false;\n\n    const metavariable = judgement.getMetavariable(),\n          judgementPresent = this.isJudgementPresentByMetavariable(metavariable);\n\n    if (!judgementPresent) {\n      this.judgements.push(judgement);\n\n      judgementAdded = true;\n    }\n\n    if (judgementAdded) {\n      const context = this, ///\n            judgementString = judgement.getString();\n\n      context.trace(`Added the '${judgementString}' judgement.`)\n    }\n\n    return judgementAdded;\n  }\n\n  addSubproofOrProofAssertion(subproofOrProofAssertion) {\n    this.subproofOrProofAssertions.push(subproofOrProofAssertion);\n  }\n\n  findEquivalenceByTerm(term) { return this.equivalences.findEquivalenceByTerm(term); }\n\n  findJudgementByMetavariable(metavariable) {\n    const judgements = this.getJudgements(),\n          judgement = judgements.find((judgement) => {\n            const judgementSingular = judgement.isSingular();\n\n            if (judgementSingular) {\n              const judgementMetavariable = judgement.getMetavariable(),\n                    judgementMetavariableEqualToMetavariable = judgementMetavariable.isEqualTo(metavariable);\n\n              if (judgementMetavariableEqualToMetavariable) {\n                return true;\n              }\n            }\n          }) || null;\n\n    return judgement;\n  }\n\n  findVariableByVariableIdentifier(variableIdentifier, nested = true) {\n    const variables = this.getVariables(nested),\n          variable = variables.find((variable) => {\n            const variableComparesToVariableIdentifier = variable.compareVariableIdentifier(variableIdentifier);\n\n            if (variableComparesToVariableIdentifier) {\n              return true;\n            }\n          }) || null;\n\n    return variable;\n  }\n\n  isTermGrounded(term) {\n    const context = this, ///\n          equivalences = this.getEquivalences(),\n          groundedTerms = [],\n          definedVariables = [];\n\n    equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);\n\n    const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {\n        const groundedTermNode = groundedTerm.getNode(),\n              groundedTermNodeMatches = term.matchNode(groundedTermNode);\n\n            if (groundedTermNodeMatches) {\n              return true;\n            }\n          }),\n          termGrounded = termMatchesGroundedTerm; ///\n\n    return termGrounded;\n  }\n\n  isVariableDefined(variable) {\n    const context = this, ///\n          equivalences = this.getEquivalences(),\n          groundedTerms = [],\n          definedVariables = [];\n\n    equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);\n\n    const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {\n            const definedVariableEqualToVariable = definedVariable.isEqualTo(variable);\n\n            if (definedVariableEqualToVariable === variable) {\n              return true;\n            }\n          }),\n          variableDefined = variableMatchesDefinedVariable; ///\n\n    return variableDefined;\n  }\n\n  isMetavariableDefined(metavariable) {\n    const judgementPresent = this.isJudgementPresentByMetavariable(metavariable),\n          metavariableDefined = judgementPresent; ///\n\n    return metavariableDefined\n  }\n\n  isJudgementPresentByMetavariable(metavariable) {\n    const judgement = this.findJudgementByMetavariable(metavariable),\n          judgementPresent = (judgement !== null);\n\n    return judgementPresent;\n  }\n\n  isVariablePresentByVariableIdentifier(variableIdentifier, nested = true) {\n    const variable = this.findVariableByVariableIdentifier(variableIdentifier, nested),\n          variablePresent = (variable !== null);\n\n    return variablePresent;\n  }\n\n  compareTermAndPropertyRelation(term, propertyRelation) {\n    const context = this, ///\n          proofAssertions = this.getProofAssertions(),\n          comparesToTermAndPropertyRelation = proofAssertions.some((proofAssertion) => {\n            const comparesToTermAndPropertyRelation = proofAssertion.compareTermAndPropertyRelation(term, propertyRelation, context);\n\n            if (comparesToTermAndPropertyRelation) {\n              return true;\n            }\n          });\n\n    return comparesToTermAndPropertyRelation;\n  }\n\n  getFileContext() { return this.context.getFileContext(); }\n\n  getDepth() {\n    let depth = this.context.getDepth();\n\n    depth++;\n\n    return depth;\n  }\n\n  static fromNothing(context) {\n    const { Equivalences } = elements,\n          variables = [],\n          judgements = [],\n          equivalences = Equivalences.fromNothing(context),\n          subproofOrProofAssertions = [],\n          scopedContext = new ScopedContext(context, variables, judgements, equivalences, subproofOrProofAssertions);\n\n    return scopedContext;\n  }\n}\n\nexport default ScopedContext;"],"names":["last","arrayUtilities","chainContext","contextUtilities","ScopedContext","context","variables","judgements","equivalences","subproofOrProofAssertions","getContext","getVariables","nested","getJudgements","getEquivalences","mergedWith","getProofAssertions","getSubproofOrProofAssertions","proofAssertions","filter","subproofOrProofAssertion","subproofOrProofAssertionproofAssertion","isProofAssertion","getLastProofAssertion","lastProofAssertion","proofAssertionsLength","length","addEquality","equality","equalityAdded","equalityReflexive","isReflexive","Equivalence","elements","equivalence","fromEquality","mergedWithEquivalence","equalityString","getString","trace","addVariable","variable","variableAdded","variableIdentifier","getIdentifier","variablePresent","isVariablePresentByVariableIdentifier","push","variableString","addJudgement","judgement","judgementAdded","metavariable","getMetavariable","judgementPresent","isJudgementPresentByMetavariable","judgementString","addSubproofOrProofAssertion","findEquivalenceByTerm","term","findJudgementByMetavariable","find","judgementSingular","isSingular","judgementMetavariable","judgementMetavariableEqualToMetavariable","isEqualTo","findVariableByVariableIdentifier","variableComparesToVariableIdentifier","compareVariableIdentifier","isTermGrounded","groundedTerms","definedVariables","separateGroundedTermsAndDefinedVariables","termMatchesGroundedTerm","some","groundedTerm","groundedTermNode","getNode","groundedTermNodeMatches","matchNode","termGrounded","isVariableDefined","variableMatchesDefinedVariable","definedVariable","definedVariableEqualToVariable","variableDefined","isMetavariableDefined","metavariableDefined","compareTermAndPropertyRelation","propertyRelation","comparesToTermAndPropertyRelation","proofAssertion","getFileContext","getDepth","depth","fromNothing","Equivalences","scopedContext"],"mappings":"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"}

package/lib/context/synthetic.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return SyntheticContext;
+    }
+});
+var _occamfurtle = require("occam-furtle");
+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;
+}
+var chainContext = _occamfurtle.contextUtilities.chainContext;
+var SyntheticContext = /*#__PURE__*/ function() {
+    function SyntheticContext(context, generalContext, specificContext) {
+        _class_call_check(this, SyntheticContext);
+        this.context = context;
+        this.generalContext = generalContext;
+        this.specificContext = specificContext;
+        return chainContext(this);
+    }
+    _create_class(SyntheticContext, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
+        {
+            key: "getGeneralContext",
+            value: function getGeneralContext() {
+                return this.generalContext;
+            }
+        },
+        {
+            key: "getSpecificContext",
+            value: function getSpecificContext() {
+                return this.specificContext;
+            }
+        },
+        {
+            key: "findTermByTermNode",
+            value: function findTermByTermNode(termNode) {
+                return this.specificContext.findTermByTermNode(termNode);
+            }
+        },
+        {
+            key: "findFrameByFrameNode",
+            value: function findFrameByFrameNode(frameNode) {
+                return this.specificContext.findFrameByFrameNode(frameNode);
+            }
+        },
+        {
+            key: "findTypeByNominalTypeName",
+            value: function findTypeByNominalTypeName(nominalTypeName) {
+                return this.specificContext.findTypeByNominalTypeName(nominalTypeName);
+            }
+        },
+        {
+            key: "isTypePresentByNominalTypeName",
+            value: function isTypePresentByNominalTypeName(nominalTypeName) {
+                return this.specificContext.isTypePresentByNominalTypeName(nominalTypeName);
+            }
+        },
+        {
+            key: "findVariableByVariableIdentifier",
+            value: function findVariableByVariableIdentifier(variableIdentifier) {
+                return this.generalContext.findVariableByVariableIdentifier(variableIdentifier);
+            }
+        },
+        {
+            key: "findMetavariableByMetavariableName",
+            value: function findMetavariableByMetavariableName(metavariableName) {
+                return this.generalContext.findMetavariableByMetavariableName(metavariableName);
+            }
+        },
+        {
+            key: "isVariablePresentByVariableIdentifier",
+            value: function isVariablePresentByVariableIdentifier(variableIdentifier) {
+                this.generalContext.isVariablePresentByVariableIdentifier(variableIdentifier);
+            }
+        },
+        {
+            key: "isMetavariablePresentByMetavariableName",
+            value: function isMetavariablePresentByMetavariableName(metavariableName) {
+                this.generalContext.isMetavariablePresentByMetavariableName(metavariableName);
+            }
+        },
+        {
+            key: "getFileContext",
+            value: function getFileContext() {
+                return this.context.getFileContext();
+            }
+        },
+        {
+            key: "getDepth",
+            value: function getDepth() {
+                var depth = this.context.getDepth();
+                depth++;
+                return depth;
+            }
+        }
+    ], [
+        {
+            key: "fromNothing",
+            value: function fromNothing(generalContext, specificContext) {
+                var context = specificContext, syntheticContext = new SyntheticContext(context, generalContext, specificContext);
+                return syntheticContext;
+            }
+        }
+    ]);
+    return SyntheticContext;
+}();
+
+//# sourceMappingURL=data:application/json;base64,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