occam-verify-cli 1.0.383 → 1.0.386

package/lib/ontology/type.js

@@ -0,0 +1,556 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get baseType () {
+        return baseType;
+    },
+    get default () {
+        return _default;
+    }
+});
+var _necessary = require("necessary");
+var _ontology = /*#__PURE__*/ _interop_require_wildcard(require("../ontology"));
+var _constants = require("../constants");
+var _node = require("../utilities/node");
+var _type = require("../utilities/type");
+var _json = require("../utilities/json");
+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 _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;
+}
+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 push = _necessary.arrayUtilities.push, first = _necessary.arrayUtilities.first;
+var Type = /*#__PURE__*/ function() {
+    function Type(string, name, prefixName, superTypes, properties, provisional) {
+        _class_call_check(this, Type);
+        this.string = string;
+        this.name = name;
+        this.prefixName = prefixName;
+        this.superTypes = superTypes;
+        this.properties = properties;
+        this.provisional = provisional;
+    }
+    _create_class(Type, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getName",
+            value: function getName() {
+                return this.name;
+            }
+        },
+        {
+            key: "getPrefixName",
+            value: function getPrefixName() {
+                return this.prefixName;
+            }
+        },
+        {
+            key: "getSuperTypes",
+            value: function getSuperTypes() {
+                return this.superTypes;
+            }
+        },
+        {
+            key: "getProperties",
+            value: function getProperties() {
+                var includeSuperTypes = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var properties = [];
+                push(properties, this.properties);
+                if (includeSuperTypes) {
+                    this.superTypes.forEach(function(superType) {
+                        var superTypeProperties = superType.getProperties();
+                        push(properties, superTypeProperties);
+                    });
+                }
+                return properties;
+            }
+        },
+        {
+            key: "isProvisional",
+            value: function isProvisional() {
+                var includeSuperTypes = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var provisional = this.provisional;
+                if (includeSuperTypes) {
+                    if (!provisional) {
+                        provisional = this.superTypes.some(function(superType) {
+                            var superTypeProvisional = superType.isProvisional();
+                            if (superTypeProvisional) {
+                                return true;
+                            }
+                        });
+                    }
+                }
+                return provisional;
+            }
+        },
+        {
+            key: "setName",
+            value: function setName(name) {
+                this.name = name;
+            }
+        },
+        {
+            key: "setPrefixName",
+            value: function setPrefixName(prefixName) {
+                this.prefixName = prefixName;
+            }
+        },
+        {
+            key: "setSuperTypes",
+            value: function setSuperTypes(superTypes) {
+                this.superTypes = superTypes;
+            }
+        },
+        {
+            key: "setProperties",
+            value: function setProperties(properties) {
+                this.properties = properties;
+            }
+        },
+        {
+            key: "setProvisional",
+            value: function setProvisional(provisional) {
+                this.provisional = provisional;
+            }
+        },
+        {
+            key: "replaceSuperType",
+            value: function replaceSuperType(oldSuperType, newSuperType) {
+                var index = this.superTypes.indexOf(oldSuperType), start = index, deleteCount = 1;
+                this.superTypes.splice(start, deleteCount, newSuperType);
+            }
+        },
+        {
+            key: "isPrefixed",
+            value: function isPrefixed() {
+                var prefixed = this.prefixName !== null;
+                return prefixed;
+            }
+        },
+        {
+            key: "getPrefixedName",
+            value: function getPrefixedName() {
+                var prefixedName = null;
+                var prefixed = this.isPrefixed();
+                if (prefixed) {
+                    prefixedName = "".concat(this.prefixName).concat(this.name);
+                }
+                return prefixedName;
+            }
+        },
+        {
+            key: "getNominalTypeName",
+            value: function getNominalTypeName() {
+                var prefixed = this.isPrefixed(), nominalTypeName = prefixed ? "".concat(this.prefixName).concat(this.name) : this.name;
+                return nominalTypeName;
+            }
+        },
+        {
+            key: "isBasic",
+            value: function isBasic() {
+                var basic = false;
+                var superTypesLength = this.superTypes.length;
+                if (superTypesLength === 1) {
+                    var firstSuperType = first(this.superTypes), superType = firstSuperType; ///
+                    if (superType === baseType) {
+                        basic = true;
+                    }
+                }
+                return basic;
+            }
+        },
+        {
+            key: "isRefined",
+            value: function isRefined() {
+                var refined = false;
+                var superTypesLength = this.superTypes.length;
+                if (superTypesLength === 1) {
+                    var firstSuperType = first(this.superTypes), superType = firstSuperType, superTypeName = superType.getName();
+                    if (superTypeName === this.name) {
+                        refined = true;
+                    }
+                }
+                return refined;
+            }
+        },
+        {
+            key: "isEqualTo",
+            value: function isEqualTo(type) {
+                var equalTo = this === type;
+                return equalTo;
+            }
+        },
+        {
+            key: "isSubTypeOf",
+            value: function isSubTypeOf(type) {
+                var subTypeOf;
+                if (this === baseType) {
+                    subTypeOf = false;
+                } else {
+                    subTypeOf = this.superTypes.some(function(superType) {
+                        if (superType === type) {
+                            return true;
+                        }
+                        var superTypeSubTypeOfType = superType.isSubTypeOf(type);
+                        if (superTypeSubTypeOfType) {
+                            return true;
+                        }
+                    });
+                }
+                return subTypeOf;
+            }
+        },
+        {
+            key: "isSuperTypeOf",
+            value: function isSuperTypeOf(type) {
+                var subTypeOf = type.isSubTypeOf(this), superTypeOf = subTypeOf; ///
+                return superTypeOf;
+            }
+        },
+        {
+            key: "isComparableTo",
+            value: function isComparableTo(type) {
+                var equalTo = this.isEqualTo(type), subTypeOf = this.isSubTypeOf(type), superTypeOf = this.isSuperTypeOf(type), comparableTo = equalTo || subTypeOf || superTypeOf;
+                return comparableTo;
+            }
+        },
+        {
+            key: "isEqualToOrSubTypeOf",
+            value: function isEqualToOrSubTypeOf(type) {
+                var equalTo = this.isEqualTo(type), subTypeOf = this.isSubTypeOf(type), equalToOrSubTypeOf = equalTo || subTypeOf;
+                return equalToOrSubTypeOf;
+            }
+        },
+        {
+            key: "isEqualToOrSuperTypeOf",
+            value: function isEqualToOrSuperTypeOf(type) {
+                var equalTo = this.isEqualTo(type), superTypeOf = this.isSuperTypeOf(type), equalToOrSuperTypeOf = equalTo || superTypeOf;
+                return equalToOrSuperTypeOf;
+            }
+        },
+        {
+            key: "matchTypeName",
+            value: function matchTypeName(typeName) {
+                var name = this.getName(), typeNameMatches = name === typeName;
+                return typeNameMatches;
+            }
+        },
+        {
+            key: "matchProvisional",
+            value: function matchProvisional(provisional) {
+                var provisionalMatches;
+                var provisionalA = provisional; ///
+                provisional = this.isProvisional();
+                var provisionalB = provisional; ///
+                provisionalMatches = provisionalA === provisionalB;
+                return provisionalMatches;
+            }
+        },
+        {
+            key: "matchPrefixedTypeName",
+            value: function matchPrefixedTypeName(prefixedTypeName) {
+                var prefixedTypeNameMatches = false;
+                var prefixed = this.isPrefixed();
+                if (prefixed) {
+                    var prefixedName = this.getPrefixedName();
+                    prefixedTypeNameMatches = prefixedTypeName === prefixedName;
+                }
+                return prefixedTypeNameMatches;
+            }
+        },
+        {
+            key: "matchNominalTypeName",
+            value: function matchNominalTypeName(nominalTypeName) {
+                var nominalTypeNameMatches = false;
+                if (!nominalTypeNameMatches) {
+                    var name = this.getName();
+                    nominalTypeNameMatches = nominalTypeName === name;
+                }
+                if (!nominalTypeNameMatches) {
+                    var prefixed = this.isPrefixed();
+                    if (prefixed) {
+                        var prefixedName = this.getPrefixedName();
+                        nominalTypeNameMatches = nominalTypeName === prefixedName;
+                    }
+                }
+                return nominalTypeNameMatches;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var propertiesJSON = (0, _json.propertiesToPropertiesJSON)(this.properties), superTypesJSON = (0, _json.superTypesToSuperTypesJSON)(this.superTypes), provisional = this.provisional, properties = propertiesJSON, superTypes = superTypesJSON, name = this.name, prefixName = this.prefixName, json = {
+                    name: name,
+                    prefixName: prefixName,
+                    superTypes: superTypes,
+                    properties: properties,
+                    provisional: provisional
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(json, context) {
+                var name = json.name, prefixName = json.prefixName, provisional = json.provisional, properties = (0, _json.propertiesFromJSON)(json, context), superTypes = (0, _json.superTypesFromJSON)(json, context), typeName = name, typePrefixName = null, string = (0, _type.stringFromTypeNameTypePrefixNameAndSuperTypes)(typeName, typePrefixName, superTypes), type = new Type(string, name, prefixName, superTypes, properties, provisional);
+                return type;
+            }
+        },
+        {
+            key: "fromTypeNode",
+            value: function fromTypeNode(typeNode, context) {
+                var type = (0, _node.typeFromTypeNode)(typeNode, context);
+                return type;
+            }
+        },
+        {
+            key: "fromSuperTypeNode",
+            value: function fromSuperTypeNode(superTypeNode, context) {
+                context = null; ///
+                var typeNode = superTypeNode, type = (0, _node.typeFromTypeNode)(typeNode, context);
+                return type;
+            }
+        },
+        {
+            key: "fromTypeAssertionNode",
+            value: function fromTypeAssertionNode(typeAssertionNode, context) {
+                var typeNode = typeAssertionNode.getTypeNode(), type = (0, _node.typeFromTypeNode)(typeNode, context);
+                return type;
+            }
+        },
+        {
+            key: "fromTypeAndProvisional",
+            value: function fromTypeAndProvisional(type, provisional) {
+                var name = type.getName(), prefixName = type.getPrefixName(), superType = type, typeName = name, typePrefixName = prefixName, superTypes = [
+                    superType
+                ], string = (0, _type.stringFromTypeNameTypePrefixNameAndSuperTypes)(typeName, typePrefixName, superTypes), properties = type.getProperties();
+                type = new Type(string, name, prefixName, superTypes, properties, provisional); ///
+                return type;
+            }
+        },
+        {
+            key: "fromPropertyDeclarationNode",
+            value: function fromPropertyDeclarationNode(propertyDeclarationNode, context) {
+                var typeNode = propertyDeclarationNode.getTypeNode(), type = (0, _node.typeFromTypeNode)(typeNode, context);
+                return type;
+            }
+        },
+        {
+            key: "fromSimpleTypeDeclarationNode",
+            value: function fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
+                var typeName = simpleTypeDeclarationNode.getTypeName(), provisional = simpleTypeDeclarationNode.isProvisional(), typePrefixName = simpleTypeDeclarationNode.getTypePrefixName(), superTypes = superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context), name = typeName, prefixName = typePrefixName, properties = [], string = (0, _type.stringFromTypeNameTypePrefixNameAndSuperTypes)(typeName, typePrefixName, superTypes), type = new Type(string, name, prefixName, superTypes, properties, provisional);
+                return type;
+            }
+        },
+        {
+            key: "fromComplexTypeDeclarationNode",
+            value: function fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
+                var typeName = complexTypeDeclarationNode.getTypeName(), provisional = complexTypeDeclarationNode.isProvisional(), typePrefixName = complexTypeDeclarationNode.getTypePrefixName(), superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context), name = typeName, prefixName = typePrefixName, properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context), string = (0, _type.stringFromTypeNameTypePrefixNameAndSuperTypes)(typeName, typePrefixName, superTypes), type = new Type(string, name, prefixName, superTypes, properties, provisional);
+                return type;
+            }
+        },
+        {
+            key: "fromConstructorDeclarationNode",
+            value: function fromConstructorDeclarationNode(constructorDeclarationNode, context) {
+                var type;
+                var typeNode = constructorDeclarationNode.getTypeNode();
+                if (typeNode === null) {
+                    type = baseType;
+                } else {
+                    var provisional = constructorDeclarationNode.isProvisional();
+                    type = (0, _node.typeFromTypeNode)(typeNode, context);
+                    type.setProvisional(provisional);
+                }
+                return type;
+            }
+        }
+    ]);
+    return Type;
+}();
+_define_property(Type, "name", "Type");
+var _default = (0, _ontology.define)(Type);
+function superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
+    var superTypeNodes = simpleTypeDeclarationNode.getSuperTypeNodes(), superTypes = superTypeNodes.map(function(superTypeNode) {
+        var superType = Type.fromSuperTypeNode(superTypeNode, context);
+        return superType;
+    }), superTypesLength = superTypes.length;
+    if (superTypesLength === 0) {
+        var superType = baseType; ///
+        superTypes.push(superType);
+    }
+    return superTypes;
+}
+function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
+    var superTypeNodes = complexTypeDeclarationNode.getSuperTypeNodes(), superTypes = superTypeNodes.map(function(superTypeNode) {
+        var superType = Type.fromSuperTypeNode(superTypeNode, context);
+        return superType;
+    }), superTypesLength = superTypes.length;
+    if (superTypesLength === 0) {
+        var superType = baseType; ///
+        superTypes.push(superType);
+    }
+    return superTypes;
+}
+function propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
+    var Property = _ontology.default.Property, propertyDeclarationNodes = complexTypeDeclarationNode.getPropertyDeclarationNodes(), properties = propertyDeclarationNodes.map(function(propertyDeclarationNode) {
+        var property = Property.fromPropertyDeclarationNode(propertyDeclarationNode, context);
+        return property;
+    });
+    return properties;
+}
+var BaseType = /*#__PURE__*/ function(Type) {
+    _inherits(BaseType, Type);
+    function BaseType() {
+        _class_call_check(this, BaseType);
+        return _call_super(this, BaseType, arguments);
+    }
+    _create_class(BaseType, null, [
+        {
+            key: "fromNothing",
+            value: function fromNothing() {
+                var name = _constants.BASE_TYPE_SYMBOL, string = name, prefixName = null, superTypes = [], properties = [], provisional = false, baseType = new BaseType(string, name, prefixName, superTypes, properties, provisional);
+                return baseType;
+            }
+        }
+    ]);
+    return BaseType;
+}(Type);
+var baseType = BaseType.fromNothing();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/ontology/type.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport ontology from \"../ontology\";\n\nimport { define } from \"../ontology\";\nimport { BASE_TYPE_SYMBOL } from \"../constants\";\nimport { typeFromTypeNode } from \"../utilities/node\";\nimport { stringFromTypeNameTypePrefixNameAndSuperTypes } from \"../utilities/type\";\nimport { superTypesFromJSON, propertiesFromJSON, superTypesToSuperTypesJSON, propertiesToPropertiesJSON } from \"../utilities/json\";\n\nconst { push, first } = arrayUtilities;\n\nclass Type {\n  constructor(string, name, prefixName, superTypes, properties, provisional) {\n    this.string = string;\n    this.name = name;\n    this.prefixName = prefixName;\n    this.superTypes = superTypes;\n    this.properties = properties;\n    this.provisional = provisional;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getName() {\n    return this.name;\n  }\n\n  getPrefixName() {\n    return this.prefixName;\n  }\n\n  getSuperTypes() {\n    return this.superTypes;\n  }\n\n  getProperties(includeSuperTypes = true) {\n    const properties = [];\n\n    push(properties, this.properties);\n\n    if (includeSuperTypes) {\n      this.superTypes.forEach((superType) => {\n        const superTypeProperties = superType.getProperties();\n\n        push(properties, superTypeProperties);\n      });\n    }\n\n    return properties;\n  }\n\n  isProvisional(includeSuperTypes = true) {\n    let provisional = this.provisional;\n\n    if (includeSuperTypes) {\n      if (!provisional) {\n        provisional = this.superTypes.some((superType) => {\n          const superTypeProvisional = superType.isProvisional();\n\n          if (superTypeProvisional) {\n            return true;\n          }\n        });\n      }\n    }\n\n    return provisional;\n  }\n\n  setName(name) {\n    this.name = name;\n  }\n\n  setPrefixName(prefixName) {\n    this.prefixName = prefixName;\n  }\n\n  setSuperTypes(superTypes) {\n    this.superTypes = superTypes;\n  }\n\n  setProperties(properties) {\n    this.properties = properties;\n  }\n\n  setProvisional(provisional) {\n    this.provisional = provisional;\n  }\n\n  replaceSuperType(oldSuperType, newSuperType) {\n    const index = this.superTypes.indexOf(oldSuperType),\n          start = index,\n          deleteCount = 1;\n\n    this.superTypes.splice(start, deleteCount, newSuperType);\n  }\n\n  isPrefixed() {\n    const prefixed = (this.prefixName !== null);\n\n    return prefixed;\n  }\n\n  getPrefixedName() {\n    let prefixedName = null;\n\n    const prefixed = this.isPrefixed();\n\n    if (prefixed) {\n      prefixedName = `${this.prefixName}${this.name}`;\n    }\n\n    return prefixedName;\n  }\n\n  getNominalTypeName() {\n    const prefixed = this.isPrefixed(),\n          nominalTypeName = prefixed ?\n                             `${this.prefixName}${this.name}` :\n                                this.name;\n\n    return nominalTypeName;\n  }\n\n  isBasic() {\n    let basic = false;\n\n    const superTypesLength = this.superTypes.length;\n\n    if (superTypesLength === 1) {\n      const firstSuperType = first(this.superTypes),\n            superType = firstSuperType; ///\n\n      if (superType === baseType) {\n        basic = true;\n      }\n    }\n\n    return basic;\n  }\n\n  isRefined() {\n    let refined = false;\n\n    const superTypesLength = this.superTypes.length;\n\n    if (superTypesLength === 1) {\n      const firstSuperType = first(this.superTypes),\n            superType = firstSuperType, ///\n            superTypeName = superType.getName();\n\n      if (superTypeName === this.name) {\n        refined = true;\n      }\n    }\n\n    return refined;\n  }\n\n  isEqualTo(type) {\n    const equalTo = (this === type);\n\n    return equalTo;\n  }\n\n  isSubTypeOf(type) {\n    let subTypeOf;\n\n    if (this === baseType) {\n      subTypeOf = false;\n    } else {\n      subTypeOf = this.superTypes.some((superType) => { ///\n        if (superType === type) {\n          return true;\n        }\n\n        const superTypeSubTypeOfType = superType.isSubTypeOf(type);\n\n        if (superTypeSubTypeOfType) {\n          return true;\n        }\n      })\n    }\n\n    return subTypeOf;\n  }\n\n  isSuperTypeOf(type) {\n    const subTypeOf = type.isSubTypeOf(this),\n          superTypeOf = subTypeOf;  ///\n\n    return superTypeOf;\n  }\n\n  isComparableTo(type) {\n    const equalTo = this.isEqualTo(type),\n          subTypeOf = this.isSubTypeOf(type),\n          superTypeOf = this.isSuperTypeOf(type),\n          comparableTo = (equalTo || subTypeOf || superTypeOf);\n\n    return comparableTo;\n  }\n\n  isEqualToOrSubTypeOf(type) {\n    const equalTo = this.isEqualTo(type),\n          subTypeOf = this.isSubTypeOf(type),\n          equalToOrSubTypeOf = (equalTo || subTypeOf);\n\n    return equalToOrSubTypeOf;\n  }\n\n  isEqualToOrSuperTypeOf(type) {\n    const equalTo = this.isEqualTo(type),\n          superTypeOf = this.isSuperTypeOf(type),\n          equalToOrSuperTypeOf = (equalTo || superTypeOf);\n\n    return equalToOrSuperTypeOf;\n  }\n\n  matchTypeName(typeName) {\n    const name = this.getName(),\n          typeNameMatches = (name === typeName);\n\n    return typeNameMatches;\n  }\n\n  matchProvisional(provisional) {\n    let provisionalMatches;\n\n    const provisionalA = provisional; ///\n\n    provisional = this.isProvisional();\n\n    const provisionalB = provisional; ///\n\n    provisionalMatches = (provisionalA === provisionalB);\n\n    return provisionalMatches;\n  }\n\n  matchPrefixedTypeName(prefixedTypeName) {\n    let prefixedTypeNameMatches = false;\n\n    const prefixed = this.isPrefixed();\n\n    if (prefixed) {\n      const prefixedName = this.getPrefixedName();\n\n      prefixedTypeNameMatches = (prefixedTypeName === prefixedName);\n    }\n\n    return prefixedTypeNameMatches;\n  }\n\n  matchNominalTypeName(nominalTypeName) {\n    let nominalTypeNameMatches = false;\n\n    if (!nominalTypeNameMatches) {\n      const name = this.getName();\n\n      nominalTypeNameMatches = (nominalTypeName === name);\n    }\n\n    if (!nominalTypeNameMatches) {\n      const prefixed = this.isPrefixed();\n\n      if (prefixed) {\n        const prefixedName = this.getPrefixedName();\n\n        nominalTypeNameMatches = (nominalTypeName === prefixedName);\n      }\n    }\n\n    return nominalTypeNameMatches;\n  }\n\n  toJSON() {\n    const propertiesJSON = propertiesToPropertiesJSON(this.properties),\n          superTypesJSON = superTypesToSuperTypesJSON(this.superTypes),\n          provisional = this.provisional,\n          properties = propertiesJSON,  ///\n          superTypes = superTypesJSON,  ///\n          name = this.name,\n          prefixName = this.prefixName,\n          json = {\n            name,\n            prefixName,\n            superTypes,\n            properties,\n            provisional\n          };\n\n    return json;\n  }\n\n  static name = \"Type\";\n\n  static fromJSON(json, context) {\n    const { name, prefixName, provisional } = json,\n          properties = propertiesFromJSON(json, context),\n          superTypes = superTypesFromJSON(json, context),\n          typeName = name,  ///\n          typePrefixName = null,\n          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),\n          type = new Type(string, name, prefixName, superTypes, properties, provisional);\n\n    return type;\n  }\n\n  static fromTypeNode(typeNode, context) {\n    const type = typeFromTypeNode(typeNode, context);\n\n    return type;\n  }\n\n  static fromSuperTypeNode(superTypeNode, context) {\n    context = null; ///\n\n    const typeNode = superTypeNode, ///\n          type = typeFromTypeNode(typeNode, context);\n\n    return type;\n  }\n\n  static fromTypeAssertionNode(typeAssertionNode, context) {\n    const typeNode = typeAssertionNode.getTypeNode(),\n          type = typeFromTypeNode(typeNode, context);\n\n    return type;\n  }\n\n  static fromTypeAndProvisional(type, provisional) {\n    const name = type.getName(),\n          prefixName = type.getPrefixName(),\n          superType = type, ///\n          typeName = name,  ///\n          typePrefixName = prefixName,  ///\n          superTypes = [\n            superType\n          ],\n          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),\n          properties = type.getProperties();\n\n    type = new Type(string, name, prefixName, superTypes, properties, provisional);  ///\n\n    return type;\n  }\n\n  static fromPropertyDeclarationNode(propertyDeclarationNode, context) {\n    const typeNode = propertyDeclarationNode.getTypeNode(),\n          type = typeFromTypeNode(typeNode, context);\n\n    return type;\n  }\n\n  static fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {\n    const typeName = simpleTypeDeclarationNode.getTypeName(),\n          provisional = simpleTypeDeclarationNode.isProvisional(),\n          typePrefixName = simpleTypeDeclarationNode.getTypePrefixName(),\n          superTypes = superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),\n          name = typeName,  ///\n          prefixName = typePrefixName,  ///\n          properties = [],\n          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),\n          type = new Type(string, name, prefixName, superTypes, properties, provisional);\n\n    return type;\n  }\n\n  static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {\n    const typeName = complexTypeDeclarationNode.getTypeName(),\n          provisional = complexTypeDeclarationNode.isProvisional(),\n          typePrefixName = complexTypeDeclarationNode.getTypePrefixName(),\n          superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),\n          name = typeName,  ///\n          prefixName = typePrefixName,  ///\n          properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),\n          string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),\n          type = new Type(string, name, prefixName, superTypes, properties, provisional);\n\n    return type;\n  }\n\n  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {\n    let type;\n\n    const typeNode = constructorDeclarationNode.getTypeNode();\n\n    if (typeNode === null) {\n      type = baseType;\n    } else {\n      const provisional = constructorDeclarationNode.isProvisional();\n\n      type = typeFromTypeNode(typeNode, context);\n\n      type.setProvisional(provisional);\n    }\n\n    return type;\n  }\n}\n\nexport default define(Type);\n\nfunction superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {\n  const superTypeNodes = simpleTypeDeclarationNode.getSuperTypeNodes(),\n        superTypes = superTypeNodes.map((superTypeNode) => {\n          const superType = Type.fromSuperTypeNode(superTypeNode, context);\n\n          return superType;\n        }),\n        superTypesLength = superTypes.length;\n\n  if (superTypesLength === 0) {\n    const superType = baseType; ///\n\n    superTypes.push(superType);\n  }\n\n  return superTypes;\n}\n\nfunction superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {\n  const superTypeNodes = complexTypeDeclarationNode.getSuperTypeNodes(),\n        superTypes = superTypeNodes.map((superTypeNode) => {\n          const superType = Type.fromSuperTypeNode(superTypeNode, context);\n\n          return superType;\n        }),\n        superTypesLength = superTypes.length;\n\n  if (superTypesLength === 0) {\n    const superType = baseType; ///\n\n    superTypes.push(superType);\n  }\n\n  return superTypes;\n}\n\nfunction propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {\n  const { Property } = ontology,\n        propertyDeclarationNodes = complexTypeDeclarationNode.getPropertyDeclarationNodes(),\n        properties = propertyDeclarationNodes.map((propertyDeclarationNode) => {\n          const property = Property.fromPropertyDeclarationNode(propertyDeclarationNode, context);\n\n          return property;\n        });\n\n  return properties;\n}\n\nclass BaseType extends Type {\n  static fromNothing() {\n    const name = BASE_TYPE_SYMBOL,  ///\n          string = name,  ///\n          prefixName = null,\n          superTypes = [],\n          properties = [],\n          provisional = false,\n          baseType = new BaseType(string, name, prefixName, superTypes, properties, provisional);\n\n    return baseType;\n  }\n}\n\nexport const baseType = BaseType.fromNothing();\n"],"names":["baseType","push","arrayUtilities","first","Type","string","name","prefixName","superTypes","properties","provisional","getString","getName","getPrefixName","getSuperTypes","getProperties","includeSuperTypes","forEach","superType","superTypeProperties","isProvisional","some","superTypeProvisional","setName","setPrefixName","setSuperTypes","setProperties","setProvisional","replaceSuperType","oldSuperType","newSuperType","index","indexOf","start","deleteCount","splice","isPrefixed","prefixed","getPrefixedName","prefixedName","getNominalTypeName","nominalTypeName","isBasic","basic","superTypesLength","length","firstSuperType","isRefined","refined","superTypeName","isEqualTo","type","equalTo","isSubTypeOf","subTypeOf","superTypeSubTypeOfType","isSuperTypeOf","superTypeOf","isComparableTo","comparableTo","isEqualToOrSubTypeOf","equalToOrSubTypeOf","isEqualToOrSuperTypeOf","equalToOrSuperTypeOf","matchTypeName","typeName","typeNameMatches","matchProvisional","provisionalMatches","provisionalA","provisionalB","matchPrefixedTypeName","prefixedTypeName","prefixedTypeNameMatches","matchNominalTypeName","nominalTypeNameMatches","toJSON","propertiesJSON","propertiesToPropertiesJSON","superTypesJSON","superTypesToSuperTypesJSON","json","fromJSON","context","propertiesFromJSON","superTypesFromJSON","typePrefixName","stringFromTypeNameTypePrefixNameAndSuperTypes","fromTypeNode","typeNode","typeFromTypeNode","fromSuperTypeNode","superTypeNode","fromTypeAssertionNode","typeAssertionNode","getTypeNode","fromTypeAndProvisional","fromPropertyDeclarationNode","propertyDeclarationNode","fromSimpleTypeDeclarationNode","simpleTypeDeclarationNode","getTypeName","getTypePrefixName","superTypesFromSimpleTypeDeclarationNode","fromComplexTypeDeclarationNode","complexTypeDeclarationNode","superTypesFromComplexTypeDeclarationNode","propertiesFromComplexTypeDeclarationNode","fromConstructorDeclarationNode","constructorDeclarationNode","define","superTypeNodes","getSuperTypeNodes","map","Property","ontology","propertyDeclarationNodes","getPropertyDeclarationNodes","property","BaseType","fromNothing","BASE_TYPE_SYMBOL"],"mappings":"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"}