occam-nominal 1.0.209 → 1.0.215

package/lib/element/declaration/cotype.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _declaration = /*#__PURE__*/ _interop_require_default(require("../declaration"));
+const _occamlanguages = require("occam-languages");
+const _elements = require("../../elements");
+const _type = require("../../utilities/type");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const { asyncEvery } = _occamlanguages.asynchronousUtilities;
+const _default = (0, _elements.define)(class CotypeDeclaration extends _declaration.default {
+    constructor(context, string, node, breakPoint, type, superTypes, provisional, propertyDeclarations){
+        super(context, string, node, breakPoint);
+        this.type = type;
+        this.superTypes = superTypes;
+        this.provisional = provisional;
+        this.propertyDeclarations = propertyDeclarations;
+    }
+    getType() {
+        return this.type;
+    }
+    getSuperTypes() {
+        return this.superTypes;
+    }
+    isProvisional() {
+        return this.provisional;
+    }
+    getPropertyDeclarations() {
+        return this.propertyDeclarations;
+    }
+    getCotypeDeclarationNode() {
+        const node = this.getNode(), cotypeDeclarationNode = node; ///
+        return cotypeDeclarationNode;
+    }
+    getProperties() {
+        const properties = this.propertyDeclarations.reduce((properties, propertyDeclaration)=>{
+            const property = propertyDeclaration.getProperty();
+            if (property !== null) {
+                properties.push(property);
+            }
+            return properties;
+        }, []);
+        return properties;
+    }
+    async verify(context) {
+        let verifies = false;
+        await this.break(context);
+        const cotypeDeclarationString = this.getString(); ///
+        context.trace(`Verifying the '${cotypeDeclarationString}' cotype declaration...`);
+        const typeVerifies = this.verifyType(context);
+        if (typeVerifies) {
+            const superTypesVerify = this.verifySuperTypes(context);
+            if (superTypesVerify) {
+                const typePrefixVerifies = this.verifyTypePrefix(context);
+                if (typePrefixVerifies) {
+                    const propertyDeclarationsVerify = await this.verifyPropertyDeclaratisons(context);
+                    if (propertyDeclarationsVerify) {
+                        const properties = this.getProperties(), typePrefix = context.getTypePrefix(), prefixName = typePrefix !== null ? typePrefix.getPrefixName() : null;
+                        this.type.setProvisional(this.provisional);
+                        this.type.setProperties(properties);
+                        this.type.setPrefixName(prefixName);
+                        context.addType(this.type);
+                        verifies = true;
+                    }
+                }
+            }
+        }
+        if (verifies) {
+            context.debug(`...verified the '${cotypeDeclarationString}' cotype declaration.`);
+        }
+        return verifies;
+    }
+    verifyType(context) {
+        let typeVerifies = false;
+        const typeString = this.type.getString(), cotypeDeclarationString = this.getString(); ///
+        context.trace(`Verifying the '${cotypeDeclarationString}' cotype declaration's '${typeString}' type...`);
+        const typeName = this.type.getName(), includeRelease = false, typePresent = context.isTypePresentByTypeName(typeName, includeRelease);
+        if (!typePresent) {
+            const prefixedTypeName = typeName, typePresent = context.isTypePresentByPrefixedTypeName(prefixedTypeName);
+            if (!typePresent) {
+                this.type.setProvisional(this.provisional);
+                typeVerifies = true;
+            } else {
+                context.debug(`The '${typeString}' type is already present.`);
+            }
+        } else {
+            context.debug(`The '${typeString}' type is already present.`);
+        }
+        if (typeVerifies) {
+            context.debug(`...verified the '${cotypeDeclarationString}' cotype declaration's '${typeString}' type`);
+        }
+        return typeVerifies;
+    }
+    verifySuperType(superType, superTypes, context) {
+        let superTypeVerifies = false;
+        const superTypeString = superType.getString(), cotypeDeclarationString = this.getString(); ///
+        context.trace(`Verifying the '${cotypeDeclarationString}' cotype declaration's '${superTypeString}' super-type...`);
+        const nominalTypeName = superType.getNominalTypeName(), typeName = nominalTypeName, typeComparesToTypeName = this.type.compareTypeName(typeName);
+        if (!typeComparesToTypeName) {
+            superType = context.findTypeByNominalTypeName(nominalTypeName);
+            if (superType !== null) {
+                superTypes.push(superType);
+                superTypeVerifies = true;
+            } else {
+                context.debug(`The '${superTypeString}' super-type is not present.`);
+            }
+        } else {
+            context.debug(`The '${superTypeString}' super-type's name compares to the ${typeName}' type's name.`);
+        }
+        if (superTypeVerifies) {
+            context.debug(`...verified the '${cotypeDeclarationString}' cotype declaration's '${superTypeString}' super-type.`);
+        }
+        return superTypeVerifies;
+    }
+    verifySuperTypes(context) {
+        let superTypesVerify;
+        const superTypes = [], cotypeDeclarationString = this.getString(); ///
+        context.trace(`Verifying the '${cotypeDeclarationString}' cotype declaration's super-types...`);
+        superTypesVerify = this.superTypes.every((superType)=>{
+            const superTypeVerifies = this.verifySuperType(superType, superTypes, context);
+            if (superTypeVerifies) {
+                return true;
+            }
+        });
+        if (superTypesVerify) {
+            const superTypesLength = superTypes.length;
+            if (superTypesLength === 0) {
+                const baseType = (0, _type.baseTypeFromNothing)(), superTyupe = baseType; ///
+                superTypes.push(superTyupe);
+            }
+            this.type.setSuperTypes(superTypes);
+            context.debug(`...verified the '${cotypeDeclarationString}' cotype declaration's super-types.`);
+        }
+        return superTypesVerify;
+    }
+    verifyTypePrefix(context) {
+        let typePrefixVerifies = false;
+        const typeString = this.type.getString(), cotypeDeclarationString = this.getString(); ///
+        context.trace(`Verifying the '${cotypeDeclarationString}' cotype declaration's '${typeString}' type's prefix...`);
+        const typePrefixed = this.type.isPrefixed();
+        if (!typePrefixed) {
+            typePrefixVerifies = true;
+        } else {
+            context.debug(`The '${cotypeDeclarationString}' cotype declaration's '${typeString}' type is prefixed.`);
+        }
+        if (typePrefixVerifies) {
+            context.debug(`...verified the '${cotypeDeclarationString}' cotype declaration's '${typeString}' type's prefix.`);
+        }
+        return typePrefixVerifies;
+    }
+    async verifyPropertyDeclaratisons(context) {
+        let propertyDeclarationsVerify;
+        const typeString = this.type.getString(), cotypeDeclarationString = this.getString(); ///
+        context.trace(`Verifying the '${cotypeDeclarationString}' cotype declaration's '${typeString}' type's property declarations...`);
+        const properties = this.getProperties();
+        propertyDeclarationsVerify = await asyncEvery(this.propertyDeclarations, async (propertyDeclaration)=>{
+            const propertyVerifes = await propertyDeclaration.verify(properties, this.type, context);
+            if (propertyVerifes) {
+                return true;
+            }
+        });
+        if (propertyDeclarationsVerify) {
+            context.debug(`...verified the '${cotypeDeclarationString}' cotype declaration's '${typeString}' type's property declarations.`);
+        }
+        return propertyDeclarationsVerify;
+    }
+    static name = "CotypeDeclaration";
+});
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/declaration/cotype.js"],"sourcesContent":["\"use strict\";\n\nimport Declaration from \"../declaration\";\n\nimport { asynchronousUtilities } from \"occam-languages\";\n\nimport { define } from \"../../elements\";\nimport { baseTypeFromNothing } from \"../../utilities/type\";\n\nconst { asyncEvery } = asynchronousUtilities;\n\nexport default define(class CotypeDeclaration extends Declaration {\n  constructor(context, string, node, breakPoint, type, superTypes, provisional, propertyDeclarations) {\n    super(context, string, node, breakPoint);\n\n    this.type = type;\n    this.superTypes = superTypes;\n    this.provisional = provisional;\n    this.propertyDeclarations = propertyDeclarations;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  getSuperTypes() {\n    return this.superTypes;\n  }\n\n  isProvisional() {\n    return this.provisional;\n  }\n\n  getPropertyDeclarations() {\n    return this.propertyDeclarations;\n  }\n\n  getCotypeDeclarationNode() {\n    const node = this.getNode(),\n          cotypeDeclarationNode = node; ///\n\n    return cotypeDeclarationNode;\n  }\n\n  getProperties() {\n    const properties = this.propertyDeclarations.reduce((properties, propertyDeclaration) => {\n      const property = propertyDeclaration.getProperty();\n\n      if (property !== null) {\n        properties.push(property);\n      }\n\n      return properties;\n    }, []);\n\n    return properties;\n  }\n\n  async verify(context) {\n    let verifies = false;\n\n    await this.break(context);\n\n    const cotypeDeclarationString = this.getString();  ///\n\n    context.trace(`Verifying the '${cotypeDeclarationString}' cotype declaration...`);\n\n    const typeVerifies = this.verifyType(context);\n\n    if (typeVerifies) {\n      const superTypesVerify = this.verifySuperTypes(context);\n\n      if (superTypesVerify) {\n        const typePrefixVerifies = this.verifyTypePrefix(context);\n\n        if (typePrefixVerifies) {\n          const propertyDeclarationsVerify = await this.verifyPropertyDeclaratisons(context);\n\n          if (propertyDeclarationsVerify) {\n            const properties = this.getProperties(),\n                  typePrefix = context.getTypePrefix(),\n                  prefixName = (typePrefix !== null) ?\n                                 typePrefix.getPrefixName() :\n                                   null;\n\n            this.type.setProvisional(this.provisional);\n\n            this.type.setProperties(properties);\n\n            this.type.setPrefixName(prefixName);\n\n            context.addType(this.type);\n\n            verifies = true;\n          }\n        }\n      }\n    }\n\n    if (verifies) {\n      context.debug(`...verified the '${cotypeDeclarationString}' cotype declaration.`);\n    }\n\n    return verifies;\n  }\n\n  verifyType(context) {\n    let typeVerifies = false;\n\n    const typeString = this.type.getString(),\n          cotypeDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${cotypeDeclarationString}' cotype declaration's '${typeString}' type...`);\n\n    const typeName = this.type.getName(),\n          includeRelease = false,\n          typePresent = context.isTypePresentByTypeName(typeName, includeRelease);\n\n    if (!typePresent) {\n      const prefixedTypeName = typeName, ///\n            typePresent = context.isTypePresentByPrefixedTypeName(prefixedTypeName);\n\n      if (!typePresent) {\n        this.type.setProvisional(this.provisional);\n\n        typeVerifies = true;\n      } else {\n        context.debug(`The '${typeString}' type is already present.`);\n      }\n    } else {\n      context.debug(`The '${typeString}' type is already present.`);\n    }\n\n    if (typeVerifies) {\n      context.debug(`...verified the '${cotypeDeclarationString}' cotype declaration's '${typeString}' type`);\n    }\n\n    return typeVerifies;\n  }\n\n  verifySuperType(superType, superTypes, context) {\n    let superTypeVerifies = false;\n\n    const superTypeString = superType.getString(),\n          cotypeDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${cotypeDeclarationString}' cotype declaration's '${superTypeString}' super-type...`);\n\n    const nominalTypeName = superType.getNominalTypeName(),\n          typeName = nominalTypeName, ///\n          typeComparesToTypeName = this.type.compareTypeName(typeName);\n\n    if (!typeComparesToTypeName) {\n      superType = context.findTypeByNominalTypeName(nominalTypeName);\n\n      if (superType !== null) {\n        superTypes.push(superType);\n\n        superTypeVerifies = true;\n      } else {\n        context.debug(`The '${superTypeString}' super-type is not present.`);\n      }\n    } else {\n      context.debug(`The '${superTypeString}' super-type's name compares to the ${typeName}' type's name.`);\n    }\n\n    if (superTypeVerifies) {\n      context.debug(`...verified the '${cotypeDeclarationString}' cotype declaration's '${superTypeString}' super-type.`);\n    }\n\n    return superTypeVerifies;\n  }\n\n  verifySuperTypes(context) {\n    let superTypesVerify;\n\n    const superTypes = [],\n          cotypeDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${cotypeDeclarationString}' cotype declaration's super-types...`);\n\n    superTypesVerify = this.superTypes.every((superType) => {\n      const superTypeVerifies = this.verifySuperType(superType, superTypes, context);\n\n      if (superTypeVerifies) {\n        return true;\n      }\n    });\n\n    if (superTypesVerify) {\n      const superTypesLength = superTypes.length;\n\n      if (superTypesLength === 0) {\n        const baseType = baseTypeFromNothing(),\n              superTyupe = baseType;  ///\n\n        superTypes.push(superTyupe);\n      }\n\n      this.type.setSuperTypes(superTypes);\n\n      context.debug(`...verified the '${cotypeDeclarationString}' cotype declaration's super-types.`);\n    }\n\n    return superTypesVerify;\n  }\n\n  verifyTypePrefix(context) {\n    let typePrefixVerifies = false;\n\n    const typeString = this.type.getString(),\n          cotypeDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${cotypeDeclarationString}' cotype declaration's '${typeString}' type's prefix...`);\n\n    const typePrefixed = this.type.isPrefixed();\n\n    if (!typePrefixed) {\n      typePrefixVerifies = true;\n    } else {\n      context.debug(`The '${cotypeDeclarationString}' cotype declaration's '${typeString}' type is prefixed.`);\n    }\n\n    if (typePrefixVerifies) {\n      context.debug(`...verified the '${cotypeDeclarationString}' cotype declaration's '${typeString}' type's prefix.`);\n    }\n\n    return typePrefixVerifies;\n  }\n\n  async verifyPropertyDeclaratisons(context) {\n    let propertyDeclarationsVerify;\n\n    const typeString = this.type.getString(),\n          cotypeDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${cotypeDeclarationString}' cotype declaration's '${typeString}' type's property declarations...`);\n\n    const properties = this.getProperties();\n\n    propertyDeclarationsVerify = await asyncEvery(this.propertyDeclarations, async (propertyDeclaration) => {\n      const propertyVerifes = await propertyDeclaration.verify(properties, this.type, context);\n\n      if (propertyVerifes) {\n        return true;\n      }\n    });\n\n    if (propertyDeclarationsVerify) {\n      context.debug(`...verified the '${cotypeDeclarationString}' cotype declaration's '${typeString}' type's property declarations.`);\n    }\n\n    return propertyDeclarationsVerify;\n  }\n\n  static name = \"CotypeDeclaration\";\n});\n"],"names":["asyncEvery","asynchronousUtilities","define","CotypeDeclaration","Declaration","context","string","node","breakPoint","type","superTypes","provisional","propertyDeclarations","getType","getSuperTypes","isProvisional","getPropertyDeclarations","getCotypeDeclarationNode","getNode","cotypeDeclarationNode","getProperties","properties","reduce","propertyDeclaration","property","getProperty","push","verify","verifies","break","cotypeDeclarationString","getString","trace","typeVerifies","verifyType","superTypesVerify","verifySuperTypes","typePrefixVerifies","verifyTypePrefix","propertyDeclarationsVerify","verifyPropertyDeclaratisons","typePrefix","getTypePrefix","prefixName","getPrefixName","setProvisional","setProperties","setPrefixName","addType","debug","typeString","typeName","getName","includeRelease","typePresent","isTypePresentByTypeName","prefixedTypeName","isTypePresentByPrefixedTypeName","verifySuperType","superType","superTypeVerifies","superTypeString","nominalTypeName","getNominalTypeName","typeComparesToTypeName","compareTypeName","findTypeByNominalTypeName","every","superTypesLength","length","baseType","baseTypeFromNothing","superTyupe","setSuperTypes","typePrefixed","isPrefixed","propertyVerifes","name"],"mappings":"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"}

package/lib/element/declaration/generator.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _declaration = /*#__PURE__*/ _interop_require_default(require("../declaration"));
+const _elements = require("../../elements");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const _default = (0, _elements.define)(class GeneratorDeclaration extends _declaration.default {
+    constructor(context, string, node, breakPoint, type, provisional, generator){
+        super(context, string, node, breakPoint);
+        this.type = type;
+        this.provisional = provisional;
+        this.generator = generator;
+    }
+    getType() {
+        return this.type;
+    }
+    isProvisional() {
+        return this.provisional;
+    }
+    getGenerator() {
+        return this.generator;
+    }
+    getGeneratorDeclarationNode() {
+        const node = this.getNode(), generatorDeclarationNode = node; ///
+        return generatorDeclarationNode;
+    }
+    async verify(context) {
+        let verifies = false;
+        await this.break(context);
+        const generatorDeclarationString = this.getString(); ///
+        context.trace(`Verifying the '${generatorDeclarationString}' generator declaration...`);
+        const typeVerified = this.verifyType(context);
+        if (typeVerified) {
+            const generatorValidates = this.validateGenerator(context);
+            if (generatorValidates) {
+                this.generator.setType(this.type);
+                context.addGenerator(this.generator);
+                verifies = true;
+            }
+        }
+        if (verifies) {
+            context.debug(`...verified the '${generatorDeclarationString}' generator declaration.`);
+        }
+        return verifies;
+    }
+    verifyType(context) {
+        let typeVerifies = false;
+        const generatorDeclarationString = this.getString(); ///
+        context.trace(`Verifying the '${generatorDeclarationString}' generator declaration's type...`);
+        const nominalTypeName = this.type.getNominalTypeName(), type = context.findTypeByNominalTypeName(nominalTypeName);
+        if (type !== null) {
+            const provisional = this.isProvisional(), typeComparesToProvisional = type.compareProvisional(provisional);
+            if (!typeComparesToProvisional) {
+                const typeString = this.type.getString();
+                provisional ? context.debug(`The '${typeString}' type is present but not provisional.`) : context.debug(`The '${typeString}' type is present but provisional.`);
+            } else {
+                this.type = type;
+                typeVerifies = true;
+            }
+        } else {
+            const typeString = this.type.getString();
+            context.debug(`The '${typeString}' type is not present.`);
+        }
+        if (typeVerifies) {
+            context.debug(`...verified the '${generatorDeclarationString}' generator declaration's type.`);
+        }
+        return typeVerifies;
+    }
+    validateGenerator(context) {
+        let generatorValidates;
+        const includeType = false, generatorString = this.generator.getString(includeType), generatorDeclarationString = this.getString(); ///
+        context.trace(`Validating the '${generatorDeclarationString}' generator declaration's '${generatorString}' generator...`);
+        generatorValidates = this.generator.validate(context);
+        if (generatorValidates) {
+            context.debug(`...validated the '${generatorDeclarationString}' generator declaration's '${generatorString}' generator.`);
+        }
+        return generatorValidates;
+    }
+    static name = "GeneratorDeclaration";
+});
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/declaration/generator.js"],"sourcesContent":["\"use strict\";\n\nimport Declaration from \"../declaration\";\n\nimport { define } from \"../../elements\";\n\nexport default define(class GeneratorDeclaration extends Declaration {\n  constructor(context, string, node, breakPoint, type, provisional, generator) {\n    super(context, string, node, breakPoint);\n\n    this.type = type;\n    this.provisional = provisional;\n    this.generator = generator;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  isProvisional() {\n    return this.provisional;\n  }\n\n  getGenerator() {\n    return this.generator;\n  }\n\n  getGeneratorDeclarationNode() {\n    const node = this.getNode(),\n          generatorDeclarationNode = node; ///\n\n    return generatorDeclarationNode;\n  }\n\n  async verify(context) {\n    let verifies = false;\n\n    await this.break(context);\n\n    const generatorDeclarationString = this.getString();  ///\n\n    context.trace(`Verifying the '${generatorDeclarationString}' generator declaration...`);\n\n    const typeVerified = this.verifyType(context);\n\n    if (typeVerified) {\n      const generatorValidates = this.validateGenerator(context);\n\n      if (generatorValidates) {\n        this.generator.setType(this.type);\n\n        context.addGenerator(this.generator);\n\n        verifies = true;\n      }\n    }\n\n    if (verifies) {\n      context.debug(`...verified the '${generatorDeclarationString}' generator declaration.`);\n    }\n\n    return verifies;\n  }\n\n  verifyType(context) {\n    let typeVerifies = false;\n\n    const generatorDeclarationString = this.getString();  ///\n\n    context.trace(`Verifying the '${generatorDeclarationString}' generator declaration's type...`);\n\n    const nominalTypeName = this.type.getNominalTypeName(),\n          type = context.findTypeByNominalTypeName(nominalTypeName);\n\n    if (type !== null) {\n      const provisional = this.isProvisional(),\n            typeComparesToProvisional = type.compareProvisional(provisional);\n\n      if (!typeComparesToProvisional) {\n        const typeString = this.type.getString();\n\n        provisional ?\n          context.debug(`The '${typeString}' type is present but not provisional.`) :\n            context.debug(`The '${typeString}' type is present but provisional.`);\n      } else {\n        this.type = type;\n\n        typeVerifies = true;\n      }\n    } else {\n      const typeString = this.type.getString();\n\n      context.debug(`The '${typeString}' type is not present.`);\n    }\n\n    if (typeVerifies) {\n      context.debug(`...verified the '${generatorDeclarationString}' generator declaration's type.`);\n    }\n\n    return typeVerifies;\n  }\n\n  validateGenerator(context) {\n    let generatorValidates;\n\n    const includeType = false,\n          generatorString = this.generator.getString(includeType),\n          generatorDeclarationString = this.getString();  ///\n\n    context.trace(`Validating the '${generatorDeclarationString}' generator declaration's '${generatorString}' generator...`);\n\n    generatorValidates = this.generator.validate(context);\n\n    if (generatorValidates) {\n      context.debug(`...validated the '${generatorDeclarationString}' generator declaration's '${generatorString}' generator.`);\n    }\n\n    return generatorValidates;\n  }\n\n  static name = \"GeneratorDeclaration\";\n});\n"],"names":["define","GeneratorDeclaration","Declaration","context","string","node","breakPoint","type","provisional","generator","getType","isProvisional","getGenerator","getGeneratorDeclarationNode","getNode","generatorDeclarationNode","verify","verifies","break","generatorDeclarationString","getString","trace","typeVerified","verifyType","generatorValidates","validateGenerator","setType","addGenerator","debug","typeVerifies","nominalTypeName","getNominalTypeName","findTypeByNominalTypeName","typeComparesToProvisional","compareProvisional","typeString","includeType","generatorString","validate","name"],"mappings":"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"}

package/lib/element/declaration/type.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _declaration = /*#__PURE__*/ _interop_require_default(require("../declaration"));
+const _elements = require("../../elements");
+const _type = require("../../utilities/type");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const _default = (0, _elements.define)(class TypeDeclaration extends _declaration.default {
+    constructor(context, string, node, breakPoint, type, superTypes, provisional){
+        super(context, string, node, breakPoint);
+        this.type = type;
+        this.superTypes = superTypes;
+        this.provisional = provisional;
+    }
+    getType() {
+        return this.type;
+    }
+    getSuperTypes() {
+        return this.superTypes;
+    }
+    isProvisional() {
+        return this.provisional;
+    }
+    gettypeDeclarationNode() {
+        const node = this.getNode(), typeDeclarationNode = node; ///
+        return typeDeclarationNode;
+    }
+    getProperties() {
+        const properties = [];
+        return properties;
+    }
+    async verify(context) {
+        let verifies = false;
+        await this.break(context);
+        const typeDeclarationString = this.getString(); ///
+        context.trace(`Verifying the '${typeDeclarationString}' type declaration...`);
+        const typeVerifies = this.verifyType(context);
+        if (typeVerifies) {
+            const superTypesVerify = this.verifySuperTypes(context);
+            if (superTypesVerify) {
+                const typePrefixVerifies = this.verifyTypePrefix(context);
+                if (typePrefixVerifies) {
+                    const properties = this.getProperties(), typePrefix = context.getTypePrefix(), prefixName = typePrefix !== null ? typePrefix.getPrefixName() : null;
+                    this.type.setProvisional(this.provisional);
+                    this.type.setProperties(properties);
+                    this.type.setPrefixName(prefixName);
+                    context.addType(this.type);
+                    verifies = true;
+                }
+            }
+        }
+        if (verifies) {
+            context.debug(`...verified the '${typeDeclarationString}' type declaration.`);
+        }
+        return verifies;
+    }
+    verifyType(context) {
+        let typeVerifies = false;
+        const typeString = this.type.getString(), typeDeclarationString = this.getString(); ///
+        context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${typeString}' type...`);
+        const typeName = this.type.getName(), typePresent = context.isTypePresentByTypeName(typeName);
+        if (!typePresent) {
+            const prefixedTypeName = typeName, typePresent = context.isTypePresentByPrefixedTypeName(prefixedTypeName);
+            if (!typePresent) {
+                typeVerifies = true;
+            } else {
+                context.debug(`The '${typeString}' type is already present.`);
+            }
+        } else {
+            context.debug(`The '${typeString}' type is already present.`);
+        }
+        if (typeVerifies) {
+            context.debug(`...verified the '${typeDeclarationString}' type declaration's '${typeString}' type`);
+        }
+        return typeVerifies;
+    }
+    verifySuperType(superType, superTypes, context) {
+        let superTypeVerifies = false;
+        const superTypeString = superType.getString(), typeDeclarationString = this.getString(); ///
+        context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${superTypeString}' super-type...`);
+        const nominalTypeName = superType.getNominalTypeName(), typeName = nominalTypeName, typeComparesToTypeName = this.type.compareTypeName(typeName);
+        if (!typeComparesToTypeName) {
+            superType = context.findTypeByNominalTypeName(nominalTypeName);
+            if (superType !== null) {
+                superTypes.push(superType);
+                superTypeVerifies = true;
+            } else {
+                context.debug(`The '${superTypeString}' super-type is not present.`);
+            }
+        } else {
+            context.debug(`The '${superTypeString}' super-type's name compares to the ${typeName}' type's name.`);
+        }
+        if (superTypeVerifies) {
+            context.debug(`...verified the '${typeDeclarationString}' type declaration's '${superTypeString}' super-type.`);
+        }
+        return superTypeVerifies;
+    }
+    verifySuperTypes(context) {
+        let superTypesVerify;
+        const superTypes = [], typeDeclarationString = this.getString(); ///
+        context.trace(`Verifying the '${typeDeclarationString}' type declaration's super-types...`);
+        superTypesVerify = this.superTypes.every((superType)=>{
+            const superTypeVerifies = this.verifySuperType(superType, superTypes, context);
+            if (superTypeVerifies) {
+                return true;
+            }
+        });
+        if (superTypesVerify) {
+            const superTypesLength = superTypes.length;
+            if (superTypesLength === 0) {
+                const baseType = (0, _type.baseTypeFromNothing)(), superTyupe = baseType; ///
+                superTypes.push(superTyupe);
+            }
+            this.type.setSuperTypes(superTypes);
+            context.debug(`...verified the '${typeDeclarationString}' type declaration's super-types.`);
+        }
+        return superTypesVerify;
+    }
+    verifyTypePrefix(context) {
+        let typePrefixVerifies = false;
+        const typeString = this.type.getString(), typeDeclarationString = this.getString(); ///
+        context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${typeString}' type's prefix...`);
+        const typePrefixed = this.type.isPrefixed();
+        if (!typePrefixed) {
+            typePrefixVerifies = true;
+        } else {
+            context.debug(`The '${typeDeclarationString}' type declaration's '${typeString}' type is prefixed.`);
+        }
+        if (typePrefixVerifies) {
+            context.debug(`...verified the '${typeDeclarationString}' type declaration's '${typeString}' type's prefix.`);
+        }
+        return typePrefixVerifies;
+    }
+    static name = "TypeDeclaration";
+});
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/declaration/type.js"],"sourcesContent":["\"use strict\";\n\nimport Declaration from \"../declaration\";\n\nimport { define } from \"../../elements\";\nimport { baseTypeFromNothing } from \"../../utilities/type\";\n\nexport default define(class TypeDeclaration extends Declaration {\n  constructor(context, string, node, breakPoint, type, superTypes, provisional) {\n    super(context, string, node, breakPoint);\n\n    this.type = type;\n    this.superTypes = superTypes;\n    this.provisional = provisional;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  getSuperTypes() {\n    return this.superTypes;\n  }\n\n  isProvisional() {\n    return this.provisional;\n  }\n\n  gettypeDeclarationNode() {\n    const node = this.getNode(),\n          typeDeclarationNode = node; ///\n\n    return typeDeclarationNode;\n  }\n\n  getProperties() {\n    const properties = [];\n\n    return properties;\n  }\n\n  async verify(context) {\n    let verifies = false;\n\n    await this.break(context);\n\n    const typeDeclarationString = this.getString();  ///\n\n    context.trace(`Verifying the '${typeDeclarationString}' type declaration...`);\n\n    const typeVerifies = this.verifyType(context);\n\n    if (typeVerifies) {\n      const superTypesVerify = this.verifySuperTypes(context);\n\n      if (superTypesVerify) {\n        const typePrefixVerifies = this.verifyTypePrefix(context);\n\n        if (typePrefixVerifies) {\n          const properties = this.getProperties(),\n                typePrefix = context.getTypePrefix(),\n                prefixName = (typePrefix !== null) ?\n                               typePrefix.getPrefixName() :\n                                 null;\n\n          this.type.setProvisional(this.provisional);\n\n          this.type.setProperties(properties);\n\n          this.type.setPrefixName(prefixName);\n\n          context.addType(this.type);\n\n          verifies = true;\n        }\n      }\n    }\n\n    if (verifies) {\n      context.debug(`...verified the '${typeDeclarationString}' type declaration.`);\n    }\n\n    return verifies;\n  }\n\n  verifyType(context) {\n    let typeVerifies = false;\n\n    const typeString = this.type.getString(),\n          typeDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${typeString}' type...`);\n\n    const typeName = this.type.getName(),\n          typePresent = context.isTypePresentByTypeName(typeName);\n\n    if (!typePresent) {\n      const prefixedTypeName = typeName, ///\n            typePresent = context.isTypePresentByPrefixedTypeName(prefixedTypeName);\n\n      if (!typePresent) {\n        typeVerifies = true;\n      } else {\n        context.debug(`The '${typeString}' type is already present.`);\n      }\n    } else {\n      context.debug(`The '${typeString}' type is already present.`);\n    }\n\n    if (typeVerifies) {\n      context.debug(`...verified the '${typeDeclarationString}' type declaration's '${typeString}' type`);\n    }\n\n    return typeVerifies;\n  }\n\n  verifySuperType(superType, superTypes, context) {\n    let superTypeVerifies = false;\n\n    const superTypeString = superType.getString(),\n          typeDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${superTypeString}' super-type...`);\n\n    const nominalTypeName = superType.getNominalTypeName(),\n          typeName = nominalTypeName, ///\n          typeComparesToTypeName = this.type.compareTypeName(typeName);\n\n    if (!typeComparesToTypeName) {\n      superType = context.findTypeByNominalTypeName(nominalTypeName);\n\n      if (superType !== null) {\n        superTypes.push(superType);\n\n        superTypeVerifies = true;\n      } else {\n        context.debug(`The '${superTypeString}' super-type is not present.`);\n      }\n    } else {\n      context.debug(`The '${superTypeString}' super-type's name compares to the ${typeName}' type's name.`);\n    }\n\n    if (superTypeVerifies) {\n      context.debug(`...verified the '${typeDeclarationString}' type declaration's '${superTypeString}' super-type.`);\n    }\n\n    return superTypeVerifies;\n  }\n\n  verifySuperTypes(context) {\n    let superTypesVerify;\n\n    const superTypes = [],\n          typeDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${typeDeclarationString}' type declaration's super-types...`);\n\n    superTypesVerify = this.superTypes.every((superType) => {\n      const superTypeVerifies = this.verifySuperType(superType, superTypes, context);\n\n      if (superTypeVerifies) {\n        return true;\n      }\n    });\n\n    if (superTypesVerify) {\n      const superTypesLength = superTypes.length;\n\n      if (superTypesLength === 0) {\n        const baseType = baseTypeFromNothing(),\n              superTyupe = baseType;  ///\n\n        superTypes.push(superTyupe);\n      }\n\n      this.type.setSuperTypes(superTypes);\n\n      context.debug(`...verified the '${typeDeclarationString}' type declaration's super-types.`);\n    }\n\n    return superTypesVerify;\n  }\n\n  verifyTypePrefix(context) {\n    let typePrefixVerifies = false;\n\n    const typeString = this.type.getString(),\n          typeDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${typeString}' type's prefix...`);\n\n    const typePrefixed = this.type.isPrefixed();\n\n    if (!typePrefixed) {\n      typePrefixVerifies = true;\n    } else {\n      context.debug(`The '${typeDeclarationString}' type declaration's '${typeString}' type is prefixed.`);\n    }\n\n    if (typePrefixVerifies) {\n      context.debug(`...verified the '${typeDeclarationString}' type declaration's '${typeString}' type's prefix.`);\n    }\n\n    return typePrefixVerifies;\n  }\n\n  static name = \"TypeDeclaration\";\n});\n"],"names":["define","TypeDeclaration","Declaration","context","string","node","breakPoint","type","superTypes","provisional","getType","getSuperTypes","isProvisional","gettypeDeclarationNode","getNode","typeDeclarationNode","getProperties","properties","verify","verifies","break","typeDeclarationString","getString","trace","typeVerifies","verifyType","superTypesVerify","verifySuperTypes","typePrefixVerifies","verifyTypePrefix","typePrefix","getTypePrefix","prefixName","getPrefixName","setProvisional","setProperties","setPrefixName","addType","debug","typeString","typeName","getName","typePresent","isTypePresentByTypeName","prefixedTypeName","isTypePresentByPrefixedTypeName","verifySuperType","superType","superTypeVerifies","superTypeString","nominalTypeName","getNominalTypeName","typeComparesToTypeName","compareTypeName","findTypeByNominalTypeName","push","every","superTypesLength","length","baseType","baseTypeFromNothing","superTyupe","setSuperTypes","typePrefixed","isPrefixed","name"],"mappings":"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"}