occam-verify-cli 0.0.1003 → 0.0.1005

package/lib/context/release.other.js

@@ -0,0 +1,605 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return ReleaseContext;
+    }
+});
+var _occamentities = require("occam-entities");
+var _occamcustomgrammars = require("occam-custom-grammars");
+var _file = /*#__PURE__*/ _interop_require_default(require("./file"));
+var _type = require("../type");
+var _array = require("../utilities/array");
+var _customGrammar = require("../utilities/customGrammar");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var isFilePathFlorenceFilePath = _occamentities.filePathUtilities.isFilePathFlorenceFilePath, nominalLexerFromCombinedCustomGrammar = _occamcustomgrammars.lexersUtilities.nominalLexerFromCombinedCustomGrammar, nominalParserFromCombinedCustomGrammar = _occamcustomgrammars.parsersUtilities.nominalParserFromCombinedCustomGrammar;
+var ReleaseContext = /*#__PURE__*/ function() {
+    function ReleaseContext(log1, name, lexer, parser, entries, released, initialised, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts) {
+        _class_call_check(this, ReleaseContext);
+        this.log = log1;
+        this.name = name;
+        this.lexer = lexer;
+        this.parser = parser;
+        this.entries = entries;
+        this.released = released;
+        this.initialised = initialised;
+        this.fileContexts = fileContexts;
+        this.customGrammar = customGrammar;
+        this.loggingDisabled = loggingDisabled;
+        this.dependencyReleaseContexts = dependencyReleaseContexts;
+    }
+    _create_class(ReleaseContext, [
+        {
+            key: "getLog",
+            value: function getLog() {
+                return log;
+            }
+        },
+        {
+            key: "getName",
+            value: function getName() {
+                return this.name;
+            }
+        },
+        {
+            key: "getLexer",
+            value: function getLexer() {
+                return this.lexer;
+            }
+        },
+        {
+            key: "getParser",
+            value: function getParser() {
+                return this.parser;
+            }
+        },
+        {
+            key: "getEntries",
+            value: function getEntries() {
+                return this.entries;
+            }
+        },
+        {
+            key: "isReleased",
+            value: function isReleased() {
+                return this.released;
+            }
+        },
+        {
+            key: "isInitialised",
+            value: function isInitialised() {
+                return this.initialised;
+            }
+        },
+        {
+            key: "getFileContexts",
+            value: function getFileContexts() {
+                return this.fileContexts;
+            }
+        },
+        {
+            key: "getCustomGrammar",
+            value: function getCustomGrammar() {
+                return this.customGrammar;
+            }
+        },
+        {
+            key: "isLoggingDisabled",
+            value: function isLoggingDisabled() {
+                return this.loggingDisabled;
+            }
+        },
+        {
+            key: "getDependencyReleaseContexts",
+            value: function getDependencyReleaseContexts() {
+                return this.dependencyReleaseContexts;
+            }
+        },
+        {
+            key: "setLog",
+            value: function setLog(log1) {
+                this.log = log1;
+            }
+        },
+        {
+            key: "setName",
+            value: function setName(name) {
+                this.name = name;
+            }
+        },
+        {
+            key: "setEntries",
+            value: function setEntries(entries) {
+                this.entries = entries;
+            }
+        },
+        {
+            key: "setReleased",
+            value: function setReleased(released) {
+                this.released = released;
+            }
+        },
+        {
+            key: "setLexer",
+            value: function setLexer(lexer) {
+                this.lexer = lexer;
+            }
+        },
+        {
+            key: "setParser",
+            value: function setParser(parser) {
+                this.parser = parser;
+            }
+        },
+        {
+            key: "setInitialised",
+            value: function setInitialised(initialised) {
+                return this.initialised = initialised;
+            }
+        },
+        {
+            key: "setFileContexts",
+            value: function setFileContexts(fileContexts) {
+                this.fileContexts = fileContexts;
+            }
+        },
+        {
+            key: "setCustomGrammar",
+            value: function setCustomGrammar(customGrammar) {
+                this.customGrammar = customGrammar;
+            }
+        },
+        {
+            key: "setLoggingDisabled",
+            value: function setLoggingDisabled(loggingDisabled) {
+                this.loggingDisabled = loggingDisabled;
+            }
+        },
+        {
+            key: "setDependencyReleaseContexts",
+            value: function setDependencyReleaseContexts(dependencyReleaseContexts) {
+                this.dependencyReleaseContexts = dependencyReleaseContexts;
+            }
+        },
+        {
+            key: "getLabels",
+            value: function getLabels() {
+                var includeDependencies = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var labels = [];
+                this.fileContexts.forEach(function(fileContext) {
+                    var includeRelease = false, fileContextLabels = fileContext.getLabels(includeRelease);
+                    (0, _array.push)(labels, fileContextLabels);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextLabels = releaseContext.getLabels(includeDependencies);
+                        (0, _array.push)(labels, releaseContextLabels);
+                    });
+                }
+                return labels;
+            }
+        },
+        {
+            key: "getTypes",
+            value: function getTypes() {
+                var includeDependencies = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var types = [];
+                this.fileContexts.forEach(function(fileContext) {
+                    var includeRelease = false, fileContextTypes = fileContext.getTypes(includeRelease);
+                    (0, _array.push)(types, fileContextTypes);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextTypes = releaseContext.getTypes(includeDependencies);
+                        (0, _array.push)(types, releaseContextTypes);
+                    });
+                }
+                return types;
+            }
+        },
+        {
+            key: "getRules",
+            value: function getRules() {
+                var includeDependencies = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var rules = [];
+                this.fileContexts.forEach(function(fileContext) {
+                    var includeRelease = false, fileContextRules = fileContext.getRules(includeRelease);
+                    (0, _array.push)(rules, fileContextRules);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextRules = releaseContext.getRules(includeDependencies);
+                        (0, _array.push)(rules, releaseContextRules);
+                    });
+                }
+                return rules;
+            }
+        },
+        {
+            key: "getAxioms",
+            value: function getAxioms() {
+                var includeDependencies = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var axioms = [];
+                this.fileContexts.forEach(function(fileContext) {
+                    var includeRelease = false, fileContextAxioms = fileContext.getAxioms(includeRelease);
+                    (0, _array.push)(axioms, fileContextAxioms);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextAxioms = releaseContext.getAxioms(includeDependencies);
+                        (0, _array.push)(axioms, releaseContextAxioms);
+                    });
+                }
+                return axioms;
+            }
+        },
+        {
+            key: "getLemmas",
+            value: function getLemmas() {
+                var includeDependencies = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var lemmas = [];
+                this.fileContexts.forEach(function(fileContext) {
+                    var includeRelease = false, fileContextLemmas = fileContext.getLemmas(includeRelease);
+                    (0, _array.push)(lemmas, fileContextLemmas);
+                });
+                return lemmas;
+            }
+        },
+        {
+            key: "getTheorems",
+            value: function getTheorems() {
+                var includeDependencies = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var theorems = [];
+                this.fileContexts.forEach(function(fileContext) {
+                    var includeRelease = false, fileContextTheorems = fileContext.getTheorems(includeRelease);
+                    (0, _array.push)(theorems, fileContextTheorems);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextTheorems = releaseContext.getTheorems(includeDependencies);
+                        (0, _array.push)(theorems, releaseContextTheorems);
+                    });
+                }
+                return theorems;
+            }
+        },
+        {
+            key: "getMetaLemmas",
+            value: function getMetaLemmas() {
+                var includeDependencies = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var metaLemmas = [];
+                this.fileContexts.forEach(function(fileContext) {
+                    var includeRelease = false, fileContextMetaLemmas = fileContext.getMetaLemmas(includeRelease);
+                    (0, _array.push)(metaLemmas, fileContextMetaLemmas);
+                });
+                return metaLemmas;
+            }
+        },
+        {
+            key: "getConjectures",
+            value: function getConjectures() {
+                var includeDependencies = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var conjectures = [];
+                this.fileContexts.forEach(function(fileContext) {
+                    var includeRelease = false, fileContextConjectures = fileContext.getConjectures(includeRelease);
+                    (0, _array.push)(conjectures, fileContextConjectures);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextConjectures = releaseContext.getConjectures(includeDependencies);
+                        (0, _array.push)(conjectures, releaseContextConjectures);
+                    });
+                }
+                return conjectures;
+            }
+        },
+        {
+            key: "getCombinators",
+            value: function getCombinators() {
+                var includeDependencies = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var combinators = [];
+                this.fileContexts.forEach(function(fileContext) {
+                    var includeRelease = false, fileContextCombinators = fileContext.getCombinators(includeRelease);
+                    (0, _array.push)(combinators, fileContextCombinators);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextCombinators = releaseContext.getCombinators(includeDependencies);
+                        (0, _array.push)(combinators, releaseContextCombinators);
+                    });
+                }
+                return combinators;
+            }
+        },
+        {
+            key: "getConstructors",
+            value: function getConstructors() {
+                var includeDependencies = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var constructors = [];
+                this.fileContexts.forEach(function(fileContext) {
+                    var includeRelease = false, fileContextConstructors = fileContext.getConstructors(includeRelease);
+                    (0, _array.push)(constructors, fileContextConstructors);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextConstructors = releaseContext.getConstructors(includeDependencies);
+                        (0, _array.push)(constructors, releaseContextConstructors);
+                    });
+                }
+                return constructors;
+            }
+        },
+        {
+            key: "getMetatheorems",
+            value: function getMetatheorems() {
+                var includeDependencies = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var metatheorems = [];
+                this.fileContexts.forEach(function(fileContext) {
+                    var includeRelease = false, fileContextMetatheorems = fileContext.getMetatheorems(includeRelease);
+                    (0, _array.push)(metatheorems, fileContextMetatheorems);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextMetatheorems = releaseContext.getMetatheorems(includeDependencies);
+                        (0, _array.push)(metatheorems, releaseContextMetatheorems);
+                    });
+                }
+                return metatheorems;
+            }
+        },
+        {
+            key: "addFileContext",
+            value: function addFileContext(fileContext) {
+                this.fileContexts.push(fileContext);
+            }
+        },
+        {
+            key: "findTypeByTypeName",
+            value: function findTypeByTypeName(typeName) {
+                var types = this.getTypes();
+                types.push(_type.objectType);
+                var type = types.find(function(type) {
+                    var typeNameMatches = type.matchTypeName(typeName);
+                    if (typeNameMatches) {
+                        return true;
+                    }
+                }) || null;
+                return type;
+            }
+        },
+        {
+            key: "getReleaseName",
+            value: function getReleaseName() {
+                var name = this.getName(), releaseName = name; ///
+                return releaseName;
+            }
+        },
+        {
+            key: "getFile",
+            value: function getFile(filePath) {
+                return this.entries.getFile(filePath);
+            }
+        },
+        {
+            key: "getVersion",
+            value: function getVersion() {
+                return this.entries.getVersion();
+            }
+        },
+        {
+            key: "getFilePaths",
+            value: function getFilePaths() {
+                return this.entries.getFilePaths();
+            }
+        },
+        {
+            key: "getDependencies",
+            value: function getDependencies() {
+                return this.entries.getDependencies();
+            }
+        },
+        {
+            key: "matchShortenedVersion",
+            value: function matchShortenedVersion(shortenedVersion) {
+                return this.entries.matchShortenedVersion(shortenedVersion);
+            }
+        },
+        {
+            key: "disableLogging",
+            value: function disableLogging() {
+                var loggingDisabled = true;
+                this.setLoggingDisabled(loggingDisabled);
+            }
+        },
+        {
+            key: "enableLogging",
+            value: function enableLogging() {
+                var loggingDisabled = false;
+                this.setLoggingDisabled(loggingDisabled);
+            }
+        },
+        {
+            key: "trace",
+            value: function trace(message) {
+                var node = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null, tokens = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null, filePath = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : null;
+                if (this.loggingDisabled) {
+                    return;
+                }
+                this.log.trace(message, node, tokens, filePath);
+            }
+        },
+        {
+            key: "debug",
+            value: function debug(message) {
+                var node = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null, tokens = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null, filePath = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : null;
+                if (this.loggingDisabled) {
+                    return;
+                }
+                this.log.debug(message, node, tokens, filePath);
+            }
+        },
+        {
+            key: "info",
+            value: function info(message) {
+                var node = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null, tokens = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null, filePath = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : null;
+                if (this.loggingDisabled) {
+                    return;
+                }
+                this.log.info(message, node, tokens, filePath);
+            }
+        },
+        {
+            key: "warning",
+            value: function warning(message) {
+                var node = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null, tokens = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null, filePath = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : null;
+                if (this.loggingDisabled) {
+                    return;
+                }
+                this.log.warning(message, node, tokens, filePath);
+            }
+        },
+        {
+            key: "error",
+            value: function error(message) {
+                var node = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null, tokens = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null, filePath = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : null;
+                if (this.loggingDisabled) {
+                    return;
+                }
+                this.log.error(message, node, tokens, filePath);
+            }
+        },
+        {
+            key: "initialise",
+            value: function initialise(releaseContexts) {
+                var combinedCustomGrammar = (0, _customGrammar.combinedCustomGrammarFromReleaseContexts)(releaseContexts), nominalParser = nominalParserFromCombinedCustomGrammar(combinedCustomGrammar), nominalLexer = nominalLexerFromCombinedCustomGrammar(combinedCustomGrammar);
+                this.lexer = nominalLexer; ///
+                this.parser = nominalParser; ///
+                this.dependencyReleaseContexts = (0, _array.tail)(releaseContexts);
+                if (this.released) {
+                    var releaseContext = this; ///
+                    this.fileContexts = fileContextsFromEntries(this.entries, releaseContext);
+                    initialiseFileContexts(this.fileContexts, releaseContext);
+                }
+                this.initialised = true;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var fileContextsJSON = this.fileContexts.map(function(fileContext) {
+                    var fileContextJSON = fileContext.toJSON();
+                    return fileContextJSON;
+                }), json = fileContextsJSON; ///
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromLogNameEntriesAndReleased",
+            value: function fromLogNameEntriesAndReleased(log1, name, entries, released) {
+                var lexer = null, parser = null, initialised = false, fileContexts = [], customGrammar = (0, _customGrammar.customGrammarFromNameAndEntries)(name, entries), loggingDisabled = false, dependencyReleaseContexts = null, releaseContext = new ReleaseContext(log1, name, lexer, parser, entries, released, initialised, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts);
+                return releaseContext;
+            }
+        }
+    ]);
+    return ReleaseContext;
+}();
+function initialiseFileContexts(fileContexts, releaseContext) {
+    var _loop = function() {
+        var fileContextsLength = fileContexts.length;
+        if (fileContextsLength === 0) {
+            return "break";
+        }
+        var initialisedFileContexts = [];
+        fileContexts.forEach(function(fileContext) {
+            var initialised = fileContext.initialise(releaseContext);
+            if (initialised) {
+                var initialisedFileContext = fileContext; ///
+                initialisedFileContexts.push(initialisedFileContext);
+            }
+        });
+        var initialisedFileContextsLength = initialisedFileContexts.length, fileInitialised = initialisedFileContextsLength > 0;
+        if (!fileInitialised) {
+            return "break";
+        }
+        (0, _array.leftDifference)(fileContexts, initialisedFileContexts);
+    };
+    fileContexts = _to_consumable_array(fileContexts);
+    for(;;){
+        var _ret = _loop();
+        if (_ret === "break") break;
+    }
+}
+function fileContextsFromEntries(entries, releaseContext) {
+    var fileContexts = [];
+    entries.forEachFile(function(file) {
+        var filePath = file.getPath(), filePathFlorenceFilePath = isFilePathFlorenceFilePath(filePath);
+        if (filePathFlorenceFilePath) {
+            var fileContext = _file.default.fromFileAndReleaseContext(file, releaseContext);
+            fileContexts.push(fileContext);
+        }
+    });
+    return fileContexts;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/release.other.js"],"sourcesContent":["\"use strict\";\n\nimport { filePathUtilities } from \"occam-entities\";\nimport { lexersUtilities, parsersUtilities } from \"occam-custom-grammars\";\n\nimport FileContext from \"./file\";\n\nimport { objectType } from \"../type\";\nimport { tail, push, leftDifference } from \"../utilities/array\";\nimport { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from \"../utilities/customGrammar\";\n\nconst { isFilePathFlorenceFilePath } = filePathUtilities,\n      { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,\n      { nominalParserFromCombinedCustomGrammar } = parsersUtilities;\n\nexport default class ReleaseContext {\n  constructor(log, name, lexer, parser, entries, released, initialised, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts) {\n    this.log = log;\n    this.name = name;\n    this.lexer = lexer;\n    this.parser = parser;\n    this.entries = entries;\n    this.released = released;\n    this.initialised = initialised;\n    this.fileContexts = fileContexts;\n    this.customGrammar = customGrammar;\n    this.loggingDisabled = loggingDisabled;\n    this.dependencyReleaseContexts = dependencyReleaseContexts;\n  }\n\n  getLog() {\n    return log;\n  }\n\n  getName() {\n    return this.name;\n  }\n\n  getLexer() {\n    return this.lexer;\n  }\n\n  getParser() {\n    return this.parser;\n  }\n\n  getEntries() {\n    return this.entries;\n  }\n\n  isReleased() {\n    return this.released;\n  }\n\n  isInitialised() {\n    return this.initialised;\n  }\n\n  getFileContexts() {\n    return this.fileContexts;\n  }\n\n  getCustomGrammar() {\n    return this.customGrammar;\n  }\n\n  isLoggingDisabled() {\n    return this.loggingDisabled;\n  }\n\n  getDependencyReleaseContexts() {\n    return this.dependencyReleaseContexts;\n  }\n\n  setLog(log) {\n    this.log = log;\n  }\n\n  setName(name) {\n    this.name = name;\n  }\n\n  setEntries(entries) {\n    this.entries = entries;\n  }\n\n  setReleased(released) {\n    this.released = released;\n  }\n\n  setLexer(lexer) {\n    this.lexer = lexer;\n  }\n\n  setParser(parser) {\n    this.parser = parser;\n  }\n\n  setInitialised(initialised) {\n    return this.initialised = initialised;\n  }\n\n  setFileContexts(fileContexts) {\n    this.fileContexts = fileContexts;\n  }\n\n  setCustomGrammar(customGrammar) {\n    this.customGrammar = customGrammar;\n  }\n\n  setLoggingDisabled(loggingDisabled) {\n    this.loggingDisabled = loggingDisabled;\n  }\n\n  setDependencyReleaseContexts(dependencyReleaseContexts) {\n    this.dependencyReleaseContexts = dependencyReleaseContexts;\n  }\n\n  getLabels(includeDependencies = true) {\n    const labels = [];\n\n    this.fileContexts.forEach((fileContext) => {\n      const includeRelease = false,\n            fileContextLabels = fileContext.getLabels(includeRelease);\n\n      push(labels, fileContextLabels);\n    });\n\n    if (includeDependencies) {\n      const dependencyReleaseContexts = this.getDependencyReleaseContexts();\n\n      dependencyReleaseContexts.forEach((releaseContext) => {\n        const includeDependencies = false,\n              releaseContextLabels = releaseContext.getLabels(includeDependencies);\n\n        push(labels, releaseContextLabels);\n      });\n    }\n\n    return labels;\n  }\n\n  getTypes(includeDependencies = true) {\n    const types = [];\n\n    this.fileContexts.forEach((fileContext) => {\n      const includeRelease = false,\n            fileContextTypes = fileContext.getTypes(includeRelease);\n\n      push(types, fileContextTypes);\n    });\n\n    if (includeDependencies) {\n      const dependencyReleaseContexts = this.getDependencyReleaseContexts();\n\n      dependencyReleaseContexts.forEach((releaseContext) => {\n        const includeDependencies = false,\n              releaseContextTypes = releaseContext.getTypes(includeDependencies);\n\n        push(types, releaseContextTypes);\n      });\n    }\n\n    return types;\n  }\n\n  getRules(includeDependencies = true) {\n    const rules = [];\n\n    this.fileContexts.forEach((fileContext) => {\n      const includeRelease = false,\n            fileContextRules = fileContext.getRules(includeRelease);\n\n      push(rules, fileContextRules);\n    });\n\n    if (includeDependencies) {\n      const dependencyReleaseContexts = this.getDependencyReleaseContexts();\n\n      dependencyReleaseContexts.forEach((releaseContext) => {\n        const includeDependencies = false,\n              releaseContextRules = releaseContext.getRules(includeDependencies);\n\n        push(rules, releaseContextRules);\n      });\n    }\n\n    return rules;\n  }\n\n  getAxioms(includeDependencies = true) {\n    const axioms = [];\n\n    this.fileContexts.forEach((fileContext) => {\n      const includeRelease = false,\n            fileContextAxioms = fileContext.getAxioms(includeRelease);\n\n      push(axioms, fileContextAxioms);\n    });\n\n    if (includeDependencies) {\n      const dependencyReleaseContexts = this.getDependencyReleaseContexts();\n\n      dependencyReleaseContexts.forEach((releaseContext) => {\n        const includeDependencies = false,\n              releaseContextAxioms = releaseContext.getAxioms(includeDependencies);\n\n        push(axioms, releaseContextAxioms);\n      });\n    }\n\n    return axioms;\n  }\n\n  getLemmas(includeDependencies = true) {\n    const lemmas = [];\n\n    this.fileContexts.forEach((fileContext) => {\n      const includeRelease = false,\n            fileContextLemmas = fileContext.getLemmas(includeRelease);\n\n      push(lemmas, fileContextLemmas);\n    });\n\n    return lemmas;\n  }\n\n  getTheorems(includeDependencies = true) {\n    const theorems = [];\n\n    this.fileContexts.forEach((fileContext) => {\n      const includeRelease = false,\n            fileContextTheorems = fileContext.getTheorems(includeRelease);\n\n      push(theorems, fileContextTheorems);\n    });\n\n    if (includeDependencies) {\n      const dependencyReleaseContexts = this.getDependencyReleaseContexts();\n\n      dependencyReleaseContexts.forEach((releaseContext) => {\n        const includeDependencies = false,\n              releaseContextTheorems = releaseContext.getTheorems(includeDependencies);\n\n        push(theorems, releaseContextTheorems);\n      });\n    }\n\n    return theorems;\n  }\n\n  getMetaLemmas(includeDependencies = true) {\n    const metaLemmas = [];\n\n    this.fileContexts.forEach((fileContext) => {\n      const includeRelease = false,\n            fileContextMetaLemmas = fileContext.getMetaLemmas(includeRelease);\n\n      push(metaLemmas, fileContextMetaLemmas);\n    });\n\n    return metaLemmas;\n  }\n\n  getConjectures(includeDependencies = true) {\n    const conjectures = [];\n\n    this.fileContexts.forEach((fileContext) => {\n      const includeRelease = false,\n            fileContextConjectures = fileContext.getConjectures(includeRelease);\n\n      push(conjectures, fileContextConjectures);\n    });\n\n    if (includeDependencies) {\n      const dependencyReleaseContexts = this.getDependencyReleaseContexts();\n\n      dependencyReleaseContexts.forEach((releaseContext) => {\n        const includeDependencies = false,\n              releaseContextConjectures = releaseContext.getConjectures(includeDependencies);\n\n        push(conjectures, releaseContextConjectures);\n      });\n    }\n\n    return conjectures;\n  }\n\n  getCombinators(includeDependencies = true) {\n    const combinators = [];\n\n    this.fileContexts.forEach((fileContext) => {\n      const includeRelease = false,\n            fileContextCombinators = fileContext.getCombinators(includeRelease);\n\n      push(combinators, fileContextCombinators);\n    });\n\n    if (includeDependencies) {\n      const dependencyReleaseContexts = this.getDependencyReleaseContexts();\n\n      dependencyReleaseContexts.forEach((releaseContext) => {\n        const includeDependencies = false,\n              releaseContextCombinators = releaseContext.getCombinators(includeDependencies);\n\n        push(combinators, releaseContextCombinators);\n      });\n    }\n\n    return combinators;\n  }\n\n  getConstructors(includeDependencies = true) {\n    const constructors = [];\n\n    this.fileContexts.forEach((fileContext) => {\n      const includeRelease = false,\n            fileContextConstructors = fileContext.getConstructors(includeRelease);\n\n      push(constructors, fileContextConstructors);\n    });\n\n    if (includeDependencies) {\n      const dependencyReleaseContexts = this.getDependencyReleaseContexts();\n\n      dependencyReleaseContexts.forEach((releaseContext) => {\n        const includeDependencies = false,\n              releaseContextConstructors = releaseContext.getConstructors(includeDependencies);\n\n        push(constructors, releaseContextConstructors);\n      });\n    }\n\n    return constructors;\n  }\n\n  getMetatheorems(includeDependencies = true) {\n    const metatheorems = [];\n\n    this.fileContexts.forEach((fileContext) => {\n      const includeRelease = false,\n            fileContextMetatheorems = fileContext.getMetatheorems(includeRelease);\n\n      push(metatheorems, fileContextMetatheorems);\n    });\n\n    if (includeDependencies) {\n      const dependencyReleaseContexts = this.getDependencyReleaseContexts();\n\n      dependencyReleaseContexts.forEach((releaseContext) => {\n        const includeDependencies = false,\n              releaseContextMetatheorems = releaseContext.getMetatheorems(includeDependencies);\n\n        push(metatheorems, releaseContextMetatheorems);\n      });\n    }\n\n    return metatheorems;\n  }\n\n  addFileContext(fileContext) {\n    this.fileContexts.push(fileContext);\n  }\n\n  findTypeByTypeName(typeName) {\n    let types = this.getTypes();\n\n    types.push(objectType);\n\n    const type = types.find((type) => {\n      const typeNameMatches = type.matchTypeName(typeName);\n\n      if (typeNameMatches) {\n        return true;\n      }\n    }) || null;\n\n    return type;\n  }\n\n  getReleaseName() {\n    const name = this.getName(),\n          releaseName = name; ///\n\n    return releaseName;\n  }\n\n  getFile(filePath) { return this.entries.getFile(filePath); }\n\n  getVersion() { return this.entries.getVersion(); }\n\n  getFilePaths() { return this.entries.getFilePaths(); }\n\n  getDependencies() { return this.entries.getDependencies(); }\n\n  matchShortenedVersion(shortenedVersion) { return this.entries.matchShortenedVersion(shortenedVersion); }\n\n  disableLogging() {\n    const loggingDisabled = true;\n\n    this.setLoggingDisabled(loggingDisabled);\n  }\n\n  enableLogging() {\n    const loggingDisabled = false;\n\n    this.setLoggingDisabled(loggingDisabled);\n  }\n\n  trace(message, node = null, tokens = null, filePath = null) {\n    if (this.loggingDisabled) {\n      return;\n    }\n\n    this.log.trace(message, node, tokens, filePath);\n  }\n\n  debug(message, node = null, tokens = null, filePath = null) {\n    if (this.loggingDisabled) {\n      return;\n    }\n\n    this.log.debug(message, node, tokens, filePath);\n  }\n\n  info(message, node = null, tokens = null, filePath = null) {\n    if (this.loggingDisabled) {\n      return;\n    }\n\n    this.log.info(message, node, tokens, filePath);\n  }\n\n  warning(message, node = null, tokens = null, filePath = null) {\n    if (this.loggingDisabled) {\n      return;\n    }\n\n    this.log.warning(message, node, tokens, filePath);\n  }\n\n  error(message, node = null, tokens = null, filePath = null) {\n    if (this.loggingDisabled) {\n      return;\n    }\n\n    this.log.error(message, node, tokens, filePath);\n  }\n\n  initialise(releaseContexts) {\n    const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),\n          nominalParser = nominalParserFromCombinedCustomGrammar(combinedCustomGrammar),\n          nominalLexer = nominalLexerFromCombinedCustomGrammar(combinedCustomGrammar);\n\n    this.lexer = nominalLexer; ///\n\n    this.parser = nominalParser; ///\n\n    this.dependencyReleaseContexts = tail(releaseContexts);\n\n    if (this.released) {\n      const releaseContext = this;  ///\n\n      this.fileContexts = fileContextsFromEntries(this.entries, releaseContext);\n\n      initialiseFileContexts(this.fileContexts, releaseContext);\n    }\n\n    this.initialised = true;\n  }\n\n  toJSON() {\n    const fileContextsJSON = this.fileContexts.map((fileContext) => {\n            const fileContextJSON = fileContext.toJSON();\n\n            return fileContextJSON;\n          }),\n          json = fileContextsJSON;  ///\n\n    return json;\n  }\n\n  static fromLogNameEntriesAndReleased(log, name, entries, released) {\n    const lexer = null,\n          parser = null,\n          initialised = false,\n          fileContexts = [],\n          customGrammar = customGrammarFromNameAndEntries(name, entries),\n          loggingDisabled = false,\n          dependencyReleaseContexts = null,\n          releaseContext = new ReleaseContext(log, name, lexer, parser, entries, released, initialised, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts);\n\n    return releaseContext;\n  }\n}\n\nfunction initialiseFileContexts(fileContexts, releaseContext) {\n  fileContexts = [  ///\n    ...fileContexts\n  ];\n\n  for (;;) {\n    const fileContextsLength = fileContexts.length;\n\n    if (fileContextsLength === 0) {\n      break;\n    }\n\n    const initialisedFileContexts = [];\n\n    fileContexts.forEach((fileContext) => {\n      const initialised = fileContext.initialise(releaseContext);\n\n      if (initialised) {\n        const initialisedFileContext = fileContext;  ///\n\n        initialisedFileContexts.push(initialisedFileContext);\n      }\n    });\n\n    const initialisedFileContextsLength = initialisedFileContexts.length,\n          fileInitialised = (initialisedFileContextsLength > 0);\n\n    if (!fileInitialised) {\n      break;\n    }\n\n    leftDifference(fileContexts, initialisedFileContexts);\n  }\n}\n\nfunction fileContextsFromEntries(entries, releaseContext) {\n  const fileContexts = [];\n\n  entries.forEachFile((file) => {\n    const filePath = file.getPath(),\n          filePathFlorenceFilePath = isFilePathFlorenceFilePath(filePath);\n\n    if (filePathFlorenceFilePath) {\n      const fileContext = FileContext.fromFileAndReleaseContext(file, releaseContext);\n\n      fileContexts.push(fileContext);\n    }\n  });\n\n  return fileContexts;\n}\n"],"names":["ReleaseContext","isFilePathFlorenceFilePath","filePathUtilities","nominalLexerFromCombinedCustomGrammar","lexersUtilities","nominalParserFromCombinedCustomGrammar","parsersUtilities","log","name","lexer","parser","entries","released","initialised","fileContexts","customGrammar","loggingDisabled","dependencyReleaseContexts","getLog","getName","getLexer","getParser","getEntries","isReleased","isInitialised","getFileContexts","getCustomGrammar","isLoggingDisabled","getDependencyReleaseContexts","setLog","setName","setEntries","setReleased","setLexer","setParser","setInitialised","setFileContexts","setCustomGrammar","setLoggingDisabled","setDependencyReleaseContexts","getLabels","includeDependencies","labels","forEach","fileContext","includeRelease","fileContextLabels","push","releaseContext","releaseContextLabels","getTypes","types","fileContextTypes","releaseContextTypes","getRules","rules","fileContextRules","releaseContextRules","getAxioms","axioms","fileContextAxioms","releaseContextAxioms","getLemmas","lemmas","fileContextLemmas","getTheorems","theorems","fileContextTheorems","releaseContextTheorems","getMetaLemmas","metaLemmas","fileContextMetaLemmas","getConjectures","conjectures","fileContextConjectures","releaseContextConjectures","getCombinators","combinators","fileContextCombinators","releaseContextCombinators","getConstructors","constructors","fileContextConstructors","releaseContextConstructors","getMetatheorems","metatheorems","fileContextMetatheorems","releaseContextMetatheorems","addFileContext","findTypeByTypeName","typeName","objectType","type","find","typeNameMatches","matchTypeName","getReleaseName","releaseName","getFile","filePath","getVersion","getFilePaths","getDependencies","matchShortenedVersion","shortenedVersion","disableLogging","enableLogging","trace","message","node","tokens","debug","info","warning","error","initialise","releaseContexts","combinedCustomGrammar","combinedCustomGrammarFromReleaseContexts","nominalParser","nominalLexer","tail","fileContextsFromEntries","initialiseFileContexts","toJSON","fileContextsJSON","map","fileContextJSON","json","fromLogNameEntriesAndReleased","customGrammarFromNameAndEntries","fileContextsLength","length","initialisedFileContexts","initialisedFileContext","initialisedFileContextsLength","fileInitialised","leftDifference","forEachFile","file","getPath","filePathFlorenceFilePath","FileContext","fromFileAndReleaseContext"],"mappings":"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"}