occam-verify-cli 1.0.388 → 1.0.404

package/lib/context/temporary.js

@@ -0,0 +1,755 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return TemporaryContext;
+    }
+});
+var _necessary = require("necessary");
+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 _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 extract = _necessary.arrayUtilities.extract, compress = _necessary.arrayUtilities.compress;
+var TemporaryContext = /*#__PURE__*/ function() {
+    function TemporaryContext(context, tokens1, terms, frames, statements, assertions, substitutions, reference) {
+        _class_call_check(this, TemporaryContext);
+        this.context = context;
+        this.tokens = tokens1;
+        this.terms = terms;
+        this.frames = frames;
+        this.statements = statements;
+        this.assertions = assertions;
+        this.substitutions = substitutions;
+        this.reference = reference;
+    }
+    _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: "getSubstitutions",
+            value: function getSubstitutions() {
+                return this.substitutions;
+            }
+        },
+        {
+            key: "getReference",
+            value: function getReference() {
+                return this.reference;
+            }
+        },
+        {
+            key: "addTerm",
+            value: function addTerm(term) {
+                var context = this, termNode = term.getNode(), termString = term.getString();
+                extract(this.terms, function(term) {
+                    var termMatchesTermNode = term.matchTermNode(termNode);
+                    if (termMatchesTermNode) {
+                        return true;
+                    }
+                });
+                context.trace("ADded the '".concat(termString, "' term."));
+                this.terms.push(term);
+            }
+        },
+        {
+            key: "addFrame",
+            value: function addFrame(frame) {
+                var context = this, frameNode = frame.getNode(), frameString = frame.getString();
+                extract(this.frames, function(frame) {
+                    var frameMatchesFrameNode = frame.matchFrameNode(frameNode);
+                    if (frameMatchesFrameNode) {
+                        return true;
+                    }
+                });
+                context.trace("Added the '".concat(frameString, "' frame."));
+                this.frames.push(frame);
+            }
+        },
+        {
+            key: "addStatement",
+            value: function addStatement(statement) {
+                var context = this, statementNode = statement.getNode(), statementString = statement.getString();
+                extract(this.statements, function(statement) {
+                    var statementMatchesFrameNode = statement.matchStatementNode(statementNode);
+                    if (statementMatchesFrameNode) {
+                        return true;
+                    }
+                });
+                context.trace("Added the '".concat(statementString, "' statement."));
+                this.statements.push(statement);
+            }
+        },
+        {
+            key: "addAssertion",
+            value: function addAssertion(assertion) {
+                var context = this, assertionNode = assertion.getNode(), assertionString = assertion.getString();
+                extract(this.assertions, function(assertion) {
+                    var assertionMatchesFrameNode = assertion.matchAssertionNode(assertionNode);
+                    if (assertionMatchesFrameNode) {
+                        return true;
+                    }
+                });
+                context.trace("Added the '".concat(assertionString, "' assertion."));
+                this.assertions.push(assertion);
+            }
+        },
+        {
+            key: "addSubstitution",
+            value: function addSubstitution(substitution) {
+                var context = this, substitutionNode = substitution.getNode(), substitutionString = substitution.getString();
+                extract(this.substitutions, function(substitution) {
+                    var substitutionMatchesFrameNode = substitution.matchSubstitutionNode(substitutionNode);
+                    if (substitutionMatchesFrameNode) {
+                        return true;
+                    }
+                });
+                context.trace("Added the '".concat(substitutionString, "' substitution."));
+                this.substitutions.push(substitution);
+            }
+        },
+        {
+            key: "addReference",
+            value: function addReference(reference) {
+                var context = this, referenceString = reference.getString();
+                this.reference = reference;
+                context.trace("Added the '".concat(referenceString, "' reference."));
+            }
+        },
+        {
+            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: "findAssertionByAssertionNode",
+            value: function findAssertionByAssertionNode(assertionNode) {
+                var assertion = this.assertions.find(function(assertion) {
+                    var assertionMatchesAssertionNode = assertion.matchAssertionNode(assertionNode);
+                    if (assertionMatchesAssertionNode) {
+                        return true;
+                    }
+                }) || null;
+                return assertion;
+            }
+        },
+        {
+            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: "findSubtitutionBySubtitutionNode",
+            value: function findSubtitutionBySubtitutionNode(substitutionNode) {
+                var substitution = this.substitutions.find(function(substitution) {
+                    var substitutionMatchesSubtitutionNode = substitution.matchSubtitutionNode(substitutionNode);
+                    if (substitutionMatchesSubtitutionNode) {
+                        return true;
+                    }
+                }) || null;
+                return substitution;
+            }
+        },
+        {
+            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) {
+                return this.context.addEquality(equality);
+            }
+        },
+        {
+            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: "marge",
+            value: function marge(context) {
+                var terms = context.getTerms(), frames = context.getFrames(), statements = context.getStatements(), assertions = context.getAssertions(), substitutions = context.getSubstitutions();
+                this.terms = _to_consumable_array(this.terms).concat(_to_consumable_array(terms));
+                this.frames = _to_consumable_array(this.frames).concat(_to_consumable_array(frames));
+                this.statements = _to_consumable_array(this.statements).concat(_to_consumable_array(statements));
+                this.assertions = _to_consumable_array(this.assertions).concat(_to_consumable_array(assertions));
+                this.substitutions = _to_consumable_array(this.substitutions).concat(_to_consumable_array(substitutions));
+                compress(this.terms, function(termA, termB) {
+                    var termANode = termA.getNode(), termBNode = termB.getNode(), termANodeMatchesTermBNode = termANode.match(termBNode);
+                    if (termAMatchesTermB) {
+                        return true;
+                    }
+                });
+            }
+        }
+    ], [
+        {
+            key: "fromNothing",
+            value: function fromNothing(context) {
+                var terms = [], frames = [], tokens1 = null, statements = [], assertions = [], substitutions = [], reference = null, temporaryContext = new TemporaryContext(context, tokens1, terms, frames, statements, assertions, substitutions, reference);
+                return temporaryContext;
+            }
+        },
+        {
+            key: "fromTermsAndFrames",
+            value: function fromTermsAndFrames(terms, frames, context) {
+                var tokens1 = null, statements = [], assertions = [], substitutions = [], reference = null, temporaryContext = new TemporaryContext(context, tokens1, terms, frames, statements, assertions, substitutions, reference);
+                return temporaryContext;
+            }
+        },
+        {
+            key: "fromContextAndTokens",
+            value: function fromContextAndTokens(context, tokens1) {
+                var terms = [], frames = [], statements = [], assertions = [], substitutions = [], reference = null, temporaryContext = new TemporaryContext(context, tokens1, terms, frames, statements, assertions, substitutions, reference);
+                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 { extract, compress } = arrayUtilities;\n\nexport default class TemporaryContext {\n  constructor(context, tokens, terms, frames, statements, assertions, substitutions, reference) {\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.substitutions = substitutions;\n    this.reference = reference;\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  getSubstitutions() {\n    return this.substitutions;\n  }\n\n  getReference() {\n    return this.reference;\n  }\n\n  addTerm(term) {\n    const context = this, ///\n          termNode = term.getNode(),\n          termString = term.getString();\n\n    extract(this.terms, (term) => {\n      const termMatchesTermNode = term.matchTermNode(termNode);\n\n      if (termMatchesTermNode) {\n        return true;\n      }\n    });\n\n    context.trace(`ADded the '${termString}' term.`);\n\n    this.terms.push(term);\n  }\n\n  addFrame(frame) {\n    const context = this, ///\n          frameNode = frame.getNode(),\n          frameString = frame.getString();\n\n    extract(this.frames, (frame) => {\n      const frameMatchesFrameNode = frame.matchFrameNode(frameNode);\n\n      if (frameMatchesFrameNode) {\n        return true;\n      }\n    });\n\n    context.trace(`Added the '${frameString}' frame.`);\n\n    this.frames.push(frame);\n  }\n\n  addStatement(statement) {\n    const context = this, ///\n          statementNode = statement.getNode(),\n          statementString = statement.getString();\n\n    extract(this.statements, (statement) => {\n      const statementMatchesFrameNode = statement.matchStatementNode(statementNode);\n\n      if (statementMatchesFrameNode) {\n        return true;\n      }\n    });\n\n    context.trace(`Added the '${statementString}' statement.`);\n\n    this.statements.push(statement);\n  }\n\n  addAssertion(assertion) {\n    const context = this, ///\n          assertionNode = assertion.getNode(),\n          assertionString = assertion.getString();\n\n    extract(this.assertions, (assertion) => {\n      const assertionMatchesFrameNode = assertion.matchAssertionNode(assertionNode);\n\n      if (assertionMatchesFrameNode) {\n        return true;\n      }\n    });\n\n    context.trace(`Added the '${assertionString}' assertion.`);\n\n    this.assertions.push(assertion);\n  }\n\n  addSubstitution(substitution) {\n    const context = this, ///\n          substitutionNode = substitution.getNode(),\n          substitutionString = substitution.getString();\n\n    extract(this.substitutions, (substitution) => {\n      const substitutionMatchesFrameNode = substitution.matchSubstitutionNode(substitutionNode);\n\n      if (substitutionMatchesFrameNode) {\n        return true;\n      }\n    });\n\n    context.trace(`Added the '${substitutionString}' substitution.`);\n\n    this.substitutions.push(substitution);\n  }\n\n  addReference(reference) {\n    const context = this, ///\n      referenceString = reference.getString();\n\n    this.reference = reference;\n\n    context.trace(`Added the '${referenceString}' reference.`);\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  findAssertionByAssertionNode(assertionNode) {\n    const assertion = this.assertions.find((assertion) => {\n      const assertionMatchesAssertionNode = assertion.matchAssertionNode(assertionNode);\n\n      if (assertionMatchesAssertionNode) {\n        return true;\n      }\n    }) || null;\n\n    return assertion;\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  findSubtitutionBySubtitutionNode(substitutionNode) {\n    const substitution = this.substitutions.find((substitution) => {\n      const substitutionMatchesSubtitutionNode = substitution.matchSubtitutionNode(substitutionNode);\n\n      if (substitutionMatchesSubtitutionNode) {\n        return true;\n      }\n    }) || null;\n\n    return substitution;\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) { return this.context.addEquality(equality); }\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  marge(context) {\n    const terms = context.getTerms(),\n          frames = context.getFrames(),\n          statements = context.getStatements(),\n          assertions = context.getAssertions(),\n          substitutions = context.getSubstitutions();\n\n    this.terms = [\n      ...this.terms,\n      ...terms\n    ];\n\n    this.frames = [\n      ...this.frames,\n      ...frames\n    ];\n\n    this.statements = [\n      ...this.statements,\n      ...statements\n    ];\n\n    this.assertions = [\n      ...this.assertions,\n      ...assertions\n    ];\n\n    this.substitutions = [\n      ...this.substitutions,\n      ...substitutions\n    ];\n\n    compress(this.terms, (termA, termB) => {\n      const termANode = termA.getNode(),\n            termBNode = termB.getNode(),\n            termANodeMatchesTermBNode = termANode.match(termBNode);\n\n      if (termAMatchesTermB) {\n        return true;\n      }\n    });\n\n  }\n\n  static fromNothing(context) {\n    const terms = [],\n          frames = [],\n          tokens = null,\n          statements = [],\n          assertions = [],\n          substitutions = [],\n          reference = null,\n          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, substitutions, reference);\n\n    return temporaryContext;\n  }\n\n  static fromTermsAndFrames(terms, frames, context) {\n    const tokens = null,\n          statements = [],\n          assertions = [],\n          substitutions = [],\n          reference = null,\n          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, substitutions, reference);\n\n    return temporaryContext;\n  }\n\n  static fromContextAndTokens(context, tokens) {\n    const terms = [],\n          frames = [],\n          statements = [],\n          assertions = [],\n          substitutions = [],\n          reference = null,\n          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, substitutions, reference);\n\n    return temporaryContext;\n  }\n}\n"],"names":["TemporaryContext","extract","arrayUtilities","compress","context","tokens","terms","frames","statements","assertions","substitutions","reference","getContext","getTokens","getTerms","getFrames","getStatements","getAssertions","getSubstitutions","getReference","addTerm","term","termNode","getNode","termString","getString","termMatchesTermNode","matchTermNode","trace","push","addFrame","frame","frameNode","frameString","frameMatchesFrameNode","matchFrameNode","addStatement","statement","statementNode","statementString","statementMatchesFrameNode","matchStatementNode","addAssertion","assertion","assertionNode","assertionString","assertionMatchesFrameNode","matchAssertionNode","addSubstitution","substitution","substitutionNode","substitutionString","substitutionMatchesFrameNode","matchSubstitutionNode","addReference","referenceString","findTermByTermNode","find","findFrameByFrameNode","findAssertionByAssertionNode","assertionMatchesAssertionNode","findStatementByStatementNode","statementMatchesStatementNode","findSubtitutionBySubtitutionNode","substitutionMatchesSubtitutionNode","matchSubtitutionNode","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","metavariableName","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","message","debug","info","warning","error","marge","termA","termB","termANode","termBNode","termANodeMatchesTermBNode","match","termAMatchesTermB","fromNothing","temporaryContext","fromTermsAndFrames","fromContextAndTokens"],"mappings":"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"}