occam-entities 1.0.1

package/lib/utilities/metaJSON.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return _default;
+    },
+    dependenciesFromNode: function() {
+        return dependenciesFromNode;
+    },
+    dependencyNamesFromNode: function() {
+        return dependencyNamesFromNode;
+    },
+    isMetaJSONFileValid: function() {
+        return isMetaJSONFileValid;
+    },
+    metaJSONNodeFromMetaJSONFile: function() {
+        return metaJSONNodeFromMetaJSONFile;
+    },
+    repositoryFromNode: function() {
+        return repositoryFromNode;
+    },
+    updateMetaJSONFileVersion: function() {
+        return updateMetaJSONFileVersion;
+    },
+    versionFromNode: function() {
+        return versionFromNode;
+    }
+});
+var _occamgrammars = require("occam-grammars");
+var _version = /*#__PURE__*/ _interop_require_default(require("../version"));
+var _dependency = /*#__PURE__*/ _interop_require_default(require("../dependency"));
+var _dependencies = /*#__PURE__*/ _interop_require_default(require("../dependencies"));
+var _shortenedVersion = /*#__PURE__*/ _interop_require_default(require("../shortenedVersion"));
+var _constants = require("../constants");
+var _content = require("../utilities/content");
+var _query = require("../utilities/query");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var metaJSONLexer = _occamgrammars.MetaJSONLexer.fromNothing(), metaJSONParser = _occamgrammars.MetaJSONParser.fromNothing(), errorNodesQuery = (0, _query.nodesQuery)("//error"), dependencyNodesQuery = (0, _query.nodesQuery)("//dependencies/dependency"), repositoryTerminalNodeQuery = (0, _query.nodeQuery)("//repository!/@*!"), versionNumberTerminalNodeQuery = (0, _query.nodeQuery)("//version!/versionNumber!/@*!"), dependencyNameTerminalNodeQuery = (0, _query.nodeQuery)("/dependency/name!/@*!"), shortenedVersionNumberTerminalNodeQuery = (0, _query.nodeQuery)("//dependency/shortenedVersionNumber/@*!");
+function versionFromNode(node) {
+    var version = null;
+    if (node !== null) {
+        var versionNumberTerminalNode = versionNumberTerminalNodeQuery(node), versionNumberTerminalNodeContent = versionNumberTerminalNode.getContent(), string = (0, _content.trimDoubleQuotes)(versionNumberTerminalNodeContent); //
+        version = _version.default.fromString(string);
+    }
+    return version;
+}
+function repositoryFromNode(node) {
+    var repository = null;
+    if (node !== null) {
+        var repositoryTerminalNode = repositoryTerminalNodeQuery(node), repositoryTerminalNodeContent = repositoryTerminalNode.getContent();
+        repository = (0, _content.trimDoubleQuotes)(repositoryTerminalNodeContent); //
+    }
+    return repository;
+}
+function isMetaJSONFileValid(metaJSONFile) {
+    var metaJSONFileValid = false;
+    var metaJSONNode = metaJSONNodeFromMetaJSONFile(metaJSONFile);
+    if (metaJSONNode !== null) {
+        var node = metaJSONNode, errorNodes = errorNodesQuery(node), errorNodesLength = errorNodes.length;
+        if (errorNodesLength === 0) {
+            metaJSONFileValid = true;
+        }
+    }
+    return metaJSONFileValid;
+}
+function dependenciesFromNode(node) {
+    var dependencies = _dependencies.default.fromNothing();
+    if (node !== null) {
+        var dependencyNodes = dependencyNodesQuery(node);
+        dependencyNodes.forEach(function(dependencyNode) {
+            var dependencyNameTerminalNode = dependencyNameTerminalNodeQuery(dependencyNode), shortenedVersionNumberTerminalNode = shortenedVersionNumberTerminalNodeQuery(dependencyNode), dependencyNameTerminalNodeContent = dependencyNameTerminalNode.getContent(), shortenedVersionNumberTerminalNodeContent = shortenedVersionNumberTerminalNode.getContent(), string = (0, _content.trimDoubleQuotes)(shortenedVersionNumberTerminalNodeContent), name = (0, _content.trimDoubleQuotes)(dependencyNameTerminalNodeContent), shortenedVersion = _shortenedVersion.default.fromString(string), dependency = _dependency.default.fromNameAndShortenedVersion(name, shortenedVersion);
+            dependencies.addDependency(dependency);
+        });
+    }
+    return dependencies;
+}
+function dependencyNamesFromNode(node) {
+    var dependencies = dependenciesFromNode(node), dependencyNames = dependencies.mapDependency(function(dependency) {
+        var dependencyName = dependency.getName();
+        return dependencyName;
+    });
+    return dependencyNames;
+}
+function updateMetaJSONFileVersion(metaJSONFile, version) {
+    var metaJSONNode = metaJSONNodeFromMetaJSONFile(metaJSONFile), node = metaJSONNode, repository = repositoryFromNode(node);
+    var dependencies = dependenciesFromNode(node);
+    var string = version.toString(), dependenciesJSON = dependencies.toJSON();
+    version = string; ///
+    dependencies = dependenciesJSON; ///
+    var metaJSON = {
+        version: version,
+        repository: repository,
+        dependencies: dependencies
+    }, metaJSONString = JSON.stringify(metaJSON, null, _constants.DOUBLE_SPACE), metaJSONFileContent = metaJSONString; ///
+    metaJSONFile.setContent(metaJSONFileContent);
+}
+function metaJSONNodeFromMetaJSONFile(metaJSONFile) {
+    var metaJSONNode = null;
+    if (metaJSONFile !== null) {
+        var content = metaJSONFile.getContent(), tokens = metaJSONLexer.tokenise(content), node = metaJSONParser.parse(tokens);
+        metaJSONNode = node; ///
+    }
+    return metaJSONNode;
+}
+var _default = {
+    versionFromNode: versionFromNode,
+    repositoryFromNode: repositoryFromNode,
+    isMetaJSONFileValid: isMetaJSONFileValid,
+    dependenciesFromNode: dependenciesFromNode,
+    dependencyNamesFromNode: dependencyNamesFromNode,
+    updateMetaJSONFileVersion: updateMetaJSONFileVersion,
+    metaJSONNodeFromMetaJSONFile: metaJSONNodeFromMetaJSONFile
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/metaJSON.js"],"sourcesContent":["\"use strict\";\n\nimport { MetaJSONLexer, MetaJSONParser } from \"occam-grammars\";\n\nimport Version from \"../version\";\nimport Dependency from \"../dependency\";\nimport Dependencies from \"../dependencies\";\nimport ShortenedVersion from \"../shortenedVersion\";\n\nimport { DOUBLE_SPACE } from \"../constants\";\nimport { trimDoubleQuotes } from \"../utilities/content\";\nimport { nodeQuery, nodesQuery } from \"../utilities/query\";\n\nconst metaJSONLexer = MetaJSONLexer.fromNothing(),\n      metaJSONParser = MetaJSONParser.fromNothing(),\n      errorNodesQuery = nodesQuery(\"//error\"),\n      dependencyNodesQuery = nodesQuery(\"//dependencies/dependency\"),\n      repositoryTerminalNodeQuery = nodeQuery(\"//repository!/@*!\"),\n      versionNumberTerminalNodeQuery = nodeQuery(\"//version!/versionNumber!/@*!\"),\n      dependencyNameTerminalNodeQuery = nodeQuery(\"/dependency/name!/@*!\"),\n      shortenedVersionNumberTerminalNodeQuery = nodeQuery(\"//dependency/shortenedVersionNumber/@*!\");\n\nexport function versionFromNode(node) {\n  let version = null;\n\n  if (node !== null) {\n    const versionNumberTerminalNode = versionNumberTerminalNodeQuery(node),\n          versionNumberTerminalNodeContent = versionNumberTerminalNode.getContent(),\n          string = trimDoubleQuotes(versionNumberTerminalNodeContent); //\n\n    version = Version.fromString(string);\n  }\n\n  return version;\n}\n\nexport function repositoryFromNode(node) {\n  let repository = null;\n\n  if (node !== null) {\n    const repositoryTerminalNode = repositoryTerminalNodeQuery(node),\n          repositoryTerminalNodeContent = repositoryTerminalNode.getContent();\n\n    repository = trimDoubleQuotes(repositoryTerminalNodeContent); //\n  }\n\n  return repository;\n}\n\nexport function isMetaJSONFileValid(metaJSONFile) {\n  let metaJSONFileValid = false;\n\n  const metaJSONNode = metaJSONNodeFromMetaJSONFile(metaJSONFile);\n\n  if (metaJSONNode !== null) {\n    const node = metaJSONNode,  ///\n          errorNodes = errorNodesQuery(node),\n          errorNodesLength = errorNodes.length;\n\n    if (errorNodesLength === 0) {\n      metaJSONFileValid = true;\n    }\n  }\n\n  return metaJSONFileValid;\n}\n\nexport function dependenciesFromNode(node) {\n  const dependencies = Dependencies.fromNothing();\n\n  if (node !== null) {\n    const dependencyNodes = dependencyNodesQuery(node);\n\n    dependencyNodes.forEach((dependencyNode) => {\n      const dependencyNameTerminalNode = dependencyNameTerminalNodeQuery(dependencyNode),\n            shortenedVersionNumberTerminalNode = shortenedVersionNumberTerminalNodeQuery(dependencyNode),\n            dependencyNameTerminalNodeContent = dependencyNameTerminalNode.getContent(),\n            shortenedVersionNumberTerminalNodeContent = shortenedVersionNumberTerminalNode.getContent(),\n            string = trimDoubleQuotes(shortenedVersionNumberTerminalNodeContent),  ///\n            name = trimDoubleQuotes(dependencyNameTerminalNodeContent),///\n            shortenedVersion = ShortenedVersion.fromString(string),\n            dependency = Dependency.fromNameAndShortenedVersion(name, shortenedVersion);\n\n      dependencies.addDependency(dependency);\n    });\n  }\n\n  return dependencies;\n}\n\nexport function dependencyNamesFromNode(node) {\n  const dependencies = dependenciesFromNode(node),\n        dependencyNames = dependencies.mapDependency((dependency) => {\n          const dependencyName = dependency.getName();\n\n          return dependencyName;\n        });\n\n  return dependencyNames;\n}\n\nexport function updateMetaJSONFileVersion(metaJSONFile, version) {\n  const metaJSONNode = metaJSONNodeFromMetaJSONFile(metaJSONFile),\n        node = metaJSONNode,  ///\n        repository = repositoryFromNode(node);\n\n  let dependencies = dependenciesFromNode(node);\n\n  const string = version.toString(),\n      dependenciesJSON = dependencies.toJSON();\n\n  version = string;  ///\n\n  dependencies = dependenciesJSON;  ///\n\n  const metaJSON = {\n          version,\n          repository,\n          dependencies\n        },\n        metaJSONString = JSON.stringify(metaJSON, null, DOUBLE_SPACE),\n        metaJSONFileContent = metaJSONString; ///\n\n  metaJSONFile.setContent(metaJSONFileContent);\n}\n\nexport function metaJSONNodeFromMetaJSONFile(metaJSONFile) {\n  let metaJSONNode = null;\n\n  if (metaJSONFile !== null) {\n    const content = metaJSONFile.getContent(),\n          tokens = metaJSONLexer.tokenise(content),\n          node = metaJSONParser.parse(tokens);\n\n    metaJSONNode = node;  ///\n  }\n\n  return metaJSONNode;\n}\n\nexport default {\n  versionFromNode,\n  repositoryFromNode,\n  isMetaJSONFileValid,\n  dependenciesFromNode,\n  dependencyNamesFromNode,\n  updateMetaJSONFileVersion,\n  metaJSONNodeFromMetaJSONFile\n};\n"],"names":["dependenciesFromNode","dependencyNamesFromNode","isMetaJSONFileValid","metaJSONNodeFromMetaJSONFile","repositoryFromNode","updateMetaJSONFileVersion","versionFromNode","metaJSONLexer","MetaJSONLexer","fromNothing","metaJSONParser","MetaJSONParser","errorNodesQuery","nodesQuery","dependencyNodesQuery","repositoryTerminalNodeQuery","nodeQuery","versionNumberTerminalNodeQuery","dependencyNameTerminalNodeQuery","shortenedVersionNumberTerminalNodeQuery","node","version","versionNumberTerminalNode","versionNumberTerminalNodeContent","getContent","string","trimDoubleQuotes","Version","fromString","repository","repositoryTerminalNode","repositoryTerminalNodeContent","metaJSONFile","metaJSONFileValid","metaJSONNode","errorNodes","errorNodesLength","length","dependencies","Dependencies","dependencyNodes","forEach","dependencyNode","dependencyNameTerminalNode","shortenedVersionNumberTerminalNode","dependencyNameTerminalNodeContent","shortenedVersionNumberTerminalNodeContent","name","shortenedVersion","ShortenedVersion","dependency","Dependency","fromNameAndShortenedVersion","addDependency","dependencyNames","mapDependency","dependencyName","getName","toString","dependenciesJSON","toJSON","metaJSON","metaJSONString","JSON","stringify","DOUBLE_SPACE","metaJSONFileContent","setContent","content","tokens","tokenise","parse"],"mappings":"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"}

package/lib/utilities/name.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "fileNameFromFilePath", {
+    enumerable: true,
+    get: function() {
+        return fileNameFromFilePath;
+    }
+});
+var _necessary = require("necessary");
+var bottommostNameFromPath = _necessary.pathUtilities.bottommostNameFromPath;
+function fileNameFromFilePath(filePath) {
+    var path = filePath, bottommostName = bottommostNameFromPath(path), fileName = bottommostName; //
+    return fileName;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsaXRpZXMvbmFtZS5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuaW1wb3J0IHsgcGF0aFV0aWxpdGllcyB9IGZyb20gXCJuZWNlc3NhcnlcIjtcblxuY29uc3QgeyBib3R0b21tb3N0TmFtZUZyb21QYXRoIH0gPSBwYXRoVXRpbGl0aWVzO1xuXG5leHBvcnQgZnVuY3Rpb24gZmlsZU5hbWVGcm9tRmlsZVBhdGgoZmlsZVBhdGgpIHtcbiAgY29uc3QgcGF0aCA9IGZpbGVQYXRoLCAgLy8vXG4gICAgICAgIGJvdHRvbW1vc3ROYW1lID0gYm90dG9tbW9zdE5hbWVGcm9tUGF0aChwYXRoKSxcbiAgICAgICAgZmlsZU5hbWUgPSBib3R0b21tb3N0TmFtZTsgIC8vXG5cbiAgcmV0dXJuIGZpbGVOYW1lO1xufVxuIl0sIm5hbWVzIjpbImZpbGVOYW1lRnJvbUZpbGVQYXRoIiwiYm90dG9tbW9zdE5hbWVGcm9tUGF0aCIsInBhdGhVdGlsaXRpZXMiLCJmaWxlUGF0aCIsInBhdGgiLCJib3R0b21tb3N0TmFtZSIsImZpbGVOYW1lIl0sIm1hcHBpbmdzIjoiQUFBQTs7OzsrQkFNZ0JBOzs7ZUFBQUE7Ozt5QkFKYztBQUU5QixJQUFNLEFBQUVDLHlCQUEyQkMsd0JBQWEsQ0FBeENEO0FBRUQsU0FBU0QscUJBQXFCRyxRQUFRO0lBQzNDLElBQU1DLE9BQU9ELFVBQ1BFLGlCQUFpQkosdUJBQXVCRyxPQUN4Q0UsV0FBV0QsZ0JBQWlCLEVBQUU7SUFFcEMsT0FBT0M7QUFDVCJ9

package/lib/utilities/query.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    nodeQuery: function() {
+        return nodeQuery;
+    },
+    nodesQuery: function() {
+        return nodesQuery;
+    }
+});
+var _occamdom = require("occam-dom");
+function nodeQuery(expression) {
+    var query = _occamdom.Query.fromExpression(expression);
+    return function(node) {
+        if (node !== null) {
+            var nodes = query.execute(node);
+            node = nodes.shift() || null; ///
+        }
+        return node;
+    };
+}
+function nodesQuery(expression) {
+    var query = _occamdom.Query.fromExpression(expression);
+    return function(node) {
+        var nodes = null;
+        if (node !== null) {
+            nodes = query.execute(node);
+        }
+        return nodes;
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsaXRpZXMvcXVlcnkuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCB7IFF1ZXJ5IH0gZnJvbSBcIm9jY2FtLWRvbVwiO1xuXG5leHBvcnQgZnVuY3Rpb24gbm9kZVF1ZXJ5KGV4cHJlc3Npb24pIHtcbiAgY29uc3QgcXVlcnkgPSBRdWVyeS5mcm9tRXhwcmVzc2lvbihleHByZXNzaW9uKTtcblxuICByZXR1cm4gZnVuY3Rpb24obm9kZSkge1xuICAgIGlmIChub2RlICE9PSBudWxsKSB7XG4gICAgICBjb25zdCBub2RlcyA9IHF1ZXJ5LmV4ZWN1dGUobm9kZSk7XG5cbiAgICAgIG5vZGUgPSBub2Rlcy5zaGlmdCgpIHx8IG51bGw7IC8vL1xuICAgIH1cblxuICAgIHJldHVybiBub2RlO1xuICB9O1xufVxuXG5leHBvcnQgZnVuY3Rpb24gbm9kZXNRdWVyeShleHByZXNzaW9uKSB7XG4gIGNvbnN0IHF1ZXJ5ID0gUXVlcnkuZnJvbUV4cHJlc3Npb24oZXhwcmVzc2lvbik7XG5cbiAgcmV0dXJuIGZ1bmN0aW9uKG5vZGUpIHtcbiAgICBsZXQgbm9kZXMgPSBudWxsO1xuXG4gICAgaWYgKG5vZGUgIT09IG51bGwpIHtcbiAgICAgIG5vZGVzID0gcXVlcnkuZXhlY3V0ZShub2RlKTtcbiAgICB9XG5cbiAgICByZXR1cm4gbm9kZXM7XG4gIH07XG59XG4iXSwibmFtZXMiOlsibm9kZVF1ZXJ5Iiwibm9kZXNRdWVyeSIsImV4cHJlc3Npb24iLCJxdWVyeSIsIlF1ZXJ5IiwiZnJvbUV4cHJlc3Npb24iLCJub2RlIiwibm9kZXMiLCJleGVjdXRlIiwic2hpZnQiXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7OztJQUlnQkEsU0FBUztlQUFUQTs7SUFjQUMsVUFBVTtlQUFWQTs7O3dCQWhCTTtBQUVmLFNBQVNELFVBQVVFLFVBQVU7SUFDbEMsSUFBTUMsUUFBUUMsZUFBSyxDQUFDQyxjQUFjLENBQUNIO0lBRW5DLE9BQU8sU0FBU0ksSUFBSTtRQUNsQixJQUFJQSxTQUFTLE1BQU07WUFDakIsSUFBTUMsUUFBUUosTUFBTUssT0FBTyxDQUFDRjtZQUU1QkEsT0FBT0MsTUFBTUUsS0FBSyxNQUFNLE1BQU0sR0FBRztRQUNuQztRQUVBLE9BQU9IO0lBQ1Q7QUFDRjtBQUVPLFNBQVNMLFdBQVdDLFVBQVU7SUFDbkMsSUFBTUMsUUFBUUMsZUFBSyxDQUFDQyxjQUFjLENBQUNIO0lBRW5DLE9BQU8sU0FBU0ksSUFBSTtRQUNsQixJQUFJQyxRQUFRO1FBRVosSUFBSUQsU0FBUyxNQUFNO1lBQ2pCQyxRQUFRSixNQUFNSyxPQUFPLENBQUNGO1FBQ3hCO1FBRUEsT0FBT0M7SUFDVDtBQUNGIn0=

package/lib/utilities/version.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    majorNumberFromNumber: function() {
+        return majorNumberFromNumber;
+    },
+    majorNumberFromString: function() {
+        return majorNumberFromString;
+    },
+    minorNumberFromNumber: function() {
+        return minorNumberFromNumber;
+    },
+    minorNumberFromString: function() {
+        return minorNumberFromString;
+    },
+    patchNumberFromNumber: function() {
+        return patchNumberFromNumber;
+    },
+    patchNumberFromString: function() {
+        return patchNumberFromString;
+    }
+});
+var _necessary = require("necessary");
+var _multiplers = require("../multiplers");
+var second = _necessary.arrayUtilities.second;
+function majorNumberFromNumber(number) {
+    var majorNumber = number !== null ? Math.floor(number / _multiplers.MAJOR_NUMBER_MULTIPLIER) : 0; ///
+    return majorNumber;
+}
+function minorNumberFromNumber(number) {
+    var minorNumber = number !== null ? Math.floor(number % _multiplers.MAJOR_NUMBER_MULTIPLIER / _multiplers.MINOR_NUMBER_MULTIPLIER) : 0; ///
+    return minorNumber;
+}
+function patchNumberFromNumber(number) {
+    var patchNumber = number !== null ? Math.floor(number % _multiplers.MINOR_NUMBER_MULTIPLIER / _multiplers.PATCH_NUMBER_MULTIPLIER) : 0; ///
+    return patchNumber;
+}
+function majorNumberFromString(string) {
+    var majorNumber = 0;
+    if (string) {
+        var matches = string.match(/^(\d+)/), secondMatch = second(matches);
+        majorNumber = Number(secondMatch); ///
+    }
+    return majorNumber;
+}
+function minorNumberFromString(string) {
+    var minorNumber = 0;
+    if (string) {
+        var matches = string.match(/^\d+\.(\d+)/), secondMatch = second(matches);
+        minorNumber = Number(secondMatch); ///
+    }
+    return minorNumber;
+}
+function patchNumberFromString(string) {
+    var patchNumber = 0;
+    if (string) {
+        var matches = string.match(/^\d+\.\d+\.(\d+)/), secondMatch = second(matches);
+        patchNumber = Number(secondMatch); ///
+    }
+    return patchNumber;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/version.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return Version;
+    }
+});
+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 Version = /*#__PURE__*/ function() {
+    function Version(majorNumber, minorNumber, patchNumber) {
+        _class_call_check(this, Version);
+        this.majorNumber = majorNumber;
+        this.minorNumber = minorNumber;
+        this.patchNumber = patchNumber;
+    }
+    _create_class(Version, [
+        {
+            key: "getMajorNumber",
+            value: function getMajorNumber() {
+                return this.majorNumber;
+            }
+        },
+        {
+            key: "getMinorNumber",
+            value: function getMinorNumber() {
+                return this.minorNumber;
+            }
+        },
+        {
+            key: "getPatchNumber",
+            value: function getPatchNumber() {
+                return this.patchNumber;
+            }
+        },
+        {
+            key: "bumpMajorNumber",
+            value: function bumpMajorNumber() {
+                this.majorNumber += 1;
+            }
+        },
+        {
+            key: "bumpMinorNumber",
+            value: function bumpMinorNumber() {
+                this.minorNumber += 1;
+            }
+        },
+        {
+            key: "bumpPatchNumber",
+            value: function bumpPatchNumber() {
+                this.patchNumber += 1;
+            }
+        },
+        {
+            key: "resetMajorNumber",
+            value: function resetMajorNumber() {
+                this.majorNumber = 0;
+            }
+        },
+        {
+            key: "resetMinorNumber",
+            value: function resetMinorNumber() {
+                this.minorNumber = 0;
+            }
+        },
+        {
+            key: "resetPatchNumber",
+            value: function resetPatchNumber() {
+                this.patchNumber = 0;
+            }
+        },
+        {
+            key: "matchShortenedVersion",
+            value: function matchShortenedVersion(shortenedVersion) {
+                var matchesShortenedVersion = false;
+                if (shortenedVersion === null) {
+                    matchesShortenedVersion = true;
+                } else {
+                    var majorNumber = shortenedVersion.getMajorNumber();
+                    if (this.majorNumber === majorNumber) {
+                        var minorNumber = shortenedVersion.getMinorNumber();
+                        if (this.minorNumber >= minorNumber) {
+                            matchesShortenedVersion = true;
+                        }
+                    }
+                }
+                return matchesShortenedVersion;
+            }
+        },
+        {
+            key: "toString",
+            value: function toString() {
+                var string = "".concat(this.majorNumber, ".").concat(this.minorNumber, ".").concat(this.patchNumber);
+                return string;
+            }
+        },
+        {
+            key: "toVersionNumber",
+            value: function toVersionNumber() {
+                var versionNumber = this.majorNumber * _multiplers.MAJOR_NUMBER_MULTIPLIER + this.minorNumber * _multiplers.MINOR_NUMBER_MULTIPLIER + this.patchNumber * _multiplers.PATCH_NUMBER_MULTIPLIER;
+                return versionNumber;
+            }
+        }
+    ], [
+        {
+            key: "fromString",
+            value: function fromString(string) {
+                var majorNumber = (0, _version.majorNumberFromString)(string), minorNumber = (0, _version.minorNumberFromString)(string), patchNumber = (0, _version.patchNumberFromString)(string), version = new Version(majorNumber, minorNumber, patchNumber);
+                return version;
+            }
+        },
+        {
+            key: "fromNothing",
+            value: function fromNothing() {
+                var majorNumber = 0, minorNumber = 0, patchNumber = 0, version = new Version(majorNumber, minorNumber, patchNumber);
+                return version;
+            }
+        },
+        {
+            key: "fromVersion",
+            value: function fromVersion(version) {
+                var majorNumber = version.getMajorNumber(), minorNumber = version.getMinorNumber(), patchNumber = version.getPatchNumber();
+                version = new Version(majorNumber, minorNumber, patchNumber); ///
+                return version;
+            }
+        },
+        {
+            key: "fromVersionNumber",
+            value: function fromVersionNumber(versionNumber) {
+                var number = versionNumber, majorNumber = (0, _version.majorNumberFromNumber)(number), minorNumber = (0, _version.minorNumberFromNumber)(number), patchNumber = (0, _version.patchNumberFromNumber)(number), version = new Version(majorNumber, minorNumber, patchNumber);
+                return version;
+            }
+        }
+    ]);
+    return Version;
+}();
+
+//# sourceMappingURL=data:application/json;base64,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

package/license.txt

@@ -0,0 +1,48 @@
+MIT And Anti-996 Licenses
+
+Copyright (c) 2023 James Smith
+
+These licenses shall be included in all copies or substantial portions of
+this software and associated documentation files (the "Software").
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this Software, to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+1. The individual or the legal entity must conspicuously display,
+without modification, this License and the notice on each redistributed
+or derivative copy of the Licensed Work.
+
+2. The individual or the legal entity must strictly comply with all
+applicable laws, regulations, rules and standards of the jurisdiction
+relating to labor and employment where the individual is physically
+located or where the individual was born or naturalized; or where the
+legal entity is registered or is operating (whichever is stricter). In
+case that the jurisdiction has no such laws, regulations, rules and
+standards or its laws, regulations, rules and standards are
+unenforceable, the individual or the legal entity are required to
+comply with Core International Labor Standards.
+
+3. The individual or the legal entity shall not induce, suggest or force
+its employee(s), whether full-time or part-time, or its independent
+contractor(s), in any methods, to agree in oral or written form, to
+directly or indirectly restrict, weaken or relinquish his or her
+rights or remedies under such laws, regulations, rules and standards
+relating to labor and employment as mentioned above, no matter whether
+such written or oral agreements are enforceable under the laws of the
+said jurisdiction, nor shall such individual or the legal entity
+limit, in any methods, the rights of its employee(s) or independent
+contractor(s) from reporting or complaining to the copyright holder or
+relevant authorities monitoring the compliance of the license about
+its violation(s) of the said license.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "occam-entities",
+  "author": "James Smith",
+  "version": "1.0.1",
+  "license": "MIT, Anti-996",
+  "homepage": "https://github.com/djalbat/occam-entities",
+  "description": "Occam's entities.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/djalbat/occam-entities"
+  },
+  "dependencies": {
+    "necessary": "^11.9.3",
+    "occam-dom": "^3.1.63",
+    "occam-grammars": "^1.0.469"
+  },
+  "devDependencies": {
+    "@swc/core": "^1.2.51",
+    "watchful-cli": "^1.7.39"
+  },
+  "scripts": {
+    "clean": "rm -rf ./lib",
+    "watchful": "watchful -m --transpiler=swc --source-directory=./src --lib-directory=./lib",
+    "batch": "npm run watchful batch --",
+    "batch-debug": "npm run watchful batch -- --debug",
+    "incremental": "npm run watchful incremental --",
+    "incremental-debug": "npm run watchful incremental -- --debug",
+    "build": "npm run clean && npm run batch",
+    "build-debug": "npm run clean && npm run batch-debug",
+    "watch": "npm run clean && npm run batch && npm run incremental",
+    "watch-debug": "npm run clean && npm run batch-debug && npm run incremental-debug"
+  },
+  "main": "./lib/index"
+}

package/src/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export const EMPTY_STRING = "";
+export const DOUBLE_SPACE = "  ";
+export const ENTRIES_MAXIMUM_LENGTH = 1024;

package/src/dependencies.js

@@ -0,0 +1,75 @@
+"use strict";
+
+import { asynchronousUtilities } from "necessary";
+
+import Dependency from "./dependency";
+import ShortenedVersion from "./shortenedVersion";
+
+const { forEach } = asynchronousUtilities;
+
+export default class Dependencies {
+  constructor(array) {
+    this.array = array;
+  }
+
+  addDependency(dependency) {
+    this.array.push(dependency);
+  }
+
+  mapDependency(callback) {
+    return this.array.map(callback);
+  }
+
+  everyDependency(callback) {
+    return this.array.every(callback);
+  }
+
+  reduceDependency(callback, initialValue) {
+    return this.array.reduce(callback, initialValue);
+  }
+
+  forEachDependency(callback) {
+    this.array.forEach(callback);
+  }
+
+  asynchronousForEachDependency(operation, done) { forEach(this.array, operation, done); }
+
+  toJSON() {
+    const dependenciesJSON = this.array.reduce((dependenciesJSON, dependency) => {
+            const name = dependency.getName(),
+                  shortenedVersion = dependency.getShortedVersion(),
+                  shortenedVersionString = shortenedVersion.toString();
+
+            dependenciesJSON[name] = shortenedVersionString;
+  
+            return dependenciesJSON;
+          }, {}),
+          json = dependenciesJSON; ///
+
+    return json;
+  }
+
+  static fromJSON(json) {
+    const dependenciesJSON = json, ///
+          dependenciesJSONKeys = Object.keys(dependenciesJSON),
+          names = dependenciesJSONKeys, ///
+          array = names.map((name) => {
+            const shortenedVersionString = dependenciesJSON[name],
+                  string = shortenedVersionString,  ///
+                  shortenedVersion = ShortenedVersion.fromString(string),
+                  dependency = Dependency.fromNameAndShortenedVersion(name, shortenedVersion);
+
+            return dependency;
+          }),
+          dependencies = new Dependencies(array);
+
+    return dependencies;
+  }
+
+  static fromNothing() {
+    const array = [],
+          dependencies = new Dependencies(array);
+
+    return dependencies;
+  }
+}

package/src/dependency.js

@@ -0,0 +1,29 @@
+"use strict";
+
+export default class Dependency {
+  constructor(name, shortenedVersion) {
+    this.name = name;
+    this.shortenedVersion = shortenedVersion;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getShortedVersion() {
+    return this.shortenedVersion;
+  }
+
+  static fromName(name) {
+    const shortenedVersion = null,
+          dependency = new Dependency(name, shortenedVersion);
+
+    return dependency;
+  }
+
+  static fromNameAndShortenedVersion(name, shortenedVersion) {
+    const dependency = new Dependency(name, shortenedVersion);
+
+    return dependency;
+  }
+}