occam-verify-cli 0.0.273 → 0.0.274

package/lib/context/proof.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return ProofContext;
+    }
+});
+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;
+}
+var ProofContext = /*#__PURE__*/ function() {
+    function ProofContext(context, derived, variables, statementNodes) {
+        _classCallCheck(this, ProofContext);
+        this.context = context;
+        this.derived = derived;
+        this.variables = variables;
+        this.statementNodes = statementNodes;
+    }
+    _createClass(ProofContext, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
+        {
+            key: "isDerived",
+            value: function isDerived() {
+                return this.derived;
+            }
+        },
+        {
+            key: "getVariables",
+            value: function getVariables() {
+                return this.variables;
+            }
+        },
+        {
+            key: "getStatementNodes",
+            value: function getStatementNodes() {
+                return this.statementNodes;
+            }
+        },
+        {
+            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) {
+                var name = variableName, variable = this.variables.find(function(variable) {
+                    var matches = variable.matchName(name);
+                    if (matches) {
+                        return true;
+                    }
+                }) || this.context.findVariableByVariableName(variableName); ///
+                return variable;
+            }
+        },
+        {
+            key: "isLabelPresent",
+            value: function isLabelPresent(label) {
+                return this.context.isLabelPresent(label);
+            }
+        },
+        {
+            key: "isTypePresentByTypeName",
+            value: function isTypePresentByTypeName(typeName) {
+                return this.context.isTypePresentByTypeName(typeName);
+            }
+        },
+        {
+            key: "isVariablePresentByVariableName",
+            value: function isVariablePresentByVariableName(variableName) {
+                var variable = this.findVariableByVariableName(variableName), variablePresent = variable !== null;
+                return variablePresent;
+            }
+        },
+        {
+            key: "setDerived",
+            value: function setDerived(derived) {
+                if (derived) {
+                    this.statementNodes.pop();
+                }
+                this.derived = derived;
+            }
+        },
+        {
+            key: "addAxiom",
+            value: function addAxiom(axiom) {
+                this.context.addAxiom(axiom);
+            }
+        },
+        {
+            key: "addVariable",
+            value: function addVariable(variable) {
+                this.variables.push(variable);
+            }
+        },
+        {
+            key: "addStatementNode",
+            value: function addStatementNode(statementNode) {
+                this.statementNodes.push(statementNode);
+            }
+        },
+        {
+            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, variables = [], statementNodes = [], proofContext = new ProofContext(context, derived, variables, statementNodes);
+                return proofContext;
+            }
+        }
+    ]);
+    return ProofContext;
+}();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/proof.js","<<jsx-config-pragma.js>>"],"sourcesContent":["\"use strict\";\n\nexport default class ProofContext {\n  constructor(context, derived, variables, statementNodes) {\n    this.context = context;\n    this.derived = derived;\n    this.variables = variables;\n    this.statementNodes = statementNodes;\n  }\n\n  getContext() {\n    return this.context;\n  }\n\n  isDerived() {\n    return this.derived;\n  }\n\n  getVariables() {\n    return this.variables;\n  }\n\n  getStatementNodes() {\n    return this.statementNodes;\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) {\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          }) || this.context.findVariableByVariableName(variableName);  ///\n\n    return variable;\n  }\n\n  isLabelPresent(label) { return this.context.isLabelPresent(label); }\n\n  isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }\n\n  isVariablePresentByVariableName(variableName) {\n    const variable = this.findVariableByVariableName(variableName),\n          variablePresent = (variable !== null);\n\n    return variablePresent;\n  }\n\n  setDerived(derived) {\n    if (derived) {\n      this.statementNodes.pop();\n    }\n\n    this.derived = derived;\n  }\n\n  addAxiom(axiom) { this.context.addAxiom(axiom); }\n\n  addVariable(variable) {\n    this.variables.push(variable);\n  }\n\n  addStatementNode(statementNode) {\n    this.statementNodes.push(statementNode);\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          variables = [],\n          statementNodes = [],\n          proofContext = new ProofContext(context, derived, variables, statementNodes);\n\n    return proofContext;\n  }\n}\n","React.createElement"],"names":["ProofContext","context","derived","variables","statementNodes","getContext","isDerived","getVariables","getStatementNodes","getRules","getTypes","getAxioms","getCombinators","getConstructors","findTypeByTypeName","typeName","findRuleByReferenceName","referenceName","findVariableByVariableName","variableName","name","variable","find","matches","matchName","isLabelPresent","label","isTypePresentByTypeName","isVariablePresentByVariableName","variablePresent","setDerived","pop","addAxiom","axiom","addVariable","push","addStatementNode","statementNode","trace","message","debug","info","warning","error","fatal","fromContext","proofContext"],"mappings":"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"}

package/lib/context/release.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return ReleaseContext;
+    }
+});
+var _occamCustomGrammars = require("occam-custom-grammars");
+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 isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Date.prototype.toString.call(Reflect.construct(Date, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _construct(Parent, args, Class) {
+    if (isNativeReflectConstruct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function _construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _setPrototypeOf(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+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 _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _setPrototypeOf(o, p);
+}
+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 florenceLexerFromCombinedCustomGrammar = _occamCustomGrammars.lexersUtilities.florenceLexerFromCombinedCustomGrammar, florenceParserFromCombinedCustomGrammar = _occamCustomGrammars.parsersUtilities.florenceParserFromCombinedCustomGrammar;
+var ReleaseContext = /*#__PURE__*/ function() {
+    function ReleaseContext(releaseName, fileContexts, florenceLexer, florenceParser, releaseContexts, releaseVerified) {
+        _classCallCheck(this, ReleaseContext);
+        this.releaseName = releaseName;
+        this.fileContexts = fileContexts;
+        this.florenceLexer = florenceLexer;
+        this.florenceParser = florenceParser;
+        this.releaseContexts = releaseContexts;
+        this.releaseVerified = releaseVerified;
+    }
+    _createClass(ReleaseContext, [
+        {
+            key: "getReleaseName",
+            value: function getReleaseName() {
+                return this.releaseName;
+            }
+        },
+        {
+            key: "getFileContexts",
+            value: function getFileContexts() {
+                return this.fileContexts;
+            }
+        },
+        {
+            key: "getFlorenceLexer",
+            value: function getFlorenceLexer() {
+                return this.florenceLexer;
+            }
+        },
+        {
+            key: "getFlorenceParser",
+            value: function getFlorenceParser() {
+                return this.florenceParser;
+            }
+        },
+        {
+            key: "getReleaseContexts",
+            value: function getReleaseContexts() {
+                return this.releaseContexts;
+            }
+        },
+        {
+            key: "isReleaseVerified",
+            value: function isReleaseVerified() {
+                return this.releaseVerified;
+            }
+        },
+        {
+            key: "getRules",
+            value: function getRules() {
+                var releaseNames = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+                var rules = [], releaseNamesIncludesReleaseName = releaseNames.includes(this.releaseName);
+                if (!releaseNamesIncludesReleaseName) {
+                    releaseNames.push(this.releaseName);
+                    var bubble = false;
+                    this.fileContexts.forEach(function(fileContext) {
+                        var fileContextRules = fileContext.getRules(bubble);
+                        (0, _array.push)(rules, fileContextRules);
+                    });
+                    this.releaseContexts.forEach(function(releaseContext) {
+                        var releaseContextRules = releaseContext.getRules(releaseNames);
+                        (0, _array.push)(rules, releaseContextRules);
+                    });
+                }
+                return rules;
+            }
+        },
+        {
+            key: "getTypes",
+            value: function getTypes() {
+                var releaseNames = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+                var types = [], releaseNamesIncludesReleaseName = releaseNames.includes(this.releaseName);
+                if (!releaseNamesIncludesReleaseName) {
+                    releaseNames.push(this.releaseName);
+                    var bubble = false;
+                    this.fileContexts.forEach(function(fileContext) {
+                        var fileContextTypes = fileContext.getTypes(bubble);
+                        (0, _array.push)(types, fileContextTypes);
+                    });
+                    this.releaseContexts.forEach(function(releaseContext) {
+                        var releaseContextTypes = releaseContext.getTypes(releaseNames);
+                        (0, _array.push)(types, releaseContextTypes);
+                    });
+                }
+                return types;
+            }
+        },
+        {
+            key: "getAxioms",
+            value: function getAxioms() {
+                var releaseNames = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+                var axioms = [], releaseNamesIncludesReleaseName = releaseNames.includes(this.releaseName);
+                if (!releaseNamesIncludesReleaseName) {
+                    releaseNames.push(this.releaseName);
+                    var bubble = false;
+                    this.fileContexts.forEach(function(fileContext) {
+                        var fileContextAxioms = fileContext.getAxioms(bubble);
+                        (0, _array.push)(axioms, fileContextAxioms);
+                    });
+                    this.releaseContexts.forEach(function(releaseContext) {
+                        var releaseContextAxioms = releaseContext.getAxioms(releaseNames);
+                        (0, _array.push)(axioms, releaseContextAxioms);
+                    });
+                }
+                return axioms;
+            }
+        },
+        {
+            key: "getCombinators",
+            value: function getCombinators() {
+                var releaseNames = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+                var combinators = [], releaseNamesIncludesReleaseName = releaseNames.includes(this.releaseName);
+                if (!releaseNamesIncludesReleaseName) {
+                    releaseNames.push(this.releaseName);
+                    var bubble = false;
+                    this.fileContexts.forEach(function(fileContext) {
+                        var fileContextCombinators = fileContext.getCombinators(bubble);
+                        (0, _array.push)(combinators, fileContextCombinators);
+                    });
+                    this.releaseContexts.forEach(function(releaseContext) {
+                        var releaseContextCombinators = releaseContext.getCombinators(releaseNames);
+                        (0, _array.push)(combinators, releaseContextCombinators);
+                    });
+                }
+                return combinators;
+            }
+        },
+        {
+            key: "getConstructors",
+            value: function getConstructors() {
+                var releaseNames = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+                var constructors = [], releaseNamesIncludesReleaseName = releaseNames.includes(this.releaseName);
+                if (!releaseNamesIncludesReleaseName) {
+                    releaseNames.push(this.releaseName);
+                    var bubble = false;
+                    this.fileContexts.forEach(function(fileContext) {
+                        var fileContextConstructors = fileContext.getConstructors(bubble);
+                        (0, _array.push)(constructors, fileContextConstructors);
+                    });
+                    this.releaseContexts.forEach(function(releaseContext) {
+                        var releaseContextConstructors = releaseContext.getConstructors(releaseNames);
+                        (0, _array.push)(constructors, releaseContextConstructors);
+                    });
+                }
+                return constructors;
+            }
+        },
+        {
+            key: "getCustomGrammar",
+            value: function getCustomGrammar() {
+                var name = this.releaseName, termBNF = this.getTermBNF(), statementBNF = this.getStatementBNF(), metastatementBNF = this.getMetastatementBNF(), typePattern = this.getTypePattern(), symbolPattern = this.getSymbolPattern(), operatorPattern = this.getOperatorPattern(), customGrammar = new _occamCustomGrammars.CustomGrammar(name, termBNF, statementBNF, metastatementBNF, typePattern, symbolPattern, operatorPattern);
+                return customGrammar;
+            }
+        },
+        {
+            key: "addFileContext",
+            value: function addFileContext(fileContext) {
+                this.fileContexts.push(fileContext);
+            }
+        },
+        {
+            key: "tokenise",
+            value: function tokenise(content) {
+                return this.florenceLexer.tokenise(content);
+            }
+        },
+        {
+            key: "parse",
+            value: function parse(tokens) {
+                return this.florenceParser.parse(tokens);
+            }
+        },
+        {
+            key: "initialise",
+            value: function initialise(releaseContexts, dependencyReleaseContexts) {
+                this.releaseContexts = releaseContexts;
+                var releaseContext = this; ///
+                releaseContexts = [
+                    releaseContext
+                ].concat(_toConsumableArray(dependencyReleaseContexts)); ///
+                var customGrammars = releaseContexts.map(function(releaseContext) {
+                    var customGrammar = releaseContext.getCustomGrammar();
+                    return customGrammar;
+                }), combinedCustomGrammar = _occamCustomGrammars.CombinedCustomGrammar.fromCustomGrammars(customGrammars);
+                this.florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
+                this.florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
+            }
+        }
+    ], [
+        {
+            key: "fromReleaseName",
+            value: function fromReleaseName(Class, releaseName) {
+                for(var _len = arguments.length, remainingArguments = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+                    remainingArguments[_key - 2] = arguments[_key];
+                }
+                var fileContexts = [], florenceLexer = null, florenceParser = null, releaseContexts = [], releaseVerified = false, releaseContext = _construct(Class, [
+                    releaseName,
+                    fileContexts,
+                    florenceLexer,
+                    florenceParser,
+                    releaseContexts,
+                    releaseVerified
+                ].concat(_toConsumableArray(remainingArguments)));
+                return releaseContext;
+            }
+        }
+    ]);
+    return ReleaseContext;
+}();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/release.js","<<jsx-config-pragma.js>>"],"sourcesContent":["\"use strict\";\n\nimport { CustomGrammar, lexersUtilities, parsersUtilities, CombinedCustomGrammar } from \"occam-custom-grammars\";\n\nimport { push } from \"../utilities/array\";\n\nconst { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,\n      { florenceParserFromCombinedCustomGrammar } = parsersUtilities;\n\nexport default class ReleaseContext {\n  constructor(releaseName, fileContexts, florenceLexer, florenceParser, releaseContexts, releaseVerified) {\n    this.releaseName = releaseName;\n    this.fileContexts = fileContexts;\n    this.florenceLexer = florenceLexer;\n    this.florenceParser = florenceParser;\n    this.releaseContexts = releaseContexts;\n    this.releaseVerified = releaseVerified;\n  }\n\n  getReleaseName() {\n    return this.releaseName;\n  }\n\n  getFileContexts() {\n    return this.fileContexts;\n  }\n\n  getFlorenceLexer() {\n    return this.florenceLexer;\n  }\n\n  getFlorenceParser() {\n    return this.florenceParser;\n  }\n\n  getReleaseContexts() {\n    return this.releaseContexts;\n  }\n\n  isReleaseVerified() {\n    return this.releaseVerified;\n  }\n\n  getRules(releaseNames = []) {\n    const rules = [],\n          releaseNamesIncludesReleaseName = releaseNames.includes(this.releaseName);\n\n    if (!releaseNamesIncludesReleaseName) {\n      releaseNames.push(this.releaseName);\n\n      const bubble = false;\n\n      this.fileContexts.forEach((fileContext) => {\n        const fileContextRules = fileContext.getRules(bubble);\n\n        push(rules, fileContextRules);\n      });\n\n      this.releaseContexts.forEach((releaseContext) => {\n        const releaseContextRules = releaseContext.getRules(releaseNames);\n\n        push(rules, releaseContextRules);\n      });\n    }\n\n    return rules;\n  }\n\n  getTypes(releaseNames = []) {\n    const types = [],\n          releaseNamesIncludesReleaseName = releaseNames.includes(this.releaseName);\n\n    if (!releaseNamesIncludesReleaseName) {\n      releaseNames.push(this.releaseName);\n\n      const bubble = false;\n\n      this.fileContexts.forEach((fileContext) => {\n        const fileContextTypes = fileContext.getTypes(bubble);\n\n        push(types, fileContextTypes);\n      });\n\n      this.releaseContexts.forEach((releaseContext) => {\n        const releaseContextTypes = releaseContext.getTypes(releaseNames);\n\n        push(types, releaseContextTypes);\n      });\n    }\n\n    return types;\n  }\n\n  getAxioms(releaseNames = []) {\n    const axioms = [],\n          releaseNamesIncludesReleaseName = releaseNames.includes(this.releaseName);\n\n    if (!releaseNamesIncludesReleaseName) {\n      releaseNames.push(this.releaseName);\n\n      const bubble = false;\n\n      this.fileContexts.forEach((fileContext) => {\n        const fileContextAxioms = fileContext.getAxioms(bubble);\n\n        push(axioms, fileContextAxioms);\n      });\n\n      this.releaseContexts.forEach((releaseContext) => {\n        const releaseContextAxioms = releaseContext.getAxioms(releaseNames);\n\n        push(axioms, releaseContextAxioms);\n      });\n    }\n\n    return axioms;\n  }\n\n  getCombinators(releaseNames = []) {\n    const combinators = [],\n          releaseNamesIncludesReleaseName = releaseNames.includes(this.releaseName);\n\n    if (!releaseNamesIncludesReleaseName) {\n      releaseNames.push(this.releaseName);\n\n      const bubble = false;\n\n      this.fileContexts.forEach((fileContext) => {\n        const fileContextCombinators = fileContext.getCombinators(bubble);\n\n        push(combinators, fileContextCombinators);\n      });\n\n      this.releaseContexts.forEach((releaseContext) => {\n        const releaseContextCombinators = releaseContext.getCombinators(releaseNames);\n\n        push(combinators, releaseContextCombinators);\n      });\n    }\n\n    return combinators;\n  }\n\n  getConstructors(releaseNames = []) {\n    const constructors = [],\n          releaseNamesIncludesReleaseName = releaseNames.includes(this.releaseName);\n\n    if (!releaseNamesIncludesReleaseName) {\n      releaseNames.push(this.releaseName);\n\n      const bubble = false;\n\n      this.fileContexts.forEach((fileContext) => {\n        const fileContextConstructors = fileContext.getConstructors(bubble);\n\n        push(constructors, fileContextConstructors);\n      });\n\n      this.releaseContexts.forEach((releaseContext) => {\n        const releaseContextConstructors = releaseContext.getConstructors(releaseNames);\n\n        push(constructors, releaseContextConstructors);\n      });\n    }\n\n    return constructors;\n  }\n\n  getCustomGrammar() {\n    const name = this.releaseName, ///\n          termBNF = this.getTermBNF(),\n          statementBNF = this.getStatementBNF(),\n          metastatementBNF = this.getMetastatementBNF(),\n          typePattern = this.getTypePattern(),\n          symbolPattern = this.getSymbolPattern(),\n          operatorPattern = this.getOperatorPattern(),\n          customGrammar = new CustomGrammar(name, termBNF, statementBNF, metastatementBNF, typePattern, symbolPattern, operatorPattern);\n\n    return customGrammar;\n  }\n\n  addFileContext(fileContext) {\n    this.fileContexts.push(fileContext);\n  }\n\n  tokenise(content) { return this.florenceLexer.tokenise(content); }\n\n  parse(tokens) { return this.florenceParser.parse(tokens); }\n\n  initialise(releaseContexts, dependencyReleaseContexts) {\n    this.releaseContexts = releaseContexts;\n\n    const releaseContext = this;  ///\n\n    releaseContexts = [ releaseContext, ...dependencyReleaseContexts ]; ///\n\n    const customGrammars = releaseContexts.map((releaseContext) => {\n            const customGrammar = releaseContext.getCustomGrammar();\n\n            return customGrammar;\n          }),\n          combinedCustomGrammar = CombinedCustomGrammar.fromCustomGrammars(customGrammars);\n\n    this.florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);\n\n    this.florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);\n  }\n\n  static fromReleaseName(Class, releaseName, ...remainingArguments) {\n    const fileContexts = [],\n          florenceLexer = null,\n          florenceParser = null,\n          releaseContexts = [],\n          releaseVerified = false,\n          releaseContext = new Class(releaseName, fileContexts, florenceLexer, florenceParser, releaseContexts, releaseVerified, ...remainingArguments);\n\n    return releaseContext;\n  }\n}\n","React.createElement"],"names":["ReleaseContext","florenceLexerFromCombinedCustomGrammar","lexersUtilities","florenceParserFromCombinedCustomGrammar","parsersUtilities","releaseName","fileContexts","florenceLexer","florenceParser","releaseContexts","releaseVerified","getReleaseName","getFileContexts","getFlorenceLexer","getFlorenceParser","getReleaseContexts","isReleaseVerified","getRules","releaseNames","rules","releaseNamesIncludesReleaseName","includes","push","bubble","forEach","fileContext","fileContextRules","releaseContext","releaseContextRules","getTypes","types","fileContextTypes","releaseContextTypes","getAxioms","axioms","fileContextAxioms","releaseContextAxioms","getCombinators","combinators","fileContextCombinators","releaseContextCombinators","getConstructors","constructors","fileContextConstructors","releaseContextConstructors","getCustomGrammar","name","termBNF","getTermBNF","statementBNF","getStatementBNF","metastatementBNF","getMetastatementBNF","typePattern","getTypePattern","symbolPattern","getSymbolPattern","operatorPattern","getOperatorPattern","customGrammar","CustomGrammar","addFileContext","tokenise","content","parse","tokens","initialise","dependencyReleaseContexts","customGrammars","map","combinedCustomGrammar","CombinedCustomGrammar","fromCustomGrammars","fromReleaseName","Class","remainingArguments"],"mappings":"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"}

package/lib/main.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    verifyRelease: function() {
+        return _release.default;
+    },
+    ReleaseContext: function() {
+        return _release1.default;
+    }
+});
+var _release = /*#__PURE__*/ _interopRequireDefault(require("./verify/release"));
+var _release1 = /*#__PURE__*/ _interopRequireDefault(require("./context/release"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9tYWluLmpzIl0sInNvdXJjZXNDb250ZW50IjpbIlwidXNlIHN0cmljdFwiO1xuXG5leHBvcnQgeyBkZWZhdWx0IGFzIHZlcmlmeVJlbGVhc2UgfSBmcm9tIFwiLi92ZXJpZnkvcmVsZWFzZVwiO1xuZXhwb3J0IHsgZGVmYXVsdCBhcyBSZWxlYXNlQ29udGV4dCB9IGZyb20gXCIuL2NvbnRleHQvcmVsZWFzZVwiO1xuIl0sIm5hbWVzIjpbInZlcmlmeVJlbGVhc2UiLCJSZWxlYXNlQ29udGV4dCJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7O0lBRW9CQSxhQUFhO2VBQWJBLGdCQUFhOztJQUNiQyxjQUFjO2VBQWRBLGlCQUFjOzs7NERBRE87NkRBQ0MifQ==