occam-verify-cli 1.0.383 → 1.0.385

package/lib/ontology/declaration/metavariable.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _ontology = /*#__PURE__*/ _interop_require_wildcard(require("../../ontology"));
+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 _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _MetavariableDeclaration;
+var _default = (0, _ontology.define)((_MetavariableDeclaration = /*#__PURE__*/ function() {
+    function MetavariableDeclaration(context, node, string, metavariable) {
+        _class_call_check(this, MetavariableDeclaration);
+        this.context = context;
+        this.node = node;
+        this.string = string;
+        this.metavariable = metavariable;
+    }
+    _create_class(MetavariableDeclaration, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getMetavariable",
+            value: function getMetavariable() {
+                return this.metavariable;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify() {
+                var verifies;
+                var metavariableDeclarationString = this.string; ///
+                this.context.trace("Verifying the '".concat(metavariableDeclarationString, "' metavariable declaration..."), this.node);
+                var metavariableVerifies = this.verifyMetavariable(this.metavariable);
+                if (metavariableVerifies) {
+                    this.context.addMetavariable(this.metavariable);
+                    verifies = true;
+                }
+                if (verifies) {
+                    this.context.debug("...verified the '".concat(metavariableDeclarationString, "' metavariable declaration."), this.node);
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifyType",
+            value: function verifyType(type) {
+                var typeVerifies;
+                if (type === null) {
+                    typeVerifies = true;
+                } else {
+                    var typeString = type.getString();
+                    this.context.trace("Verifying the '".concat(typeString, "' type..."), this.node);
+                    var nominalTypeName = type.getNominalTypeName(), typePresent = this.context.isTypePresentByNominalTypeName(nominalTypeName);
+                    if (!typePresent) {
+                        this.context.debug("The '".concat(typeString, "' type is not present."), this.node);
+                    } else {
+                        typeVerifies = true;
+                    }
+                    if (typeVerifies) {
+                        this.context.debug("...verified the '".concat(typeString, "' type."), this.node);
+                    }
+                }
+                return typeVerifies;
+            }
+        },
+        {
+            key: "verifyMetavariable",
+            value: function verifyMetavariable(metavariable) {
+                var metavariableVerifies = false;
+                var metavariableString = metavariable.getString();
+                this.context.trace("Verifying the '".concat(metavariableString, "' metavariable when declared..."), this.node);
+                var metavariableNode = metavariable.getNode(), termNode = metavariableNode.getTermNode();
+                if (termNode !== null) {
+                    this.context.debug("A term was found in the '".concat(metavariableString, "' metavariable when a type should have been present."), this.node);
+                } else {
+                    var metavariableName = metavariable.getName(), metavariablePresent = this.context.isMetavariablePresentByMetavariableName(metavariableName);
+                    if (metavariablePresent) {
+                        this.context.debug("The '".concat(metavariableName, "' metavariable is already present."), this.node);
+                    } else {
+                        var type = metavariable.getType(), typeVerifies = this.verifyType(type);
+                        metavariableVerifies = typeVerifies; ///
+                    }
+                }
+                if (metavariableVerifies) {
+                    this.context.debug("...verified the '".concat(metavariableString, "' metavariable when declared."), this.node);
+                }
+                return metavariableVerifies;
+            }
+        }
+    ], [
+        {
+            key: "fromMetavariableDeclarationNode",
+            value: function fromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
+                var Metavariable = _ontology.default.Metavariable, node = metavariableDeclarationNode, metaType = metaTypeFromMetavariableDeclarationNode(metavariableDeclarationNode, context), metavariable = Metavariable.fromMetavariableDeclarationNode(metavariableDeclarationNode, context), string = stringFromMetavariableAndMetaType(metavariable, metaType), metavariableDeclaration = new MetavariableDeclaration(context, node, string, metavariable);
+                return metavariableDeclaration;
+            }
+        }
+    ]);
+    return MetavariableDeclaration;
+}(), _define_property(_MetavariableDeclaration, "name", "MetavariableDeclaration"), _MetavariableDeclaration));
+function stringFromMetavariableAndMetaType(metavariable, metaType) {
+    var string;
+    var metavariableString = metavariable.getString();
+    if (metaType === null) {
+        string = metavariableString; ///
+    } else {
+        var metaTypeString = metaType.getString();
+        string = "".concat(metavariableString, ":").concat(metaTypeString);
+    }
+    return string;
+}
+function metaTypeFromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
+    var MetaType = _ontology.default.MetaType, metaTypeNode = metavariableDeclarationNode.getMetaTypeNode(), metaType = MetaType.fromMetaTypeNode(metaTypeNode, context);
+    return metaType;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/ontology/declaration/metavariable.js"],"sourcesContent":["\"use strict\";\n\nimport ontology from \"../../ontology\";\n\nimport { define } from \"../../ontology\";\n\nexport default define(class MetavariableDeclaration {\n  constructor(context, node, string, metavariable) {\n    this.context = context;\n    this.node = node;\n    this.string = string;\n    this.metavariable = metavariable;\n  }\n\n  getContext() {\n    return this.context;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getMetavariable() {\n    return this.metavariable;\n  }\n\n  verify() {\n    let verifies;\n\n    const metavariableDeclarationString = this.string; ///\n\n    this.context.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`, this.node);\n\n    const metavariableVerifies = this.verifyMetavariable(this.metavariable);\n\n    if (metavariableVerifies) {\n      this.context.addMetavariable(this.metavariable);\n\n      verifies = true;\n    }\n\n    if (verifies) {\n      this.context.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration.`, this.node);\n    }\n\n    return verifies;\n  }\n\n  verifyType(type) {\n    let typeVerifies;\n\n    if (type === null) {\n      typeVerifies = true;\n    } else {\n      const typeString = type.getString();\n\n      this.context.trace(`Verifying the '${typeString}' type...`, this.node);\n\n      const nominalTypeName = type.getNominalTypeName(),\n            typePresent = this.context.isTypePresentByNominalTypeName(nominalTypeName);\n\n      if (!typePresent) {\n        this.context.debug(`The '${typeString}' type is not present.`, this.node);\n      } else {\n        typeVerifies = true;\n      }\n\n      if (typeVerifies) {\n        this.context.debug(`...verified the '${typeString}' type.`, this.node);\n      }\n    }\n\n    return typeVerifies;\n  }\n\n  verifyMetavariable(metavariable) {\n    let metavariableVerifies = false;\n\n    const metavariableString = metavariable.getString();\n\n    this.context.trace(`Verifying the '${metavariableString}' metavariable when declared...`, this.node);\n\n    const metavariableNode = metavariable.getNode(), ///\n          termNode = metavariableNode.getTermNode();\n\n    if (termNode !== null) {\n      this.context.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`, this.node);\n    } else {\n      const metavariableName = metavariable.getName(),\n            metavariablePresent = this.context.isMetavariablePresentByMetavariableName(metavariableName);\n\n      if (metavariablePresent) {\n        this.context.debug(`The '${metavariableName}' metavariable is already present.`, this.node);\n      } else {\n        const type = metavariable.getType(),\n              typeVerifies = this.verifyType(type);\n\n        metavariableVerifies = typeVerifies;  ///\n      }\n    }\n\n    if (metavariableVerifies) {\n      this.context.debug(`...verified the '${metavariableString}' metavariable when declared.`, this.node);\n    }\n\n    return metavariableVerifies;\n  }\n\n  static name = \"MetavariableDeclaration\";\n\n  static fromMetavariableDeclarationNode(metavariableDeclarationNode, context) {\n    const { Metavariable } = ontology,\n          node = metavariableDeclarationNode, ///\n          metaType = metaTypeFromMetavariableDeclarationNode(metavariableDeclarationNode, context),\n          metavariable = Metavariable.fromMetavariableDeclarationNode(metavariableDeclarationNode, context),\n          string = stringFromMetavariableAndMetaType(metavariable, metaType),\n          metavariableDeclaration = new MetavariableDeclaration(context, node, string, metavariable);\n\n    return metavariableDeclaration;\n  }\n});\n\nfunction stringFromMetavariableAndMetaType(metavariable, metaType) {\n  let string;\n\n  const metavariableString = metavariable.getString();\n\n  if (metaType === null) {\n    string = metavariableString; ///\n  } else {\n    const metaTypeString = metaType.getString();\n\n    string = `${metavariableString}:${metaTypeString}`;\n  }\n\n  return string;\n}\n\nfunction metaTypeFromMetavariableDeclarationNode(metavariableDeclarationNode, context) {\n  const { MetaType } = ontology,\n        metaTypeNode = metavariableDeclarationNode.getMetaTypeNode(),\n        metaType = MetaType.fromMetaTypeNode(metaTypeNode, context);\n\n  return metaType;\n}\n"],"names":["define","MetavariableDeclaration","context","node","string","metavariable","getContext","getNode","getString","getMetavariable","verify","verifies","metavariableDeclarationString","trace","metavariableVerifies","verifyMetavariable","addMetavariable","debug","verifyType","type","typeVerifies","typeString","nominalTypeName","getNominalTypeName","typePresent","isTypePresentByNominalTypeName","metavariableString","metavariableNode","termNode","getTermNode","metavariableName","getName","metavariablePresent","isMetavariablePresentByMetavariableName","getType","fromMetavariableDeclarationNode","metavariableDeclarationNode","Metavariable","ontology","metaType","metaTypeFromMetavariableDeclarationNode","stringFromMetavariableAndMetaType","metavariableDeclaration","name","metaTypeString","MetaType","metaTypeNode","getMetaTypeNode","fromMetaTypeNode"],"mappings":"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"}

package/lib/ontology/declaration/simpleType.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _ontology = /*#__PURE__*/ _interop_require_wildcard(require("../../ontology"));
+var _type = require("../../utilities/type");
+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 _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _SimpleTypeDeclaration;
+var _default = (0, _ontology.define)((_SimpleTypeDeclaration = /*#__PURE__*/ function() {
+    function SimpleTypeDeclaration(context, node, string, type, prefixed) {
+        _class_call_check(this, SimpleTypeDeclaration);
+        this.context = context;
+        this.node = node;
+        this.string = string;
+        this.type = type;
+        this.prefixed = prefixed;
+    }
+    _create_class(SimpleTypeDeclaration, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getType",
+            value: function getType() {
+                return this.type;
+            }
+        },
+        {
+            key: "isPrefixed",
+            value: function isPrefixed() {
+                return this.prefixed;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify() {
+                var verifies = false;
+                var simpleTypeDeclarationString = this.string; ///
+                this.context.trace("Verifying the '".concat(simpleTypeDeclarationString, "' simple type declaration..."), this.node);
+                if (this.prefixed) {
+                    var typeString = this.type.getString();
+                    this.context.trace("The '".concat(typeString, "' type is prefixed."));
+                } else {
+                    var typeVerifies = this.verifyType();
+                    if (typeVerifies) {
+                        var superTypesVerify = this.verifySuperTypes();
+                        if (superTypesVerify) {
+                            var typePrefix = this.context.getTypePrefix();
+                            if (typePrefix !== null) {
+                                var typePrefixName = typePrefix.getName(), prefixName = typePrefixName; ///
+                                this.type.setPrefixName(prefixName);
+                            }
+                            this.context.addType(this.type);
+                            verifies = true;
+                        }
+                    }
+                }
+                if (verifies) {
+                    this.context.debug("...verified the '".concat(simpleTypeDeclarationString, "' simple type declaration."), this.node);
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifyType",
+            value: function verifyType() {
+                var typeVerifies = false;
+                var typeString = this.type.getString();
+                this.context.trace("Verifying the '".concat(typeString, "' simple type..."), this.node);
+                var typeName = this.type.getName(), includeRelease = true, includeDependencies = false, typePresent = this.context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies);
+                if (typePresent) {
+                    this.context.trace("The '".concat(typeString, "' type is already present."), this.node);
+                } else {
+                    var prefixedTypeName = typeName, typePresent1 = this.context.isTypePresentByPrefixedTypeName(prefixedTypeName);
+                    if (typePresent1) {
+                        this.context.trace("The '".concat(typeString, "' type is already present."), this.node);
+                    } else {
+                        typeVerifies = true;
+                    }
+                }
+                if (typeVerifies) {
+                    this.context.trace("...verified the '".concat(typeString, "' simple type."), this.node);
+                }
+                return typeVerifies;
+            }
+        },
+        {
+            key: "verifySuperType",
+            value: function verifySuperType(superType) {
+                var superTypeVerifies = false;
+                var superTypeString = superType.getString();
+                this.context.trace("Verifying the '".concat(superTypeString, "' super-type..."), this.node);
+                var nominalTypeName = superType.getNominalTypeName(), typeName = nominalTypeName, typeNameMatches = this.type.matchTypeName(typeName);
+                if (typeNameMatches) {
+                    this.context.trace("The super-type's name matches the ".concat(typeName, "' simple type's name."), this.node);
+                } else {
+                    var oldSuperType = superType;
+                    superType = this.context.findTypeByNominalTypeName(nominalTypeName);
+                    var superTypePresent = superType !== null;
+                    if (superTypePresent) {
+                        var newSuperType = superType; ///
+                        this.type.replaceSuperType(oldSuperType, newSuperType);
+                        superTypeVerifies = true;
+                    }
+                }
+                if (superTypeVerifies) {
+                    this.context.debug("...verified the '".concat(superTypeString, "' super-type."), this.node);
+                }
+                return superTypeVerifies;
+            }
+        },
+        {
+            key: "verifySuperTypes",
+            value: function verifySuperTypes() {
+                var _this = this;
+                var superTypesVerify;
+                var typeString = this.type.getString();
+                this.context.trace("Verifying the '".concat(typeString, "' simple type's super-types..."), this.node);
+                var typeBasic = this.type.isBasic();
+                if (typeBasic) {
+                    superTypesVerify = true;
+                    this.context.trace("The '".concat(typeString, "' simple type is basic."), this.node);
+                } else {
+                    var superTypes = this.type.getSuperTypes();
+                    superTypesVerify = superTypes.every(function(superType) {
+                        var superTypeVerifies = _this.verifySuperType(superType);
+                        if (superTypeVerifies) {
+                            return true;
+                        }
+                    });
+                }
+                if (superTypesVerify) {
+                    this.context.debug("...verified the '".concat(typeString, "' simple type's super-types."), this.node);
+                }
+                return superTypesVerify;
+            }
+        }
+    ], [
+        {
+            key: "fromSimpleTypeDeclarationNode",
+            value: function fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
+                var Type = _ontology.default.Type, type = Type.fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context), node = simpleTypeDeclarationNode, prefixed = simpleTypeDeclarationNode.isPrefixed(), typePrefixName = simpleTypeDeclarationNode.getTypePrefixName(), typeName = type.getName(), superTypes = type.getSuperTypes(), string = (0, _type.stringFromTypeNameTypePrefixNameAndSuperTypes)(typeName, typePrefixName, superTypes), simpleTypeDeclaration = new SimpleTypeDeclaration(context, node, string, type, prefixed);
+                return simpleTypeDeclaration;
+            }
+        }
+    ]);
+    return SimpleTypeDeclaration;
+}(), _define_property(_SimpleTypeDeclaration, "name", "SimpleTypeDeclaration"), _SimpleTypeDeclaration));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/ontology/declaration/simpleType.js"],"sourcesContent":["\"use strict\";\n\nimport ontology from \"../../ontology\";\n\nimport { define } from \"../../ontology\";\nimport { stringFromTypeNameTypePrefixNameAndSuperTypes } from \"../../utilities/type\";\n\nexport default define(class SimpleTypeDeclaration {\n  constructor(context, node, string, type, prefixed) {\n    this.context = context;\n    this.node = node;\n    this.string = string;\n    this.type = type;\n    this.prefixed = prefixed;\n  }\n\n  getContext() {\n    return this.context;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  isPrefixed() {\n    return this.prefixed;\n  }\n\n  verify() {\n    let verifies = false;\n\n    const simpleTypeDeclarationString = this.string;  ///\n\n    this.context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration...`, this.node);\n\n    if (this.prefixed) {\n      const typeString = this.type.getString();\n\n      this.context.trace(`The '${typeString}' type is prefixed.`);\n    } else {\n      const typeVerifies = this.verifyType();\n\n      if (typeVerifies) {\n        const superTypesVerify = this.verifySuperTypes();\n\n        if (superTypesVerify) {\n          const typePrefix = this.context.getTypePrefix();\n\n          if (typePrefix !== null) {\n            const typePrefixName = typePrefix.getName(),\n                  prefixName = typePrefixName;  ///\n\n            this.type.setPrefixName(prefixName);\n          }\n\n          this.context.addType(this.type);\n\n          verifies = true;\n        }\n      }\n    }\n\n    if (verifies) {\n      this.context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration.`, this.node);\n    }\n\n    return verifies;\n  }\n\n  verifyType() {\n    let typeVerifies = false;\n\n    const typeString = this.type.getString();\n\n    this.context.trace(`Verifying the '${typeString}' simple type...`, this.node);\n\n    const typeName = this.type.getName(),\n          includeRelease = true,\n          includeDependencies = false,\n          typePresent = this.context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies);\n\n    if (typePresent) {\n      this.context.trace(`The '${typeString}' type is already present.`, this.node);\n    } else {\n      const prefixedTypeName = typeName, ///\n            typePresent = this.context.isTypePresentByPrefixedTypeName(prefixedTypeName);\n\n      if (typePresent) {\n        this.context.trace(`The '${typeString}' type is already present.`, this.node);\n      } else {\n        typeVerifies = true;\n      }\n    }\n\n    if (typeVerifies) {\n      this.context.trace(`...verified the '${typeString}' simple type.`, this.node);\n    }\n\n    return typeVerifies;\n  }\n\n  verifySuperType(superType) {\n    let superTypeVerifies = false;\n\n    const superTypeString = superType.getString();\n\n    this.context.trace(`Verifying the '${superTypeString}' super-type...`, this.node);\n\n    const nominalTypeName = superType.getNominalTypeName(),\n          typeName = nominalTypeName, ///\n          typeNameMatches = this.type.matchTypeName(typeName);\n\n    if (typeNameMatches) {\n      this.context.trace(`The super-type's name matches the ${typeName}' simple type's name.`, this.node);\n    } else {\n      const oldSuperType = superType;\n\n      superType = this.context.findTypeByNominalTypeName(nominalTypeName);\n\n      const superTypePresent = (superType !== null);\n\n      if (superTypePresent) {\n        const newSuperType = superType; ///\n\n        this.type.replaceSuperType(oldSuperType, newSuperType);\n\n        superTypeVerifies = true;\n      }\n    }\n\n    if (superTypeVerifies) {\n      this.context.debug(`...verified the '${superTypeString}' super-type.`, this.node);\n    }\n\n    return superTypeVerifies;\n  }\n\n  verifySuperTypes() {\n    let superTypesVerify;\n\n    const typeString = this.type.getString();\n\n    this.context.trace(`Verifying the '${typeString}' simple type's super-types...`, this.node);\n\n    const typeBasic = this.type.isBasic();\n\n    if (typeBasic) {\n      superTypesVerify = true;\n\n      this.context.trace(`The '${typeString}' simple type is basic.`, this.node)\n    } else  {\n      const superTypes = this.type.getSuperTypes();\n\n      superTypesVerify = superTypes.every((superType) => {\n        const superTypeVerifies = this.verifySuperType(superType);\n\n        if (superTypeVerifies) {\n          return true;\n        }\n      });\n    }\n\n    if (superTypesVerify) {\n      this.context.debug(`...verified the '${typeString}' simple type's super-types.`, this.node);\n    }\n\n    return superTypesVerify;\n  }\n\n  static name = \"SimpleTypeDeclaration\";\n\n  static fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {\n    const { Type } = ontology,\n          type = Type.fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),\n          node = simpleTypeDeclarationNode, ///\n          prefixed = simpleTypeDeclarationNode.isPrefixed(),\n          typePrefixName = simpleTypeDeclarationNode.getTypePrefixName(),\n          typeName = type.getName(),\n          superTypes = type.getSuperTypes(),\n          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),\n          simpleTypeDeclaration = new SimpleTypeDeclaration(context, node, string, type, prefixed);\n\n    return simpleTypeDeclaration;\n  }\n});\n"],"names":["define","SimpleTypeDeclaration","context","node","string","type","prefixed","getContext","getNode","getString","getType","isPrefixed","verify","verifies","simpleTypeDeclarationString","trace","typeString","typeVerifies","verifyType","superTypesVerify","verifySuperTypes","typePrefix","getTypePrefix","typePrefixName","getName","prefixName","setPrefixName","addType","debug","typeName","includeRelease","includeDependencies","typePresent","isTypePresentByTypeName","prefixedTypeName","isTypePresentByPrefixedTypeName","verifySuperType","superType","superTypeVerifies","superTypeString","nominalTypeName","getNominalTypeName","typeNameMatches","matchTypeName","oldSuperType","findTypeByNominalTypeName","superTypePresent","newSuperType","replaceSuperType","typeBasic","isBasic","superTypes","getSuperTypes","every","fromSimpleTypeDeclarationNode","simpleTypeDeclarationNode","Type","ontology","getTypePrefixName","stringFromTypeNameTypePrefixNameAndSuperTypes","simpleTypeDeclaration","name"],"mappings":"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"}