occam-verify-cli 0.0.273 → 0.0.274

package/lib/context/file.js

@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return FileContext;
+    }
+});
+var _occamGrammarUtilities = require("occam-grammar-utilities");
+var _array = require("../utilities/array");
+function _arrayLikeToArray(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 _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _classCallCheck(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 _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    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 _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(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 _arrayLikeToArray(o, minLen);
+}
+var FileContext = /*#__PURE__*/ function() {
+    function FileContext(tokens, node, rules, types, axioms, variables, combinators, constructors, releaseContext) {
+        _classCallCheck(this, FileContext);
+        this.tokens = tokens;
+        this.node = node;
+        this.rules = rules;
+        this.types = types;
+        this.axioms = axioms;
+        this.variables = variables;
+        this.combinators = combinators;
+        this.constructors = constructors;
+        this.releaseContext = releaseContext;
+    }
+    _createClass(FileContext, [
+        {
+            key: "getTokens",
+            value: function getTokens() {
+                return this.tokens;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getRules",
+            value: function getRules() {
+                var bubble = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var rules = _toConsumableArray(this.rules);
+                if (bubble) {
+                    var releaseContextRules = this.releaseContext.getRules();
+                    (0, _array.push)(rules, releaseContextRules);
+                }
+                return rules;
+            }
+        },
+        {
+            key: "getTypes",
+            value: function getTypes() {
+                var bubble = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var types = _toConsumableArray(this.types);
+                if (bubble) {
+                    var releaseContextTypes = this.releaseContext.getTypes();
+                    (0, _array.push)(types, releaseContextTypes);
+                }
+                return types;
+            }
+        },
+        {
+            key: "getAxioms",
+            value: function getAxioms() {
+                var bubble = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var axioms = _toConsumableArray(this.axioms);
+                if (bubble) {
+                    var releaseContextAxioms = this.releaseContext.getAxioms();
+                    (0, _array.push)(axioms, releaseContextAxioms);
+                }
+                return axioms;
+            }
+        },
+        {
+            key: "getLabels",
+            value: function getLabels() {
+                var axioms = this.getAxioms(), labels = axioms.reduce(function(labels, axiom) {
+                    var axiomLabels = axiom.getLabels();
+                    (0, _array.push)(labels, axiomLabels);
+                    return labels;
+                }, []);
+                return labels;
+            }
+        },
+        {
+            key: "getVariables",
+            value: function getVariables() {
+                return this.variables;
+            }
+        },
+        {
+            key: "getCombinators",
+            value: function getCombinators() {
+                var bubble = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var combinators = _toConsumableArray(this.combinators);
+                if (bubble) {
+                    var releaseContextCombinators = this.releaseContext.getCombinators();
+                    (0, _array.push)(combinators, releaseContextCombinators);
+                }
+                return combinators;
+            }
+        },
+        {
+            key: "getConstructors",
+            value: function getConstructors() {
+                var bubble = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var constructors = _toConsumableArray(this.constructors);
+                if (bubble) {
+                    var releaseContextConstructors = this.releaseContext.getConstructors();
+                    (0, _array.push)(constructors, releaseContextConstructors);
+                }
+                return constructors;
+            }
+        },
+        {
+            key: "getReleaseContext",
+            value: function getReleaseContext() {
+                return this.releaseContext;
+            }
+        },
+        {
+            key: "getMetaAssertions",
+            value: function getMetaAssertions() {
+                var metaAssertions = [];
+                return metaAssertions;
+            }
+        },
+        {
+            key: "findTypeByTypeName",
+            value: function findTypeByTypeName(typeName) {
+                var types = this.getTypes(), type = types.find(function(type) {
+                    var matches = type.matchTypeName(typeName);
+                    if (matches) {
+                        return true;
+                    }
+                }) || null;
+                return type;
+            }
+        },
+        {
+            key: "findRuleByReferenceName",
+            value: function findRuleByReferenceName(referenceName) {
+                var label = referenceName, rules = this.getRules(), rule = rules.find(function(rule) {
+                    var ruleLabels = rule.getLabels(), ruleLabelsIncludesLabel = ruleLabels.includes(label);
+                    if (ruleLabelsIncludesLabel) {
+                        return true;
+                    }
+                }) || null;
+                return rule;
+            }
+        },
+        {
+            key: "findAxiomByReferenceName",
+            value: function findAxiomByReferenceName(referenceName) {
+                var label = referenceName, axioms = this.getAxioms(), axiom = axioms.find(function(axiom) {
+                    var axiomLabels = axiom.getLabels(), axiomLabelsIncludesLabel = axiomLabels.includes(label);
+                    if (axiomLabelsIncludesLabel) {
+                        return true;
+                    }
+                }) || null;
+                return axiom;
+            }
+        },
+        {
+            key: "findVariableByVariableName",
+            value: function findVariableByVariableName(variableName) {
+                var name = variableName, variable = this.variables.find(function(variable) {
+                    var matches = variable.matchName(name);
+                    if (matches) {
+                        return true;
+                    }
+                }) || null;
+                return variable;
+            }
+        },
+        {
+            key: "isDerived",
+            value: function isDerived() {
+                var derived = false;
+                return derived;
+            }
+        },
+        {
+            key: "isLabelPresent",
+            value: function isLabelPresent(label) {
+                var labels = this.getLabels(), labelsIncludesLabel = labels.includes(label), labelPresent = labelsIncludesLabel; ///
+                return labelPresent;
+            }
+        },
+        {
+            key: "matchMetaAssertion",
+            value: function matchMetaAssertion(metaAssertion) {
+                var metaAssertionMatches = false;
+                return metaAssertionMatches;
+            }
+        },
+        {
+            key: "isTypePresentByTypeName",
+            value: function isTypePresentByTypeName(typeName) {
+                var type = this.findTypeByTypeName(typeName), typePresent = type !== null;
+                return typePresent;
+            }
+        },
+        {
+            key: "isVariablePresentByVariableName",
+            value: function isVariablePresentByVariableName(variableName) {
+                var variable = this.findVariableByVariableName(variableName), variablePresent = variable !== null;
+                return variablePresent;
+            }
+        },
+        {
+            key: "addType",
+            value: function addType(type) {
+                this.types.push(type);
+            }
+        },
+        {
+            key: "addRule",
+            value: function addRule(rule) {
+                this.rules.push(rule);
+            }
+        },
+        {
+            key: "addAxiom",
+            value: function addAxiom(axiom) {
+                this.axioms.push(axiom);
+            }
+        },
+        {
+            key: "addVariable",
+            value: function addVariable(variable) {
+                this.variables.push(variable);
+            }
+        },
+        {
+            key: "addCombinator",
+            value: function addCombinator(combinator) {
+                this.combinators.push(combinator);
+            }
+        },
+        {
+            key: "addConstructor",
+            value: function addConstructor(constructor) {
+                this.constructors.push(constructor);
+            }
+        },
+        {
+            key: "trace",
+            value: function trace(message) {
+                this.releaseContext.trace(message);
+            }
+        },
+        {
+            key: "debug",
+            value: function debug(message) {
+                this.releaseContext.debug(message);
+            }
+        },
+        {
+            key: "info",
+            value: function info(message) {
+                this.releaseContext.info(message);
+            }
+        },
+        {
+            key: "warning",
+            value: function warning(message) {
+                this.releaseContext.warning(message);
+            }
+        },
+        {
+            key: "error",
+            value: function error(message) {
+                this.releaseContext.error(message);
+            }
+        },
+        {
+            key: "fatal",
+            value: function fatal(message) {
+                this.releaseContext.fatal(message);
+            }
+        }
+    ], [
+        {
+            key: "fromReleaseContextAndFilePath",
+            value: function fromReleaseContextAndFilePath(releaseContext, filePath) {
+                var fileContent = releaseContext.getFileContent(filePath), content = fileContent, tokens = releaseContext.tokenise(content), node = releaseContext.parse(tokens);
+                (0, _occamGrammarUtilities.rewriteNodes)(node);
+                var rules = [], types = [], axioms = [], variables = [], combinators = [], constructors = [], fileContext = new FileContext(tokens, node, rules, types, axioms, variables, combinators, constructors, releaseContext);
+                return fileContext;
+            }
+        }
+    ]);
+    return FileContext;
+}();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/file.js","<<jsx-config-pragma.js>>"],"sourcesContent":["\"use strict\";\n\nimport { rewriteNodes } from \"occam-grammar-utilities\";\n\nimport { push } from \"../utilities/array\";\n\nexport default class FileContext {\n  constructor(tokens, node, rules, types, axioms, variables, combinators, constructors, releaseContext) {\n    this.tokens = tokens;\n    this.node = node;\n    this.rules = rules;\n    this.types = types;\n    this.axioms = axioms;\n    this.variables = variables;\n    this.combinators = combinators;\n    this.constructors = constructors;\n    this.releaseContext = releaseContext;\n  }\n\n  getTokens() {\n    return this.tokens;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getRules(bubble = true) {\n    const rules = [\n      ...this.rules\n    ];\n\n    if (bubble) {\n      const releaseContextRules = this.releaseContext.getRules();\n\n      push(rules, releaseContextRules);\n    }\n\n    return rules;\n  }\n\n  getTypes(bubble = true) {\n    const types = [\n      ...this.types\n    ];\n\n    if (bubble) {\n      const releaseContextTypes = this.releaseContext.getTypes();\n\n      push(types, releaseContextTypes);\n    }\n\n    return types;\n  }\n\n  getAxioms(bubble = true) {\n    const axioms = [\n      ...this.axioms\n    ];\n\n    if (bubble) {\n      const releaseContextAxioms = this.releaseContext.getAxioms();\n\n      push(axioms, releaseContextAxioms);\n    }\n\n    return axioms;\n  }\n\n  getLabels() {\n    const axioms = this.getAxioms(),\n          labels = axioms.reduce((labels, axiom) => {\n            const axiomLabels = axiom.getLabels();\n\n            push(labels, axiomLabels);\n\n            return labels;\n          }, []);\n\n    return labels;\n  }\n\n  getVariables() {\n    return this.variables;\n  }\n\n  getCombinators(bubble = true) {\n    const combinators = [\n      ...this.combinators\n    ];\n\n    if (bubble) {\n      const releaseContextCombinators = this.releaseContext.getCombinators();\n\n      push(combinators, releaseContextCombinators);\n    }\n\n    return combinators;\n  }\n\n  getConstructors(bubble = true) {\n    const constructors = [\n      ...this.constructors\n    ];\n\n    if (bubble) {\n      const releaseContextConstructors = this.releaseContext.getConstructors();\n\n      push(constructors, releaseContextConstructors);\n    }\n\n    return constructors;\n  }\n\n  getReleaseContext() {\n    return this.releaseContext;\n  }\n\n  getMetaAssertions() {\n    const metaAssertions = [];\n\n    return metaAssertions;\n  }\n\n  findTypeByTypeName(typeName) {\n    const types = this.getTypes(),\n          type = types.find((type) => {\n            const matches = type.matchTypeName(typeName);\n\n            if (matches) {\n              return true;\n            }\n          }) || null;\n\n    return type;\n  }\n\n  findRuleByReferenceName(referenceName) {\n    const label = referenceName,  ///\n          rules = this.getRules(),\n          rule = rules.find((rule) => {\n            const ruleLabels = rule.getLabels(),\n                  ruleLabelsIncludesLabel = ruleLabels.includes(label);\n\n            if (ruleLabelsIncludesLabel) {\n              return true;\n            }\n          }) || null;\n\n    return rule;\n  }\n\n  findAxiomByReferenceName(referenceName) {\n    const label = referenceName,  ///\n          axioms = this.getAxioms(),\n          axiom = axioms.find((axiom) => {\n            const axiomLabels = axiom.getLabels(),\n                  axiomLabelsIncludesLabel = axiomLabels.includes(label);\n\n            if (axiomLabelsIncludesLabel) {\n              return true;\n            }\n          }) || null;\n\n    return axiom;\n  }\n\n  findVariableByVariableName(variableName) {\n    const name = variableName,  ///\n          variable = this.variables.find((variable) => {\n            const matches = variable.matchName(name);\n\n            if (matches) {\n              return true;\n            }\n          }) || null;\n\n    return variable;\n  }\n\n  isDerived() {\n    const derived = false;\n\n    return derived;\n  }\n\n  isLabelPresent(label) {\n    const labels = this.getLabels(),\n          labelsIncludesLabel = labels.includes(label),\n          labelPresent = labelsIncludesLabel; ///\n\n    return labelPresent;\n  }\n\n  matchMetaAssertion(metaAssertion) {\n    const metaAssertionMatches = false;\n\n    return metaAssertionMatches;\n  }\n\n  isTypePresentByTypeName(typeName) {\n    const type = this.findTypeByTypeName(typeName),\n          typePresent = (type !== null);\n\n    return typePresent;\n  }\n\n  isVariablePresentByVariableName(variableName) {\n    const variable = this.findVariableByVariableName(variableName),\n          variablePresent = (variable !== null);\n\n    return variablePresent;\n  }\n\n  addType(type) {\n    this.types.push(type);\n  }\n\n  addRule(rule) {\n    this.rules.push(rule);\n  }\n\n  addAxiom(axiom) {\n    this.axioms.push(axiom);\n  }\n\n  addVariable(variable) {\n    this.variables.push(variable);\n  }\n\n  addCombinator(combinator) {\n    this.combinators.push(combinator);\n  }\n\n  addConstructor(constructor) {\n    this.constructors.push(constructor);\n  }\n\n  trace(message) { this.releaseContext.trace(message); }\n\n  debug(message) { this.releaseContext.debug(message); }\n\n  info(message) { this.releaseContext.info(message); }\n\n  warning(message) { this.releaseContext.warning(message); }\n\n  error(message) { this.releaseContext.error(message); }\n\n  fatal(message) { this.releaseContext.fatal(message); }\n\n  static fromReleaseContextAndFilePath(releaseContext, filePath) {\n    const fileContent = releaseContext.getFileContent(filePath),\n          content = fileContent,  ///\n          tokens = releaseContext.tokenise(content),\n          node = releaseContext.parse(tokens);\n\n    rewriteNodes(node);\n\n    const rules = [],\n          types = [],\n          axioms = [],\n          variables = [],\n          combinators = [],\n          constructors = [],\n          fileContext = new FileContext(tokens, node, rules, types, axioms, variables, combinators, constructors, releaseContext);\n\n    return fileContext;\n  }\n}\n","React.createElement"],"names":["FileContext","tokens","node","rules","types","axioms","variables","combinators","constructors","releaseContext","getTokens","getNode","getRules","bubble","releaseContextRules","push","getTypes","releaseContextTypes","getAxioms","releaseContextAxioms","getLabels","labels","reduce","axiom","axiomLabels","getVariables","getCombinators","releaseContextCombinators","getConstructors","releaseContextConstructors","getReleaseContext","getMetaAssertions","metaAssertions","findTypeByTypeName","typeName","type","find","matches","matchTypeName","findRuleByReferenceName","referenceName","label","rule","ruleLabels","ruleLabelsIncludesLabel","includes","findAxiomByReferenceName","axiomLabelsIncludesLabel","findVariableByVariableName","variableName","name","variable","matchName","isDerived","derived","isLabelPresent","labelsIncludesLabel","labelPresent","matchMetaAssertion","metaAssertion","metaAssertionMatches","isTypePresentByTypeName","typePresent","isVariablePresentByVariableName","variablePresent","addType","addRule","addAxiom","addVariable","addCombinator","combinator","addConstructor","constructor","trace","message","debug","info","warning","error","fatal","fromReleaseContextAndFilePath","filePath","fileContent","getFileContent","content","tokenise","parse","rewriteNodes","fileContext"],"mappings":"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"}

package/lib/context/metaproof.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return MetaproofContext;
+    }
+});
+function _arrayLikeToArray(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 _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _classCallCheck(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 _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    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 _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(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 _arrayLikeToArray(o, minLen);
+}
+var MetaproofContext = /*#__PURE__*/ function() {
+    function MetaproofContext(context, derived, metaAssertions) {
+        _classCallCheck(this, MetaproofContext);
+        this.context = context;
+        this.derived = derived;
+        this.metaAssertions = metaAssertions;
+    }
+    _createClass(MetaproofContext, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
+        {
+            key: "isDerived",
+            value: function isDerived() {
+                return this.derived;
+            }
+        },
+        {
+            key: "getMetaAssertions",
+            value: function getMetaAssertions() {
+                var metaAssertions = this.context.getMetaAssertions();
+                metaAssertions = _toConsumableArray(metaAssertions).concat(_toConsumableArray(this.metaAssertions));
+                return metaAssertions;
+            }
+        },
+        {
+            key: "getRules",
+            value: function getRules() {
+                return this.context.getRules();
+            }
+        },
+        {
+            key: "getTypes",
+            value: function getTypes() {
+                return this.context.getTypes();
+            }
+        },
+        {
+            key: "getAxioms",
+            value: function getAxioms() {
+                return this.context.getAxioms();
+            }
+        },
+        {
+            key: "getCombinators",
+            value: function getCombinators() {
+                return this.context.getCombinators();
+            }
+        },
+        {
+            key: "getConstructors",
+            value: function getConstructors() {
+                return this.context.getConstructors();
+            }
+        },
+        {
+            key: "findTypeByTypeName",
+            value: function findTypeByTypeName(typeName) {
+                return this.context.findTypeByTypeName(typeName);
+            }
+        },
+        {
+            key: "findRuleByReferenceName",
+            value: function findRuleByReferenceName(referenceName) {
+                return this.context.findRuleByReferenceName(referenceName);
+            }
+        },
+        {
+            key: "findVariableByVariableName",
+            value: function findVariableByVariableName(variableName) {
+                return this.context.findVariableByVariableName(variableName);
+            }
+        },
+        {
+            key: "isLabelPresent",
+            value: function isLabelPresent(label) {
+                return this.context.isLabelPresent(label);
+            }
+        },
+        {
+            key: "isTypePresentByTypeName",
+            value: function isTypePresentByTypeName(typeName) {
+                return this.context.isTypePresentByTypeName(typeName);
+            }
+        },
+        {
+            key: "matchMetaAssertion",
+            value: function matchMetaAssertion(metaAssertion) {
+                var metaAssertionMatches;
+                var metaAssertionB = metaAssertion; ///
+                metaAssertionMatches = this.metaAssertions.some(function(metaAssertion) {
+                    var metaAssertionA = metaAssertion, matches = metaAssertionA.match(metaAssertionB);
+                    if (matches) {
+                        return true;
+                    }
+                });
+                if (!metaAssertionMatches) {
+                    metaAssertionMatches = this.context.matchMetaAssertion(metaAssertion);
+                }
+                return metaAssertionMatches;
+            }
+        },
+        {
+            key: "isVariablePresentByVariableName",
+            value: function isVariablePresentByVariableName(variableName) {
+                return this.context.isVariablePresentByVariableName(variableName);
+            }
+        },
+        {
+            key: "setDerived",
+            value: function setDerived(derived) {
+                this.derived = derived;
+            }
+        },
+        {
+            key: "addRule",
+            value: function addRule(rule) {
+                this.context.addRule(rule);
+            }
+        },
+        {
+            key: "addMetaAssertion",
+            value: function addMetaAssertion(metaAssertion) {
+                this.metaAssertions.push(metaAssertion);
+            }
+        },
+        {
+            key: "trace",
+            value: function trace(message) {
+                this.context.trace(message);
+            }
+        },
+        {
+            key: "debug",
+            value: function debug(message) {
+                this.context.debug(message);
+            }
+        },
+        {
+            key: "info",
+            value: function info(message) {
+                this.context.info(message);
+            }
+        },
+        {
+            key: "warning",
+            value: function warning(message) {
+                this.context.warning(message);
+            }
+        },
+        {
+            key: "error",
+            value: function error(message) {
+                this.context.error(message);
+            }
+        },
+        {
+            key: "fatal",
+            value: function fatal(message) {
+                this.context.fatal(message);
+            }
+        }
+    ], [
+        {
+            key: "fromContext",
+            value: function fromContext(context) {
+                var derived = false, metaAssertions = [], metaproofContext = new MetaproofContext(context, derived, metaAssertions);
+                return metaproofContext;
+            }
+        }
+    ]);
+    return MetaproofContext;
+}();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/metaproof.js","<<jsx-config-pragma.js>>"],"sourcesContent":["\"use strict\";\n\nexport default class MetaproofContext {\n  constructor(context, derived, metaAssertions) {\n    this.context = context;\n    this.derived = derived;\n    this.metaAssertions = metaAssertions;\n  }\n\n  getContext() {\n    return this.context;\n  }\n\n  isDerived() {\n    return this.derived;\n  }\n\n  getMetaAssertions() {\n    let metaAssertions = this.context.getMetaAssertions();\n\n    metaAssertions = [\n      ...metaAssertions,\n      ...this.metaAssertions\n    ];\n\n    return metaAssertions;\n  }\n\n  getRules() { return this.context.getRules(); }\n\n  getTypes() { return this.context.getTypes(); }\n\n  getAxioms() { return this.context.getAxioms(); }\n\n  getCombinators() { return this.context.getCombinators(); }\n\n  getConstructors() { return this.context.getConstructors(); }\n\n  findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }\n\n  findRuleByReferenceName(referenceName) { return this.context.findRuleByReferenceName(referenceName); }\n\n  findVariableByVariableName(variableName) { return this.context.findVariableByVariableName(variableName); }\n\n  isLabelPresent(label) { return this.context.isLabelPresent(label); }\n\n  isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }\n\n  matchMetaAssertion(metaAssertion) {\n    let metaAssertionMatches;\n\n    const metaAssertionB = metaAssertion; ///\n\n    metaAssertionMatches = this.metaAssertions.some((metaAssertion) => {\n      const metaAssertionA = metaAssertion, ///\n            matches = metaAssertionA.match(metaAssertionB);\n\n      if (matches) {\n        return true;\n      }\n    });\n\n    if (!metaAssertionMatches) {\n      metaAssertionMatches = this.context.matchMetaAssertion(metaAssertion);\n    }\n\n    return metaAssertionMatches;\n  }\n\n  isVariablePresentByVariableName(variableName) { return this.context.isVariablePresentByVariableName(variableName); }\n\n  setDerived(derived) {\n    this.derived = derived;\n  }\n\n  addRule(rule) { this.context.addRule(rule); }\n\n  addMetaAssertion(metaAssertion) {\n    this.metaAssertions.push(metaAssertion);\n  }\n\n  trace(message) { this.context.trace(message); }\n\n  debug(message) { this.context.debug(message); }\n\n  info(message) { this.context.info(message); }\n\n  warning(message) { this.context.warning(message); }\n\n  error(message) { this.context.error(message); }\n\n  fatal(message) { this.context.fatal(message); }\n\n  static fromContext(context) {\n    const derived = false,\n          metaAssertions = [],\n          metaproofContext = new MetaproofContext(context, derived, metaAssertions);\n\n    return metaproofContext;\n  }\n}\n","React.createElement"],"names":["MetaproofContext","context","derived","metaAssertions","getContext","isDerived","getMetaAssertions","getRules","getTypes","getAxioms","getCombinators","getConstructors","findTypeByTypeName","typeName","findRuleByReferenceName","referenceName","findVariableByVariableName","variableName","isLabelPresent","label","isTypePresentByTypeName","matchMetaAssertion","metaAssertion","metaAssertionMatches","metaAssertionB","some","metaAssertionA","matches","match","isVariablePresentByVariableName","setDerived","addRule","rule","addMetaAssertion","push","trace","message","debug","info","warning","error","fatal","fromContext","metaproofContext"],"mappings":"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"}