occam-verify-cli 1.0.421 → 1.0.428

package/lib/element/declaration/simpleType.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _declaration = /*#__PURE__*/ _interop_require_default(require("../declaration"));
+var _elements = require("../../elements");
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+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 _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+var _SimpleTypeDeclaration;
+var _default = (0, _elements.define)((_SimpleTypeDeclaration = /*#__PURE__*/ function(Declaration) {
+    _inherits(SimpleTypeDeclaration, Declaration);
+    function SimpleTypeDeclaration(context, string, node, type, prefixed) {
+        _class_call_check(this, SimpleTypeDeclaration);
+        var _this;
+        _this = _call_super(this, SimpleTypeDeclaration, [
+            context,
+            string,
+            node
+        ]);
+        _this.type = type;
+        _this.prefixed = prefixed;
+        return _this;
+    }
+    _create_class(SimpleTypeDeclaration, [
+        {
+            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 node = this.getNode(), context = this.getContext(), simpleTypeDeclarationString = this.getString(); ///
+                context.trace("Verifying the '".concat(simpleTypeDeclarationString, "' simple type declaration..."), node);
+                if (this.prefixed) {
+                    var typeString = this.type.getString();
+                    context.trace("The '".concat(typeString, "' type is prefixed."));
+                } else {
+                    var typeVerifies = this.verifyType();
+                    if (typeVerifies) {
+                        var superTypesVerify = this.verifySuperTypes();
+                        if (superTypesVerify) {
+                            var typePrefix = context.getTypePrefix();
+                            if (typePrefix !== null) {
+                                var typePrefixName = typePrefix.getName(), prefixName = typePrefixName; ///
+                                this.type.setPrefixName(prefixName);
+                            }
+                            context.addType(this.type);
+                            verifies = true;
+                        }
+                    }
+                }
+                if (verifies) {
+                    context.debug("...verified the '".concat(simpleTypeDeclarationString, "' simple type declaration."), node);
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifyType",
+            value: function verifyType() {
+                var typeVerifies = false;
+                var node = this.getNode(), context = this.getContext(), typeString = this.type.getString();
+                context.trace("Verifying the '".concat(typeString, "' simple type..."), node);
+                var typeName = this.type.getName(), includeRelease = true, includeDependencies = false, typePresent = context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies);
+                if (typePresent) {
+                    context.trace("The '".concat(typeString, "' type is already present."), node);
+                } else {
+                    var prefixedTypeName = typeName, typePresent1 = context.isTypePresentByPrefixedTypeName(prefixedTypeName);
+                    if (typePresent1) {
+                        context.trace("The '".concat(typeString, "' type is already present."), node);
+                    } else {
+                        typeVerifies = true;
+                    }
+                }
+                if (typeVerifies) {
+                    context.trace("...verified the '".concat(typeString, "' simple type."), node);
+                }
+                return typeVerifies;
+            }
+        },
+        {
+            key: "verifySuperType",
+            value: function verifySuperType(superType) {
+                var superTypeVerifies = false;
+                var node = this.getNode(), context = this.getContext(), superTypeString = superType.getString();
+                context.trace("Verifying the '".concat(superTypeString, "' super-type..."), node);
+                var nominalTypeName = superType.getNominalTypeName(), typeName = nominalTypeName, typeNameMatches = this.type.matchTypeName(typeName);
+                if (typeNameMatches) {
+                    context.trace("The super-type's name matches the ".concat(typeName, "' simple type's name."), node);
+                } else {
+                    var oldSuperType = superType;
+                    superType = context.findTypeByNominalTypeName(nominalTypeName);
+                    var superTypePresent = superType !== null;
+                    if (superTypePresent) {
+                        var newSuperType = superType; ///
+                        this.type.replaceSuperType(oldSuperType, newSuperType);
+                        superTypeVerifies = true;
+                    }
+                }
+                if (superTypeVerifies) {
+                    context.debug("...verified the '".concat(superTypeString, "' super-type."), node);
+                }
+                return superTypeVerifies;
+            }
+        },
+        {
+            key: "verifySuperTypes",
+            value: function verifySuperTypes() {
+                var _this = this;
+                var superTypesVerify;
+                var node = this.getNode(), context = this.getContext(), typeString = this.type.getString();
+                context.trace("Verifying the '".concat(typeString, "' simple type's super-types..."), node);
+                var typeBasic = this.type.isBasic();
+                if (typeBasic) {
+                    superTypesVerify = true;
+                    context.trace("The '".concat(typeString, "' simple type is basic."), node);
+                } else {
+                    var superTypes = this.type.getSuperTypes();
+                    superTypesVerify = superTypes.every(function(superType) {
+                        var superTypeVerifies = _this.verifySuperType(superType);
+                        if (superTypeVerifies) {
+                            return true;
+                        }
+                    });
+                }
+                if (superTypesVerify) {
+                    context.debug("...verified the '".concat(typeString, "' simple type's super-types."), node);
+                }
+                return superTypesVerify;
+            }
+        }
+    ]);
+    return SimpleTypeDeclaration;
+}(_declaration.default), _define_property(_SimpleTypeDeclaration, "name", "SimpleTypeDeclaration"), _SimpleTypeDeclaration));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/declaration/simpleType.js"],"sourcesContent":["\"use strict\";\n\nimport Declaration from \"../declaration\";\n\nimport { define } from \"../../elements\";\n\nexport default define(class SimpleTypeDeclaration extends Declaration {\n  constructor(context, string, node, type, prefixed) {\n    super(context, string, node);\n\n    this.type = type;\n    this.prefixed = prefixed;\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 node = this.getNode(),\n          context = this.getContext(),\n          simpleTypeDeclarationString = this.getString();  ///\n\n    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration...`, node);\n\n    if (this.prefixed) {\n      const typeString = this.type.getString();\n\n      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 = context.getTypePrefix();\n\n          if (typePrefix !== null) {\n            const typePrefixName = typePrefix.getName(),\n                  prefixName = typePrefixName;  ///\n\n            this.type.setPrefixName(prefixName);\n          }\n\n          context.addType(this.type);\n\n          verifies = true;\n        }\n      }\n    }\n\n    if (verifies) {\n      context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration.`, node);\n    }\n\n    return verifies;\n  }\n\n  verifyType() {\n    let typeVerifies = false;\n\n    const node = this.getNode(),\n          context = this.getContext(),\n          typeString = this.type.getString();\n\n    context.trace(`Verifying the '${typeString}' simple type...`, node);\n\n    const typeName = this.type.getName(),\n          includeRelease = true,\n          includeDependencies = false,\n          typePresent = context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies);\n\n    if (typePresent) {\n      context.trace(`The '${typeString}' type is already present.`, node);\n    } else {\n      const prefixedTypeName = typeName, ///\n            typePresent = context.isTypePresentByPrefixedTypeName(prefixedTypeName);\n\n      if (typePresent) {\n        context.trace(`The '${typeString}' type is already present.`, node);\n      } else {\n        typeVerifies = true;\n      }\n    }\n\n    if (typeVerifies) {\n      context.trace(`...verified the '${typeString}' simple type.`, node);\n    }\n\n    return typeVerifies;\n  }\n\n  verifySuperType(superType) {\n    let superTypeVerifies = false;\n\n    const node = this.getNode(),\n          context = this.getContext(),\n          superTypeString = superType.getString();\n\n    context.trace(`Verifying the '${superTypeString}' super-type...`, node);\n\n    const nominalTypeName = superType.getNominalTypeName(),\n          typeName = nominalTypeName, ///\n          typeNameMatches = this.type.matchTypeName(typeName);\n\n    if (typeNameMatches) {\n      context.trace(`The super-type's name matches the ${typeName}' simple type's name.`, node);\n    } else {\n      const oldSuperType = superType;\n\n      superType = 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      context.debug(`...verified the '${superTypeString}' super-type.`, node);\n    }\n\n    return superTypeVerifies;\n  }\n\n  verifySuperTypes() {\n    let superTypesVerify;\n\n    const node = this.getNode(),\n          context = this.getContext(),\n          typeString = this.type.getString();\n\n    context.trace(`Verifying the '${typeString}' simple type's super-types...`, node);\n\n    const typeBasic = this.type.isBasic();\n\n    if (typeBasic) {\n      superTypesVerify = true;\n\n      context.trace(`The '${typeString}' simple type is basic.`, 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      context.debug(`...verified the '${typeString}' simple type's super-types.`, node);\n    }\n\n    return superTypesVerify;\n  }\n\n  static name = \"SimpleTypeDeclaration\";\n});\n"],"names":["define","SimpleTypeDeclaration","context","string","node","type","prefixed","getType","isPrefixed","verify","verifies","getNode","getContext","simpleTypeDeclarationString","getString","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","Declaration","name"],"mappings":"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"}

package/lib/element/declaration/typePrefix.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _declaration = /*#__PURE__*/ _interop_require_default(require("../declaration"));
+var _elements = require("../../elements");
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+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 _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+var _TypePrefixDeclaration;
+var _default = (0, _elements.define)((_TypePrefixDeclaration = /*#__PURE__*/ function(Declaration) {
+    _inherits(TypePrefixDeclaration, Declaration);
+    function TypePrefixDeclaration(context, string, node, typePrefix) {
+        _class_call_check(this, TypePrefixDeclaration);
+        var _this;
+        _this = _call_super(this, TypePrefixDeclaration, [
+            context,
+            string,
+            node
+        ]);
+        _this.typePrefix = typePrefix;
+        return _this;
+    }
+    _create_class(TypePrefixDeclaration, [
+        {
+            key: "getTypePrefix",
+            value: function getTypePrefix() {
+                return this.typePrefix;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify() {
+                var verifies = false;
+                var node = this.getNode(), context = this.getContext(), typePrefixDeclarationString = this.getString(); ///
+                context.trace("Verifying the '".concat(typePrefixDeclarationString, "' type prefix declaration..."), node);
+                var includeRelease = true, includeDependencies = false, types = context.getTypes(includeRelease, includeDependencies), typesLength = types.length;
+                if (typesLength > 0) {
+                    context.debug("Cannot verify the '".concat(typePrefixDeclarationString, "' type prefix declaration because types have already been declared."), node);
+                } else {
+                    var typePrefixVerifies = this.verifyTypePrefix();
+                    if (typePrefixVerifies) {
+                        context.addTypePrefix(this.typePrefix);
+                        verifies = true;
+                    }
+                }
+                if (verifies) {
+                    context.debug("...verified the '".concat(typePrefixDeclarationString, "' type prefix declaration."), node);
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifyTypePrefix",
+            value: function verifyTypePrefix() {
+                var typePrefixVerifies = false;
+                var node = this.getNode(), context = this.getContext(), typePrefixString = this.typePrefix.getString();
+                context.trace("Verifying the '".concat(typePrefixString, "' type prefix..."), node);
+                var typePrefix = context.getTypePrefix();
+                if (typePrefix !== null) {
+                    context.trace("The package already has a '".concat(typePrefixString, "' type prefix."), node);
+                } else {
+                    var typePrefixName = this.typePrefix.getName(), typePrefixPresent = context.isTypePrefixPresentByTypePrefixName(typePrefixName);
+                    if (typePrefixPresent) {
+                        context.trace("The '".concat(typePrefixString, "' type prefix is already present."), node);
+                    } else {
+                        var nominalTypeName = typePrefixName, typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
+                        if (typePresent) {
+                            context.trace("The '".concat(typePrefixString, "' type is already present."), node);
+                        } else {
+                            typePrefixVerifies = true;
+                        }
+                    }
+                }
+                if (typePrefixVerifies) {
+                    context.debug("...verified the '".concat(typePrefixString, "' type prefix."), node);
+                }
+                return typePrefixVerifies;
+            }
+        }
+    ]);
+    return TypePrefixDeclaration;
+}(_declaration.default), _define_property(_TypePrefixDeclaration, "name", "TypePrefixDeclaration"), _TypePrefixDeclaration));
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9lbGVtZW50L2RlY2xhcmF0aW9uL3R5cGVQcmVmaXguanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCBEZWNsYXJhdGlvbiBmcm9tIFwiLi4vZGVjbGFyYXRpb25cIjtcblxuaW1wb3J0IHsgZGVmaW5lIH0gZnJvbSBcIi4uLy4uL2VsZW1lbnRzXCI7XG5cbmV4cG9ydCBkZWZhdWx0IGRlZmluZShjbGFzcyBUeXBlUHJlZml4RGVjbGFyYXRpb24gZXh0ZW5kcyBEZWNsYXJhdGlvbiB7XG4gIGNvbnN0cnVjdG9yKGNvbnRleHQsIHN0cmluZywgbm9kZSwgdHlwZVByZWZpeCkge1xuICAgIHN1cGVyKGNvbnRleHQsIHN0cmluZywgbm9kZSk7XG5cbiAgICB0aGlzLnR5cGVQcmVmaXggPSB0eXBlUHJlZml4O1xuICB9XG5cbiAgZ2V0VHlwZVByZWZpeCgpIHtcbiAgICByZXR1cm4gdGhpcy50eXBlUHJlZml4O1xuICB9XG5cbiAgdmVyaWZ5KCkge1xuICAgIGxldCB2ZXJpZmllcyA9IGZhbHNlO1xuXG4gICAgY29uc3Qgbm9kZSA9IHRoaXMuZ2V0Tm9kZSgpLFxuICAgICAgICAgIGNvbnRleHQgPSB0aGlzLmdldENvbnRleHQoKSxcbiAgICAgICAgICB0eXBlUHJlZml4RGVjbGFyYXRpb25TdHJpbmcgPSB0aGlzLmdldFN0cmluZygpOyAgLy8vXG5cbiAgICBjb250ZXh0LnRyYWNlKGBWZXJpZnlpbmcgdGhlICcke3R5cGVQcmVmaXhEZWNsYXJhdGlvblN0cmluZ30nIHR5cGUgcHJlZml4IGRlY2xhcmF0aW9uLi4uYCwgbm9kZSk7XG5cbiAgICBjb25zdCBpbmNsdWRlUmVsZWFzZSA9IHRydWUsXG4gICAgICAgICAgaW5jbHVkZURlcGVuZGVuY2llcyA9IGZhbHNlLFxuICAgICAgICAgIHR5cGVzID0gY29udGV4dC5nZXRUeXBlcyhpbmNsdWRlUmVsZWFzZSwgaW5jbHVkZURlcGVuZGVuY2llcyksXG4gICAgICAgICAgdHlwZXNMZW5ndGggPSB0eXBlcy5sZW5ndGg7XG5cbiAgICBpZiAodHlwZXNMZW5ndGggPiAwKSB7XG4gICAgICBjb250ZXh0LmRlYnVnKGBDYW5ub3QgdmVyaWZ5IHRoZSAnJHt0eXBlUHJlZml4RGVjbGFyYXRpb25TdHJpbmd9JyB0eXBlIHByZWZpeCBkZWNsYXJhdGlvbiBiZWNhdXNlIHR5cGVzIGhhdmUgYWxyZWFkeSBiZWVuIGRlY2xhcmVkLmAsIG5vZGUpO1xuICAgIH0gZWxzZSB7XG4gICAgICBjb25zdCB0eXBlUHJlZml4VmVyaWZpZXMgPSB0aGlzLnZlcmlmeVR5cGVQcmVmaXgoKTtcblxuICAgICAgaWYgKHR5cGVQcmVmaXhWZXJpZmllcykge1xuICAgICAgICBjb250ZXh0LmFkZFR5cGVQcmVmaXgodGhpcy50eXBlUHJlZml4KTtcblxuICAgICAgICB2ZXJpZmllcyA9IHRydWU7XG4gICAgICB9XG4gICAgfVxuXG4gICAgaWYgKHZlcmlmaWVzKSB7XG4gICAgICBjb250ZXh0LmRlYnVnKGAuLi52ZXJpZmllZCB0aGUgJyR7dHlwZVByZWZpeERlY2xhcmF0aW9uU3RyaW5nfScgdHlwZSBwcmVmaXggZGVjbGFyYXRpb24uYCwgbm9kZSk7XG4gICAgfVxuXG4gICAgcmV0dXJuIHZlcmlmaWVzO1xuICB9XG5cbiAgdmVyaWZ5VHlwZVByZWZpeCgpIHtcbiAgICBsZXQgdHlwZVByZWZpeFZlcmlmaWVzID0gZmFsc2U7XG5cbiAgICBjb25zdCBub2RlID0gdGhpcy5nZXROb2RlKCksXG4gICAgICAgICAgY29udGV4dCA9IHRoaXMuZ2V0Q29udGV4dCgpLFxuICAgICAgICAgIHR5cGVQcmVmaXhTdHJpbmcgPSB0aGlzLnR5cGVQcmVmaXguZ2V0U3RyaW5nKCk7XG5cbiAgICBjb250ZXh0LnRyYWNlKGBWZXJpZnlpbmcgdGhlICcke3R5cGVQcmVmaXhTdHJpbmd9JyB0eXBlIHByZWZpeC4uLmAsIG5vZGUpO1xuXG4gICAgY29uc3QgdHlwZVByZWZpeCA9IGNvbnRleHQuZ2V0VHlwZVByZWZpeCgpO1xuXG4gICAgaWYgKHR5cGVQcmVmaXggIT09IG51bGwpIHtcbiAgICAgIGNvbnRleHQudHJhY2UoYFRoZSBwYWNrYWdlIGFscmVhZHkgaGFzIGEgJyR7dHlwZVByZWZpeFN0cmluZ30nIHR5cGUgcHJlZml4LmAsIG5vZGUpO1xuICAgIH0gZWxzZSB7XG5cbiAgICAgIGNvbnN0IHR5cGVQcmVmaXhOYW1lID0gdGhpcy50eXBlUHJlZml4LmdldE5hbWUoKSxcbiAgICAgICAgICAgIHR5cGVQcmVmaXhQcmVzZW50ID0gY29udGV4dC5pc1R5cGVQcmVmaXhQcmVzZW50QnlUeXBlUHJlZml4TmFtZSh0eXBlUHJlZml4TmFtZSk7XG5cbiAgICAgIGlmICh0eXBlUHJlZml4UHJlc2VudCkge1xuICAgICAgICBjb250ZXh0LnRyYWNlKGBUaGUgJyR7dHlwZVByZWZpeFN0cmluZ30nIHR5cGUgcHJlZml4IGlzIGFscmVhZHkgcHJlc2VudC5gLCBub2RlKTtcbiAgICAgIH0gZWxzZSB7XG4gICAgICAgIGNvbnN0IG5vbWluYWxUeXBlTmFtZSA9IHR5cGVQcmVmaXhOYW1lLCAgLy8vXG4gICAgICAgICAgICAgIHR5cGVQcmVzZW50ID0gY29udGV4dC5pc1R5cGVQcmVzZW50QnlOb21pbmFsVHlwZU5hbWUobm9taW5hbFR5cGVOYW1lKTtcblxuICAgICAgICBpZiAodHlwZVByZXNlbnQpIHtcbiAgICAgICAgICBjb250ZXh0LnRyYWNlKGBUaGUgJyR7dHlwZVByZWZpeFN0cmluZ30nIHR5cGUgaXMgYWxyZWFkeSBwcmVzZW50LmAsIG5vZGUpO1xuICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgIHR5cGVQcmVmaXhWZXJpZmllcyA9IHRydWU7XG4gICAgICAgIH1cbiAgICAgIH1cbiAgICB9XG5cbiAgICBpZiAodHlwZVByZWZpeFZlcmlmaWVzKSB7XG4gICAgICBjb250ZXh0LmRlYnVnKGAuLi52ZXJpZmllZCB0aGUgJyR7dHlwZVByZWZpeFN0cmluZ30nIHR5cGUgcHJlZml4LmAsIG5vZGUpO1xuICAgIH1cblxuICAgIHJldHVybiB0eXBlUHJlZml4VmVyaWZpZXM7XG4gIH1cblxuICBzdGF0aWMgbmFtZSA9IFwiVHlwZVByZWZpeERlY2xhcmF0aW9uXCI7XG59KTtcbiJdLCJuYW1lcyI6WyJkZWZpbmUiLCJUeXBlUHJlZml4RGVjbGFyYXRpb24iLCJjb250ZXh0Iiwic3RyaW5nIiwibm9kZSIsInR5cGVQcmVmaXgiLCJnZXRUeXBlUHJlZml4IiwidmVyaWZ5IiwidmVyaWZpZXMiLCJnZXROb2RlIiwiZ2V0Q29udGV4dCIsInR5cGVQcmVmaXhEZWNsYXJhdGlvblN0cmluZyIsImdldFN0cmluZyIsInRyYWNlIiwiaW5jbHVkZVJlbGVhc2UiLCJpbmNsdWRlRGVwZW5kZW5jaWVzIiwidHlwZXMiLCJnZXRUeXBlcyIsInR5cGVzTGVuZ3RoIiwibGVuZ3RoIiwiZGVidWciLCJ0eXBlUHJlZml4VmVyaWZpZXMiLCJ2ZXJpZnlUeXBlUHJlZml4IiwiYWRkVHlwZVByZWZpeCIsInR5cGVQcmVmaXhTdHJpbmciLCJ0eXBlUHJlZml4TmFtZSIsImdldE5hbWUiLCJ0eXBlUHJlZml4UHJlc2VudCIsImlzVHlwZVByZWZpeFByZXNlbnRCeVR5cGVQcmVmaXhOYW1lIiwibm9taW5hbFR5cGVOYW1lIiwidHlwZVByZXNlbnQiLCJpc1R5cGVQcmVzZW50QnlOb21pbmFsVHlwZU5hbWUiLCJEZWNsYXJhdGlvbiIsIm5hbWUiXSwibWFwcGluZ3MiOiJBQUFBOzs7OytCQU1BOzs7ZUFBQTs7O2tFQUp3Qjt3QkFFRDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0lBRXZCLFdBQWVBLElBQUFBLGdCQUFNLDBDQUFDOzthQUFNQyxzQkFDZEMsT0FBTyxFQUFFQyxNQUFNLEVBQUVDLElBQUksRUFBRUMsVUFBVTtnQ0FEbkJKOztnQkFFeEIsa0JBRndCQTtZQUVsQkM7WUFBU0M7WUFBUUM7O1FBRXZCLE1BQUtDLFVBQVUsR0FBR0E7Ozs7O1lBR3BCQyxLQUFBQTttQkFBQUEsU0FBQUE7Z0JBQ0UsT0FBTyxJQUFJLENBQUNELFVBQVU7WUFDeEI7OztZQUVBRSxLQUFBQTttQkFBQUEsU0FBQUE7Z0JBQ0UsSUFBSUMsV0FBVztnQkFFZixJQUFNSixPQUFPLElBQUksQ0FBQ0ssT0FBTyxJQUNuQlAsVUFBVSxJQUFJLENBQUNRLFVBQVUsSUFDekJDLDhCQUE4QixJQUFJLENBQUNDLFNBQVMsSUFBSyxHQUFHO2dCQUUxRFYsUUFBUVcsS0FBSyxDQUFDLEFBQUMsa0JBQTZDLE9BQTVCRiw2QkFBNEIsaUNBQStCUDtnQkFFM0YsSUFBTVUsaUJBQWlCLE1BQ2pCQyxzQkFBc0IsT0FDdEJDLFFBQVFkLFFBQVFlLFFBQVEsQ0FBQ0gsZ0JBQWdCQyxzQkFDekNHLGNBQWNGLE1BQU1HLE1BQU07Z0JBRWhDLElBQUlELGNBQWMsR0FBRztvQkFDbkJoQixRQUFRa0IsS0FBSyxDQUFDLEFBQUMsc0JBQWlELE9BQTVCVCw2QkFBNEIsd0VBQXNFUDtnQkFDeEksT0FBTztvQkFDTCxJQUFNaUIscUJBQXFCLElBQUksQ0FBQ0MsZ0JBQWdCO29CQUVoRCxJQUFJRCxvQkFBb0I7d0JBQ3RCbkIsUUFBUXFCLGFBQWEsQ0FBQyxJQUFJLENBQUNsQixVQUFVO3dCQUVyQ0csV0FBVztvQkFDYjtnQkFDRjtnQkFFQSxJQUFJQSxVQUFVO29CQUNaTixRQUFRa0IsS0FBSyxDQUFDLEFBQUMsb0JBQStDLE9BQTVCVCw2QkFBNEIsK0JBQTZCUDtnQkFDN0Y7Z0JBRUEsT0FBT0k7WUFDVDs7O1lBRUFjLEtBQUFBO21CQUFBQSxTQUFBQTtnQkFDRSxJQUFJRCxxQkFBcUI7Z0JBRXpCLElBQU1qQixPQUFPLElBQUksQ0FBQ0ssT0FBTyxJQUNuQlAsVUFBVSxJQUFJLENBQUNRLFVBQVUsSUFDekJjLG1CQUFtQixJQUFJLENBQUNuQixVQUFVLENBQUNPLFNBQVM7Z0JBRWxEVixRQUFRVyxLQUFLLENBQUMsQUFBQyxrQkFBa0MsT0FBakJXLGtCQUFpQixxQkFBbUJwQjtnQkFFcEUsSUFBTUMsYUFBYUgsUUFBUUksYUFBYTtnQkFFeEMsSUFBSUQsZUFBZSxNQUFNO29CQUN2QkgsUUFBUVcsS0FBSyxDQUFDLEFBQUMsOEJBQThDLE9BQWpCVyxrQkFBaUIsbUJBQWlCcEI7Z0JBQ2hGLE9BQU87b0JBRUwsSUFBTXFCLGlCQUFpQixJQUFJLENBQUNwQixVQUFVLENBQUNxQixPQUFPLElBQ3hDQyxvQkFBb0J6QixRQUFRMEIsbUNBQW1DLENBQUNIO29CQUV0RSxJQUFJRSxtQkFBbUI7d0JBQ3JCekIsUUFBUVcsS0FBSyxDQUFDLEFBQUMsUUFBd0IsT0FBakJXLGtCQUFpQixzQ0FBb0NwQjtvQkFDN0UsT0FBTzt3QkFDTCxJQUFNeUIsa0JBQWtCSixnQkFDbEJLLGNBQWM1QixRQUFRNkIsOEJBQThCLENBQUNGO3dCQUUzRCxJQUFJQyxhQUFhOzRCQUNmNUIsUUFBUVcsS0FBSyxDQUFDLEFBQUMsUUFBd0IsT0FBakJXLGtCQUFpQiwrQkFBNkJwQjt3QkFDdEUsT0FBTzs0QkFDTGlCLHFCQUFxQjt3QkFDdkI7b0JBQ0Y7Z0JBQ0Y7Z0JBRUEsSUFBSUEsb0JBQW9CO29CQUN0Qm5CLFFBQVFrQixLQUFLLENBQUMsQUFBQyxvQkFBb0MsT0FBakJJLGtCQUFpQixtQkFBaUJwQjtnQkFDdEU7Z0JBRUEsT0FBT2lCO1lBQ1Q7Ozs7RUFqRndEVyxvQkFBVyxHQW1GbkUseUNBQU9DLFFBQU8ifQ==

package/lib/element/declaration/variable.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _declaration = /*#__PURE__*/ _interop_require_default(require("../declaration"));
+var _elements = require("../../elements");
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+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 _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+var _VariableDeclaration;
+var _default = (0, _elements.define)((_VariableDeclaration = /*#__PURE__*/ function(Declaration) {
+    _inherits(VariableDeclaration, Declaration);
+    function VariableDeclaration(context, string, node, variable) {
+        _class_call_check(this, VariableDeclaration);
+        var _this;
+        _this = _call_super(this, VariableDeclaration, [
+            context,
+            string,
+            node
+        ]);
+        _this.variable = variable;
+        return _this;
+    }
+    _create_class(VariableDeclaration, [
+        {
+            key: "getVariable",
+            value: function getVariable() {
+                return this.variable;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify() {
+                var verifies = false;
+                var node = this.getNode(), context = this.getContext(), variableDeclarationString = this.getString(); ///
+                context.trace("Verifying the '".concat(variableDeclarationString, "' variable declaration..."), node);
+                var variableTypeVerifies = this.verifyVariableType();
+                if (variableTypeVerifies) {
+                    var variableVerifies = this.verifyVariable();
+                    if (variableVerifies) {
+                        context.addVariable(this.variable);
+                        verifies = true;
+                    }
+                }
+                if (verifies) {
+                    context.debug("...verified the '".concat(variableDeclarationString, "' variable declaration."), node);
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifyVariable",
+            value: function verifyVariable() {
+                var variableVerifies = false;
+                var node = this.getNode(), context = this.getContext(), variableString = this.variable.getString();
+                context.trace("Verifying the '".concat(variableString, "' variable..."), node);
+                var variableIdentifier = this.variable.getIdentifier(), variablePresent = context.isVariablePresentByVariableIdentifier(variableIdentifier);
+                if (variablePresent) {
+                    context.debug("The '".concat(variableName, "' variable is already present."), node);
+                } else {
+                    variableVerifies = true;
+                }
+                if (variableVerifies) {
+                    context.debug("...verified the '".concat(variableString, "' variable."), node);
+                }
+                return variableVerifies;
+            }
+        },
+        {
+            key: "verifyVariableType",
+            value: function verifyVariableType() {
+                var variableTypeVerifies = false;
+                var node = this.getNode(), context = this.getContext();
+                var type;
+                type = this.variable.getType();
+                var typeString = type.getString();
+                context.trace("Verifying the '".concat(typeString, "' type..."), node);
+                var nominalTypeName = type.getNominalTypeName();
+                type = context.findTypeByNominalTypeName(nominalTypeName);
+                var typePresent = type !== null;
+                if (!typePresent) {
+                    context.debug("The '".concat(typeString, "' type is not present."), node);
+                } else {
+                    var includeSupertypes = false, provisional = type.isProvisional(includeSupertypes), provisionalMatches = type.matchProvisional(provisional);
+                    if (!provisionalMatches) {
+                        provisional ? context.debug("The '".concat(typeString, "' type is present but not provisional."), node) : context.debug("The '".concat(typeString, "' type is present but provisional."), node);
+                    } else {
+                        this.variable.setType(type);
+                        variableTypeVerifies = true;
+                    }
+                }
+                if (variableTypeVerifies) {
+                    context.debug("...verified the '".concat(typeString, "' type."), node);
+                }
+                return variableTypeVerifies;
+            }
+        }
+    ]);
+    return VariableDeclaration;
+}(_declaration.default), _define_property(_VariableDeclaration, "name", "VariableDeclaration"), _VariableDeclaration));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/declaration/variable.js"],"sourcesContent":["\"use strict\";\n\nimport Declaration from \"../declaration\";\n\nimport { define } from \"../../elements\";\n\nexport default define(class VariableDeclaration extends Declaration {\n  constructor(context, string, node, variable) {\n    super(context, string, node);\n\n    this.variable = variable;\n  }\n\n  getVariable() {\n    return this.variable;\n  }\n\n  verify() {\n    let verifies = false;\n\n    const node = this.getNode(),\n          context = this.getContext(),\n          variableDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${variableDeclarationString}' variable declaration...`, node);\n\n    const variableTypeVerifies = this.verifyVariableType();\n\n    if (variableTypeVerifies) {\n      const variableVerifies = this.verifyVariable();\n\n      if (variableVerifies) {\n        context.addVariable(this.variable);\n\n        verifies = true;\n      }\n    }\n\n    if (verifies) {\n      context.debug(`...verified the '${variableDeclarationString}' variable declaration.`, node);\n    }\n\n    return verifies;\n  }\n\n  verifyVariable() {\n    let  variableVerifies = false;\n\n    const node = this.getNode(),\n          context = this.getContext(),\n          variableString = this.variable.getString();\n\n    context.trace(`Verifying the '${variableString}' variable...`, node);\n\n    const variableIdentifier = this.variable.getIdentifier(),\n          variablePresent = context.isVariablePresentByVariableIdentifier(variableIdentifier);\n\n    if (variablePresent) {\n      context.debug(`The '${variableName}' variable is already present.`, node);\n    } else {\n      variableVerifies = true;\n    }\n\n    if ( variableVerifies) {\n      context.debug(`...verified the '${variableString}' variable.`, node);\n    }\n\n    return  variableVerifies;\n  }\n\n  verifyVariableType() {\n    let variableTypeVerifies = false;\n\n    const node = this.getNode(),\n          context = this.getContext();\n\n    let type;\n\n    type = this.variable.getType();\n\n    const typeString = type.getString();\n\n    context.trace(`Verifying the '${typeString}' type...`, node);\n\n    const nominalTypeName = type.getNominalTypeName();\n\n    type = context.findTypeByNominalTypeName(nominalTypeName);\n\n    const typePresent = (type !== null)\n\n    if (!typePresent) {\n      context.debug(`The '${typeString}' type is not present.`, node);\n    } else {\n      const includeSupertypes = false,\n            provisional = type.isProvisional(includeSupertypes),\n            provisionalMatches = type.matchProvisional(provisional);\n\n      if (!provisionalMatches) {\n        provisional ?\n          context.debug(`The '${typeString}' type is present but not provisional.`, node) :\n            context.debug(`The '${typeString}' type is present but provisional.`, node);\n      } else {\n        this.variable.setType(type);\n\n        variableTypeVerifies = true;\n      }\n    }\n\n    if (variableTypeVerifies) {\n      context.debug(`...verified the '${typeString}' type.`, node);\n    }\n\n    return variableTypeVerifies;\n  }\n\n  static name = \"VariableDeclaration\";\n});\n"],"names":["define","VariableDeclaration","context","string","node","variable","getVariable","verify","verifies","getNode","getContext","variableDeclarationString","getString","trace","variableTypeVerifies","verifyVariableType","variableVerifies","verifyVariable","addVariable","debug","variableString","variableIdentifier","getIdentifier","variablePresent","isVariablePresentByVariableIdentifier","variableName","type","getType","typeString","nominalTypeName","getNominalTypeName","findTypeByNominalTypeName","typePresent","includeSupertypes","provisional","isProvisional","provisionalMatches","matchProvisional","setType","Declaration","name"],"mappings":"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"}