occam-furtle 2.0.340 → 3.0.1

package/lib/context/release.js

@@ -0,0 +1,675 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return ReleaseContext;
+    }
+});
+var _necessary = require("necessary");
+var _occammodel = require("occam-model");
+var _occamcustomgrammars = require("occam-custom-grammars");
+var _furtle = /*#__PURE__*/ _interop_require_default(require("../context/file/furtle"));
+var _nominal = /*#__PURE__*/ _interop_require_default(require("../context/file/nominal"));
+var _constants = require("../constants");
+var _metaTypes = require("../metaTypes");
+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_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+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 _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+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 _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+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 nominalLexerFromCombinedCustomGrammar = _occamcustomgrammars.lexersUtilities.nominalLexerFromCombinedCustomGrammar, nominalParserFromCombinedCustomGrammar = _occamcustomgrammars.parsersUtilities.nominalParserFromCombinedCustomGrammar, tail = _necessary.arrayUtilities.tail, push = _necessary.arrayUtilities.push, first = _necessary.arrayUtilities.first, clear = _necessary.arrayUtilities.clear, filter = _necessary.arrayUtilities.filter, resolve = _necessary.arrayUtilities.resolve, compress = _necessary.arrayUtilities.compress, isFilePathFurtleFilePath = _occammodel.filePathUtilities.isFilePathFurtleFilePath, isFilePathNominalFilePath = _occammodel.filePathUtilities.isFilePathNominalFilePath, _LEVELS = _sliced_to_array(_constants.LEVELS, 5), TRACE_LEVEL = _LEVELS[0], DEBUG_LEVEL = _LEVELS[1], INFO_LEVEL = _LEVELS[2], WARNING_LEVEL = _LEVELS[3], ERROR_LEVEL = _LEVELS[4];
+var ReleaseContext = /*#__PURE__*/ function() {
+    function ReleaseContext(log1, name, json, entries, lexer, parser, verified, initialised, fileContexts, customGrammar, dependencyReleaseContexts) {
+        _class_call_check(this, ReleaseContext);
+        this.log = log1;
+        this.name = name;
+        this.json = json;
+        this.entries = entries;
+        this.lexer = lexer;
+        this.parser = parser;
+        this.verified = verified;
+        this.initialised = initialised;
+        this.fileContexts = fileContexts;
+        this.customGrammar = customGrammar;
+        this.dependencyReleaseContexts = dependencyReleaseContexts;
+    }
+    _create_class(ReleaseContext, [
+        {
+            key: "getLog",
+            value: function getLog() {
+                return log;
+            }
+        },
+        {
+            key: "getName",
+            value: function getName() {
+                return this.name;
+            }
+        },
+        {
+            key: "getJSON",
+            value: function getJSON() {
+                return this.json;
+            }
+        },
+        {
+            key: "getEntries",
+            value: function getEntries() {
+                return this.entries;
+            }
+        },
+        {
+            key: "getLexer",
+            value: function getLexer() {
+                return this.lexer;
+            }
+        },
+        {
+            key: "getParser",
+            value: function getParser() {
+                return this.parser;
+            }
+        },
+        {
+            key: "getMetaTypes",
+            value: function getMetaTypes() {
+                var metaTypes = (0, _metaTypes.getMetaTypes)();
+                return metaTypes;
+            }
+        },
+        {
+            key: "isVerified",
+            value: function isVerified() {
+                return this.verified;
+            }
+        },
+        {
+            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: "getDependencyReleaseContexts",
+            value: function getDependencyReleaseContexts() {
+                return this.dependencyReleaseContexts;
+            }
+        },
+        {
+            key: "isReleased",
+            value: function isReleased() {
+                var released = this.json !== null;
+                return released;
+            }
+        },
+        {
+            key: "findFile",
+            value: function findFile(filePath) {
+                return this.entries.findFile(filePath);
+            }
+        },
+        {
+            key: "findFileContext",
+            value: function findFileContext(filePath) {
+                var fileContext = this.fileContexts.find(function(fileContext) {
+                    var fileContextFilePath = fileContext.getFilePath();
+                    if (fileContextFilePath === filePath) {
+                        return true;
+                    }
+                });
+                return fileContext;
+            }
+        },
+        {
+            key: "getTypePrefix",
+            value: function getTypePrefix() {
+                var typePrefix = null;
+                var includeDependencies = false, typePrefixes = this.getTypePrefixes(includeDependencies), typePrefixesLength = typePrefixes.length;
+                if (typePrefixesLength === 1) {
+                    var firstTypePrefix = first(typePrefixes);
+                    typePrefix = firstTypePrefix; ///
+                }
+                return typePrefix;
+            }
+        },
+        {
+            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);
+                    push(labels, fileContextLabels);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextLabels = releaseContext.getLabels(includeDependencies);
+                        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);
+                    push(types, fileContextTypes);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextTypes = releaseContext.getTypes(includeDependencies);
+                        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);
+                    push(rules, fileContextRules);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextRules = releaseContext.getRules(includeDependencies);
+                        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);
+                    push(axioms, fileContextAxioms);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextAxioms = releaseContext.getAxioms(includeDependencies);
+                        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);
+                    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);
+                    push(theorems, fileContextTheorems);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextTheorems = releaseContext.getTheorems(includeDependencies);
+                        push(theorems, releaseContextTheorems);
+                    });
+                }
+                return theorems;
+            }
+        },
+        {
+            key: "getProcedures",
+            value: function getProcedures() {
+                var includeDependencies = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var procedures = [];
+                this.fileContexts.forEach(function(fileContext) {
+                    var includeRelease = false, fileContextProcedures = fileContext.getProcedures(includeRelease);
+                    push(procedures, fileContextProcedures);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextProcedures = releaseContext.getProcedures(includeDependencies);
+                        push(procedures, releaseContextProcedures);
+                    });
+                }
+                return procedures;
+            }
+        },
+        {
+            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);
+                    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);
+                    push(conjectures, fileContextConjectures);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextConjectures = releaseContext.getConjectures(includeDependencies);
+                        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);
+                    push(combinators, fileContextCombinators);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextCombinators = releaseContext.getCombinators(includeDependencies);
+                        push(combinators, releaseContextCombinators);
+                    });
+                }
+                return combinators;
+            }
+        },
+        {
+            key: "getTypePrefixes",
+            value: function getTypePrefixes() {
+                var includeDependencies = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var typePrefixes = [];
+                this.fileContexts.forEach(function(fileContext) {
+                    var includeRelease = false, fileContextTypePrefixes = fileContext.getTypePrefixes(includeRelease);
+                    push(typePrefixes, fileContextTypePrefixes);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextTypePrefixes = releaseContext.getTypePrefixes(includeDependencies);
+                        push(typePrefixes, releaseContextTypePrefixes);
+                    });
+                }
+                return typePrefixes;
+            }
+        },
+        {
+            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);
+                    push(constructors, fileContextConstructors);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextConstructors = releaseContext.getConstructors(includeDependencies);
+                        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);
+                    push(metatheorems, fileContextMetatheorems);
+                });
+                if (includeDependencies) {
+                    var dependencyReleaseContexts = this.getDependencyReleaseContexts();
+                    dependencyReleaseContexts.forEach(function(releaseContext) {
+                        var includeDependencies = false, releaseContextMetatheorems = releaseContext.getMetatheorems(includeDependencies);
+                        push(metatheorems, releaseContextMetatheorems);
+                    });
+                }
+                return metatheorems;
+            }
+        },
+        {
+            key: "addFileContext",
+            value: function addFileContext(fileContext) {
+                this.fileContexts.push(fileContext);
+            }
+        },
+        {
+            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: "trace",
+            value: function trace(message) {
+                var filePath = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null, lineIndex = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null;
+                var level = TRACE_LEVEL;
+                this.writeToLog(level, message, filePath, lineIndex);
+            }
+        },
+        {
+            key: "debug",
+            value: function debug(message) {
+                var filePath = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null, lineIndex = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null;
+                var level = DEBUG_LEVEL;
+                this.writeToLog(level, message, filePath, lineIndex);
+            }
+        },
+        {
+            key: "info",
+            value: function info(message) {
+                var filePath = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null, lineIndex = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null;
+                var level = INFO_LEVEL;
+                this.writeToLog(level, message, filePath, lineIndex);
+            }
+        },
+        {
+            key: "warning",
+            value: function warning(message) {
+                var filePath = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null, lineIndex = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null;
+                var level = WARNING_LEVEL;
+                this.writeToLog(level, message, filePath, lineIndex);
+            }
+        },
+        {
+            key: "error",
+            value: function error(message) {
+                var filePath = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null, lineIndex = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null;
+                var level = ERROR_LEVEL;
+                this.writeToLog(level, message, filePath, lineIndex);
+            }
+        },
+        {
+            key: "writeToLog",
+            value: function writeToLog(level, message, filePath, lineIndex) {
+                this.log.write(level, message, filePath, lineIndex);
+            }
+        },
+        {
+            key: "getFileContext",
+            value: function getFileContext() {
+                var fileContext = null;
+                return fileContext;
+            }
+        },
+        {
+            key: "getDepth",
+            value: function getDepth() {
+                var depth = -1;
+                return depth;
+            }
+        },
+        {
+            key: "initialise",
+            value: function initialise(releaseContexts) {
+                var combinedCustomGrammar = (0, _customGrammar.combinedCustomGrammarFromReleaseContexts)(releaseContexts), nominalLexer = nominalLexerFromCombinedCustomGrammar(NominalLexer, combinedCustomGrammar), nominalParser = nominalParserFromCombinedCustomGrammar(NominalParser, combinedCustomGrammar), releaseContext = this, released = this.isReleased();
+                this.dependencyReleaseContexts = tail(releaseContexts); ///
+                this.lexer = nominalLexer; ///
+                this.parser = nominalParser; ///
+                clear(this.fileContexts);
+                released ? fileContextsFromJSON(this.json, this.fileContexts, releaseContext) : fileContextsFromEntries(this.entries, this.fileContexts, releaseContext);
+                this.initialised = true;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify() {
+                var verifies = false;
+                var typePrefixes = this.getTypePrefixes(), releaseContext = this, typePrefixesVerify = verifyTypePrefixes(typePrefixes, releaseContext);
+                if (typePrefixesVerify) {
+                    var verifiedFileContexts = [], fileContextsVerify = verifyFileContexts(this.fileContexts, verifiedFileContexts, releaseContext);
+                    if (fileContextsVerify) {
+                        this.fileContexts = verifiedFileContexts; ///
+                        this.verified = true;
+                        verifies = true;
+                    }
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var fileContextsJSON = this.fileContexts.map(function(fileContext) {
+                    var fileContextJSON = fileContext.toJSON();
+                    return fileContextJSON;
+                }), json = fileContextsJSON; ///
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromLogNameJSONAndEntries",
+            value: function fromLogNameJSONAndEntries(log1, name, json, entries) {
+                var lexer = null, parser = null, verifies = false, initialised = false, fileContexts = [], customGrammar = (0, _customGrammar.customGrammarFromNameAndEntries)(name, entries), dependencyReleaseContexts = null, releaseContext = new ReleaseContext(log1, name, json, entries, lexer, parser, verifies, initialised, fileContexts, customGrammar, dependencyReleaseContexts);
+                return releaseContext;
+            }
+        }
+    ]);
+    return ReleaseContext;
+}();
+function verifyTypePrefixes(typePrefixes, releaseContext) {
+    var typePrefixesVerify = true;
+    var typePrefixesLength = typePrefixes.length, compressedTypePrefixes = _to_consumable_array(typePrefixes);
+    compress(compressedTypePrefixes, function(typePrefixA, typePrefixB) {
+        var typePrefixAName = typePrefixA.getName(), typePrefixBName = typePrefixB.getName();
+        if (typePrefixAName !== typePrefixBName) {
+            return true;
+        }
+    });
+    var compressTypePrefixesLength = compressedTypePrefixes.length;
+    if (typePrefixesLength > compressTypePrefixesLength) {
+        filter(compressedTypePrefixes, function(typePrefix) {
+            var typePrefixesIncludesTypePrefix = typePrefixes.includes(typePrefix);
+            if (!typePrefixesIncludesTypePrefix) {
+                return true;
+            }
+        });
+        var firstTypePrefix = first(typePrefixes), typePrefix = firstTypePrefix, typePrefixString = typePrefix.getString();
+        releaseContext.info("The '".concat(typePrefixString, "' type prefix is duplicated at least once, possibly among others."));
+        typePrefixesVerify = false;
+    }
+    return typePrefixesVerify;
+}
+function verifyFileContexts(fileContexts, verifiedFileContexts) {
+    var resolved = resolve(fileContexts, verifiedFileContexts, function(fileContext) {
+        var fileContextVerifies = fileContext.verify();
+        if (fileContextVerifies) {
+            return true;
+        }
+    }), fileContextsVerify = resolved; ///
+    return fileContextsVerify;
+}
+function fileContextsFromJSON(json, fileContexts, releaseContext) {
+    var fileContextsJSON = json; ///
+    fileContextsJSON.forEach(function(fileContextJSON) {
+        var filePath = fileContextJSON.filePath, _$json = fileContextJSON, filePathFurtleFilePath = isFilePathFurtleFilePath(filePath), filePathNominalFilePath = isFilePathNominalFilePath(filePath);
+        if (filePathFurtleFilePath) {
+            var furtleFileContext = _furtle.default.fromFilePath(filePath, releaseContext), fileContext = furtleFileContext; ///
+            fileContexts.push(fileContext);
+            fileContext.initialise(_$json);
+        }
+        if (filePathNominalFilePath) {
+            var context = releaseContext, fileContext1 = _nominal.default.fromFilePath(filePath, context);
+            fileContexts.push(fileContext1);
+            fileContext1.initialise(_$json);
+        }
+    });
+}
+function fileContextsFromEntries(entries, fileContexts, releaseContext) {
+    entries.forEachFile(function(file) {
+        var filePath = file.getPath(), filePathFurtleFilePath = isFilePathFurtleFilePath(filePath), filePathNominalFilePath = isFilePathNominalFilePath(filePath);
+        if (filePathFurtleFilePath) {
+            var furtleFileContext = _furtle.default.fromFile(file, releaseContext), fileContext = furtleFileContext; ///
+            fileContexts.push(fileContext);
+        }
+        if (filePathNominalFilePath) {
+            var context = releaseContext, fileContext1 = _nominal.default.fromFile(file, context);
+            fileContexts.push(fileContext1);
+        }
+    });
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/release.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport { filePathUtilities } from \"occam-model\";\nimport { lexersUtilities, parsersUtilities } from \"occam-custom-grammars\";\n\n// import NominalLexer from \"../nominal/lexer\";\n// import NominalParser from \"../nominal/parser\";\nimport FurtleFileContext from \"../context/file/furtle\";\nimport NominalFileContext from \"../context/file/nominal\";\n\nimport { LEVELS } from \"../constants\";\nimport { getMetaTypes } from \"../metaTypes\";\nimport { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from \"../utilities/customGrammar\";\n\nconst { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,\n      { nominalParserFromCombinedCustomGrammar } = parsersUtilities,\n      { tail, push, first, clear, filter, resolve, compress } = arrayUtilities,\n      { isFilePathFurtleFilePath, isFilePathNominalFilePath } = filePathUtilities,\n      [ TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL ] = LEVELS;\n\nexport default class ReleaseContext {\n  constructor(log, name, json, entries, lexer, parser, verified, initialised, fileContexts, customGrammar, dependencyReleaseContexts) {\n    this.log = log;\n    this.name = name;\n    this.json = json;\n    this.entries = entries;\n    this.lexer = lexer;\n    this.parser = parser;\n    this.verified = verified;\n    this.initialised = initialised;\n    this.fileContexts = fileContexts;\n    this.customGrammar = customGrammar;\n    this.dependencyReleaseContexts = dependencyReleaseContexts;\n  }\n\n  getLog() {\n    return log;\n  }\n\n  getName() {\n    return this.name;\n  }\n\n  getJSON() {\n    return this.json;\n  }\n\n  getEntries() {\n    return this.entries;\n  }\n\n  getLexer() {\n    return this.lexer;\n  }\n\n  getParser() {\n    return this.parser;\n  }\n\n  getMetaTypes() {\n    const metaTypes = getMetaTypes();\n\n    return metaTypes;\n  }\n\n  isVerified() {\n    return this.verified;\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  getDependencyReleaseContexts() {\n    return this.dependencyReleaseContexts;\n  }\n\n  isReleased() {\n    const released = (this.json !== null);\n\n    return released;\n  }\n\n  findFile(filePath) { return this.entries.findFile(filePath); }\n\n  findFileContext(filePath) {\n    const fileContext = this.fileContexts.find((fileContext) => {\n      const fileContextFilePath = fileContext.getFilePath();\n\n      if (fileContextFilePath === filePath) {\n        return true;\n      }\n    });\n\n    return fileContext;\n  }\n\n  getTypePrefix() {\n    let typePrefix = null;\n\n    const includeDependencies = false,\n          typePrefixes = this.getTypePrefixes(includeDependencies),\n          typePrefixesLength = typePrefixes.length;\n\n    if (typePrefixesLength === 1) {\n      const firstTypePrefix = first(typePrefixes);\n\n      typePrefix = firstTypePrefix; ///\n    }\n\n    return typePrefix;\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  getProcedures(includeDependencies = true) {\n    const procedures = [];\n\n    this.fileContexts.forEach((fileContext) => {\n      const includeRelease = false,\n            fileContextProcedures = fileContext.getProcedures(includeRelease);\n\n      push(procedures, fileContextProcedures);\n    });\n\n    if (includeDependencies) {\n      const dependencyReleaseContexts = this.getDependencyReleaseContexts();\n\n      dependencyReleaseContexts.forEach((releaseContext) => {\n        const includeDependencies = false,\n          releaseContextProcedures = releaseContext.getProcedures(includeDependencies);\n\n        push(procedures, releaseContextProcedures);\n      });\n    }\n\n    return procedures;\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  getTypePrefixes(includeDependencies = true) {\n    const typePrefixes = [];\n\n    this.fileContexts.forEach((fileContext) => {\n      const includeRelease = false,\n            fileContextTypePrefixes = fileContext.getTypePrefixes(includeRelease);\n\n      push(typePrefixes, fileContextTypePrefixes);\n    });\n\n    if (includeDependencies) {\n      const dependencyReleaseContexts = this.getDependencyReleaseContexts();\n\n      dependencyReleaseContexts.forEach((releaseContext) => {\n        const includeDependencies = false,\n              releaseContextTypePrefixes = releaseContext.getTypePrefixes(includeDependencies);\n\n        push(typePrefixes, releaseContextTypePrefixes);\n      });\n    }\n\n    return typePrefixes;\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  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  trace(message, filePath = null, lineIndex = null) {\n    const level = TRACE_LEVEL;\n\n    this.writeToLog(level, message, filePath, lineIndex);\n  }\n\n  debug(message, filePath = null, lineIndex = null) {\n    const level = DEBUG_LEVEL\n\n    this.writeToLog(level, message, filePath, lineIndex);\n  }\n\n  info(message, filePath = null, lineIndex = null) {\n    const level = INFO_LEVEL;\n\n    this.writeToLog(level, message, filePath, lineIndex);\n  }\n\n  warning(message, filePath = null, lineIndex = null) {\n    const level = WARNING_LEVEL;\n\n    this.writeToLog(level, message, filePath, lineIndex);\n  }\n\n  error(message, filePath = null, lineIndex = null) {\n    const level = ERROR_LEVEL;\n\n    this.writeToLog(level, message, filePath, lineIndex);\n  }\n\n  writeToLog(level, message, filePath, lineIndex) {\n    this.log.write(level, message, filePath, lineIndex);\n  }\n\n  getFileContext() {\n    const fileContext = null;\n\n    return fileContext;\n  }\n\n  getDepth() {\n    const depth = -1;\n\n    return depth;\n  }\n\n  initialise(releaseContexts) {\n    const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),\n          nominalLexer = nominalLexerFromCombinedCustomGrammar(NominalLexer, combinedCustomGrammar),\n          nominalParser = nominalParserFromCombinedCustomGrammar(NominalParser, combinedCustomGrammar),\n          releaseContext = this,  ///\n          released = this.isReleased();\n\n    this.dependencyReleaseContexts = tail(releaseContexts); ///\n\n    this.lexer = nominalLexer; ///\n\n    this.parser = nominalParser; ///\n\n    clear(this.fileContexts);\n\n    released ?\n      fileContextsFromJSON(this.json, this.fileContexts, releaseContext) :\n        fileContextsFromEntries(this.entries, this.fileContexts, releaseContext);\n\n    this.initialised = true;\n  }\n\n  verify() {\n    let verifies = false;\n\n    const typePrefixes = this.getTypePrefixes(),\n          releaseContext = this, ///\n          typePrefixesVerify = verifyTypePrefixes(typePrefixes, releaseContext);\n\n    if (typePrefixesVerify) {\n      const verifiedFileContexts = [],\n            fileContextsVerify = verifyFileContexts(this.fileContexts, verifiedFileContexts, releaseContext);\n\n      if (fileContextsVerify) {\n        this.fileContexts = verifiedFileContexts; ///\n\n        this.verified = true;\n\n        verifies = true;\n      }\n    }\n\n    return verifies;\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 fromLogNameJSONAndEntries(log, name, json, entries) {\n    const lexer = null,\n          parser = null,\n          verifies = false,\n          initialised = false,\n          fileContexts = [],\n          customGrammar = customGrammarFromNameAndEntries(name, entries),\n          dependencyReleaseContexts = null,\n          releaseContext = new ReleaseContext(log, name, json, entries, lexer, parser, verifies, initialised, fileContexts, customGrammar, dependencyReleaseContexts);\n\n    return releaseContext;\n  }\n}\n\nfunction verifyTypePrefixes(typePrefixes, releaseContext) {\n  let typePrefixesVerify = true;\n\n  const typePrefixesLength = typePrefixes.length,\n        compressedTypePrefixes = [  ///\n          ...typePrefixes,\n        ];\n\n  compress(compressedTypePrefixes, (typePrefixA, typePrefixB) => {\n    const typePrefixAName = typePrefixA.getName(),\n          typePrefixBName = typePrefixB.getName();\n\n    if (typePrefixAName !== typePrefixBName) {\n      return true;\n    }\n  });\n\n  const compressTypePrefixesLength = compressedTypePrefixes.length;\n\n  if (typePrefixesLength > compressTypePrefixesLength) {\n    filter(compressedTypePrefixes, (typePrefix) => {\n      const typePrefixesIncludesTypePrefix = typePrefixes.includes(typePrefix);\n\n      if (!typePrefixesIncludesTypePrefix) {\n        return true;\n      }\n    });\n\n    const firstTypePrefix = first(typePrefixes),\n          typePrefix = firstTypePrefix, ///\n          typePrefixString = typePrefix.getString();\n\n    releaseContext.info(`The '${typePrefixString}' type prefix is duplicated at least once, possibly among others.`)\n\n    typePrefixesVerify = false;\n  }\n\n  return typePrefixesVerify;\n}\n\nfunction verifyFileContexts(fileContexts, verifiedFileContexts) {\n  const resolved = resolve(fileContexts, verifiedFileContexts, (fileContext) => {\n          const fileContextVerifies = fileContext.verify();\n\n          if (fileContextVerifies) {\n            return true;\n          }\n        }),\n        fileContextsVerify = resolved;  ///\n\n  return fileContextsVerify;\n}\n\nfunction fileContextsFromJSON(json,fileContexts, releaseContext) {\n  const fileContextsJSON = json;  ///\n\n  fileContextsJSON.forEach((fileContextJSON) => {\n    const { filePath } = fileContextJSON,\n          json = fileContextJSON, ///\n          filePathFurtleFilePath = isFilePathFurtleFilePath(filePath),\n          filePathNominalFilePath = isFilePathNominalFilePath(filePath);\n\n    if (filePathFurtleFilePath) {\n      const furtleFileContext = FurtleFileContext.fromFilePath(filePath, releaseContext),\n            fileContext = furtleFileContext;  ///\n\n      fileContexts.push(fileContext);\n\n      fileContext.initialise(json);\n    }\n\n    if (filePathNominalFilePath) {\n      const context = releaseContext, ///\n            fileContext = NominalFileContext.fromFilePath(filePath, context);\n\n      fileContexts.push(fileContext);\n\n      fileContext.initialise(json);\n    }\n  });\n}\n\nfunction fileContextsFromEntries(entries, fileContexts, releaseContext) {\n  entries.forEachFile((file) => {\n    const filePath = file.getPath(),\n          filePathFurtleFilePath = isFilePathFurtleFilePath(filePath),\n          filePathNominalFilePath = isFilePathNominalFilePath(filePath);\n\n    if (filePathFurtleFilePath) {\n      const furtleFileContext = FurtleFileContext.fromFile(file, releaseContext),\n            fileContext = furtleFileContext;  ///\n\n      fileContexts.push(fileContext);\n    }\n\n    if (filePathNominalFilePath) {\n      const context = releaseContext, ///\n            fileContext = NominalFileContext.fromFile(file, context);\n\n      fileContexts.push(fileContext);\n    }\n  });\n}\n"],"names":["ReleaseContext","nominalLexerFromCombinedCustomGrammar","lexersUtilities","nominalParserFromCombinedCustomGrammar","parsersUtilities","tail","arrayUtilities","push","first","clear","filter","resolve","compress","isFilePathFurtleFilePath","filePathUtilities","isFilePathNominalFilePath","LEVELS","TRACE_LEVEL","DEBUG_LEVEL","INFO_LEVEL","WARNING_LEVEL","ERROR_LEVEL","log","name","json","entries","lexer","parser","verified","initialised","fileContexts","customGrammar","dependencyReleaseContexts","getLog","getName","getJSON","getEntries","getLexer","getParser","getMetaTypes","metaTypes","isVerified","isInitialised","getFileContexts","getCustomGrammar","getDependencyReleaseContexts","isReleased","released","findFile","filePath","findFileContext","fileContext","find","fileContextFilePath","getFilePath","getTypePrefix","typePrefix","includeDependencies","typePrefixes","getTypePrefixes","typePrefixesLength","length","firstTypePrefix","getLabels","labels","forEach","includeRelease","fileContextLabels","releaseContext","releaseContextLabels","getTypes","types","fileContextTypes","releaseContextTypes","getRules","rules","fileContextRules","releaseContextRules","getAxioms","axioms","fileContextAxioms","releaseContextAxioms","getLemmas","lemmas","fileContextLemmas","getTheorems","theorems","fileContextTheorems","releaseContextTheorems","getProcedures","procedures","fileContextProcedures","releaseContextProcedures","getMetaLemmas","metaLemmas","fileContextMetaLemmas","getConjectures","conjectures","fileContextConjectures","releaseContextConjectures","getCombinators","combinators","fileContextCombinators","releaseContextCombinators","fileContextTypePrefixes","releaseContextTypePrefixes","getConstructors","constructors","fileContextConstructors","releaseContextConstructors","getMetatheorems","metatheorems","fileContextMetatheorems","releaseContextMetatheorems","addFileContext","getReleaseName","releaseName","getFile","getVersion","getFilePaths","getDependencies","matchShortenedVersion","shortenedVersion","trace","message","lineIndex","level","writeToLog","debug","info","warning","error","write","getFileContext","getDepth","depth","initialise","releaseContexts","combinedCustomGrammar","combinedCustomGrammarFromReleaseContexts","nominalLexer","NominalLexer","nominalParser","NominalParser","fileContextsFromJSON","fileContextsFromEntries","verify","verifies","typePrefixesVerify","verifyTypePrefixes","verifiedFileContexts","fileContextsVerify","verifyFileContexts","toJSON","fileContextsJSON","map","fileContextJSON","fromLogNameJSONAndEntries","customGrammarFromNameAndEntries","compressedTypePrefixes","typePrefixA","typePrefixB","typePrefixAName","typePrefixBName","compressTypePrefixesLength","typePrefixesIncludesTypePrefix","includes","typePrefixString","getString","resolved","fileContextVerifies","filePathFurtleFilePath","filePathNominalFilePath","furtleFileContext","FurtleFileContext","fromFilePath","context","NominalFileContext","forEachFile","file","getPath","fromFile"],"mappings":"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"}