occam-model 1.0.484

package/lib/release.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _file = /*#__PURE__*/ _interop_require_default(require("./file"));
+var _entries = /*#__PURE__*/ _interop_require_default(require("./entries"));
+var _entries1 = /*#__PURE__*/ _interop_require_default(require("./mixins/entries"));
+var _constants = require("./constants");
+var _metaJSON = require("./utilities/metaJSON");
+var _filePath = require("./utilities/filePath");
+var _files = require("./utilities/files");
+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
+    };
+}
+var Release = /*#__PURE__*/ function() {
+    function Release(name, entries) {
+        _class_call_check(this, Release);
+        this.name = name;
+        this.entries = entries;
+    }
+    _create_class(Release, [
+        {
+            key: "getName",
+            value: function getName() {
+                return this.name;
+            }
+        },
+        {
+            key: "getEntries",
+            value: function getEntries() {
+                return this.entries;
+            }
+        },
+        {
+            key: "updateVersion",
+            value: function updateVersion(version) {
+                var repository = this.getRepository(), dependencies = this.getDependencies();
+                var versionString = version.toString(), repositoryJSON = repository, dependenciesJSON = dependencies.toJSON();
+                version = versionString; ///
+                repository = repositoryJSON; ///
+                dependencies = dependenciesJSON; ///
+                var metaJSONFile = this.getMetaJSONFile(), json = {
+                    version: version,
+                    repository: repository,
+                    dependencies: dependencies
+                }, jsonString = JSON.stringify(json, null, _constants.DOUBLE_SPACE), file = metaJSONFile, content = jsonString; ///
+                file.setContent(content);
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var entriesJSON = this.entries.toJSON(), name = this.name, entries = entriesJSON, json = {
+                    name: name,
+                    entries: entries
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(json) {
+                var entries = json.entries;
+                var name = json.name, entriesJSON = entries; ///
+                json = entriesJSON; ///
+                entries = _entries.default.fromJSON(json); ///
+                var release = new Release(name, entries);
+                return release;
+            }
+        },
+        {
+            key: "fromProject",
+            value: function fromProject(project) {
+                var release = null, entries = project.getEntries();
+                var entriesReleasable = areEntriesReleasable(entries);
+                if (entriesReleasable) {
+                    var name = project.getName(), releasedEntries = releaseEntriesFromEntries(entries);
+                    entries = releasedEntries; ///
+                    release = new Release(name, entries);
+                }
+                return release;
+            }
+        },
+        {
+            key: "fromNameAndEntries",
+            value: function fromNameAndEntries(name, entries) {
+                var release = null;
+                var entriesReleasable = areEntriesReleasable(entries);
+                if (entriesReleasable) {
+                    release = new Release(name, entries);
+                }
+                return release;
+            }
+        }
+    ]);
+    return Release;
+}();
+Object.assign(Release.prototype, _entries1.default);
+var _default = Release;
+function releaseEntriesFromEntries(entries) {
+    var releasedEntries = _entries.default.fromNothing(), files = entries.getFiles();
+    files.forEachFile(function(file) {
+        var filePath = file.getPath(), filePathReleaseFilePath = (0, _filePath.isFilePathReleaseFilePath)(filePath);
+        if (filePathReleaseFilePath) {
+            var path = filePath, content = file.getContent(), released = true;
+            file = _file.default.fromPathContentAndReleased(path, content, released); ///
+            releasedEntries.addFile(file);
+        }
+    });
+    return releasedEntries;
+}
+function areEntriesReleasable(entries) {
+    var entriesReleasable = false;
+    var files = entries.getFiles(), readmeFile = (0, _files.readmeFileFromFiles)(files), metaJSONFile = (0, _files.metaJSONFileFromFiles)(files);
+    if (readmeFile !== null && metaJSONFile !== null) {
+        var metaJSONFileValid = (0, _metaJSON.isMetaJSONFileValid)(metaJSONFile);
+        if (metaJSONFileValid) {
+            entriesReleasable = true;
+        }
+    }
+    return entriesReleasable;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/release.js"],"sourcesContent":["\"use strict\";\n\nimport File from \"./file\";\nimport Entries from \"./entries\";\nimport entriesMixins from \"./mixins/entries\";\n\nimport { DOUBLE_SPACE } from \"./constants\";\nimport { isMetaJSONFileValid } from \"./utilities/metaJSON\";\nimport { isFilePathReleaseFilePath } from \"./utilities/filePath\";\nimport { readmeFileFromFiles, metaJSONFileFromFiles } from \"./utilities/files\";\n\nclass Release {\n  constructor(name, entries) {\n    this.name = name;\n    this.entries = entries;\n  }\n\n  getName() {\n    return this.name;\n  }\n\n  getEntries() {\n    return this.entries;\n  }\n\n  updateVersion(version) {\n    let repository = this.getRepository(),\n        dependencies = this.getDependencies();\n\n    const versionString = version.toString(),\n          repositoryJSON = repository,  ///\n          dependenciesJSON = dependencies.toJSON();\n\n    version = versionString;  ///\n    repository = repositoryJSON;  ///\n    dependencies = dependenciesJSON;  ///\n\n    const metaJSONFile = this.getMetaJSONFile(),\n          json = {\n            version,\n            repository,\n            dependencies\n          },\n          jsonString = JSON.stringify(json, null, DOUBLE_SPACE),\n          file = metaJSONFile,  ///\n          content = jsonString; ///\n\n    file.setContent(content);\n  }\n\n  toJSON() {\n    const entriesJSON = this.entries.toJSON(),\n          name = this.name,\n          entries = entriesJSON,  ///\n          json = {\n            name,\n            entries\n          };\n\n    return json;\n  }\n\n  static fromJSON(json) {\n    let { entries } = json;\n\n    const { name } = json,\n          entriesJSON = entries;  ///\n\n    json = entriesJSON; ///\n\n    entries = Entries.fromJSON(json); ///\n\n    const release = new Release(name, entries);\n\n    return release;\n  }\n\n  static fromProject(project) {\n    let release = null,\n        entries = project.getEntries();\n\n    const entriesReleasable = areEntriesReleasable(entries);\n\n    if (entriesReleasable) {\n      const name = project.getName(),\n            releasedEntries = releaseEntriesFromEntries(entries);\n\n      entries = releasedEntries;  ///\n\n      release = new Release(name, entries);\n    }\n\n    return release;\n  }\n\n  static fromNameAndEntries(name, entries) {\n    let release = null;\n\n    const entriesReleasable = areEntriesReleasable(entries);\n\n    if (entriesReleasable) {\n      release = new Release(name, entries);\n    }\n\n    return release;\n  }\n}\n\nObject.assign(Release.prototype, entriesMixins);\n\nexport default Release;\n\nfunction releaseEntriesFromEntries(entries) {\n  const releasedEntries = Entries.fromNothing(),  ///\n        files = entries.getFiles();\n\n  files.forEachFile((file) => {\n    const filePath = file.getPath(),\n          filePathReleaseFilePath = isFilePathReleaseFilePath(filePath);\n\n    if (filePathReleaseFilePath) {\n      const path = filePath,  ///\n            content = file.getContent(),\n            released = true;\n\n      file = File.fromPathContentAndReleased(path, content, released);  ///\n\n      releasedEntries.addFile(file);\n    }\n  });\n\n  return releasedEntries;\n}\n\nfunction areEntriesReleasable(entries) {\n  let entriesReleasable = false;\n\n  const files = entries.getFiles(),\n        readmeFile = readmeFileFromFiles(files),\n        metaJSONFile = metaJSONFileFromFiles(files);\n\n  if ((readmeFile !== null) && (metaJSONFile !== null)) {\n    const metaJSONFileValid = isMetaJSONFileValid(metaJSONFile);\n\n    if (metaJSONFileValid) {\n      entriesReleasable = true;\n    }\n  }\n\n  return entriesReleasable;\n}\n"],"names":["Release","name","entries","getName","getEntries","updateVersion","version","repository","getRepository","dependencies","getDependencies","versionString","toString","repositoryJSON","dependenciesJSON","toJSON","metaJSONFile","getMetaJSONFile","json","jsonString","JSON","stringify","DOUBLE_SPACE","file","content","setContent","entriesJSON","fromJSON","Entries","release","fromProject","project","entriesReleasable","areEntriesReleasable","releasedEntries","releaseEntriesFromEntries","fromNameAndEntries","Object","assign","prototype","entriesMixins","fromNothing","files","getFiles","forEachFile","filePath","getPath","filePathReleaseFilePath","isFilePathReleaseFilePath","path","getContent","released","File","fromPathContentAndReleased","addFile","readmeFile","readmeFileFromFiles","metaJSONFileFromFiles","metaJSONFileValid","isMetaJSONFileValid"],"mappings":"AAAA;;;;+BA8GA;;;eAAA;;;2DA5GiB;8DACG;+DACM;yBAEG;wBACO;wBACM;qBACiB;;;;;;;;;;;;;;;;;;;;;;;;;AAE3D,IAAA,AAAMA,wBAAN;aAAMA,QACQC,IAAI,EAAEC,OAAO;gCADrBF;QAEF,IAAI,CAACC,IAAI,GAAGA;QACZ,IAAI,CAACC,OAAO,GAAGA;;kBAHbF;;YAMJG,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACF,IAAI;YAClB;;;YAEAG,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACF,OAAO;YACrB;;;YAEAG,KAAAA;mBAAAA,SAAAA,cAAcC,OAAO;gBACnB,IAAIC,aAAa,IAAI,CAACC,aAAa,IAC/BC,eAAe,IAAI,CAACC,eAAe;gBAEvC,IAAMC,gBAAgBL,QAAQM,QAAQ,IAChCC,iBAAiBN,YACjBO,mBAAmBL,aAAaM,MAAM;gBAE5CT,UAAUK,eAAgB,GAAG;gBAC7BJ,aAAaM,gBAAiB,GAAG;gBACjCJ,eAAeK,kBAAmB,GAAG;gBAErC,IAAME,eAAe,IAAI,CAACC,eAAe,IACnCC,OAAO;oBACLZ,SAAAA;oBACAC,YAAAA;oBACAE,cAAAA;gBACF,GACAU,aAAaC,KAAKC,SAAS,CAACH,MAAM,MAAMI,uBAAY,GACpDC,OAAOP,cACPQ,UAAUL,YAAY,GAAG;gBAE/BI,KAAKE,UAAU,CAACD;YAClB;;;YAEAT,KAAAA;mBAAAA,SAAAA;gBACE,IAAMW,cAAc,IAAI,CAACxB,OAAO,CAACa,MAAM,IACjCd,OAAO,IAAI,CAACA,IAAI,EAChBC,UAAUwB,aACVR,OAAO;oBACLjB,MAAAA;oBACAC,SAAAA;gBACF;gBAEN,OAAOgB;YACT;;;;YAEOS,KAAAA;mBAAP,SAAOA,SAAST,IAAI;gBAClB,IAAI,AAAEhB,UAAYgB,KAAZhB;gBAEN,IAAM,AAAED,OAASiB,KAATjB,MACFyB,cAAcxB,SAAU,GAAG;gBAEjCgB,OAAOQ,aAAa,GAAG;gBAEvBxB,UAAU0B,gBAAO,CAACD,QAAQ,CAACT,OAAO,GAAG;gBAErC,IAAMW,UAAU,IA7Dd7B,QA6D0BC,MAAMC;gBAElC,OAAO2B;YACT;;;YAEOC,KAAAA;mBAAP,SAAOA,YAAYC,OAAO;gBACxB,IAAIF,UAAU,MACV3B,UAAU6B,QAAQ3B,UAAU;gBAEhC,IAAM4B,oBAAoBC,qBAAqB/B;gBAE/C,IAAI8B,mBAAmB;oBACrB,IAAM/B,OAAO8B,QAAQ5B,OAAO,IACtB+B,kBAAkBC,0BAA0BjC;oBAElDA,UAAUgC,iBAAkB,GAAG;oBAE/BL,UAAU,IA9EV7B,QA8EsBC,MAAMC;gBAC9B;gBAEA,OAAO2B;YACT;;;YAEOO,KAAAA;mBAAP,SAAOA,mBAAmBnC,IAAI,EAAEC,OAAO;gBACrC,IAAI2B,UAAU;gBAEd,IAAMG,oBAAoBC,qBAAqB/B;gBAE/C,IAAI8B,mBAAmB;oBACrBH,UAAU,IA1FV7B,QA0FsBC,MAAMC;gBAC9B;gBAEA,OAAO2B;YACT;;;WA9FI7B;;AAiGNqC,OAAOC,MAAM,CAACtC,QAAQuC,SAAS,EAAEC,iBAAa;IAE9C,WAAexC;AAEf,SAASmC,0BAA0BjC,OAAO;IACxC,IAAMgC,kBAAkBN,gBAAO,CAACa,WAAW,IACrCC,QAAQxC,QAAQyC,QAAQ;IAE9BD,MAAME,WAAW,CAAC,SAACrB;QACjB,IAAMsB,WAAWtB,KAAKuB,OAAO,IACvBC,0BAA0BC,IAAAA,mCAAyB,EAACH;QAE1D,IAAIE,yBAAyB;YAC3B,IAAME,OAAOJ,UACPrB,UAAUD,KAAK2B,UAAU,IACzBC,WAAW;YAEjB5B,OAAO6B,aAAI,CAACC,0BAA0B,CAACJ,MAAMzB,SAAS2B,WAAY,GAAG;YAErEjB,gBAAgBoB,OAAO,CAAC/B;QAC1B;IACF;IAEA,OAAOW;AACT;AAEA,SAASD,qBAAqB/B,OAAO;IACnC,IAAI8B,oBAAoB;IAExB,IAAMU,QAAQxC,QAAQyC,QAAQ,IACxBY,aAAaC,IAAAA,0BAAmB,EAACd,QACjC1B,eAAeyC,IAAAA,4BAAqB,EAACf;IAE3C,IAAI,AAACa,eAAe,QAAUvC,iBAAiB,MAAO;QACpD,IAAM0C,oBAAoBC,IAAAA,6BAAmB,EAAC3C;QAE9C,IAAI0C,mBAAmB;YACrB1B,oBAAoB;QACtB;IACF;IAEA,OAAOA;AACT"}

package/lib/releases.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return Releases;
+    }
+});
+var _necessary = require("necessary");
+var _release = /*#__PURE__*/ _interop_require_default(require("./release"));
+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
+    };
+}
+var forEach = _necessary.asynchronousUtilities.forEach;
+var Releases = /*#__PURE__*/ function() {
+    function Releases(array) {
+        _class_call_check(this, Releases);
+        this.array = array;
+    }
+    _create_class(Releases, [
+        {
+            key: "getLength",
+            value: function getLength() {
+                return this.array.length;
+            }
+        },
+        {
+            key: "addRelease",
+            value: function addRelease(release) {
+                this.array.push(release);
+            }
+        },
+        {
+            key: "mapRelease",
+            value: function mapRelease(callback) {
+                return this.array.map(callback);
+            }
+        },
+        {
+            key: "reduceRelease",
+            value: function reduceRelease(callback, initialValue) {
+                return this.array.reduce(callback, initialValue);
+            }
+        },
+        {
+            key: "forEachRelease",
+            value: function forEachRelease(callback) {
+                this.array.forEach(callback);
+            }
+        },
+        {
+            key: "asynchronousForEachRelease",
+            value: function asynchronousForEachRelease(callback, done) {
+                forEach(this.array, callback, done);
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var json = this.array.map(function(release) {
+                    var releaseJSON = release.toJSON();
+                    return releaseJSON;
+                });
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(json) {
+                var array = json.map(function(json) {
+                    var release = _release.default.fromJSON(json);
+                    return release;
+                }), releases = new Releases(array);
+                return releases;
+            }
+        },
+        {
+            key: "fromNothing",
+            value: function fromNothing() {
+                var array = [], releases = new Releases(array);
+                return releases;
+            }
+        }
+    ]);
+    return Releases;
+}();
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/shortenedVersion.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return ShortenedVersion;
+    }
+});
+var _multiplers = require("./multiplers");
+var _version = require("./utilities/version");
+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;
+}
+var ShortenedVersion = /*#__PURE__*/ function() {
+    function ShortenedVersion(majorNumber, minorNumber) {
+        _class_call_check(this, ShortenedVersion);
+        this.majorNumber = majorNumber;
+        this.minorNumber = minorNumber;
+    }
+    _create_class(ShortenedVersion, [
+        {
+            key: "getMajorNumber",
+            value: function getMajorNumber() {
+                return this.majorNumber;
+            }
+        },
+        {
+            key: "getMinorNumber",
+            value: function getMinorNumber() {
+                return this.minorNumber;
+            }
+        },
+        {
+            key: "toString",
+            value: function toString() {
+                var string = "".concat(this.majorNumber, ".").concat(this.minorNumber);
+                return string;
+            }
+        },
+        {
+            key: "toVersionNumber",
+            value: function toVersionNumber() {
+                var versionNumber = this.majorNumber * _multiplers.MAJOR_NUMBER_MULTIPLIER + this.minorNumber * _multiplers.MINOR_NUMBER_MULTIPLIER;
+                return versionNumber;
+            }
+        },
+        {
+            key: "getLeastMatchingVersionNumber",
+            value: function getLeastMatchingVersionNumber() {
+                var versionNumber = this.toVersionNumber(), leastMatchingVersionNumber = versionNumber; ///
+                return leastMatchingVersionNumber;
+            }
+        },
+        {
+            key: "getGreatestMatchingVersionNumber",
+            value: function getGreatestMatchingVersionNumber() {
+                var majorNumber = this.majorNumber + 1, minorNumber = 0, shortenedVersion = ShortenedVersion.fromMajorNumberAndMinorNumber(majorNumber, minorNumber), shortenedVersionNumber = shortenedVersion.toVersionNumber(), greatestMatchingVersionNumber = shortenedVersionNumber - 1;
+                return greatestMatchingVersionNumber;
+            }
+        }
+    ], [
+        {
+            key: "fromString",
+            value: function fromString(string) {
+                var majorNumber = (0, _version.majorNumberFromString)(string), minorNumber = (0, _version.minorNumberFromString)(string), shortenedVersion = new ShortenedVersion(majorNumber, minorNumber);
+                return shortenedVersion;
+            }
+        },
+        {
+            key: "fromVersionNumber",
+            value: function fromVersionNumber(versionNumber) {
+                var number = versionNumber, majorNumber = (0, _version.majorNumberFromNumber)(number), minorNumber = (0, _version.minorNumberFromNumber)(number), shortenedVersion = new ShortenedVersion(majorNumber, minorNumber);
+                return shortenedVersion;
+            }
+        },
+        {
+            key: "fromMajorNumberAndMinorNumber",
+            value: function fromMajorNumberAndMinorNumber(majorNumber, minorNumber) {
+                var shortenedVersion = new ShortenedVersion(majorNumber, minorNumber);
+                return shortenedVersion;
+            }
+        }
+    ]);
+    return ShortenedVersion;
+}();
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DIRECTORY_TYPE () {
+        return DIRECTORY_TYPE;
+    },
+    get FILE_TYPE () {
+        return FILE_TYPE;
+    }
+});
+var FILE_TYPE = "File";
+var DIRECTORY_TYPE = "Directory";
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy90eXBlcy5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuZXhwb3J0IGNvbnN0IEZJTEVfVFlQRSA9IFwiRmlsZVwiO1xuZXhwb3J0IGNvbnN0IERJUkVDVE9SWV9UWVBFID0gXCJEaXJlY3RvcnlcIjtcbiJdLCJuYW1lcyI6WyJESVJFQ1RPUllfVFlQRSIsIkZJTEVfVFlQRSJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7O1FBR2FBO2VBQUFBOztRQURBQztlQUFBQTs7O0FBQU4sSUFBTUEsWUFBWTtBQUNsQixJQUFNRCxpQkFBaUIifQ==

package/lib/utilities/content.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get convertContentTabsToWhitespace () {
+        return convertContentTabsToWhitespace;
+    },
+    get default () {
+        return _default;
+    },
+    get sanitiseContent () {
+        return sanitiseContent;
+    },
+    get trimDoubleQuotes () {
+        return trimDoubleQuotes;
+    }
+});
+var _constants = require("../constants");
+function sanitiseContent(content) {
+    var sanitisedContent = content.replace(/&/g, _constants.ESCAPED_AMPERSAND).replace(/</g, _constants.ESCAPED_LESS_THAN).replace(/>/g, _constants.ESCAPED_GREATER_THAN);
+    return sanitisedContent;
+}
+function trimDoubleQuotes(content) {
+    return content.replace(/(^"|"$)/g, _constants.EMPTY_STRING);
+} ///
+function convertContentTabsToWhitespace(content) {
+    return content.replace(/\t/g, _constants.DOUBLE_SPACE);
+} ///
+var _default = {
+    sanitiseContent: sanitiseContent,
+    trimDoubleQuotes: trimDoubleQuotes,
+    convertContentTabsToWhitespace: convertContentTabsToWhitespace
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsaXRpZXMvY29udGVudC5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuaW1wb3J0IHsgRE9VQkxFX1NQQUNFLCBFTVBUWV9TVFJJTkcsIEVTQ0FQRURfQU1QRVJTQU5ELCBFU0NBUEVEX0xFU1NfVEhBTiwgRVNDQVBFRF9HUkVBVEVSX1RIQU4gfSBmcm9tIFwiLi4vY29uc3RhbnRzXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiBzYW5pdGlzZUNvbnRlbnQoY29udGVudCkge1xuICBjb25zdCBzYW5pdGlzZWRDb250ZW50ID0gY29udGVudFxuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAucmVwbGFjZSgvJi9nLCBFU0NBUEVEX0FNUEVSU0FORClcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLnJlcGxhY2UoLzwvZywgRVNDQVBFRF9MRVNTX1RIQU4pXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5yZXBsYWNlKC8+L2csIEVTQ0FQRURfR1JFQVRFUl9USEFOKTtcblxuICByZXR1cm4gc2FuaXRpc2VkQ29udGVudDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHRyaW1Eb3VibGVRdW90ZXMoY29udGVudCkgeyByZXR1cm4gY29udGVudC5yZXBsYWNlKC8oXlwifFwiJCkvZywgRU1QVFlfU1RSSU5HKTsgfSAvLy9cblxuZXhwb3J0IGZ1bmN0aW9uIGNvbnZlcnRDb250ZW50VGFic1RvV2hpdGVzcGFjZShjb250ZW50KSB7IHJldHVybiBjb250ZW50LnJlcGxhY2UoL1xcdC9nLCBET1VCTEVfU1BBQ0UpOyB9IC8vL1xuXG5leHBvcnQgZGVmYXVsdCB7XG4gIHNhbml0aXNlQ29udGVudCxcbiAgdHJpbURvdWJsZVF1b3RlcyxcbiAgY29udmVydENvbnRlbnRUYWJzVG9XaGl0ZXNwYWNlXG59O1xuIl0sIm5hbWVzIjpbImNvbnZlcnRDb250ZW50VGFic1RvV2hpdGVzcGFjZSIsInNhbml0aXNlQ29udGVudCIsInRyaW1Eb3VibGVRdW90ZXMiLCJjb250ZW50Iiwic2FuaXRpc2VkQ29udGVudCIsInJlcGxhY2UiLCJFU0NBUEVEX0FNUEVSU0FORCIsIkVTQ0FQRURfTEVTU19USEFOIiwiRVNDQVBFRF9HUkVBVEVSX1RIQU4iLCJFTVBUWV9TVFJJTkciLCJET1VCTEVfU1BBQ0UiXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7OztRQWVnQkE7ZUFBQUE7O1FBRWhCO2VBQUE7O1FBYmdCQztlQUFBQTs7UUFTQUM7ZUFBQUE7Ozt5QkFYdUY7QUFFaEcsU0FBU0QsZ0JBQWdCRSxPQUFPO0lBQ3JDLElBQU1DLG1CQUFtQkQsUUFDR0UsT0FBTyxDQUFDLE1BQU1DLDRCQUFpQixFQUMvQkQsT0FBTyxDQUFDLE1BQU1FLDRCQUFpQixFQUMvQkYsT0FBTyxDQUFDLE1BQU1HLCtCQUFvQjtJQUU5RCxPQUFPSjtBQUNUO0FBRU8sU0FBU0YsaUJBQWlCQyxPQUFPO0lBQUksT0FBT0EsUUFBUUUsT0FBTyxDQUFDLFlBQVlJLHVCQUFZO0FBQUcsRUFBRSxHQUFHO0FBRTVGLFNBQVNULCtCQUErQkcsT0FBTztJQUFJLE9BQU9BLFFBQVFFLE9BQU8sQ0FBQyxPQUFPSyx1QkFBWTtBQUFHLEVBQUUsR0FBRztJQUU1RyxXQUFlO0lBQ2JULGlCQUFBQTtJQUNBQyxrQkFBQUE7SUFDQUYsZ0NBQUFBO0FBQ0YifQ==

package/lib/utilities/filePath.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get default () {
+        return _default;
+    },
+    get isFilePathCustomGrammarBNFFilePath () {
+        return isFilePathCustomGrammarBNFFilePath;
+    },
+    get isFilePathCustomGrammarVocabularyFilePath () {
+        return isFilePathCustomGrammarVocabularyFilePath;
+    },
+    get isFilePathDefaultMarkdownStyleFilePath () {
+        return isFilePathDefaultMarkdownStyleFilePath;
+    },
+    get isFilePathFurtleFilePath () {
+        return isFilePathFurtleFilePath;
+    },
+    get isFilePathIndexJSONFilePath () {
+        return isFilePathIndexJSONFilePath;
+    },
+    get isFilePathMarkdownFilePath () {
+        return isFilePathMarkdownFilePath;
+    },
+    get isFilePathMarkdownStyleFilePath () {
+        return isFilePathMarkdownStyleFilePath;
+    },
+    get isFilePathMetaJSONFilePath () {
+        return isFilePathMetaJSONFilePath;
+    },
+    get isFilePathNominalFilePath () {
+        return isFilePathNominalFilePath;
+    },
+    get isFilePathReadmeFilePath () {
+        return isFilePathReadmeFilePath;
+    },
+    get isFilePathRecognisedFilePath () {
+        return isFilePathRecognisedFilePath;
+    },
+    get isFilePathReleaseFilePath () {
+        return isFilePathReleaseFilePath;
+    }
+});
+var readmeFilePathPattern = "^(?:[^\\/]+\\/){1}README\\.md$", furtleFilePathPattern = "^(?:[^\\/]+\\/){1,}[^\\.]+\\.ftl$", nominalFilePathPattern = "^(?:[^\\/]+\\/){1,}[^\\.]+\\.nml$", markdownFilePathPattern = "^(?:[^\\/]+\\/){1,}[^\\.]+\\.md$", metaJSONFilePathPattern = "^(?:[^\\/]+\\/){1}meta\\.json$", indexJSONFilePathPattern = "^(?:[^\\/]+\\/){1}index\\.json$", markdownStyleFilePathPattern = "^(?:[^\\/]+\\/){1,}[^\\.]+\\.mds$", customGrammarBNFFilePathPattern = "^(?:[^\\/]+\\/){1}(term|statement)\\.bnf$", defaultMarkdownStyleFilePathPattern = "^[^\\/]+\\/default\\.mds$", customGrammarVocabularyFilePathPattern = "^(?:[^\\/]+\\/){1}(type|symbol)\\.vcb$", releaseFilePathPattern = "".concat(readmeFilePathPattern, "|").concat(furtleFilePathPattern, "|").concat(nominalFilePathPattern, "|").concat(metaJSONFilePathPattern, "|").concat(customGrammarBNFFilePathPattern, "|").concat(customGrammarVocabularyFilePathPattern), recognisedFilePathPattern = "".concat(releaseFilePathPattern, "|").concat(indexJSONFilePathPattern, "|").concat(markdownFilePathPattern, "|").concat(markdownStyleFilePathPattern);
+var readmeFilePathRegularExpression = new RegExp(readmeFilePathPattern), furtleFilePathRegularExpression = new RegExp(furtleFilePathPattern), releaseFilePathRegularExpression = new RegExp(releaseFilePathPattern), nominalFilePathRegularExpression = new RegExp(nominalFilePathPattern), markdownFilePathRegularExpression = new RegExp(markdownFilePathPattern), metaJSONFilePathRegularExpression = new RegExp(metaJSONFilePathPattern), indexJSONFilePathRegularExpression = new RegExp(indexJSONFilePathPattern), recognisedFilePathRegularExpression = new RegExp(recognisedFilePathPattern), markdownStyleFilePathRegularExpression = new RegExp(markdownStyleFilePathPattern), customGrammarBNFFilePathRegularExpression = new RegExp(customGrammarBNFFilePathPattern), defaultMarkdownStyleFilePathRegularExpression = new RegExp(defaultMarkdownStyleFilePathPattern), customGrammarVocabularyFilePathRegularExpression = new RegExp(customGrammarVocabularyFilePathPattern);
+function isFilePathReadmeFilePath(filePath) {
+    return readmeFilePathRegularExpression.test(filePath);
+}
+function isFilePathFurtleFilePath(filePath) {
+    return furtleFilePathRegularExpression.test(filePath);
+}
+function isFilePathReleaseFilePath(filePath) {
+    return releaseFilePathRegularExpression.test(filePath);
+}
+function isFilePathNominalFilePath(filePath) {
+    return nominalFilePathRegularExpression.test(filePath);
+}
+function isFilePathMarkdownFilePath(filePath) {
+    return markdownFilePathRegularExpression.test(filePath);
+}
+function isFilePathMetaJSONFilePath(filePath) {
+    return metaJSONFilePathRegularExpression.test(filePath);
+}
+function isFilePathIndexJSONFilePath(filePath) {
+    return indexJSONFilePathRegularExpression.test(filePath);
+}
+function isFilePathRecognisedFilePath(filePath) {
+    return recognisedFilePathRegularExpression.test(filePath);
+}
+function isFilePathMarkdownStyleFilePath(filePath) {
+    return markdownStyleFilePathRegularExpression.test(filePath);
+}
+function isFilePathCustomGrammarBNFFilePath(filePath) {
+    return customGrammarBNFFilePathRegularExpression.test(filePath);
+}
+function isFilePathDefaultMarkdownStyleFilePath(filePath) {
+    return defaultMarkdownStyleFilePathRegularExpression.test(filePath);
+}
+function isFilePathCustomGrammarVocabularyFilePath(filePath) {
+    return customGrammarVocabularyFilePathRegularExpression.test(filePath);
+}
+var _default = {
+    isFilePathReadmeFilePath: isFilePathReadmeFilePath,
+    isFilePathFurtleFilePath: isFilePathFurtleFilePath,
+    isFilePathReleaseFilePath: isFilePathReleaseFilePath,
+    isFilePathNominalFilePath: isFilePathNominalFilePath,
+    isFilePathMarkdownFilePath: isFilePathMarkdownFilePath,
+    isFilePathMetaJSONFilePath: isFilePathMetaJSONFilePath,
+    isFilePathIndexJSONFilePath: isFilePathIndexJSONFilePath,
+    isFilePathRecognisedFilePath: isFilePathRecognisedFilePath,
+    isFilePathMarkdownStyleFilePath: isFilePathMarkdownStyleFilePath,
+    isFilePathCustomGrammarBNFFilePath: isFilePathCustomGrammarBNFFilePath,
+    isFilePathDefaultMarkdownStyleFilePath: isFilePathDefaultMarkdownStyleFilePath,
+    isFilePathCustomGrammarVocabularyFilePath: isFilePathCustomGrammarVocabularyFilePath
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/filePath.js"],"sourcesContent":["\"use strict\";\r\n\r\nconst readmeFilePathPattern = \"^(?:[^\\\\/]+\\\\/){1}README\\\\.md$\",\r\n      furtleFilePathPattern = \"^(?:[^\\\\/]+\\\\/){1,}[^\\\\.]+\\\\.ftl$\",\r\n      nominalFilePathPattern = \"^(?:[^\\\\/]+\\\\/){1,}[^\\\\.]+\\\\.nml$\",\r\n      markdownFilePathPattern = \"^(?:[^\\\\/]+\\\\/){1,}[^\\\\.]+\\\\.md$\",\r\n      metaJSONFilePathPattern = \"^(?:[^\\\\/]+\\\\/){1}meta\\\\.json$\",\r\n      indexJSONFilePathPattern = \"^(?:[^\\\\/]+\\\\/){1}index\\\\.json$\",\r\n      markdownStyleFilePathPattern = \"^(?:[^\\\\/]+\\\\/){1,}[^\\\\.]+\\\\.mds$\",\r\n      customGrammarBNFFilePathPattern = \"^(?:[^\\\\/]+\\\\/){1}(term|statement)\\\\.bnf$\",\r\n      defaultMarkdownStyleFilePathPattern = \"^[^\\\\/]+\\\\/default\\\\.mds$\",\r\n      customGrammarVocabularyFilePathPattern = \"^(?:[^\\\\/]+\\\\/){1}(type|symbol)\\\\.vcb$\",\r\n      releaseFilePathPattern = `${readmeFilePathPattern}|${furtleFilePathPattern}|${nominalFilePathPattern}|${metaJSONFilePathPattern}|${customGrammarBNFFilePathPattern}|${customGrammarVocabularyFilePathPattern}`,\r\n      recognisedFilePathPattern = `${releaseFilePathPattern}|${indexJSONFilePathPattern}|${markdownFilePathPattern}|${markdownStyleFilePathPattern}`;\r\n\r\nconst readmeFilePathRegularExpression = new RegExp(readmeFilePathPattern),\r\n      furtleFilePathRegularExpression = new RegExp(furtleFilePathPattern),\r\n      releaseFilePathRegularExpression = new RegExp(releaseFilePathPattern),\r\n      nominalFilePathRegularExpression = new RegExp(nominalFilePathPattern),\r\n      markdownFilePathRegularExpression = new RegExp(markdownFilePathPattern),\r\n      metaJSONFilePathRegularExpression = new RegExp(metaJSONFilePathPattern),\r\n      indexJSONFilePathRegularExpression = new RegExp(indexJSONFilePathPattern),\r\n      recognisedFilePathRegularExpression = new RegExp(recognisedFilePathPattern),\r\n      markdownStyleFilePathRegularExpression = new RegExp(markdownStyleFilePathPattern),\r\n      customGrammarBNFFilePathRegularExpression = new RegExp(customGrammarBNFFilePathPattern),\r\n      defaultMarkdownStyleFilePathRegularExpression = new RegExp(defaultMarkdownStyleFilePathPattern),\r\n      customGrammarVocabularyFilePathRegularExpression = new RegExp(customGrammarVocabularyFilePathPattern);\r\n\r\nexport function isFilePathReadmeFilePath(filePath) { return readmeFilePathRegularExpression.test(filePath); }\r\n\r\nexport function isFilePathFurtleFilePath(filePath) { return furtleFilePathRegularExpression.test(filePath); }\r\n\r\nexport function isFilePathReleaseFilePath(filePath) { return releaseFilePathRegularExpression.test(filePath); }\r\n\r\nexport function isFilePathNominalFilePath(filePath) { return nominalFilePathRegularExpression.test(filePath); }\r\n\r\nexport function isFilePathMarkdownFilePath(filePath) { return markdownFilePathRegularExpression.test(filePath); }\r\n\r\nexport function isFilePathMetaJSONFilePath(filePath) { return metaJSONFilePathRegularExpression.test(filePath); }\r\n\r\nexport function isFilePathIndexJSONFilePath(filePath) { return indexJSONFilePathRegularExpression.test(filePath); }\r\n\r\nexport function isFilePathRecognisedFilePath(filePath) { return recognisedFilePathRegularExpression.test(filePath); }\r\n\r\nexport function isFilePathMarkdownStyleFilePath(filePath) { return markdownStyleFilePathRegularExpression.test(filePath); }\r\n\r\nexport function isFilePathCustomGrammarBNFFilePath(filePath) { return customGrammarBNFFilePathRegularExpression.test(filePath); }\r\n\r\nexport function isFilePathDefaultMarkdownStyleFilePath(filePath) { return defaultMarkdownStyleFilePathRegularExpression.test(filePath); }\r\n\r\nexport function isFilePathCustomGrammarVocabularyFilePath(filePath) { return customGrammarVocabularyFilePathRegularExpression.test(filePath); }\r\n\r\nexport default {\r\n  isFilePathReadmeFilePath,\r\n  isFilePathFurtleFilePath,\r\n  isFilePathReleaseFilePath,\r\n  isFilePathNominalFilePath,\r\n  isFilePathMarkdownFilePath,\r\n  isFilePathMetaJSONFilePath,\r\n  isFilePathIndexJSONFilePath,\r\n  isFilePathRecognisedFilePath,\r\n  isFilePathMarkdownStyleFilePath,\r\n  isFilePathCustomGrammarBNFFilePath,\r\n  isFilePathDefaultMarkdownStyleFilePath,\r\n  isFilePathCustomGrammarVocabularyFilePath\r\n};\r\n"],"names":["isFilePathCustomGrammarBNFFilePath","isFilePathCustomGrammarVocabularyFilePath","isFilePathDefaultMarkdownStyleFilePath","isFilePathFurtleFilePath","isFilePathIndexJSONFilePath","isFilePathMarkdownFilePath","isFilePathMarkdownStyleFilePath","isFilePathMetaJSONFilePath","isFilePathNominalFilePath","isFilePathReadmeFilePath","isFilePathRecognisedFilePath","isFilePathReleaseFilePath","readmeFilePathPattern","furtleFilePathPattern","nominalFilePathPattern","markdownFilePathPattern","metaJSONFilePathPattern","indexJSONFilePathPattern","markdownStyleFilePathPattern","customGrammarBNFFilePathPattern","defaultMarkdownStyleFilePathPattern","customGrammarVocabularyFilePathPattern","releaseFilePathPattern","recognisedFilePathPattern","readmeFilePathRegularExpression","RegExp","furtleFilePathRegularExpression","releaseFilePathRegularExpression","nominalFilePathRegularExpression","markdownFilePathRegularExpression","metaJSONFilePathRegularExpression","indexJSONFilePathRegularExpression","recognisedFilePathRegularExpression","markdownStyleFilePathRegularExpression","customGrammarBNFFilePathRegularExpression","defaultMarkdownStyleFilePathRegularExpression","customGrammarVocabularyFilePathRegularExpression","filePath","test"],"mappings":"AAAA;;;;;;;;;;;QAoDA;eAAA;;QANgBA;eAAAA;;QAIAC;eAAAA;;QAFAC;eAAAA;;QAlBAC;eAAAA;;QAUAC;eAAAA;;QAJAC;eAAAA;;QAQAC;eAAAA;;QANAC;eAAAA;;QAJAC;eAAAA;;QANAC;eAAAA;;QAcAC;eAAAA;;QAVAC;eAAAA;;;AA9BhB,IAAMC,wBAAwB,kCACxBC,wBAAwB,qCACxBC,yBAAyB,qCACzBC,0BAA0B,oCAC1BC,0BAA0B,kCAC1BC,2BAA2B,mCAC3BC,+BAA+B,qCAC/BC,kCAAkC,6CAClCC,sCAAsC,6BACtCC,yCAAyC,0CACzCC,yBAAyB,AAAC,GAA2BT,OAAzBD,uBAAsB,KAA4BE,OAAzBD,uBAAsB,KAA6BG,OAA1BF,wBAAuB,KAA8BK,OAA3BH,yBAAwB,KAAsCK,OAAnCF,iCAAgC,KAA0C,OAAvCE,yCACtKE,4BAA4B,AAAC,GAA4BN,OAA1BK,wBAAuB,KAA+BP,OAA5BE,0BAAyB,KAA8BC,OAA3BH,yBAAwB,KAAgC,OAA7BG;AAEtH,IAAMM,kCAAkC,IAAIC,OAAOb,wBAC7Cc,kCAAkC,IAAID,OAAOZ,wBAC7Cc,mCAAmC,IAAIF,OAAOH,yBAC9CM,mCAAmC,IAAIH,OAAOX,yBAC9Ce,oCAAoC,IAAIJ,OAAOV,0BAC/Ce,oCAAoC,IAAIL,OAAOT,0BAC/Ce,qCAAqC,IAAIN,OAAOR,2BAChDe,sCAAsC,IAAIP,OAAOF,4BACjDU,yCAAyC,IAAIR,OAAOP,+BACpDgB,4CAA4C,IAAIT,OAAON,kCACvDgB,gDAAgD,IAAIV,OAAOL,sCAC3DgB,mDAAmD,IAAIX,OAAOJ;AAE7D,SAASZ,yBAAyB4B,QAAQ;IAAI,OAAOb,gCAAgCc,IAAI,CAACD;AAAW;AAErG,SAASlC,yBAAyBkC,QAAQ;IAAI,OAAOX,gCAAgCY,IAAI,CAACD;AAAW;AAErG,SAAS1B,0BAA0B0B,QAAQ;IAAI,OAAOV,iCAAiCW,IAAI,CAACD;AAAW;AAEvG,SAAS7B,0BAA0B6B,QAAQ;IAAI,OAAOT,iCAAiCU,IAAI,CAACD;AAAW;AAEvG,SAAShC,2BAA2BgC,QAAQ;IAAI,OAAOR,kCAAkCS,IAAI,CAACD;AAAW;AAEzG,SAAS9B,2BAA2B8B,QAAQ;IAAI,OAAOP,kCAAkCQ,IAAI,CAACD;AAAW;AAEzG,SAASjC,4BAA4BiC,QAAQ;IAAI,OAAON,mCAAmCO,IAAI,CAACD;AAAW;AAE3G,SAAS3B,6BAA6B2B,QAAQ;IAAI,OAAOL,oCAAoCM,IAAI,CAACD;AAAW;AAE7G,SAAS/B,gCAAgC+B,QAAQ;IAAI,OAAOJ,uCAAuCK,IAAI,CAACD;AAAW;AAEnH,SAASrC,mCAAmCqC,QAAQ;IAAI,OAAOH,0CAA0CI,IAAI,CAACD;AAAW;AAEzH,SAASnC,uCAAuCmC,QAAQ;IAAI,OAAOF,8CAA8CG,IAAI,CAACD;AAAW;AAEjI,SAASpC,0CAA0CoC,QAAQ;IAAI,OAAOD,iDAAiDE,IAAI,CAACD;AAAW;IAE9I,WAAe;IACb5B,0BAAAA;IACAN,0BAAAA;IACAQ,2BAAAA;IACAH,2BAAAA;IACAH,4BAAAA;IACAE,4BAAAA;IACAH,6BAAAA;IACAM,8BAAAA;IACAJ,iCAAAA;IACAN,oCAAAA;IACAE,wCAAAA;IACAD,2CAAAA;AACF"}