occam-verify-cli 1.0.387 → 1.0.396

package/lib/context/temporary.js

@@ -0,0 +1,705 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return TemporaryContext;
+    }
+});
+var _necessary = require("necessary");
+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 first = _necessary.arrayUtilities.first, extract = _necessary.arrayUtilities.extract;
+var TemporaryContext = /*#__PURE__*/ function() {
+    function TemporaryContext(context, tokens1, terms, frames, statements, assertions, reference, substitution) {
+        _class_call_check(this, TemporaryContext);
+        this.context = context;
+        this.tokens = tokens1;
+        this.terms = terms;
+        this.frames = frames;
+        this.statements = statements;
+        this.assertions = assertions;
+        this.reference = reference;
+        this.substitution = substitution;
+    }
+    _create_class(TemporaryContext, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
+        {
+            key: "getTokens",
+            value: function getTokens() {
+                return tokens;
+            }
+        },
+        {
+            key: "getTerms",
+            value: function getTerms() {
+                return this.terms;
+            }
+        },
+        {
+            key: "getFrames",
+            value: function getFrames() {
+                return this.frames;
+            }
+        },
+        {
+            key: "getStatements",
+            value: function getStatements() {
+                return this.statements;
+            }
+        },
+        {
+            key: "getAssertions",
+            value: function getAssertions() {
+                return this.assertions;
+            }
+        },
+        {
+            key: "getReferences",
+            value: function getReferences() {
+                return this.reference;
+            }
+        },
+        {
+            key: "getSubstitution",
+            value: function getSubstitution() {
+                return this.substitution;
+            }
+        },
+        {
+            key: "addTerm",
+            value: function addTerm(term) {
+                var termNode = term.getNode();
+                extract(this.terms, function(term) {
+                    var termMatchesTermNode = term.matchTermNode(termNode);
+                    if (termMatchesTermNode) {
+                        return true;
+                    }
+                });
+                this.terms.push(term);
+            }
+        },
+        {
+            key: "addFrame",
+            value: function addFrame(frame) {
+                var frameNode = frame.getNode();
+                extract(this.frames, function(frame) {
+                    var frameMatchesFrameNode = frame.matchFrameNode(frameNode);
+                    if (frameMatchesFrameNode) {
+                        return true;
+                    }
+                });
+                this.frames.push(frame);
+            }
+        },
+        {
+            key: "removeFrame",
+            value: function removeFrame(frame) {
+                var index = this.frames.indexOf(frame), start = index, deleteCount = 1;
+                this.frames.splice(start, deleteCount);
+            }
+        },
+        {
+            key: "addStatement",
+            value: function addStatement(statement) {
+                var statementNode = statement.getNode();
+                extract(this.statements, function(statement) {
+                    var statementMatchesFrameNode = statement.matchStatementNode(statementNode);
+                    if (statementMatchesFrameNode) {
+                        return true;
+                    }
+                });
+                this.statements.push(statement);
+            }
+        },
+        {
+            key: "addAssertion",
+            value: function addAssertion(assertion) {
+                var assertionNode = assertion.getNode();
+                extract(this.assertions, function(assertion) {
+                    var assertionMatchesFrameNode = assertion.matchAssertionNode(assertionNode);
+                    if (assertionMatchesFrameNode) {
+                        return true;
+                    }
+                });
+                this.assertions.push(assertion);
+            }
+        },
+        {
+            key: "addReference",
+            value: function addReference(reference) {
+                this.reference = reference;
+            }
+        },
+        {
+            key: "addSubstitution",
+            value: function addSubstitution(substitution) {
+                this.substitution = substitution;
+            }
+        },
+        {
+            key: "findTermByTermNode",
+            value: function findTermByTermNode(termNode) {
+                var term = this.terms.find(function(term) {
+                    var termMatchesTermNode = term.matchTermNode(termNode);
+                    if (termMatchesTermNode) {
+                        return true;
+                    }
+                }) || null;
+                return term;
+            }
+        },
+        {
+            key: "findFrameByFrameNode",
+            value: function findFrameByFrameNode(frameNode) {
+                var frame = this.frames.find(function(frame) {
+                    var frameMatchesFrameNode = frame.matchFrameNode(frameNode);
+                    if (frameMatchesFrameNode) {
+                        return true;
+                    }
+                }) || null;
+                return frame;
+            }
+        },
+        {
+            key: "findStatementByStatementNode",
+            value: function findStatementByStatementNode(statementNode) {
+                var statement = this.statements.find(function(statement) {
+                    var statementMatchesStatementNode = statement.matchStatementNode(statementNode);
+                    if (statementMatchesStatementNode) {
+                        return true;
+                    }
+                }) || null;
+                return statement;
+            }
+        },
+        {
+            key: "findReferenceByMetavariableName",
+            value: function findReferenceByMetavariableName(metavariableName) {
+                var reference = null;
+                var referenceMatchesMetavariableName = this.reference.matchMetavariableName(metavariableName);
+                if (referenceMatchesMetavariableName) {
+                    reference = this.reference;
+                }
+                return reference;
+            }
+        },
+        {
+            key: "getFrame",
+            value: function getFrame() {
+                var frame = null;
+                var framesLengtrh = this.frames.length;
+                if (framesLengtrh === 1) {
+                    var firstFrame = first(this.frames);
+                    frame = firstFrame; ///
+                }
+                return frame;
+            }
+        },
+        {
+            key: "getVariables",
+            value: function getVariables() {
+                var nested = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                return this.context.getVariables(nested);
+            }
+        },
+        {
+            key: "getJudgements",
+            value: function getJudgements() {
+                return this.context.getJudgements();
+            }
+        },
+        {
+            key: "getEquivalences",
+            value: function getEquivalences() {
+                return this.context.getEquivalences();
+            }
+        },
+        {
+            key: "getSteps",
+            value: function getSteps() {
+                return this.context.getSteps();
+            }
+        },
+        {
+            key: "getLastStep",
+            value: function getLastStep() {
+                return this.context.getLastStep();
+            }
+        },
+        {
+            key: "getStepsOrSubproofs",
+            value: function getStepsOrSubproofs() {
+                return this.context.getStepsOrSubproofs();
+            }
+        },
+        {
+            key: "getFilePath",
+            value: function getFilePath() {
+                return this.context.getFilePath();
+            }
+        },
+        {
+            key: "getLexer",
+            value: function getLexer() {
+                return this.context.getLexer();
+            }
+        },
+        {
+            key: "getParser",
+            value: function getParser() {
+                return this.context.getParser();
+            }
+        },
+        {
+            key: "getAxioms",
+            value: function getAxioms() {
+                return this.context.getAxioms();
+            }
+        },
+        {
+            key: "getLemmas",
+            value: function getLemmas() {
+                return this.context.getLemmas();
+            }
+        },
+        {
+            key: "getTheorems",
+            value: function getTheorems() {
+                return this.context.getTheorems();
+            }
+        },
+        {
+            key: "getConjectures",
+            value: function getConjectures() {
+                return this.context.getConjectures();
+            }
+        },
+        {
+            key: "getCombinators",
+            value: function getCombinators() {
+                return this.context.getCombinators();
+            }
+        },
+        {
+            key: "getConstructors",
+            value: function getConstructors() {
+                return this.context.getConstructors();
+            }
+        },
+        {
+            key: "getTypePrefix",
+            value: function getTypePrefix() {
+                return this.context.getTypePrefix();
+            }
+        },
+        {
+            key: "addAxiom",
+            value: function addAxiom(axiom) {
+                this.context.addAxiom(axiom);
+            }
+        },
+        {
+            key: "addLemma",
+            value: function addLemma(lemma) {
+                this.context.addLemma(lemma);
+            }
+        },
+        {
+            key: "addTheorem",
+            value: function addTheorem(theorem) {
+                this.context.addTheorem(theorem);
+            }
+        },
+        {
+            key: "addEquality",
+            value: function addEquality(equality, context) {
+                return this.context.addEquality(equality, context);
+            }
+        },
+        {
+            key: "addVariable",
+            value: function addVariable(variable) {
+                var nested = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+                return this.context.addVariable(variable, nested);
+            }
+        },
+        {
+            key: "addJudgement",
+            value: function addJudgement(judgement) {
+                return this.context.addJudgement(judgement);
+            }
+        },
+        {
+            key: "addStepOrSubproof",
+            value: function addStepOrSubproof(stepOrSubproof) {
+                this.context.addStepOrSubproof(stepOrSubproof);
+            }
+        },
+        {
+            key: "findProcedureByName",
+            value: function findProcedureByName(name) {
+                return this.context.findProcedureByName(name);
+            }
+        },
+        {
+            key: "findLabelByReference",
+            value: function findLabelByReference(reference, context) {
+                return this.context.findLabelByReference(reference, context);
+            }
+        },
+        {
+            key: "findRuleByReference",
+            value: function findRuleByReference(reference) {
+                return this.context.findRuleByReference(reference);
+            }
+        },
+        {
+            key: "findAxiomByReference",
+            value: function findAxiomByReference(reference) {
+                return this.context.findAxiomByReference(reference);
+            }
+        },
+        {
+            key: "findLemmaByReference",
+            value: function findLemmaByReference(reference) {
+                return this.context.findLemmaByReference(reference);
+            }
+        },
+        {
+            key: "findTheoremByReference",
+            value: function findTheoremByReference(reference) {
+                return this.context.findTheoremByReference(reference);
+            }
+        },
+        {
+            key: "findConjectureByReference",
+            value: function findConjectureByReference(reference) {
+                return this.context.findConjectureByReference(reference);
+            }
+        },
+        {
+            key: "findMetaLemmasByReference",
+            value: function findMetaLemmasByReference(reference) {
+                return this.context.findMetaLemmasByReference(reference);
+            }
+        },
+        {
+            key: "findMetatheoremsByReference",
+            value: function findMetatheoremsByReference(reference) {
+                return this.context.findMetatheoremsByReference(reference);
+            }
+        },
+        {
+            key: "findMetaLemmaMetatheoremByReference",
+            value: function findMetaLemmaMetatheoremByReference(reference) {
+                return this.context.findMetaLemmaMetatheoremByReference(reference);
+            }
+        },
+        {
+            key: "findMetaLemmaMetatheoremsByReference",
+            value: function findMetaLemmaMetatheoremsByReference(reference) {
+                return this.context.findMetaLemmaMetatheoremsByReference(reference);
+            }
+        },
+        {
+            key: "findVariableByVariableIdentifier",
+            value: function findVariableByVariableIdentifier(variableIdentifier) {
+                var nested = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+                return this.context.findVariableByVariableIdentifier(variableIdentifier, nested);
+            }
+        },
+        {
+            key: "findJudgementByMetavariable",
+            value: function findJudgementByMetavariable(metavariable) {
+                return this.context.findJudgementByMetavariable(metavariable);
+            }
+        },
+        {
+            key: "findEquivalenceByTerm",
+            value: function findEquivalenceByTerm(term) {
+                return this.context.findEquivalenceByTerm(term);
+            }
+        },
+        {
+            key: "findMetavariable",
+            value: function findMetavariable(metavariable) {
+                return this.context.findMetavariable(metavariable);
+            }
+        },
+        {
+            key: "findLabelByMetavariable",
+            value: function findLabelByMetavariable(metavariable) {
+                return this.context.findLabelByMetavariable(metavariable);
+            }
+        },
+        {
+            key: "findTypeByNominalTypeName",
+            value: function findTypeByNominalTypeName(nominalTypeName) {
+                return this.context.findTypeByNominalTypeName(nominalTypeName);
+            }
+        },
+        {
+            key: "findMetaTypeByMetaTypeName",
+            value: function findMetaTypeByMetaTypeName(metaTypeName) {
+                return this.context.findMetaTypeByMetaTypeName(metaTypeName);
+            }
+        },
+        {
+            key: "findMetavariableByMetavariableName",
+            value: function findMetavariableByMetavariableName(metavariableName) {
+                return this.context.findMetavariableByMetavariableName(metavariableName);
+            }
+        },
+        {
+            key: "isProcedurePresentByName",
+            value: function isProcedurePresentByName(name) {
+                return this.context.isProcedurePresentByName(name);
+            }
+        },
+        {
+            key: "isLabelPresentByReference",
+            value: function isLabelPresentByReference(reference) {
+                return this.context.isLabelPresentByReference(reference);
+            }
+        },
+        {
+            key: "isMetavariablePresentByReference",
+            value: function isMetavariablePresentByReference(reference) {
+                return this.context.isMetavariablePresentByReference(reference);
+            }
+        },
+        {
+            key: "isMetaLemmaMetatheoremPresentByReference",
+            value: function isMetaLemmaMetatheoremPresentByReference(reference) {
+                return this.context.isMetaLemmaMetatheoremPresentByReference(reference);
+            }
+        },
+        {
+            key: "findAxiomLemmaTheoremOrConjectureByReference",
+            value: function findAxiomLemmaTheoremOrConjectureByReference(reference) {
+                return this.context.findAxiomLemmaTheoremOrConjectureByReference(reference);
+            }
+        },
+        {
+            key: "isMetavariablePresent",
+            value: function isMetavariablePresent(metavariable) {
+                return this.context.isMetavariablePresent(metavariable);
+            }
+        },
+        {
+            key: "isTypePresentByTypeName",
+            value: function isTypePresentByTypeName(typeName) {
+                var includeRelease = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true, includeDependencies = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true;
+                return this.context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies);
+            }
+        },
+        {
+            key: "isTypePresentByNominalTypeName",
+            value: function isTypePresentByNominalTypeName(nominalTypeName) {
+                return this.context.isTypePresentByNominalTypeName(nominalTypeName);
+            }
+        },
+        {
+            key: "isTypePresentByPrefixedTypeName",
+            value: function isTypePresentByPrefixedTypeName(prefixedTypeName) {
+                return this.context.isTypePresentByPrefixedTypeName(prefixedTypeName);
+            }
+        },
+        {
+            key: "isTypePrefixPresentByTypePrefixName",
+            value: function isTypePrefixPresentByTypePrefixName(typePrefixName) {
+                return this.context.isTypePrefixPresentByTypePrefixName(typePrefixName);
+            }
+        },
+        {
+            key: "isVariablePresentByVariableIdentifier",
+            value: function isVariablePresentByVariableIdentifier(variableIdentifier) {
+                var nested = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+                return this.context.findVariableByVariableIdentifier(variableIdentifier, nested);
+            }
+        },
+        {
+            key: "isLabelPresentByMetavariableName",
+            value: function isLabelPresentByMetavariableName(metavariableName) {
+                return this.context.isLabelPresentByMetavariableName(metavariableName);
+            }
+        },
+        {
+            key: "isLabelPresentByMetavariable",
+            value: function isLabelPresentByMetavariable(metavariable) {
+                return this.context.isLabelPresentByMetavariable(metavariable);
+            }
+        },
+        {
+            key: "isMetavariablePresentByMetavariableName",
+            value: function isMetavariablePresentByMetavariableName(metavariableNode) {
+                return this.context.isMetavariablePresentByMetavariableName(metavariableNode);
+            }
+        },
+        {
+            key: "isJudgementPresentByMetavariable",
+            value: function isJudgementPresentByMetavariable(metavariable) {
+                return this.context.isJudgementPresentByMetavariable(metavariable);
+            }
+        },
+        {
+            key: "isTermGrounded",
+            value: function isTermGrounded(term) {
+                return this.context.isTermGrounded(term);
+            }
+        },
+        {
+            key: "isVariableDefined",
+            value: function isVariableDefined(variable) {
+                return this.context.isVariableDefined(variable);
+            }
+        },
+        {
+            key: "isMetavariableDefined",
+            value: function isMetavariableDefined(metavariable) {
+                return this.context.isMetavariableDefined(metavariable);
+            }
+        },
+        {
+            key: "matchTermAndPropertyRelation",
+            value: function matchTermAndPropertyRelation(term, propertyRelation) {
+                return this.context.matchTermAndPropertyRelation(term, propertyRelation);
+            }
+        },
+        {
+            key: "nodeAsString",
+            value: function nodeAsString(node) {
+                var tokens1 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+                if (tokens1 === null) {
+                    tokens1 = this.tokens;
+                }
+                var string = this.context.nodeAsString(node, tokens1);
+                return string;
+            }
+        },
+        {
+            key: "nodesAsString",
+            value: function nodesAsString(node) {
+                var tokens1 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+                if (tokens1 === null) {
+                    tokens1 = this.tokens;
+                }
+                var string = this.context.nodesAsString(node, tokens1);
+                return string;
+            }
+        },
+        {
+            key: "nodeAsTokens",
+            value: function nodeAsTokens(node) {
+                var tokens1 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+                if (tokens1 === null) {
+                    tokens1 = this.tokens;
+                }
+                tokens1 = this.context.nodeAsTokens(node, tokens1); ///
+                return tokens1;
+            }
+        },
+        {
+            key: "nodesAsTokens",
+            value: function nodesAsTokens(node) {
+                var tokens1 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+                if (tokens1 === null) {
+                    tokens1 = this.tokens;
+                }
+                tokens1 = this.context.nodesAsTokens(node, tokens1); ///
+                return tokens1;
+            }
+        },
+        {
+            key: "tokensAsString",
+            value: function tokensAsString(tokens1) {
+                return this.context.tokensAsString(tokens1);
+            }
+        },
+        {
+            key: "trace",
+            value: function trace(message) {
+                var node = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+                this.context.trace(message, node);
+            }
+        },
+        {
+            key: "debug",
+            value: function debug(message) {
+                var node = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+                this.context.debug(message, node);
+            }
+        },
+        {
+            key: "info",
+            value: function info(message) {
+                var node = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+                this.context.info(message, node);
+            }
+        },
+        {
+            key: "warning",
+            value: function warning(message) {
+                var node = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+                this.context.warning(message, node);
+            }
+        },
+        {
+            key: "error",
+            value: function error(message) {
+                var node = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+                this.context.error(message, node);
+            }
+        }
+    ], [
+        {
+            key: "fromNothing",
+            value: function fromNothing(context) {
+                var terms = [], frames = [], tokens1 = null, statements = [], assertions = [], reference = null, substitution = null, temporaryContext = new TemporaryContext(context, tokens1, terms, frames, statements, assertions, reference, substitution);
+                return temporaryContext;
+            }
+        },
+        {
+            key: "fromTermsAndFrames",
+            value: function fromTermsAndFrames(terms, frames, context) {
+                var tokens1 = null, statements = [], assertions = [], reference = null, substitution = null, temporaryContext = new TemporaryContext(context, tokens1, terms, frames, statements, assertions, reference, substitution);
+                return temporaryContext;
+            }
+        },
+        {
+            key: "fromContextAndTokens",
+            value: function fromContextAndTokens(context, tokens1) {
+                var terms = [], frames = [], statements = [], assertions = [], reference = null, substitution = null, temporaryContext = new TemporaryContext(context, tokens1, terms, frames, statements, assertions, reference, substitution);
+                return temporaryContext;
+            }
+        }
+    ]);
+    return TemporaryContext;
+}();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/temporary.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nconst { first, extract } = arrayUtilities;\n\nexport default class TemporaryContext {\n  constructor(context, tokens, terms, frames, statements, assertions, reference, substitution) {\n    this.context = context;\n    this.tokens = tokens;\n    this.terms = terms;\n    this.frames = frames;\n    this.statements = statements;\n    this.assertions = assertions;\n    this.reference = reference;\n    this.substitution = substitution;\n  }\n\n  getContext() {\n    return this.context;\n  }\n\n  getTokens() {\n    return tokens;\n  }\n\n  getTerms() {\n    return this.terms;\n  }\n\n  getFrames() {\n    return this.frames;\n  }\n\n  getStatements() {\n    return this.statements;\n  }\n\n  getAssertions() {\n    return this.assertions;\n  }\n\n  getReferences() {\n    return this.reference;\n  }\n\n  getSubstitution() {\n    return this.substitution;\n  }\n\n  addTerm(term) {\n    const termNode = term.getNode();\n\n    extract(this.terms, (term) => {\n      const termMatchesTermNode = term.matchTermNode(termNode);\n\n      if (termMatchesTermNode) {\n        return true;\n      }\n    });\n\n    this.terms.push(term);\n  }\n\n  addFrame(frame) {\n    const frameNode = frame.getNode();\n\n    extract(this.frames, (frame) => {\n      const frameMatchesFrameNode = frame.matchFrameNode(frameNode);\n\n      if (frameMatchesFrameNode) {\n        return true;\n      }\n    });\n\n    this.frames.push(frame);\n  }\n\n  removeFrame(frame) {\n    const index = this.frames.indexOf(frame),\n          start = index,  ///\n          deleteCount = 1;\n\n    this.frames.splice(start, deleteCount);\n  }\n\n  addStatement(statement) {\n    const statementNode = statement.getNode();\n\n    extract(this.statements, (statement) => {\n      const statementMatchesFrameNode = statement.matchStatementNode(statementNode);\n\n      if (statementMatchesFrameNode) {\n        return true;\n      }\n    });\n\n    this.statements.push(statement);\n  }\n\n  addAssertion(assertion) {\n    const assertionNode = assertion.getNode();\n\n    extract(this.assertions, (assertion) => {\n      const assertionMatchesFrameNode = assertion.matchAssertionNode(assertionNode);\n\n      if (assertionMatchesFrameNode) {\n        return true;\n      }\n    });\n\n    this.assertions.push(assertion);\n  }\n\n  addReference(reference) {\n    this.reference = reference;\n  }\n\n  addSubstitution(substitution) {\n    this.substitution = substitution;\n  }\n\n  findTermByTermNode(termNode) {\n    const term = this.terms.find((term) => {\n      const termMatchesTermNode = term.matchTermNode(termNode);\n\n      if (termMatchesTermNode) {\n        return true;\n      }\n    }) || null;\n\n    return term;\n  }\n\n  findFrameByFrameNode(frameNode) {\n    const frame = this.frames.find((frame) => {\n      const frameMatchesFrameNode = frame.matchFrameNode(frameNode);\n\n      if (frameMatchesFrameNode) {\n        return true;\n      }\n    }) || null;\n\n    return frame;\n  }\n\n  findStatementByStatementNode(statementNode) {\n    const statement = this.statements.find((statement) => {\n      const statementMatchesStatementNode = statement.matchStatementNode(statementNode);\n\n      if (statementMatchesStatementNode) {\n        return true;\n      }\n    }) || null;\n\n    return statement;\n  }\n\n  findReferenceByMetavariableName(metavariableName) {\n    let reference = null;\n\n    const referenceMatchesMetavariableName = this.reference.matchMetavariableName(metavariableName);\n\n    if (referenceMatchesMetavariableName) {\n      reference = this.reference;\n    }\n\n    return reference;\n  }\n\n  getFrame() {\n    let frame = null;\n\n    const framesLengtrh = this.frames.length;\n\n    if (framesLengtrh === 1) {\n      const firstFrame = first(this.frames);\n\n      frame = firstFrame; ///\n    }\n\n    return frame;\n  }\n\n  getVariables(nested = true) { return this.context.getVariables(nested); }\n\n  getJudgements() { return this.context.getJudgements(); }\n\n  getEquivalences() { return this.context.getEquivalences(); }\n\n  getSteps() { return this.context.getSteps(); }\n\n  getLastStep() { return this.context.getLastStep(); }\n\n  getStepsOrSubproofs() { return this.context.getStepsOrSubproofs(); }\n\n  getFilePath() { return this.context.getFilePath(); }\n\n  getLexer() { return this.context.getLexer(); }\n\n  getParser() { return this.context.getParser(); }\n\n  getAxioms() { return this.context.getAxioms(); }\n\n  getLemmas() { return this.context.getLemmas(); }\n\n  getTheorems() { return this.context.getTheorems(); }\n\n  getConjectures() { return this.context.getConjectures(); }\n\n  getCombinators() { return this.context.getCombinators(); }\n\n  getConstructors() { return this.context.getConstructors(); }\n\n  getTypePrefix() { return this.context.getTypePrefix(); }\n\n  addAxiom(axiom) { this.context.addAxiom(axiom); }\n\n  addLemma(lemma) { this.context.addLemma(lemma); }\n\n  addTheorem(theorem) { this.context.addTheorem(theorem); }\n\n  addEquality(equality, context) { return this.context.addEquality(equality, context); }\n\n  addVariable(variable, nested = true) { return this.context.addVariable(variable, nested); }\n\n  addJudgement(judgement) { return this.context.addJudgement(judgement); }\n\n  addStepOrSubproof(stepOrSubproof) { this.context.addStepOrSubproof(stepOrSubproof); }\n\n  findProcedureByName(name) { return this.context.findProcedureByName(name); }\n\n  findLabelByReference(reference, context) { return this.context.findLabelByReference(reference, context); }\n\n  findRuleByReference(reference) { return this.context.findRuleByReference(reference); }\n\n  findAxiomByReference(reference) { return this.context.findAxiomByReference(reference); }\n\n  findLemmaByReference(reference) { return this.context.findLemmaByReference(reference); }\n\n  findTheoremByReference(reference) { return this.context.findTheoremByReference(reference); }\n\n  findConjectureByReference(reference) { return this.context.findConjectureByReference(reference); }\n\n  findMetaLemmasByReference(reference) { return this.context.findMetaLemmasByReference(reference); }\n\n  findMetatheoremsByReference(reference) { return this.context.findMetatheoremsByReference(reference); }\n\n  findMetaLemmaMetatheoremByReference(reference) { return this.context.findMetaLemmaMetatheoremByReference(reference); }\n\n  findMetaLemmaMetatheoremsByReference(reference) { return this.context.findMetaLemmaMetatheoremsByReference(reference); }\n\n  findVariableByVariableIdentifier(variableIdentifier, nested = true) { return this.context.findVariableByVariableIdentifier(variableIdentifier, nested); }\n\n  findJudgementByMetavariable(metavariable) { return this.context.findJudgementByMetavariable(metavariable); }\n\n  findEquivalenceByTerm(term) { return this.context.findEquivalenceByTerm(term); }\n\n  findMetavariable(metavariable) { return this.context.findMetavariable(metavariable); }\n\n  findLabelByMetavariable(metavariable) { return this.context.findLabelByMetavariable(metavariable); }\n\n  findTypeByNominalTypeName(nominalTypeName) { return this.context.findTypeByNominalTypeName(nominalTypeName); }\n\n  findMetaTypeByMetaTypeName(metaTypeName) { return this.context.findMetaTypeByMetaTypeName(metaTypeName); }\n\n  findMetavariableByMetavariableName(metavariableName) { return this.context.findMetavariableByMetavariableName(metavariableName); }\n\n  isProcedurePresentByName(name) { return this.context.isProcedurePresentByName(name); }\n\n  isLabelPresentByReference(reference) { return this.context.isLabelPresentByReference(reference); }\n\n  isMetavariablePresentByReference(reference) { return this.context.isMetavariablePresentByReference(reference); }\n\n  isMetaLemmaMetatheoremPresentByReference(reference) { return this.context.isMetaLemmaMetatheoremPresentByReference(reference); }\n\n  findAxiomLemmaTheoremOrConjectureByReference(reference) { return this.context.findAxiomLemmaTheoremOrConjectureByReference(reference); }\n\n  isMetavariablePresent(metavariable) { return this.context.isMetavariablePresent(metavariable); }\n\n  isTypePresentByTypeName(typeName, includeRelease = true, includeDependencies = true) { return this.context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies); }\n\n  isTypePresentByNominalTypeName(nominalTypeName) { return this.context.isTypePresentByNominalTypeName(nominalTypeName); }\n\n  isTypePresentByPrefixedTypeName(prefixedTypeName) { return this.context.isTypePresentByPrefixedTypeName(prefixedTypeName); }\n\n  isTypePrefixPresentByTypePrefixName(typePrefixName) { return this.context.isTypePrefixPresentByTypePrefixName(typePrefixName); }\n\n  isVariablePresentByVariableIdentifier(variableIdentifier, nested = true) { return this.context.findVariableByVariableIdentifier(variableIdentifier, nested); }\n\n  isLabelPresentByMetavariableName(metavariableName) { return this.context.isLabelPresentByMetavariableName(metavariableName); }\n\n  isLabelPresentByMetavariable(metavariable) { return this.context.isLabelPresentByMetavariable(metavariable); }\n\n  isMetavariablePresentByMetavariableName(metavariableNode) { return this.context.isMetavariablePresentByMetavariableName(metavariableNode); }\n\n  isJudgementPresentByMetavariable(metavariable) { return this.context.isJudgementPresentByMetavariable(metavariable); }\n\n  isTermGrounded(term) { return this.context.isTermGrounded(term); }\n\n  isVariableDefined(variable) { return this.context.isVariableDefined(variable); }\n\n  isMetavariableDefined(metavariable) { return this.context.isMetavariableDefined(metavariable); }\n\n  matchTermAndPropertyRelation(term, propertyRelation) { return this.context.matchTermAndPropertyRelation(term, propertyRelation); }\n\n  nodeAsString(node, tokens = null) {\n    if (tokens === null) {\n      tokens = this.tokens;\n    }\n\n    const string = this.context.nodeAsString(node, tokens);\n\n    return string;\n  }\n\n  nodesAsString(node, tokens = null) {\n    if (tokens === null) {\n      tokens = this.tokens;\n    }\n\n    const string = this.context.nodesAsString(node, tokens);\n\n    return string;\n  }\n\n  nodeAsTokens(node, tokens = null) {\n    if (tokens === null) {\n      tokens = this.tokens;\n    }\n\n    tokens = this.context.nodeAsTokens(node, tokens); ///\n\n    return tokens;\n  }\n\n  nodesAsTokens(node, tokens = null) {\n    if (tokens === null) {\n      tokens = this.tokens;\n    }\n\n    tokens = this.context.nodesAsTokens(node, tokens);  ///\n\n    return tokens;\n  }\n\n  tokensAsString(tokens) { return this.context.tokensAsString(tokens); }\n\n  trace(message, node = null) { this.context.trace(message, node); }\n\n  debug(message, node = null) { this.context.debug(message, node); }\n\n  info(message, node = null) { this.context.info(message, node); }\n\n  warning(message, node = null) { this.context.warning(message, node); }\n\n  error(message, node = null) { this.context.error(message, node); }\n\n  static fromNothing(context) {\n    const terms = [],\n          frames = [],\n          tokens = null,\n          statements = [],\n          assertions = [],\n          reference = null,\n          substitution = null,\n          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, reference, substitution);\n\n    return temporaryContext;\n  }\n\n  static fromTermsAndFrames(terms, frames, context) {\n    const tokens = null,\n          statements = [],\n          assertions = [],\n          reference = null,\n          substitution = null,\n          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, reference, substitution);\n\n    return temporaryContext;\n  }\n\n  static fromContextAndTokens(context, tokens) {\n    const terms = [],\n          frames = [],\n          statements = [],\n          assertions = [],\n          reference = null,\n          substitution = null,\n          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, reference, substitution);\n\n    return temporaryContext;\n  }\n}\n"],"names":["TemporaryContext","first","arrayUtilities","extract","context","tokens","terms","frames","statements","assertions","reference","substitution","getContext","getTokens","getTerms","getFrames","getStatements","getAssertions","getReferences","getSubstitution","addTerm","term","termNode","getNode","termMatchesTermNode","matchTermNode","push","addFrame","frame","frameNode","frameMatchesFrameNode","matchFrameNode","removeFrame","index","indexOf","start","deleteCount","splice","addStatement","statement","statementNode","statementMatchesFrameNode","matchStatementNode","addAssertion","assertion","assertionNode","assertionMatchesFrameNode","matchAssertionNode","addReference","addSubstitution","findTermByTermNode","find","findFrameByFrameNode","findStatementByStatementNode","statementMatchesStatementNode","findReferenceByMetavariableName","metavariableName","referenceMatchesMetavariableName","matchMetavariableName","getFrame","framesLengtrh","length","firstFrame","getVariables","nested","getJudgements","getEquivalences","getSteps","getLastStep","getStepsOrSubproofs","getFilePath","getLexer","getParser","getAxioms","getLemmas","getTheorems","getConjectures","getCombinators","getConstructors","getTypePrefix","addAxiom","axiom","addLemma","lemma","addTheorem","theorem","addEquality","equality","addVariable","variable","addJudgement","judgement","addStepOrSubproof","stepOrSubproof","findProcedureByName","name","findLabelByReference","findRuleByReference","findAxiomByReference","findLemmaByReference","findTheoremByReference","findConjectureByReference","findMetaLemmasByReference","findMetatheoremsByReference","findMetaLemmaMetatheoremByReference","findMetaLemmaMetatheoremsByReference","findVariableByVariableIdentifier","variableIdentifier","findJudgementByMetavariable","metavariable","findEquivalenceByTerm","findMetavariable","findLabelByMetavariable","findTypeByNominalTypeName","nominalTypeName","findMetaTypeByMetaTypeName","metaTypeName","findMetavariableByMetavariableName","isProcedurePresentByName","isLabelPresentByReference","isMetavariablePresentByReference","isMetaLemmaMetatheoremPresentByReference","findAxiomLemmaTheoremOrConjectureByReference","isMetavariablePresent","isTypePresentByTypeName","typeName","includeRelease","includeDependencies","isTypePresentByNominalTypeName","isTypePresentByPrefixedTypeName","prefixedTypeName","isTypePrefixPresentByTypePrefixName","typePrefixName","isVariablePresentByVariableIdentifier","isLabelPresentByMetavariableName","isLabelPresentByMetavariable","isMetavariablePresentByMetavariableName","metavariableNode","isJudgementPresentByMetavariable","isTermGrounded","isVariableDefined","isMetavariableDefined","matchTermAndPropertyRelation","propertyRelation","nodeAsString","node","string","nodesAsString","nodeAsTokens","nodesAsTokens","tokensAsString","trace","message","debug","info","warning","error","fromNothing","temporaryContext","fromTermsAndFrames","fromContextAndTokens"],"mappings":"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"}