@alterior/annotations 3.0.0-rc.5 → 3.0.0

package/dist/annotations.js

@@ -2,7 +2,7 @@
 /// <reference types="reflect-metadata" />
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Label = exports.LabelAnnotation = exports.Annotations = exports.Annotation = exports.Mutator = exports.MetadataName = exports.AnnotationTargetError = exports.METHOD_PARAMETER_ANNOTATIONS_KEY = exports.PROPERTY_ANNOTATIONS_KEY = exports.CONSTRUCTOR_PARAMETERS_ANNOTATIONS_KEY = exports.ANNOTATIONS_KEY = void 0;
-var tslib_1 = require("tslib");
+const tslib_1 = require("tslib");
 /**
  * @alterior/annotations
  * A class library for handling Typescript metadata decorators via "annotation" classes
@@ -10,7 +10,7 @@ var tslib_1 = require("tslib");
  * (C) 2017-2019 William Lahti
  *
  */
-var common_1 = require("@alterior/common");
+const common_1 = require("@alterior/common");
 // These are the properties on a class where annotation metadata is deposited 
 // when annotation decorators are executed. Note that these are intended to 
 // be compatible with Angular 6's model
@@ -22,38 +22,23 @@ exports.METHOD_PARAMETER_ANNOTATIONS_KEY = '__parameter__metadata__';
  * Thrown when a caller attempts to decorate an annotation target when the
  * annotation does not support that target.
  */
-var AnnotationTargetError = /** @class */ (function (_super) {
-    (0, tslib_1.__extends)(AnnotationTargetError, _super);
-    function AnnotationTargetError(annotationClass, invalidType, supportedTypes, message) {
-        var _this = _super.call(this, message || "You cannot decorate a " + invalidType + " with annotation " + annotationClass.name + ". Valid targets: " + supportedTypes.join(', ')) || this;
-        _this._invalidType = invalidType;
-        _this._annotationClass = annotationClass;
-        _this._supportedTypes = supportedTypes;
-        return _this;
-    }
-    Object.defineProperty(AnnotationTargetError.prototype, "invalidType", {
-        get: function () {
-            return this._invalidType;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AnnotationTargetError.prototype, "supportedTypes", {
-        get: function () {
-            return this._supportedTypes;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AnnotationTargetError.prototype, "annotationClass", {
-        get: function () {
-            return this._annotationClass;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return AnnotationTargetError;
-}(common_1.NotSupportedError));
+class AnnotationTargetError extends common_1.NotSupportedError {
+    constructor(annotationClass, invalidType, supportedTypes, message) {
+        super(message || `You cannot decorate a ${invalidType} with annotation ${annotationClass.name}. Valid targets: ${supportedTypes.join(', ')}`);
+        this._invalidType = invalidType;
+        this._annotationClass = annotationClass;
+        this._supportedTypes = supportedTypes;
+    }
+    get invalidType() {
+        return this._invalidType;
+    }
+    get supportedTypes() {
+        return this._supportedTypes;
+    }
+    get annotationClass() {
+        return this._annotationClass;
+    }
+}
 exports.AnnotationTargetError = AnnotationTargetError;
 /**
  * Create a decorator suitable for use along with an Annotation class.
@@ -64,10 +49,10 @@ exports.AnnotationTargetError = AnnotationTargetError;
  */
 function makeDecorator(ctor, options) {
     if (!ctor)
-        throw new Error("Cannot create decorator: Passed class reference was undefined/null: This can happen due to circular dependencies.");
-    var factory = null;
-    var validTargets = null;
-    var allowMultiple = false;
+        throw new Error(`Cannot create decorator: Passed class reference was undefined/null: This can happen due to circular dependencies.`);
+    let factory = null;
+    let validTargets = null;
+    let allowMultiple = false;
     if (options) {
         if (options.factory)
             factory = options.factory;
@@ -77,58 +62,44 @@ function makeDecorator(ctor, options) {
             allowMultiple = options.allowMultiple;
     }
     if (!factory)
-        factory = function (target) {
-            var args = [];
-            for (var _i = 1; _i < arguments.length; _i++) {
-                args[_i - 1] = arguments[_i];
-            }
-            return new (ctor.bind.apply(ctor, (0, tslib_1.__spreadArray)([void 0], (0, tslib_1.__read)(args), false)))();
-        };
+        factory = (target, ...args) => new ctor(...args);
     if (!validTargets)
         validTargets = ['class', 'method', 'property', 'parameter'];
-    return function () {
-        var decoratorArgs = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            decoratorArgs[_i] = arguments[_i];
-        }
-        return function (target) {
+    return (...decoratorArgs) => {
+        return (target, ...args) => {
             // Note that checking the length is not enough, because for properties
             // two arguments are passed, but the property descriptor is `undefined`.
             // So we make sure that we have a valid property descriptor (args[1]) 
-            var args = [];
-            for (var _i = 1; _i < arguments.length; _i++) {
-                args[_i - 1] = arguments[_i];
-            }
             if (args.length === 2 && args[1] !== undefined) {
                 if (typeof args[1] === 'number') {
                     // Parameter decorator on a method or a constructor (methodName will be undefined)
-                    var methodName = args[0];
-                    var index = args[1];
+                    let methodName = args[0];
+                    let index = args[1];
                     if (!validTargets.includes('parameter'))
                         throw new AnnotationTargetError(ctor, 'parameter', validTargets);
                     if (!allowMultiple) {
-                        var existingParamDecs = Annotations.getParameterAnnotations(target, methodName, true);
-                        var existingParamAnnots = existingParamDecs[index] || [];
-                        if (existingParamAnnots.find(function (x) { return x.$metadataName === ctor['$metadataName']; }))
-                            throw new Error("Annotation " + ctor.name + " can only be applied to an element once.");
+                        let existingParamDecs = Annotations.getParameterAnnotations(target, methodName, true);
+                        let existingParamAnnots = existingParamDecs[index] || [];
+                        if (existingParamAnnots.find(x => x.$metadataName === ctor['$metadataName']))
+                            throw new Error(`Annotation ${ctor.name} can only be applied to an element once.`);
                     }
                     if (methodName) {
-                        var annotation = factory.apply(void 0, (0, tslib_1.__spreadArray)([{
-                                type: 'parameter',
-                                target: target,
-                                propertyKey: methodName,
-                                index: index
-                            }], (0, tslib_1.__read)(decoratorArgs), false));
+                        let annotation = factory({
+                            type: 'parameter',
+                            target,
+                            propertyKey: methodName,
+                            index
+                        }, ...decoratorArgs);
                         if (!annotation)
                             return;
                         annotation.applyToParameter(target, methodName, index);
                     }
                     else {
-                        var annotation = factory.apply(void 0, (0, tslib_1.__spreadArray)([{
-                                type: 'parameter',
-                                target: target,
-                                index: index
-                            }], (0, tslib_1.__read)(decoratorArgs), false));
+                        let annotation = factory({
+                            type: 'parameter',
+                            target,
+                            index
+                        }, ...decoratorArgs);
                         if (!annotation)
                             return;
                         annotation.applyToConstructorParameter(target, index);
@@ -136,21 +107,21 @@ function makeDecorator(ctor, options) {
                 }
                 else {
                     // Method decorator
-                    var methodName = args[0];
-                    var descriptor = args[1];
+                    let methodName = args[0];
+                    let descriptor = args[1];
                     if (!validTargets.includes('method'))
                         throw new AnnotationTargetError(ctor, 'method', validTargets);
                     if (!allowMultiple) {
-                        var existingAnnots = Annotations.getMethodAnnotations(target, methodName, true);
-                        if (existingAnnots.find(function (x) { return x.$metadataName === ctor['$metadataName']; }))
-                            throw new Error("Annotation " + ctor.name + " can only be applied to an element once.");
+                        let existingAnnots = Annotations.getMethodAnnotations(target, methodName, true);
+                        if (existingAnnots.find(x => x.$metadataName === ctor['$metadataName']))
+                            throw new Error(`Annotation ${ctor.name} can only be applied to an element once.`);
                     }
-                    var annotation = factory.apply(void 0, (0, tslib_1.__spreadArray)([{
-                            type: 'method',
-                            target: target,
-                            propertyKey: methodName,
-                            propertyDescriptor: descriptor
-                        }], (0, tslib_1.__read)(decoratorArgs), false));
+                    let annotation = factory({
+                        type: 'method',
+                        target,
+                        propertyKey: methodName,
+                        propertyDescriptor: descriptor
+                    }, ...decoratorArgs);
                     if (!annotation)
                         return;
                     annotation.applyToMethod(target, methodName);
@@ -158,19 +129,19 @@ function makeDecorator(ctor, options) {
             }
             else if (args.length >= 1) {
                 // Property decorator
-                var propertyKey = args[0];
+                let propertyKey = args[0];
                 if (!validTargets.includes('property'))
                     throw new AnnotationTargetError(ctor, 'property', validTargets);
                 if (!allowMultiple) {
-                    var existingAnnots = Annotations.getPropertyAnnotations(target, propertyKey, true);
-                    if (existingAnnots.find(function (x) { return x.$metadataName === ctor['$metadataName']; }))
-                        throw new Error("Annotation " + ctor.name + " can only be applied to an element once.");
+                    let existingAnnots = Annotations.getPropertyAnnotations(target, propertyKey, true);
+                    if (existingAnnots.find(x => x.$metadataName === ctor['$metadataName']))
+                        throw new Error(`Annotation ${ctor.name} can only be applied to an element once.`);
                 }
-                var annotation = factory.apply(void 0, (0, tslib_1.__spreadArray)([{
-                        type: 'property',
-                        target: target,
-                        propertyKey: propertyKey
-                    }], (0, tslib_1.__read)(decoratorArgs), false));
+                let annotation = factory({
+                    type: 'property',
+                    target,
+                    propertyKey
+                }, ...decoratorArgs);
                 if (!annotation)
                     return;
                 annotation.applyToProperty(target, propertyKey);
@@ -180,27 +151,27 @@ function makeDecorator(ctor, options) {
                 if (!validTargets.includes('class'))
                     throw new AnnotationTargetError(ctor, 'class', validTargets);
                 if (!allowMultiple) {
-                    var existingAnnots = Annotations.getClassAnnotations(target);
-                    if (existingAnnots.find(function (x) { return x.$metadataName === ctor['$metadataName']; }))
-                        throw new Error("Annotation " + ctor.name + " can only be applied to an element once.");
+                    let existingAnnots = Annotations.getClassAnnotations(target);
+                    if (existingAnnots.find(x => x.$metadataName === ctor['$metadataName']))
+                        throw new Error(`Annotation ${ctor.name} can only be applied to an element once.`);
                 }
-                var annotation = factory.apply(void 0, (0, tslib_1.__spreadArray)([{
-                        type: 'class',
-                        target: target
-                    }], (0, tslib_1.__read)(decoratorArgs), false));
+                let annotation = factory({
+                    type: 'class',
+                    target
+                }, ...decoratorArgs);
                 if (!annotation)
                     return;
                 annotation.applyToClass(target);
             }
             else {
                 // Invalid, or future decorator types we don't support yet.
-                throw new Error("Encountered unknown decorator invocation with " + (args.length + 1) + " parameters.");
+                throw new Error(`Encountered unknown decorator invocation with ${args.length + 1} parameters.`);
             }
         };
     };
 }
 function MetadataName(name) {
-    return function (target) { return Object.defineProperty(target, '$metadataName', { value: name }); };
+    return target => Object.defineProperty(target, '$metadataName', { value: name });
 }
 exports.MetadataName = MetadataName;
 /**
@@ -210,24 +181,18 @@ exports.MetadataName = MetadataName;
  *
  * Create a mutator with Mutator.create().
  */
-var Mutator = /** @class */ (function () {
-    function Mutator() {
-    }
+class Mutator {
     /**
      * Low-level method to ceate a new mutation decorator (mutator) based on the given function.
      * Use `Mutator.define()` instead.
      */
-    Mutator.create = function (mutator, options) {
+    static create(mutator, options) {
         return Annotation.decorator(Object.assign({}, options || {}, {
-            factory: function (target) {
-                var args = [];
-                for (var _i = 1; _i < arguments.length; _i++) {
-                    args[_i - 1] = arguments[_i];
-                }
-                mutator.apply(void 0, (0, tslib_1.__spreadArray)([target], (0, tslib_1.__read)(args), false));
+            factory: (target, ...args) => {
+                mutator(target, ...args);
             }
         }));
-    };
+    }
     /**
      * Define a new mutation decorator (mutator).
      * This should be called and returned from a
@@ -265,11 +230,10 @@ export function RunTwice() {
 )
      * ```
      */
-    Mutator.define = function (definition) {
+    static define(definition) {
         return this.create(definition.invoke, definition.options)();
-    };
-    return Mutator;
-}());
+    }
+}
 exports.Mutator = Mutator;
 /**
  * Represents a metadata annotation which can be applied to classes,
@@ -318,23 +282,23 @@ class ABC {
 ```
  *
  */
-var Annotation = /** @class */ (function () {
-    function Annotation(props) {
+class Annotation {
+    constructor(props) {
         this.$metadataName = this.constructor['$metadataName'];
         if (!this.$metadataName || !this.$metadataName.includes(':')) {
-            throw new Error("You must specify a metadata name for this annotation in the form of "
-                + (" 'mynamespace:myproperty'. You specified: '" + (this.$metadataName || '<none>') + "'"));
+            throw new Error(`You must specify a metadata name for this annotation in the form of `
+                + ` 'mynamespace:myproperty'. You specified: '${this.$metadataName || '<none>'}'`);
         }
         Object.assign(this, props || {});
     }
-    Annotation.prototype.toString = function () {
-        return "@" + this.constructor.name;
-    };
-    Annotation.getMetadataName = function () {
+    toString() {
+        return `@${this.constructor.name}`;
+    }
+    static getMetadataName() {
         if (!this['$metadataName'])
-            throw new Error("Annotation subclass " + this.name + " must have @MetadataName()");
+            throw new Error(`Annotation subclass ${this.name} must have @MetadataName()`);
         return this['$metadataName'];
-    };
+    }
     /**
      * Construct a decorator suitable for attaching annotations of the called type
      * onto classes, constructor parameters, methods, properties, and parameters.
@@ -345,61 +309,61 @@ var Annotation = /** @class */ (function () {
      * @param options Allows for specifying options which will modify the behavior of the decorator.
      *  See the DecoratorOptions documentation for more information.
      */
-    Annotation.decorator = function (options) {
+    static decorator(options) {
         if (this === Annotation) {
             if (!options || !options.factory) {
-                throw new Error("When calling Annotation.decorator() to create a mutator, you must specify a factory (or use Mutator.decorator())");
+                throw new Error(`When calling Annotation.decorator() to create a mutator, you must specify a factory (or use Mutator.decorator())`);
             }
         }
         return makeDecorator(this, options);
-    };
+    }
     /**
      * Clone this annotation instance into a new one. This is not a deep copy.
      */
-    Annotation.prototype.clone = function () {
+    clone() {
         return Annotations.clone(this);
-    };
+    }
     /**
      * Apply this annotation to a given target.
      * @param target
      */
-    Annotation.prototype.applyToClass = function (target) {
+    applyToClass(target) {
         return Annotations.applyToClass(this, target);
-    };
+    }
     /**
      * Apply this annotation instance to the given property.
      * @param target
      * @param name
      */
-    Annotation.prototype.applyToProperty = function (target, name) {
+    applyToProperty(target, name) {
         return Annotations.applyToProperty(this, target, name);
-    };
+    }
     /**
      * Apply this annotation instance to the given method.
      * @param target
      * @param name
      */
-    Annotation.prototype.applyToMethod = function (target, name) {
+    applyToMethod(target, name) {
         return Annotations.applyToMethod(this, target, name);
-    };
+    }
     /**
      * Apply this annotation instance to the given method parameter.
      * @param target
      * @param name
      * @param index
      */
-    Annotation.prototype.applyToParameter = function (target, name, index) {
+    applyToParameter(target, name, index) {
         return Annotations.applyToParameter(this, target, name, index);
-    };
+    }
     /**
      * Apply this annotation instance to the given constructor parameter.
      * @param target
      * @param name
      * @param index
      */
-    Annotation.prototype.applyToConstructorParameter = function (target, index) {
+    applyToConstructorParameter(target, index) {
         return Annotations.applyToConstructorParameter(this, target, index);
-    };
+    }
     /**
      * Filter the given list of annotations for the ones which match this annotation class
      * based on matching $metadataName.
@@ -407,10 +371,9 @@ var Annotation = /** @class */ (function () {
      * @param this
      * @param annotations
      */
-    Annotation.filter = function (annotations) {
-        var _this = this;
-        return annotations.filter(function (x) { return x.$metadataName === _this.getMetadataName(); });
-    };
+    static filter(annotations) {
+        return annotations.filter(x => x.$metadataName === this.getMetadataName());
+    }
     /**
      * Get all instances of this annotation class attached to the given class.
      * If called on a subclass of Annotation, it returns only annotations that match
@@ -418,11 +381,10 @@ var Annotation = /** @class */ (function () {
      * @param this
      * @param type The class to check
      */
-    Annotation.getAllForClass = function (type) {
-        var _this = this;
+    static getAllForClass(type) {
         return Annotations.getClassAnnotations(type)
-            .filter(function (x) { return x.$metadataName === _this.getMetadataName(); });
-    };
+            .filter(x => x.$metadataName === this.getMetadataName());
+    }
     /**
      * Get a single instance of this annotation class attached to the given class.
      * If called on a subclass of Annotation, it returns only annotations that match
@@ -431,9 +393,9 @@ var Annotation = /** @class */ (function () {
      * @param this
      * @param type
      */
-    Annotation.getForClass = function (type) {
+    static getForClass(type) {
         return this.getAllForClass(type)[0];
-    };
+    }
     /**
      * Get all instances of this annotation class attached to the given method.
      * If called on a subclass of Annotation, it returns only annotations that match
@@ -443,11 +405,10 @@ var Annotation = /** @class */ (function () {
      * @param type The class where the method is defined
      * @param methodName The name of the method to check
      */
-    Annotation.getAllForMethod = function (type, methodName) {
-        var _this = this;
+    static getAllForMethod(type, methodName) {
         return Annotations.getMethodAnnotations(type, methodName)
-            .filter(function (x) { return x.$metadataName === _this.getMetadataName(); });
-    };
+            .filter(x => x.$metadataName === this.getMetadataName());
+    }
     /**
      * Get one instance of this annotation class attached to the given method.
      * If called on a subclass of Annotation, it returns only annotations that match
@@ -457,9 +418,9 @@ var Annotation = /** @class */ (function () {
      * @param type The class where the method is defined
      * @param methodName The name of the method to check
      */
-    Annotation.getForMethod = function (type, methodName) {
+    static getForMethod(type, methodName) {
         return this.getAllForMethod(type, methodName)[0];
-    };
+    }
     /**
      * Get all instances of this annotation class attached to the given property.
      * If called on a subclass of Annotation, it returns only annotations that match
@@ -469,11 +430,10 @@ var Annotation = /** @class */ (function () {
      * @param type The class where the property is defined
      * @param propertyName The name of the property to check
      */
-    Annotation.getAllForProperty = function (type, propertyName) {
-        var _this = this;
+    static getAllForProperty(type, propertyName) {
         return Annotations.getPropertyAnnotations(type, propertyName)
-            .filter(function (x) { return x.$metadataName === _this.getMetadataName(); });
-    };
+            .filter(x => x.$metadataName === this.getMetadataName());
+    }
     /**
      * Get one instance of this annotation class attached to the given property.
      * If called on a subclass of Annotation, it returns only annotations that match
@@ -483,9 +443,9 @@ var Annotation = /** @class */ (function () {
      * @param type The class where the property is defined
      * @param propertyName The name of the property to check
      */
-    Annotation.getForProperty = function (type, propertyName) {
+    static getForProperty(type, propertyName) {
         return this.getAllForProperty(type, propertyName)[0];
-    };
+    }
     /**
      * Get all instances of this annotation class attached to the parameters of the given method.
      * If called on a subclass of Annotation, it returns only annotations that match
@@ -495,11 +455,10 @@ var Annotation = /** @class */ (function () {
      * @param type The class where the method is defined
      * @param methodName The name of the method where parameter annotations should be checked for
      */
-    Annotation.getAllForParameters = function (type, methodName) {
-        var _this = this;
+    static getAllForParameters(type, methodName) {
         return Annotations.getParameterAnnotations(type, methodName)
-            .map(function (set) { return (set || []).filter(function (x) { return _this === Annotation ? true : (x.$metadataName === _this.getMetadataName()); }); });
-    };
+            .map(set => (set || []).filter(x => this === Annotation ? true : (x.$metadataName === this.getMetadataName())));
+    }
     /**
      * Get all instances of this annotation class attached to the parameters of the constructor
      * for the given class.
@@ -509,168 +468,159 @@ var Annotation = /** @class */ (function () {
      * @param this
      * @param type The class where constructor parameter annotations should be checked for
      */
-    Annotation.getAllForConstructorParameters = function (type) {
-        var _this = this;
-        var finalSet = new Array(type.length).fill(undefined);
-        var annotations = Annotations.getConstructorParameterAnnotations(type)
-            .map(function (set) { return (set || []).filter(function (x) { return _this === Annotation ? true : (x.$metadataName === _this.getMetadataName()); }); });
-        for (var i = 0, max = annotations.length; i < max; ++i)
+    static getAllForConstructorParameters(type) {
+        let finalSet = new Array(type.length).fill(undefined);
+        let annotations = Annotations.getConstructorParameterAnnotations(type)
+            .map(set => (set || []).filter(x => this === Annotation ? true : (x.$metadataName === this.getMetadataName())));
+        for (let i = 0, max = annotations.length; i < max; ++i)
             finalSet[i] = annotations[i];
         return finalSet;
-    };
-    return Annotation;
-}());
+    }
+}
 exports.Annotation = Annotation;
 /**
  * A helper class for managing annotations
  */
-var Annotations = /** @class */ (function () {
-    function Annotations() {
-    }
+class Annotations {
     /**
      * Copy the annotations defined for one class onto another.
      * @param from The class to copy annotations from
      * @param to The class to copy annotations to
      */
-    Annotations.copyClassAnnotations = function (from, to) {
-        var annotations = Annotations.getClassAnnotations(from);
-        annotations.forEach(function (x) { return Annotations.applyToClass(x, to); });
-    };
+    static copyClassAnnotations(from, to) {
+        let annotations = Annotations.getClassAnnotations(from);
+        annotations.forEach(x => Annotations.applyToClass(x, to));
+    }
     /**
      * Apply this annotation to a given target.
      * @param target
      */
-    Annotations.applyToClass = function (annotation, target) {
-        var list = this.getOrCreateListForClass(target);
-        var clone = this.clone(annotation);
+    static applyToClass(annotation, target) {
+        let list = this.getOrCreateListForClass(target);
+        let clone = this.clone(annotation);
         list.push(clone);
         if (Reflect.getOwnMetadata) {
-            var reflectedAnnotations = Reflect.getOwnMetadata('annotations', target) || [];
-            reflectedAnnotations.push({ toString: function () { return "" + clone.$metadataName; }, annotation: clone });
+            let reflectedAnnotations = Reflect.getOwnMetadata('annotations', target) || [];
+            reflectedAnnotations.push({ toString() { return `${clone.$metadataName}`; }, annotation: clone });
             Reflect.defineMetadata('annotations', reflectedAnnotations, target);
         }
         return clone;
-    };
+    }
     /**
      * Apply this annotation instance to the given property.
      * @param target
      * @param name
      */
-    Annotations.applyToProperty = function (annotation, target, name) {
-        var list = this.getOrCreateListForProperty(target, name);
-        var clone = this.clone(annotation);
+    static applyToProperty(annotation, target, name) {
+        let list = this.getOrCreateListForProperty(target, name);
+        let clone = this.clone(annotation);
         list.push(clone);
         if (Reflect.getOwnMetadata) {
-            var reflectedAnnotations = Reflect.getOwnMetadata('propMetadata', target, name) || [];
-            reflectedAnnotations.push({ toString: function () { return "" + clone.$metadataName; }, annotation: clone });
+            let reflectedAnnotations = Reflect.getOwnMetadata('propMetadata', target, name) || [];
+            reflectedAnnotations.push({ toString() { return `${clone.$metadataName}`; }, annotation: clone });
             Reflect.defineMetadata('propMetadata', reflectedAnnotations, target, name);
         }
         return clone;
-    };
+    }
     /**
      * Apply this annotation instance to the given method.
      * @param target
      * @param name
      */
-    Annotations.applyToMethod = function (annotation, target, name) {
-        var list = this.getOrCreateListForMethod(target, name);
-        var clone = Annotations.clone(annotation);
+    static applyToMethod(annotation, target, name) {
+        let list = this.getOrCreateListForMethod(target, name);
+        let clone = Annotations.clone(annotation);
         list.push(clone);
         if (Reflect.getOwnMetadata && target.constructor) {
-            var meta = Reflect.getOwnMetadata('propMetadata', target.constructor) || {};
+            const meta = Reflect.getOwnMetadata('propMetadata', target.constructor) || {};
             meta[name] = (meta.hasOwnProperty(name) && meta[name]) || [];
-            meta[name].unshift({ toString: function () { return "" + clone.$metadataName; }, annotation: clone });
+            meta[name].unshift({ toString() { return `${clone.$metadataName}`; }, annotation: clone });
             Reflect.defineMetadata('propMetadata', meta, target.constructor);
         }
         return clone;
-    };
+    }
     /**
      * Apply this annotation instance to the given method parameter.
      * @param target
      * @param name
      * @param index
      */
-    Annotations.applyToParameter = function (annotation, target, name, index) {
-        var list = this.getOrCreateListForMethodParameters(target, name);
+    static applyToParameter(annotation, target, name, index) {
+        let list = this.getOrCreateListForMethodParameters(target, name);
         while (list.length < index)
             list.push(null);
-        var paramList = list[index] || [];
-        var clone = this.clone(annotation);
+        let paramList = list[index] || [];
+        let clone = this.clone(annotation);
         paramList.push(clone);
         list[index] = paramList;
         return clone;
-    };
+    }
     /**
      * Apply this annotation instance to the given constructor parameter.
      * @param target
      * @param name
      * @param index
      */
-    Annotations.applyToConstructorParameter = function (annotation, target, index) {
-        var list = this.getOrCreateListForConstructorParameters(target);
+    static applyToConstructorParameter(annotation, target, index) {
+        let list = this.getOrCreateListForConstructorParameters(target);
         while (list.length < index)
             list.push(null);
-        var paramList = list[index] || [];
-        var clone = this.clone(annotation);
+        let paramList = list[index] || [];
+        let clone = this.clone(annotation);
         paramList.push(clone);
         list[index] = paramList;
         if (Reflect.getOwnMetadata) {
-            var parameterList = Reflect.getOwnMetadata('parameters', target) || [];
+            let parameterList = Reflect.getOwnMetadata('parameters', target) || [];
             while (parameterList.length < index)
                 parameterList.push(null);
-            var parameterAnnotes = parameterList[index] || [];
+            let parameterAnnotes = parameterList[index] || [];
             parameterAnnotes.push(clone);
             parameterList[index] = parameterAnnotes;
             Reflect.defineMetadata('parameters', parameterList, target);
         }
         return clone;
-    };
+    }
     /**
      * Clone the given Annotation instance into a new instance. This is not
      * a deep copy.
      *
      * @param annotation
      */
-    Annotations.clone = function (annotation) {
+    static clone(annotation) {
         if (!annotation)
             return annotation;
         return Object.assign(Object.create(Object.getPrototypeOf(annotation)), annotation);
-    };
+    }
     /**
      * Get all annotations (including from Angular and other compatible
      * frameworks).
      *
      * @param target The target to fetch annotations for
      */
-    Annotations.getClassAnnotations = function (target) {
-        var _this = this;
+    static getClassAnnotations(target) {
         return (this.getListForClass(target) || [])
-            .map(function (x) { return _this.clone(x); });
-    };
+            .map(x => this.clone(x));
+    }
     /**
      * Get all annotations (including from Angular and other compatible
      * frameworks).
      *
      * @param target The target to fetch annotations for
      */
-    Annotations.getMethodAnnotations = function (target, methodName, isStatic) {
-        var _this = this;
-        if (isStatic === void 0) { isStatic = false; }
+    static getMethodAnnotations(target, methodName, isStatic = false) {
         return (this.getListForMethod(isStatic ? target : target.prototype, methodName) || [])
-            .map(function (x) { return _this.clone(x); });
-    };
+            .map(x => this.clone(x));
+    }
     /**
      * Get all annotations (including from Angular and other compatible
      * frameworks).
      *
      * @param target The target to fetch annotations for
      */
-    Annotations.getPropertyAnnotations = function (target, methodName, isStatic) {
-        var _this = this;
-        if (isStatic === void 0) { isStatic = false; }
+    static getPropertyAnnotations(target, methodName, isStatic = false) {
         return (this.getListForProperty(isStatic ? target : target.prototype, methodName) || [])
-            .map(function (x) { return _this.clone(x); });
-    };
+            .map(x => this.clone(x));
+    }
     /**
      * Get the annotations defined on the parameters of the given method of the given
      * class.
@@ -680,12 +630,10 @@ var Annotations = /** @class */ (function () {
      * @param isStatic Whether `type` itself (isStatic = true), or `type.prototype` (isStatic = false) should be the target.
      *  Note that passing true may indicate that the passed `type` is already the prototype of a class.
      */
-    Annotations.getParameterAnnotations = function (type, methodName, isStatic) {
-        var _this = this;
-        if (isStatic === void 0) { isStatic = false; }
+    static getParameterAnnotations(type, methodName, isStatic = false) {
         return (this.getListForMethodParameters(isStatic ? type : type.prototype, methodName) || [])
-            .map(function (set) { return set ? set.map(function (anno) { return _this.clone(anno); }) : []; });
-    };
+            .map(set => set ? set.map(anno => this.clone(anno)) : []);
+    }
     /**
      * Get the annotations defined on the parameters of the given method of the given
      * class.
@@ -693,165 +641,137 @@ var Annotations = /** @class */ (function () {
      * @param type
      * @param methodName
      */
-    Annotations.getConstructorParameterAnnotations = function (type) {
-        var _this = this;
+    static getConstructorParameterAnnotations(type) {
         return (this.getListForConstructorParameters(type) || [])
-            .map(function (set) { return set ? set.map(function (anno) { return _this.clone(anno); }) : []; });
-    };
+            .map(set => set ? set.map(anno => this.clone(anno)) : []);
+    }
     /**
      * Get a list of annotations for the given class.
      * @param target
      */
-    Annotations.getListForClass = function (target) {
+    static getListForClass(target) {
         if (!target)
             return [];
-        var combinedSet = [];
-        var superclass = Object.getPrototypeOf(target);
+        let combinedSet = [];
+        let superclass = Object.getPrototypeOf(target);
         if (superclass && superclass !== Function)
             combinedSet = combinedSet.concat(this.getListForClass(superclass));
         if (target.hasOwnProperty(exports.ANNOTATIONS_KEY))
             combinedSet = combinedSet.concat(target[exports.ANNOTATIONS_KEY] || []);
         return combinedSet;
-    };
+    }
     /**
      * Get a list of own annotations for the given class, or create that list.
      * @param target
      */
-    Annotations.getOrCreateListForClass = function (target) {
+    static getOrCreateListForClass(target) {
         if (!target.hasOwnProperty(exports.ANNOTATIONS_KEY))
             Object.defineProperty(target, exports.ANNOTATIONS_KEY, { enumerable: false, value: [] });
         return target[exports.ANNOTATIONS_KEY];
-    };
+    }
     /**
      * Gets a map of the annotations defined on all properties of the given class/function. To get the annotations of instance fields,
      * make sure to use `Class.prototype`, otherwise static annotations are returned.
      */
-    Annotations.getMapForClassProperties = function (target, mapToPopulate) {
-        var e_1, _a;
-        var combinedSet = mapToPopulate || {};
+    static getMapForClassProperties(target, mapToPopulate) {
+        let combinedSet = mapToPopulate || {};
         if (!target || target === Function)
             return combinedSet;
         this.getMapForClassProperties(Object.getPrototypeOf(target), combinedSet);
         if (target.hasOwnProperty(exports.PROPERTY_ANNOTATIONS_KEY)) {
-            var ownMap = target[exports.PROPERTY_ANNOTATIONS_KEY] || {};
-            try {
-                for (var _b = (0, tslib_1.__values)(Object.keys(ownMap)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var key = _c.value;
-                    combinedSet[key] = (combinedSet[key] || []).concat(ownMap[key]);
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
+            let ownMap = target[exports.PROPERTY_ANNOTATIONS_KEY] || {};
+            for (let key of Object.keys(ownMap))
+                combinedSet[key] = (combinedSet[key] || []).concat(ownMap[key]);
         }
         return combinedSet;
-    };
-    Annotations.getOrCreateMapForClassProperties = function (target) {
+    }
+    static getOrCreateMapForClassProperties(target) {
         if (!target.hasOwnProperty(exports.PROPERTY_ANNOTATIONS_KEY))
             Object.defineProperty(target, exports.PROPERTY_ANNOTATIONS_KEY, { enumerable: false, value: [] });
         return target[exports.PROPERTY_ANNOTATIONS_KEY];
-    };
-    Annotations.getListForProperty = function (target, propertyKey) {
-        var map = this.getMapForClassProperties(target);
+    }
+    static getListForProperty(target, propertyKey) {
+        let map = this.getMapForClassProperties(target);
         if (!map)
             return null;
         return map[propertyKey];
-    };
-    Annotations.getOrCreateListForProperty = function (target, propertyKey) {
-        var map = this.getOrCreateMapForClassProperties(target);
+    }
+    static getOrCreateListForProperty(target, propertyKey) {
+        let map = this.getOrCreateMapForClassProperties(target);
         if (!map[propertyKey])
             map[propertyKey] = [];
         return map[propertyKey];
-    };
-    Annotations.getOrCreateListForMethod = function (target, methodName) {
+    }
+    static getOrCreateListForMethod(target, methodName) {
         return this.getOrCreateListForProperty(target, methodName);
-    };
-    Annotations.getListForMethod = function (target, methodName) {
+    }
+    static getListForMethod(target, methodName) {
         return this.getListForProperty(target, methodName);
-    };
+    }
     /**
      * Get a map of the annotations defined on all parameters of all methods of the given class/function.
      * To get instance methods, make sure to pass `Class.prototype`, otherwise the results are for static fields.
      */
-    Annotations.getMapForMethodParameters = function (target, mapToPopulate) {
-        var e_2, _a;
-        var combinedMap = mapToPopulate || {};
+    static getMapForMethodParameters(target, mapToPopulate) {
+        let combinedMap = mapToPopulate || {};
         if (!target || target === Function)
             return combinedMap;
         // superclass/prototype
         this.getMapForMethodParameters(Object.getPrototypeOf(target), combinedMap);
         if (target.hasOwnProperty(exports.METHOD_PARAMETER_ANNOTATIONS_KEY)) {
-            var ownMap = target[exports.METHOD_PARAMETER_ANNOTATIONS_KEY] || {};
-            try {
-                for (var _b = (0, tslib_1.__values)(Object.keys(ownMap)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var methodName = _c.value;
-                    var parameters = ownMap[methodName];
-                    var combinedMethodMap = combinedMap[methodName] || [];
-                    for (var i = 0, max = parameters.length; i < max; ++i) {
-                        combinedMethodMap[i] = (combinedMethodMap[i] || []).concat(parameters[i] || []);
-                    }
-                    combinedMap[methodName] = combinedMethodMap;
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            let ownMap = target[exports.METHOD_PARAMETER_ANNOTATIONS_KEY] || {};
+            for (let methodName of Object.keys(ownMap)) {
+                let parameters = ownMap[methodName];
+                let combinedMethodMap = combinedMap[methodName] || [];
+                for (let i = 0, max = parameters.length; i < max; ++i) {
+                    combinedMethodMap[i] = (combinedMethodMap[i] || []).concat(parameters[i] || []);
                 }
-                finally { if (e_2) throw e_2.error; }
+                combinedMap[methodName] = combinedMethodMap;
             }
         }
         return combinedMap;
-    };
-    Annotations.getOrCreateMapForMethodParameters = function (target) {
+    }
+    static getOrCreateMapForMethodParameters(target) {
         if (!target.hasOwnProperty(exports.METHOD_PARAMETER_ANNOTATIONS_KEY))
             Object.defineProperty(target, exports.METHOD_PARAMETER_ANNOTATIONS_KEY, { enumerable: false, value: [] });
         return target[exports.METHOD_PARAMETER_ANNOTATIONS_KEY];
-    };
-    Annotations.getListForMethodParameters = function (target, methodName) {
-        var map = this.getMapForMethodParameters(target);
+    }
+    static getListForMethodParameters(target, methodName) {
+        let map = this.getMapForMethodParameters(target);
         if (!map)
             return null;
         return map[methodName];
-    };
-    Annotations.getOrCreateListForMethodParameters = function (target, methodName) {
-        var map = this.getOrCreateMapForMethodParameters(target);
+    }
+    static getOrCreateListForMethodParameters(target, methodName) {
+        let map = this.getOrCreateMapForMethodParameters(target);
         if (!map[methodName])
             map[methodName] = [];
         return map[methodName];
-    };
-    Annotations.getOrCreateListForConstructorParameters = function (target) {
+    }
+    static getOrCreateListForConstructorParameters(target) {
         if (!target[exports.CONSTRUCTOR_PARAMETERS_ANNOTATIONS_KEY])
             Object.defineProperty(target, exports.CONSTRUCTOR_PARAMETERS_ANNOTATIONS_KEY, { enumerable: false, value: [] });
         return target[exports.CONSTRUCTOR_PARAMETERS_ANNOTATIONS_KEY];
-    };
-    Annotations.getListForConstructorParameters = function (target) {
+    }
+    static getListForConstructorParameters(target) {
         return target[exports.CONSTRUCTOR_PARAMETERS_ANNOTATIONS_KEY];
-    };
-    return Annotations;
-}());
+    }
+}
 exports.Annotations = Annotations;
 /**
  * An annotation for attaching a label to a programmatic element.
  * Can be queried with LabelAnnotation.getForClass() for example.
  */
-var LabelAnnotation = /** @class */ (function (_super) {
-    (0, tslib_1.__extends)(LabelAnnotation, _super);
-    function LabelAnnotation(text) {
-        var _this = _super.call(this) || this;
-        _this.text = text;
-        return _this;
-    }
-    LabelAnnotation = (0, tslib_1.__decorate)([
-        MetadataName('alterior:Label'),
-        (0, tslib_1.__metadata)("design:paramtypes", [String])
-    ], LabelAnnotation);
-    return LabelAnnotation;
-}(Annotation));
+let LabelAnnotation = class LabelAnnotation extends Annotation {
+    constructor(text) {
+        super();
+        this.text = text;
+    }
+};
+LabelAnnotation = (0, tslib_1.__decorate)([
+    MetadataName('alterior:Label'),
+    (0, tslib_1.__metadata)("design:paramtypes", [String])
+], LabelAnnotation);
 exports.LabelAnnotation = LabelAnnotation;
 exports.Label = LabelAnnotation.decorator();
 //# sourceMappingURL=annotations.js.map