occam-verify-cli 1.0.382 → 1.0.385

package/lib/ontology/declaration/complexType.js

@@ -0,0 +1,346 @@
+"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 _ComplexTypeDeclaration;
+var _default = (0, _ontology.define)((_ComplexTypeDeclaration = /*#__PURE__*/ function() {
+    function ComplexTypeDeclaration(context, node, string, type, prefixed) {
+        _class_call_check(this, ComplexTypeDeclaration);
+        this.context = context;
+        this.node = node;
+        this.string = string;
+        this.type = type;
+        this.prefixed = prefixed;
+    }
+    _create_class(ComplexTypeDeclaration, [
+        {
+            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 complexTypeDeclarationString = this.string; ///
+                this.context.trace("Verifying the '".concat(complexTypeDeclarationString, "' complex 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 propertiesVerify = this.verifyProperties();
+                            if (propertiesVerify) {
+                                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(complexTypeDeclarationString, "' complex 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, "' complex 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, "' complex 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, "' complex 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, "' complex type's super-types..."), this.node);
+                var typeBasic = this.type.isBasic();
+                if (typeBasic) {
+                    superTypesVerify = true;
+                    this.context.trace("The '".concat(typeString, "' complex 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, "' complex type's super-types."), this.node);
+                }
+                return superTypesVerify;
+            }
+        },
+        {
+            key: "verifyProperty",
+            value: function verifyProperty(property, properties) {
+                var propertyVerifies = false;
+                var propertyString = property.getString();
+                this.context.trace("Verifying the '".concat(propertyString, "' property..."), this.node);
+                var propertyNameVerifies = this.verifyPropertyName(property, properties);
+                if (propertyNameVerifies) {
+                    var propertyNominalTypeNameVerifies = this.verifyPropertyNominalTypeName(property, properties);
+                    if (propertyNominalTypeNameVerifies) {
+                        propertyVerifies = true;
+                    }
+                }
+                if (propertyVerifies) {
+                    this.context.debug("...verified the '".concat(propertyString, "' property."), this.node);
+                }
+                return propertyVerifies;
+            }
+        },
+        {
+            key: "verifyProperties",
+            value: function verifyProperties() {
+                var _this = this;
+                var propertiesVerify;
+                var typeString = this.type.getString();
+                this.context.trace("Verifying the '".concat(typeString, "' complex type's properties..."), this.node);
+                var includeSuperTypes = false, properties = this.type.getProperties(includeSuperTypes);
+                propertiesVerify = properties.every(function(property) {
+                    var propertyVerifies = _this.verifyProperty(property, properties);
+                    if (propertyVerifies) {
+                        return true;
+                    }
+                });
+                if (propertiesVerify) {
+                    this.context.debug("...verified the '".concat(typeString, "' complex type's properties."), this.node);
+                }
+                return propertiesVerify;
+            }
+        },
+        {
+            key: "verifyPropertyName",
+            value: function verifyPropertyName(property, properties) {
+                var propertyNameVerifies = false;
+                var propertyString = property.getString();
+                this.context.trace("Verifying the '".concat(propertyString, "' property's name..."), this.node);
+                var propertyName = property.getName(), count = properties.reduce(function(count, property) {
+                    var propertyNameMatches = property.matchPropertyName(propertyName);
+                    if (propertyNameMatches) {
+                        count++;
+                    }
+                    return count;
+                }, 0);
+                if (count > 1) {
+                    this.context.debug("The '".concat(propertyString, "' property appears more than once."), this.node);
+                } else {
+                    var superTypes = this.type.getSuperTypes(), superType = superTypes.find(function(superType) {
+                        var superTypeProperties = superType.getProperties(), propertyNameMatches = superTypeProperties.some(function(superTypeProperty) {
+                            var propertyNameMatches = superTypeProperty.matchPropertyName(propertyName);
+                            if (propertyNameMatches) {
+                                return true;
+                            }
+                        });
+                        if (propertyNameMatches) {
+                            return true;
+                        }
+                    }) || null;
+                    if (superType !== null) {
+                        var superTypeString = superType.getString();
+                        this.context.debug("The '".concat(superTypeString, "' super-type has the same property."), this.node);
+                    } else {
+                        propertyNameVerifies = true;
+                    }
+                }
+                if (propertyNameVerifies) {
+                    this.context.debug("...verified the '".concat(propertyString, "' property's name."), this.node);
+                }
+                return propertyNameVerifies;
+            }
+        },
+        {
+            key: "verifyPropertyNominalTypeName",
+            value: function verifyPropertyNominalTypeName(property) {
+                var propertyNominalTypeNameVerifies = false;
+                var propertyString = property.getString(), nominalTypeName = property.getNominalTypeName();
+                this.context.trace("Verifying the '".concat(propertyString, "' property's '").concat(nominalTypeName, "' nominal type name..."), this.node);
+                var nominalTypeNameMatches = this.type.matchNominalTypeName(nominalTypeName);
+                if (nominalTypeNameMatches) {
+                    propertyNominalTypeNameVerifies = true;
+                } else {
+                    var typePresent = this.context.isTypePresentByNominalTypeName(nominalTypeName);
+                    if (typePresent) {
+                        propertyNominalTypeNameVerifies = true;
+                    }
+                }
+                if (propertyNominalTypeNameVerifies) {
+                    this.context.debug("...verifies the '".concat(propertyString, "' property's '").concat(nominalTypeName, "' nominal type name."), this.node);
+                }
+                return propertyNominalTypeNameVerifies;
+            }
+        }
+    ], [
+        {
+            key: "fromComplexTypeDeclarationNode",
+            value: function fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
+                var Type = _ontology.default.Type, type = Type.fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context), node = complexTypeDeclarationNode, prefixed = complexTypeDeclarationNode.isPrefixed(), typePrefixName = complexTypeDeclarationNode.getTypePrefixName(), typeName = type.getName(), superTypes = type.getSuperTypes(), string = (0, _type.stringFromTypeNameTypePrefixNameAndSuperTypes)(typeName, typePrefixName, superTypes), complexTypeDeclaration = new ComplexTypeDeclaration(context, node, string, type, prefixed);
+                return complexTypeDeclaration;
+            }
+        }
+    ]);
+    return ComplexTypeDeclaration;
+}(), _define_property(_ComplexTypeDeclaration, "name", "ComplexTypeDeclaration"), _ComplexTypeDeclaration));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/ontology/declaration/complexType.js"],"sourcesContent":["\"use strict\";\n\nimport ontology from \"../../ontology\";\n\nimport { define } from \"../../ontology\";\nimport { stringFromTypeNameTypePrefixNameAndSuperTypes } from \"../../utilities/type\";\n\nexport default define(class ComplexTypeDeclaration {\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 complexTypeDeclarationString = this.string; ///\n\n    this.context.trace(`Verifying the '${complexTypeDeclarationString}' complex 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 propertiesVerify = this.verifyProperties();\n\n          if (propertiesVerify) {\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\n    if (verifies) {\n      this.context.debug(`...verified the '${complexTypeDeclarationString}' complex 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}' complex 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}' complex 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}' complex 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}' complex 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}' complex 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}' complex type's super-types.`, this.node);\n    }\n\n    return superTypesVerify;\n  }\n\n  verifyProperty(property, properties) {\n    let propertyVerifies = false;\n\n    const propertyString = property.getString();\n\n    this.context.trace(`Verifying the '${propertyString}' property...`, this.node);\n\n    const propertyNameVerifies = this.verifyPropertyName(property, properties);\n\n    if (propertyNameVerifies) {\n      const propertyNominalTypeNameVerifies = this.verifyPropertyNominalTypeName(property, properties);\n\n      if (propertyNominalTypeNameVerifies) {\n        propertyVerifies = true;\n      }\n    }\n\n    if (propertyVerifies) {\n      this.context.debug(`...verified the '${propertyString}' property.`, this.node);\n    }\n\n    return propertyVerifies;\n  }\n\n  verifyProperties() {\n    let propertiesVerify;\n\n    const typeString = this.type.getString();\n\n    this.context.trace(`Verifying the '${typeString}' complex type's properties...`, this.node);\n\n    const includeSuperTypes = false,\n          properties = this.type.getProperties(includeSuperTypes);\n\n    propertiesVerify = properties.every((property) => {\n      const propertyVerifies = this.verifyProperty(property, properties);\n\n      if (propertyVerifies) {\n        return true;\n      }\n    });\n\n    if (propertiesVerify) {\n      this.context.debug(`...verified the '${typeString}' complex type's properties.`, this.node);\n    }\n\n    return propertiesVerify;\n  }\n\n  verifyPropertyName(property, properties) {\n    let propertyNameVerifies = false;\n\n    const propertyString = property.getString();\n\n    this.context.trace(`Verifying the '${propertyString}' property's name...`, this.node);\n\n    const propertyName = property.getName(),\n          count = properties.reduce((count, property) => {\n            const propertyNameMatches = property.matchPropertyName(propertyName);\n\n            if (propertyNameMatches) {\n              count++;\n            }\n\n            return count;\n          }, 0);\n\n    if (count > 1) {\n      this.context.debug(`The '${propertyString}' property appears more than once.`, this.node);\n    } else {\n      const superTypes = this.type.getSuperTypes(),\n            superType = superTypes.find((superType) => {\n              const superTypeProperties = superType.getProperties(),\n                    propertyNameMatches = superTypeProperties.some((superTypeProperty) => {\n                      const propertyNameMatches = superTypeProperty.matchPropertyName(propertyName);\n\n                      if (propertyNameMatches) {\n                        return true;\n                      }\n                    });\n\n              if (propertyNameMatches) {\n                return true;\n              }\n            }) || null;\n\n      if (superType !== null) {\n        const superTypeString = superType.getString();\n\n        this.context.debug(`The '${superTypeString}' super-type has the same property.`, this.node);\n      } else {\n        propertyNameVerifies = true;\n      }\n    }\n\n    if (propertyNameVerifies) {\n      this.context.debug(`...verified the '${propertyString}' property's name.`, this.node);\n    }\n\n    return propertyNameVerifies;\n  }\n\n  verifyPropertyNominalTypeName(property) {\n    let propertyNominalTypeNameVerifies = false;\n\n    const propertyString = property.getString(),\n          nominalTypeName = property.getNominalTypeName();\n\n    this.context.trace(`Verifying the '${propertyString}' property's '${nominalTypeName}' nominal type name...`, this.node);\n\n    const nominalTypeNameMatches = this.type.matchNominalTypeName(nominalTypeName);\n\n    if (nominalTypeNameMatches) {\n      propertyNominalTypeNameVerifies = true;\n    } else {\n      const typePresent = this.context.isTypePresentByNominalTypeName(nominalTypeName);\n\n      if (typePresent) {\n        propertyNominalTypeNameVerifies = true;\n      }\n    }\n\n    if (propertyNominalTypeNameVerifies) {\n      this.context.debug(`...verifies the '${propertyString}' property's '${nominalTypeName}' nominal type name.`, this.node);\n    }\n\n    return propertyNominalTypeNameVerifies;\n  }\n\n  static name = \"ComplexTypeDeclaration\";\n\n  static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {\n    const { Type } = ontology,\n          type = Type.fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),\n          node = complexTypeDeclarationNode,  ///\n          prefixed = complexTypeDeclarationNode.isPrefixed(),\n          typePrefixName = complexTypeDeclarationNode.getTypePrefixName(),\n          typeName = type.getName(),\n          superTypes = type.getSuperTypes(),\n          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),\n          complexTypeDeclaration = new ComplexTypeDeclaration(context, node, string, type, prefixed);\n\n    return complexTypeDeclaration;\n  }\n});\n"],"names":["define","ComplexTypeDeclaration","context","node","string","type","prefixed","getContext","getNode","getString","getType","isPrefixed","verify","verifies","complexTypeDeclarationString","trace","typeString","typeVerifies","verifyType","superTypesVerify","verifySuperTypes","propertiesVerify","verifyProperties","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","verifyProperty","property","properties","propertyVerifies","propertyString","propertyNameVerifies","verifyPropertyName","propertyNominalTypeNameVerifies","verifyPropertyNominalTypeName","includeSuperTypes","getProperties","propertyName","count","reduce","propertyNameMatches","matchPropertyName","find","superTypeProperties","some","superTypeProperty","nominalTypeNameMatches","matchNominalTypeName","isTypePresentByNominalTypeName","fromComplexTypeDeclarationNode","complexTypeDeclarationNode","Type","ontology","getTypePrefixName","stringFromTypeNameTypePrefixNameAndSuperTypes","complexTypeDeclaration","name"],"mappings":"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"}

package/lib/ontology/declaration/constructor.js

@@ -0,0 +1,199 @@
+"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 _constructor = /*#__PURE__*/ _interop_require_default(require("../../verifier/constructor"));
+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 _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: 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 _ConstructorDeclaration;
+var _default = (0, _ontology.define)((_ConstructorDeclaration = /*#__PURE__*/ function() {
+    function ConstructorDeclaration(context, node, string, constructor) {
+        _class_call_check(this, ConstructorDeclaration);
+        this.context = context;
+        this.node = node;
+        this.string = string;
+        this.constructor = constructor;
+    }
+    _create_class(ConstructorDeclaration, [
+        {
+            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: "getConstructor",
+            value: function getConstructor() {
+                return this.constructor;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify() {
+                var verifies;
+                var constructorDeclarationString = this.string; ///
+                this.context.trace("Verifying the '".concat(constructorDeclarationString, "' constructor declaration..."), this.node);
+                var constructorTypeVerifies = this.verifyConstructorType();
+                if (constructorTypeVerifies) {
+                    var constructorVerifies = this.verifyConstructor();
+                    if (constructorVerifies) {
+                        this.context.addConstructor(this.constructor);
+                        verifies = true;
+                    }
+                }
+                if (verifies) {
+                    this.context.debug("...verified the '".concat(constructorDeclarationString, "' constructor declaration."), this.node);
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifyConstructor",
+            value: function verifyConstructor() {
+                var constructorVerifies;
+                var constructorString = this.constructor.getString();
+                this.context.trace("Verifying the '".concat(constructorString, "' constructor..."), this.node);
+                var term = this.constructor.getTerm(), termNode = term.getNode();
+                constructorVerifies = _constructor.default.verifyTerm(termNode, this.context);
+                if (constructorVerifies) {
+                    this.context.debug("...verified the '".concat(constructorString, "' constructor."), this.node);
+                }
+                return constructorVerifies;
+            }
+        },
+        {
+            key: "verifyConstructorType",
+            value: function verifyConstructorType() {
+                var constructorTypeVerifies = false;
+                var type;
+                type = this.constructor.getType();
+                var typeString = type.getString();
+                this.context.trace("Verifying the '".concat(typeString, "' type..."), this.node);
+                var nominalTypeName = type.getNominalTypeName();
+                type = this.context.findTypeByNominalTypeName(nominalTypeName);
+                var typePresent = type !== null;
+                if (!typePresent) {
+                    this.context.debug("The '".concat(typeString, "' type is not present."), this.node);
+                } else {
+                    var includeSupertypes = false, provisional = type.isProvisional(includeSupertypes), provisionalMatches = type.matchProvisional(provisional);
+                    if (!provisionalMatches) {
+                        provisional ? this.context.debug("The '".concat(typeString, "' type is present but not provisional."), this.node) : this.context.debug("The '".concat(typeString, "' type is present but provisional."), this.node);
+                    } else {
+                        this.constructor.setType(type);
+                        constructorTypeVerifies = true;
+                    }
+                }
+                if (constructorTypeVerifies) {
+                    this.context.debug("...verified the '".concat(typeString, "' type."), this.node);
+                }
+                return constructorTypeVerifies;
+            }
+        }
+    ], [
+        {
+            key: "fromConstructorDeclarationNode",
+            value: function fromConstructorDeclarationNode(constructorDeclarationNode, context) {
+                var Constructor = _ontology.default.Constructor, node = constructorDeclarationNode, string = context.nodeAsString(node), constructor = Constructor.fromConstructorDeclarationNode(constructorDeclarationNode, context), constructorDeclaration = new ConstructorDeclaration(context, node, string, constructor);
+                return constructorDeclaration;
+            }
+        }
+    ]);
+    return ConstructorDeclaration;
+}(), _define_property(_ConstructorDeclaration, "name", "ConstructorDeclaration"), _ConstructorDeclaration));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/ontology/declaration/constructor.js"],"sourcesContent":["\"use strict\";\n\nimport ontology from \"../../ontology\";\n\nimport constructorVerifier from \"../../verifier/constructor\";\n\nimport { define } from \"../../ontology\";\n\nexport default define(class ConstructorDeclaration {\n  constructor(context, node, string, constructor) {\n    this.context = context;\n    this.node = node;\n    this.string = string;\n    this.constructor = constructor;\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  getConstructor() {\n    return this.constructor;\n  }\n\n  verify() {\n    let verifies;\n\n    const constructorDeclarationString = this.string; ///\n\n    this.context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`, this.node);\n\n    const constructorTypeVerifies = this.verifyConstructorType();\n\n    if (constructorTypeVerifies) {\n      const constructorVerifies = this.verifyConstructor();\n\n      if (constructorVerifies) {\n        this.context.addConstructor(this.constructor);\n\n        verifies = true;\n      }\n    }\n\n    if (verifies) {\n      this.context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`, this.node);\n    }\n\n    return verifies;\n  }\n\n  verifyConstructor() {\n    let constructorVerifies;\n\n    const constructorString = this.constructor.getString();\n\n    this.context.trace(`Verifying the '${constructorString}' constructor...`, this.node);\n\n    const term = this.constructor.getTerm(),\n          termNode = term.getNode();\n\n    constructorVerifies = constructorVerifier.verifyTerm(termNode, this.context);\n\n    if (constructorVerifies) {\n      this.context.debug(`...verified the '${constructorString}' constructor.`, this.node);\n    }\n\n    return constructorVerifies;\n  }\n\n  verifyConstructorType() {\n    let constructorTypeVerifies = false;\n\n    let type;\n\n    type = this.constructor.getType();\n\n    const typeString = type.getString();\n\n    this.context.trace(`Verifying the '${typeString}' type...`, this.node);\n\n    const nominalTypeName = type.getNominalTypeName();\n\n    type = this.context.findTypeByNominalTypeName(nominalTypeName);\n\n    const typePresent = (type !== null)\n\n    if (!typePresent) {\n      this.context.debug(`The '${typeString}' type is not present.`, this.node);\n    } else {\n      const includeSupertypes = false,\n            provisional = type.isProvisional(includeSupertypes),\n            provisionalMatches = type.matchProvisional(provisional);\n\n      if (!provisionalMatches) {\n        provisional ?\n          this.context.debug(`The '${typeString}' type is present but not provisional.`, this.node) :\n            this.context.debug(`The '${typeString}' type is present but provisional.`, this.node);\n      } else {\n        this.constructor.setType(type);\n\n        constructorTypeVerifies = true;\n      }\n    }\n\n    if (constructorTypeVerifies) {\n      this.context.debug(`...verified the '${typeString}' type.`, this.node);\n    }\n\n    return constructorTypeVerifies;\n  }\n\n  static name = \"ConstructorDeclaration\";\n\n  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {\n    const { Constructor } = ontology,\n          node = constructorDeclarationNode,  ///\n          string = context.nodeAsString(node),\n          constructor = Constructor.fromConstructorDeclarationNode(constructorDeclarationNode, context),\n          constructorDeclaration = new ConstructorDeclaration(context, node, string, constructor);\n\n    return constructorDeclaration;\n  }\n});\n"],"names":["define","ConstructorDeclaration","context","node","string","constructor","getContext","getNode","getString","getConstructor","verify","verifies","constructorDeclarationString","trace","constructorTypeVerifies","verifyConstructorType","constructorVerifies","verifyConstructor","addConstructor","debug","constructorString","term","getTerm","termNode","constructorVerifier","verifyTerm","type","getType","typeString","nominalTypeName","getNominalTypeName","findTypeByNominalTypeName","typePresent","includeSupertypes","provisional","isProvisional","provisionalMatches","matchProvisional","setType","fromConstructorDeclarationNode","constructorDeclarationNode","Constructor","ontology","nodeAsString","constructorDeclaration","name"],"mappings":"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"}