Skip to content

Instantly share code, notes, and snippets.

@mikilian

mikilian/reflect-metadata.ts

Last active May 16, 2020 21:27
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save mikilian/d7b589ee50dc24672d1cba212f0ab542 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save mikilian/d7b589ee50dc24672d1cba212f0ab542 to your computer and use it in GitHub Desktop.
Download ZIP

Revisions

  1. mikilian revised this gist May 16, 2020. No changes.
  2. mikilian created this gist May 16, 2020.
    1,807 changes: 1,807 additions & 0 deletions reflect-metadata.ts
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,1807 @@
    /*! *****************************************************************************
    Copyright (C) Microsoft. All rights reserved.
    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
    this file except in compliance with the License. You may obtain a copy of the
    License at http://www.apache.org/licenses/LICENSE-2.0
    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
    MERCHANTABLITY OR NON-INFRINGEMENT.
    See the Apache Version 2.0 License for specific language governing permissions
    and limitations under the License.
    ***************************************************************************** */
    export namespace Reflect {
    // Metadata Proposal
    // https://rbuckton.github.io/reflect-metadata/

    type HashMap<V> = Record<string, V>;

    interface BufferLike {
    [offset: number]: number;
    length: number;
    }

    type IteratorResult<T> = { value: T, done: false } | { value: never, done: true };

    interface Iterator<T> {
    next(value?: any): IteratorResult<T>;
    throw?(value: any): IteratorResult<T>;
    return?(value?: T): IteratorResult<T>;
    }

    interface Iterable<T> {
    "@@iterator"(): Iterator<T>;
    }

    interface IterableIterator<T> extends Iterator<T> {
    "@@iterator"(): IterableIterator<T>;
    }

    interface Map<K, V> extends Iterable<[K, V]> {
    size: number;
    has(key: K): boolean;
    get(key: K): V;
    set(key: K, value?: V): this;
    delete(key: K): boolean;
    clear(): void;
    keys(): IterableIterator<K>;
    values(): IterableIterator<V>;
    entries(): IterableIterator<[K, V]>;
    }

    interface MapConstructor {
    new (): Map<any, any>;
    new <K, V>(): Map<K, V>;
    prototype: Map<any, any>;
    }

    interface Set<T> extends Iterable<T> {
    size: number;
    has(value: T): boolean;
    add(value: T): this;
    delete(value: T): boolean;
    clear(): void;
    keys(): IterableIterator<T>;
    values(): IterableIterator<T>;
    entries(): IterableIterator<[T, T]>;
    }

    interface SetConstructor {
    new (): Set<any>;
    new <T>(): Set<T>;
    prototype: Set<any>;
    }

    interface WeakMap<K, V> {
    clear(): void;
    delete(key: K): boolean;
    get(key: K): V;
    has(key: K): boolean;
    set(key: K, value?: V): WeakMap<K, V>;
    }

    interface WeakMapConstructor {
    new (): WeakMap<any, any>;
    new <K, V>(): WeakMap<K, V>;
    prototype: WeakMap<any, any>;
    }

    type MemberDecorator = <T>(target: Object, propertyKey: string | symbol, descriptor?: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;
    declare const Symbol: { iterator: symbol, toPrimitive: symbol };
    declare const Set: SetConstructor;
    declare const WeakMap: WeakMapConstructor;
    declare const Map: MapConstructor;
    declare const global: any;
    declare const crypto: Crypto;
    declare const msCrypto: Crypto;
    declare const process: any;

    /**
    * Applies a set of decorators to a target object.
    * @param decorators An array of decorators.
    * @param target The target object.
    * @returns The result of applying the provided decorators.
    * @remarks Decorators are applied in reverse order of their positions in the array.
    * @example
    *
    * class Example { }
    *
    * // constructor
    * Example = Reflect.decorate(decoratorsArray, Example);
    *
    */
    export declare function decorate(decorators: ClassDecorator[], target: Function): Function;

    /**
    * Applies a set of decorators to a property of a target object.
    * @param decorators An array of decorators.
    * @param target The target object.
    * @param propertyKey The property key to decorate.
    * @param attributes A property descriptor.
    * @remarks Decorators are applied in reverse order.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * static staticMethod() { }
    * method() { }
    * }
    *
    * // property (on constructor)
    * Reflect.decorate(decoratorsArray, Example, "staticProperty");
    *
    * // property (on prototype)
    * Reflect.decorate(decoratorsArray, Example.prototype, "property");
    *
    * // method (on constructor)
    * Object.defineProperty(Example, "staticMethod",
    * Reflect.decorate(decoratorsArray, Example, "staticMethod",
    * Object.getOwnPropertyDescriptor(Example, "staticMethod")));
    *
    * // method (on prototype)
    * Object.defineProperty(Example.prototype, "method",
    * Reflect.decorate(decoratorsArray, Example.prototype, "method",
    * Object.getOwnPropertyDescriptor(Example.prototype, "method")));
    *
    */
    export declare function decorate(decorators: (PropertyDecorator | MethodDecorator)[], target: any, propertyKey: string | symbol, attributes?: PropertyDescriptor | null): PropertyDescriptor | undefined;

    /**
    * Applies a set of decorators to a property of a target object.
    * @param decorators An array of decorators.
    * @param target The target object.
    * @param propertyKey The property key to decorate.
    * @param attributes A property descriptor.
    * @remarks Decorators are applied in reverse order.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * static staticMethod() { }
    * method() { }
    * }
    *
    * // property (on constructor)
    * Reflect.decorate(decoratorsArray, Example, "staticProperty");
    *
    * // property (on prototype)
    * Reflect.decorate(decoratorsArray, Example.prototype, "property");
    *
    * // method (on constructor)
    * Object.defineProperty(Example, "staticMethod",
    * Reflect.decorate(decoratorsArray, Example, "staticMethod",
    * Object.getOwnPropertyDescriptor(Example, "staticMethod")));
    *
    * // method (on prototype)
    * Object.defineProperty(Example.prototype, "method",
    * Reflect.decorate(decoratorsArray, Example.prototype, "method",
    * Object.getOwnPropertyDescriptor(Example.prototype, "method")));
    *
    */
    export declare function decorate(decorators: (PropertyDecorator | MethodDecorator)[], target: any, propertyKey: string | symbol, attributes: PropertyDescriptor): PropertyDescriptor;

    /**
    * A default metadata decorator factory that can be used on a class, class member, or parameter.
    * @param metadataKey The key for the metadata entry.
    * @param metadataValue The value for the metadata entry.
    * @returns A decorator function.
    * @remarks
    * If `metadataKey` is already defined for the target and target key, the
    * metadataValue for that key will be overwritten.
    * @example
    *
    * // constructor
    * @Reflect.metadata(key, value)
    * class Example {
    * }
    *
    * // property (on constructor, TypeScript only)
    * class Example {
    * @Reflect.metadata(key, value)
    * static staticProperty;
    * }
    *
    * // property (on prototype, TypeScript only)
    * class Example {
    * @Reflect.metadata(key, value)
    * property;
    * }
    *
    * // method (on constructor)
    * class Example {
    * @Reflect.metadata(key, value)
    * static staticMethod() { }
    * }
    *
    * // method (on prototype)
    * class Example {
    * @Reflect.metadata(key, value)
    * method() { }
    * }
    *
    */
    export declare function metadata(metadataKey: any, metadataValue: any): { (target: Function): void; (target: any, propertyKey: string | symbol): void; };

    /**
    * Define a unique metadata entry on the target.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param metadataValue A value that contains attached metadata.
    * @param target The target object on which to define metadata.
    * @example
    *
    * class Example {
    * }
    *
    * // constructor
    * Reflect.defineMetadata("custom:annotation", options, Example);
    *
    * // decorator factory as metadata-producing annotation.
    * function MyAnnotation(options): ClassDecorator {
    * return target => Reflect.defineMetadata("custom:annotation", options, target);
    * }
    *
    */
    export declare function defineMetadata(metadataKey: any, metadataValue: any, target: any): void;

    /**
    * Define a unique metadata entry on the target.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param metadataValue A value that contains attached metadata.
    * @param target The target object on which to define metadata.
    * @param propertyKey The property key for the target.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * static staticMethod(p) { }
    * method(p) { }
    * }
    *
    * // property (on constructor)
    * Reflect.defineMetadata("custom:annotation", Number, Example, "staticProperty");
    *
    * // property (on prototype)
    * Reflect.defineMetadata("custom:annotation", Number, Example.prototype, "property");
    *
    * // method (on constructor)
    * Reflect.defineMetadata("custom:annotation", Number, Example, "staticMethod");
    *
    * // method (on prototype)
    * Reflect.defineMetadata("custom:annotation", Number, Example.prototype, "method");
    *
    * // decorator factory as metadata-producing annotation.
    * function MyAnnotation(options): PropertyDecorator {
    * return (target, key) => Reflect.defineMetadata("custom:annotation", options, target, key);
    * }
    *
    */
    export declare function defineMetadata(metadataKey: any, metadataValue: any, target: any, propertyKey: string | symbol): void;

    /**
    * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param target The target object on which the metadata is defined.
    * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
    * @example
    *
    * class Example {
    * }
    *
    * // constructor
    * result = Reflect.hasMetadata("custom:annotation", Example);
    *
    */
    export declare function hasMetadata(metadataKey: any, target: any): boolean;

    /**
    * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param target The target object on which the metadata is defined.
    * @param propertyKey The property key for the target.
    * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * static staticMethod(p) { }
    * method(p) { }
    * }
    *
    * // property (on constructor)
    * result = Reflect.hasMetadata("custom:annotation", Example, "staticProperty");
    *
    * // property (on prototype)
    * result = Reflect.hasMetadata("custom:annotation", Example.prototype, "property");
    *
    * // method (on constructor)
    * result = Reflect.hasMetadata("custom:annotation", Example, "staticMethod");
    *
    * // method (on prototype)
    * result = Reflect.hasMetadata("custom:annotation", Example.prototype, "method");
    *
    */
    export declare function hasMetadata(metadataKey: any, target: any, propertyKey: string | symbol): boolean;

    /**
    * Gets a value indicating whether the target object has the provided metadata key defined.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param target The target object on which the metadata is defined.
    * @returns `true` if the metadata key was defined on the target object; otherwise, `false`.
    * @example
    *
    * class Example {
    * }
    *
    * // constructor
    * result = Reflect.hasOwnMetadata("custom:annotation", Example);
    *
    */
    export declare function hasOwnMetadata(metadataKey: any, target: any): boolean;

    /**
    * Gets a value indicating whether the target object has the provided metadata key defined.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param target The target object on which the metadata is defined.
    * @param propertyKey The property key for the target.
    * @returns `true` if the metadata key was defined on the target object; otherwise, `false`.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * static staticMethod(p) { }
    * method(p) { }
    * }
    *
    * // property (on constructor)
    * result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticProperty");
    *
    * // property (on prototype)
    * result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "property");
    *
    * // method (on constructor)
    * result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticMethod");
    *
    * // method (on prototype)
    * result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "method");
    *
    */
    export declare function hasOwnMetadata(metadataKey: any, target: any, propertyKey: string | symbol): boolean;

    /**
    * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param target The target object on which the metadata is defined.
    * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
    * @example
    *
    * class Example {
    * }
    *
    * // constructor
    * result = Reflect.getMetadata("custom:annotation", Example);
    *
    */
    export declare function getMetadata(metadataKey: any, target: any): any;

    /**
    * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param target The target object on which the metadata is defined.
    * @param propertyKey The property key for the target.
    * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * static staticMethod(p) { }
    * method(p) { }
    * }
    *
    * // property (on constructor)
    * result = Reflect.getMetadata("custom:annotation", Example, "staticProperty");
    *
    * // property (on prototype)
    * result = Reflect.getMetadata("custom:annotation", Example.prototype, "property");
    *
    * // method (on constructor)
    * result = Reflect.getMetadata("custom:annotation", Example, "staticMethod");
    *
    * // method (on prototype)
    * result = Reflect.getMetadata("custom:annotation", Example.prototype, "method");
    *
    */
    export declare function getMetadata(metadataKey: any, target: any, propertyKey: string | symbol): any;

    /**
    * Gets the metadata value for the provided metadata key on the target object.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param target The target object on which the metadata is defined.
    * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
    * @example
    *
    * class Example {
    * }
    *
    * // constructor
    * result = Reflect.getOwnMetadata("custom:annotation", Example);
    *
    */
    export declare function getOwnMetadata(metadataKey: any, target: any): any;

    /**
    * Gets the metadata value for the provided metadata key on the target object.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param target The target object on which the metadata is defined.
    * @param propertyKey The property key for the target.
    * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * static staticMethod(p) { }
    * method(p) { }
    * }
    *
    * // property (on constructor)
    * result = Reflect.getOwnMetadata("custom:annotation", Example, "staticProperty");
    *
    * // property (on prototype)
    * result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "property");
    *
    * // method (on constructor)
    * result = Reflect.getOwnMetadata("custom:annotation", Example, "staticMethod");
    *
    * // method (on prototype)
    * result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "method");
    *
    */
    export declare function getOwnMetadata(metadataKey: any, target: any, propertyKey: string | symbol): any;

    /**
    * Gets the metadata keys defined on the target object or its prototype chain.
    * @param target The target object on which the metadata is defined.
    * @returns An array of unique metadata keys.
    * @example
    *
    * class Example {
    * }
    *
    * // constructor
    * result = Reflect.getMetadataKeys(Example);
    *
    */
    export declare function getMetadataKeys(target: any): any[];

    /**
    * Gets the metadata keys defined on the target object or its prototype chain.
    * @param target The target object on which the metadata is defined.
    * @param propertyKey The property key for the target.
    * @returns An array of unique metadata keys.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * static staticMethod(p) { }
    * method(p) { }
    * }
    *
    * // property (on constructor)
    * result = Reflect.getMetadataKeys(Example, "staticProperty");
    *
    * // property (on prototype)
    * result = Reflect.getMetadataKeys(Example.prototype, "property");
    *
    * // method (on constructor)
    * result = Reflect.getMetadataKeys(Example, "staticMethod");
    *
    * // method (on prototype)
    * result = Reflect.getMetadataKeys(Example.prototype, "method");
    *
    */
    export declare function getMetadataKeys(target: any, propertyKey: string | symbol): any[];

    /**
    * Gets the unique metadata keys defined on the target object.
    * @param target The target object on which the metadata is defined.
    * @returns An array of unique metadata keys.
    * @example
    *
    * class Example {
    * }
    *
    * // constructor
    * result = Reflect.getOwnMetadataKeys(Example);
    *
    */
    export declare function getOwnMetadataKeys(target: any): any[];

    /**
    * Gets the unique metadata keys defined on the target object.
    * @param target The target object on which the metadata is defined.
    * @param propertyKey The property key for the target.
    * @returns An array of unique metadata keys.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * static staticMethod(p) { }
    * method(p) { }
    * }
    *
    * // property (on constructor)
    * result = Reflect.getOwnMetadataKeys(Example, "staticProperty");
    *
    * // property (on prototype)
    * result = Reflect.getOwnMetadataKeys(Example.prototype, "property");
    *
    * // method (on constructor)
    * result = Reflect.getOwnMetadataKeys(Example, "staticMethod");
    *
    * // method (on prototype)
    * result = Reflect.getOwnMetadataKeys(Example.prototype, "method");
    *
    */
    export declare function getOwnMetadataKeys(target: any, propertyKey: string | symbol): any[];

    /**
    * Deletes the metadata entry from the target object with the provided key.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param target The target object on which the metadata is defined.
    * @returns `true` if the metadata entry was found and deleted; otherwise, false.
    * @example
    *
    * class Example {
    * }
    *
    * // constructor
    * result = Reflect.deleteMetadata("custom:annotation", Example);
    *
    */
    export declare function deleteMetadata(metadataKey: any, target: any): boolean;

    /**
    * Deletes the metadata entry from the target object with the provided key.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param target The target object on which the metadata is defined.
    * @param propertyKey The property key for the target.
    * @returns `true` if the metadata entry was found and deleted; otherwise, false.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * static staticMethod(p) { }
    * method(p) { }
    * }
    *
    * // property (on constructor)
    * result = Reflect.deleteMetadata("custom:annotation", Example, "staticProperty");
    *
    * // property (on prototype)
    * result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "property");
    *
    * // method (on constructor)
    * result = Reflect.deleteMetadata("custom:annotation", Example, "staticMethod");
    *
    * // method (on prototype)
    * result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "method");
    *
    */
    export declare function deleteMetadata(metadataKey: any, target: any, propertyKey: string | symbol): boolean;
    declare var self: { [key: string]: any };
    (function (this: any, factory: (exporter: <K extends keyof typeof Reflect>(key: K, value: typeof Reflect[K]) => void) => void) {
    const root = typeof global === "object" ? global :
    typeof self === "object" ? self :
    typeof this === "object" ? this :
    Function("return this;")();

    let exporter = makeExporter(Reflect);
    if (typeof root.Reflect === "undefined") {
    root.Reflect = Reflect;
    }
    else {
    exporter = makeExporter(root.Reflect, exporter);
    }

    factory(exporter);

    function makeExporter(target: typeof Reflect, previous?: <K extends keyof typeof Reflect>(key: K, value: typeof Reflect[K]) => void) {
    return <K extends keyof typeof Reflect>(key: K, value: typeof Reflect[K]) => {
    if (typeof target[key] !== "function") {
    Object.defineProperty(target, key, { configurable: true, writable: true, value });
    }
    if (previous) previous(key, value);
    };
    }
    })
    (function (exporter) {
    const hasOwn = Object.prototype.hasOwnProperty;

    // feature test for Symbol support
    const supportsSymbol = typeof Symbol === "function";
    const toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
    const iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
    const supportsCreate = typeof Object.create === "function"; // feature test for Object.create support
    const supportsProto = { __proto__: [] } instanceof Array; // feature test for __proto__ support
    const downLevel = !supportsCreate && !supportsProto;

    const HashMap = {
    // create an object in dictionary mode (a.k.a. "slow" mode in v8)
    create: supportsCreate
    ? <V>() => MakeDictionary(Object.create(null) as HashMap<V>)
    : supportsProto
    ? <V>() => MakeDictionary({ __proto__: null as any } as HashMap<V>)
    : <V>() => MakeDictionary({} as HashMap<V>),

    has: downLevel
    ? <V>(map: HashMap<V>, key: string | number | symbol) => hasOwn.call(map, key)
    : <V>(map: HashMap<V>, key: string | number | symbol) => key in map,

    get: downLevel
    ? <V>(map: HashMap<V>, key: string | number | symbol): V | undefined => hasOwn.call(map, key) ? map[key as string | number] : undefined
    : <V>(map: HashMap<V>, key: string | number | symbol): V | undefined => map[key as string | number],
    };

    // Load global or shim versions of Map, Set, and WeakMap
    const functionPrototype = Object.getPrototypeOf(Function);
    const usePolyfill = typeof process === "object" && process.env && process.env["REFLECT_METADATA_USE_MAP_POLYFILL"] === "true";
    const _Map: typeof Map = !usePolyfill && typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
    const _Set: typeof Set = !usePolyfill && typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
    const _WeakMap: typeof WeakMap = !usePolyfill && typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();

    // [[Metadata]] internal slot
    // https://rbuckton.github.io/reflect-metadata/#ordinary-object-internal-methods-and-internal-slots
    const Metadata = new _WeakMap<any, Map<string | symbol | undefined, Map<any, any>>>();

    // function decorate(decorators: ClassDecorator[], target: Function): Function;
    // function decorate(decorators: (PropertyDecorator | MethodDecorator)[], target: any, propertyKey: string | symbol, attributes?: PropertyDescriptor | null): PropertyDescriptor | undefined;
    // function decorate(decorators: (PropertyDecorator | MethodDecorator)[], target: any, propertyKey: string | symbol, attributes: PropertyDescriptor): PropertyDescriptor;

    /**
    * Applies a set of decorators to a property of a target object.
    * @param decorators An array of decorators.
    * @param target The target object.
    * @param propertyKey (Optional) The property key to decorate.
    * @param attributes (Optional) The property descriptor for the target key.
    * @remarks Decorators are applied in reverse order.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * constructor(p) { }
    * static staticMethod(p) { }
    * method(p) { }
    * }
    *
    * // constructor
    * Example = Reflect.decorate(decoratorsArray, Example);
    *
    * // property (on constructor)
    * Reflect.decorate(decoratorsArray, Example, "staticProperty");
    *
    * // property (on prototype)
    * Reflect.decorate(decoratorsArray, Example.prototype, "property");
    *
    * // method (on constructor)
    * Object.defineProperty(Example, "staticMethod",
    * Reflect.decorate(decoratorsArray, Example, "staticMethod",
    * Object.getOwnPropertyDescriptor(Example, "staticMethod")));
    *
    * // method (on prototype)
    * Object.defineProperty(Example.prototype, "method",
    * Reflect.decorate(decoratorsArray, Example.prototype, "method",
    * Object.getOwnPropertyDescriptor(Example.prototype, "method")));
    *
    */
    function decorate(decorators: (ClassDecorator | MemberDecorator)[], target: any, propertyKey?: string | symbol, attributes?: PropertyDescriptor | null): PropertyDescriptor | Function | undefined {
    if (!IsUndefined(propertyKey)) {
    if (!IsArray(decorators)) throw new TypeError();
    if (!IsObject(target)) throw new TypeError();
    if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes)) throw new TypeError();
    if (IsNull(attributes)) attributes = undefined;
    propertyKey = ToPropertyKey(propertyKey);
    return DecorateProperty(<MemberDecorator[]>decorators, target, propertyKey, attributes);
    }
    else {
    if (!IsArray(decorators)) throw new TypeError();
    if (!IsConstructor(target)) throw new TypeError();
    return DecorateConstructor(<ClassDecorator[]>decorators, <Function>target);
    }
    }

    exporter("decorate", <any>decorate);

    // 4.1.2 Reflect.metadata(metadataKey, metadataValue)
    // https://rbuckton.github.io/reflect-metadata/#reflect.metadata

    /**
    * A default metadata decorator factory that can be used on a class, class member, or parameter.
    * @param metadataKey The key for the metadata entry.
    * @param metadataValue The value for the metadata entry.
    * @returns A decorator function.
    * @remarks
    * If `metadataKey` is already defined for the target and target key, the
    * metadataValue for that key will be overwritten.
    * @example
    *
    * // constructor
    * @Reflect.metadata(key, value)
    * class Example {
    * }
    *
    * // property (on constructor, TypeScript only)
    * class Example {
    * @Reflect.metadata(key, value)
    * static staticProperty;
    * }
    *
    * // property (on prototype, TypeScript only)
    * class Example {
    * @Reflect.metadata(key, value)
    * property;
    * }
    *
    * // method (on constructor)
    * class Example {
    * @Reflect.metadata(key, value)
    * static staticMethod() { }
    * }
    *
    * // method (on prototype)
    * class Example {
    * @Reflect.metadata(key, value)
    * method() { }
    * }
    *
    */
    function metadata(metadataKey: any, metadataValue: any) {
    function decorator(target: Function): void;
    function decorator(target: any, propertyKey: string | symbol): void;
    function decorator(target: any, propertyKey?: string | symbol): void {
    if (!IsObject(target)) throw new TypeError();
    if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey)) throw new TypeError();
    OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
    }
    return decorator;
    }

    exporter("metadata", metadata);

    // 4.1.3 Reflect.defineMetadata(metadataKey, metadataValue, target [, propertyKey])
    // https://rbuckton.github.io/reflect-metadata/#reflect.definemetadata

    function defineMetadata(metadataKey: any, metadataValue: any, target: any): void;
    function defineMetadata(metadataKey: any, metadataValue: any, target: any, propertyKey: string | symbol): void;

    /**
    * Define a unique metadata entry on the target.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param metadataValue A value that contains attached metadata.
    * @param target The target object on which to define metadata.
    * @param propertyKey (Optional) The property key for the target.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * constructor(p) { }
    * static staticMethod(p) { }
    * method(p) { }
    * }
    *
    * // constructor
    * Reflect.defineMetadata("custom:annotation", options, Example);
    *
    * // property (on constructor)
    * Reflect.defineMetadata("custom:annotation", options, Example, "staticProperty");
    *
    * // property (on prototype)
    * Reflect.defineMetadata("custom:annotation", options, Example.prototype, "property");
    *
    * // method (on constructor)
    * Reflect.defineMetadata("custom:annotation", options, Example, "staticMethod");
    *
    * // method (on prototype)
    * Reflect.defineMetadata("custom:annotation", options, Example.prototype, "method");
    *
    * // decorator factory as metadata-producing annotation.
    * function MyAnnotation(options): Decorator {
    * return (target, key?) => Reflect.defineMetadata("custom:annotation", options, target, key);
    * }
    *
    */
    function defineMetadata(metadataKey: any, metadataValue: any, target: any, propertyKey?: string | symbol): void {
    if (!IsObject(target)) throw new TypeError();
    if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
    return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
    }

    exporter("defineMetadata", defineMetadata);

    // 4.1.4 Reflect.hasMetadata(metadataKey, target [, propertyKey])
    // https://rbuckton.github.io/reflect-metadata/#reflect.hasmetadata

    function hasMetadata(metadataKey: any, target: any): boolean;
    function hasMetadata(metadataKey: any, target: any, propertyKey: string | symbol): boolean;

    /**
    * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param target The target object on which the metadata is defined.
    * @param propertyKey (Optional) The property key for the target.
    * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * constructor(p) { }
    * static staticMethod(p) { }
    * method(p) { }
    * }
    *
    * // constructor
    * result = Reflect.hasMetadata("custom:annotation", Example);
    *
    * // property (on constructor)
    * result = Reflect.hasMetadata("custom:annotation", Example, "staticProperty");
    *
    * // property (on prototype)
    * result = Reflect.hasMetadata("custom:annotation", Example.prototype, "property");
    *
    * // method (on constructor)
    * result = Reflect.hasMetadata("custom:annotation", Example, "staticMethod");
    *
    * // method (on prototype)
    * result = Reflect.hasMetadata("custom:annotation", Example.prototype, "method");
    *
    */
    function hasMetadata(metadataKey: any, target: any, propertyKey?: string | symbol): boolean {
    if (!IsObject(target)) throw new TypeError();
    if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
    return OrdinaryHasMetadata(metadataKey, target, propertyKey);
    }

    exporter("hasMetadata", hasMetadata);

    // 4.1.5 Reflect.hasOwnMetadata(metadataKey, target [, propertyKey])
    // https://rbuckton.github.io/reflect-metadata/#reflect-hasownmetadata

    function hasOwnMetadata(metadataKey: any, target: any): boolean;
    function hasOwnMetadata(metadataKey: any, target: any, propertyKey: string | symbol): boolean;

    /**
    * Gets a value indicating whether the target object has the provided metadata key defined.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param target The target object on which the metadata is defined.
    * @param propertyKey (Optional) The property key for the target.
    * @returns `true` if the metadata key was defined on the target object; otherwise, `false`.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * constructor(p) { }
    * static staticMethod(p) { }
    * method(p) { }
    * }
    *
    * // constructor
    * result = Reflect.hasOwnMetadata("custom:annotation", Example);
    *
    * // property (on constructor)
    * result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticProperty");
    *
    * // property (on prototype)
    * result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "property");
    *
    * // method (on constructor)
    * result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticMethod");
    *
    * // method (on prototype)
    * result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "method");
    *
    */
    function hasOwnMetadata(metadataKey: any, target: any, propertyKey?: string | symbol): boolean {
    if (!IsObject(target)) throw new TypeError();
    if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
    return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
    }

    exporter("hasOwnMetadata", hasOwnMetadata);

    // 4.1.6 Reflect.getMetadata(metadataKey, target [, propertyKey])
    // https://rbuckton.github.io/reflect-metadata/#reflect-getmetadata

    function getMetadata(metadataKey: any, target: any): any;
    function getMetadata(metadataKey: any, target: any, propertyKey: string | symbol): any;

    /**
    * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param target The target object on which the metadata is defined.
    * @param propertyKey (Optional) The property key for the target.
    * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * constructor(p) { }
    * static staticMethod(p) { }
    * method(p) { }
    * }
    *
    * // constructor
    * result = Reflect.getMetadata("custom:annotation", Example);
    *
    * // property (on constructor)
    * result = Reflect.getMetadata("custom:annotation", Example, "staticProperty");
    *
    * // property (on prototype)
    * result = Reflect.getMetadata("custom:annotation", Example.prototype, "property");
    *
    * // method (on constructor)
    * result = Reflect.getMetadata("custom:annotation", Example, "staticMethod");
    *
    * // method (on prototype)
    * result = Reflect.getMetadata("custom:annotation", Example.prototype, "method");
    *
    */
    function getMetadata(metadataKey: any, target: any, propertyKey?: string | symbol): any {
    if (!IsObject(target)) throw new TypeError();
    if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
    return OrdinaryGetMetadata(metadataKey, target, propertyKey);
    }

    exporter("getMetadata", getMetadata);

    // 4.1.7 Reflect.getOwnMetadata(metadataKey, target [, propertyKey])
    // https://rbuckton.github.io/reflect-metadata/#reflect-getownmetadata

    function getOwnMetadata(metadataKey: any, target: any): any;
    function getOwnMetadata(metadataKey: any, target: any, propertyKey: string | symbol): any;

    /**
    * Gets the metadata value for the provided metadata key on the target object.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param target The target object on which the metadata is defined.
    * @param propertyKey (Optional) The property key for the target.
    * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * constructor(p) { }
    * static staticMethod(p) { }
    * method(p) { }
    * }
    *
    * // constructor
    * result = Reflect.getOwnMetadata("custom:annotation", Example);
    *
    * // property (on constructor)
    * result = Reflect.getOwnMetadata("custom:annotation", Example, "staticProperty");
    *
    * // property (on prototype)
    * result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "property");
    *
    * // method (on constructor)
    * result = Reflect.getOwnMetadata("custom:annotation", Example, "staticMethod");
    *
    * // method (on prototype)
    * result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "method");
    *
    */
    function getOwnMetadata(metadataKey: any, target: any, propertyKey?: string | symbol): any {
    if (!IsObject(target)) throw new TypeError();
    if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
    return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
    }

    exporter("getOwnMetadata", getOwnMetadata);

    // 4.1.8 Reflect.getMetadataKeys(target [, propertyKey])
    // https://rbuckton.github.io/reflect-metadata/#reflect-getmetadatakeys

    function getMetadataKeys(target: any): any[];
    function getMetadataKeys(target: any, propertyKey: string | symbol): any[];

    /**
    * Gets the metadata keys defined on the target object or its prototype chain.
    * @param target The target object on which the metadata is defined.
    * @param propertyKey (Optional) The property key for the target.
    * @returns An array of unique metadata keys.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * constructor(p) { }
    * static staticMethod(p) { }
    * method(p) { }
    * }
    *
    * // constructor
    * result = Reflect.getMetadataKeys(Example);
    *
    * // property (on constructor)
    * result = Reflect.getMetadataKeys(Example, "staticProperty");
    *
    * // property (on prototype)
    * result = Reflect.getMetadataKeys(Example.prototype, "property");
    *
    * // method (on constructor)
    * result = Reflect.getMetadataKeys(Example, "staticMethod");
    *
    * // method (on prototype)
    * result = Reflect.getMetadataKeys(Example.prototype, "method");
    *
    */
    function getMetadataKeys(target: any, propertyKey?: string | symbol): any[] {
    if (!IsObject(target)) throw new TypeError();
    if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
    return OrdinaryMetadataKeys(target, propertyKey);
    }

    exporter("getMetadataKeys", getMetadataKeys);

    // 4.1.9 Reflect.getOwnMetadataKeys(target [, propertyKey])
    // https://rbuckton.github.io/reflect-metadata/#reflect-getownmetadata

    function getOwnMetadataKeys(target: any): any[];
    function getOwnMetadataKeys(target: any, propertyKey: string | symbol): any[];

    /**
    * Gets the unique metadata keys defined on the target object.
    * @param target The target object on which the metadata is defined.
    * @param propertyKey (Optional) The property key for the target.
    * @returns An array of unique metadata keys.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * constructor(p) { }
    * static staticMethod(p) { }
    * method(p) { }
    * }
    *
    * // constructor
    * result = Reflect.getOwnMetadataKeys(Example);
    *
    * // property (on constructor)
    * result = Reflect.getOwnMetadataKeys(Example, "staticProperty");
    *
    * // property (on prototype)
    * result = Reflect.getOwnMetadataKeys(Example.prototype, "property");
    *
    * // method (on constructor)
    * result = Reflect.getOwnMetadataKeys(Example, "staticMethod");
    *
    * // method (on prototype)
    * result = Reflect.getOwnMetadataKeys(Example.prototype, "method");
    *
    */
    function getOwnMetadataKeys(target: any, propertyKey?: string | symbol): any[] {
    if (!IsObject(target)) throw new TypeError();
    if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
    return OrdinaryOwnMetadataKeys(target, propertyKey);
    }

    exporter("getOwnMetadataKeys", getOwnMetadataKeys);

    // 4.1.10 Reflect.deleteMetadata(metadataKey, target [, propertyKey])
    // https://rbuckton.github.io/reflect-metadata/#reflect-deletemetadata

    function deleteMetadata(metadataKey: any, target: any): boolean;
    function deleteMetadata(metadataKey: any, target: any, propertyKey: string | symbol): boolean;

    /**
    * Deletes the metadata entry from the target object with the provided key.
    * @param metadataKey A key used to store and retrieve metadata.
    * @param target The target object on which the metadata is defined.
    * @param propertyKey (Optional) The property key for the target.
    * @returns `true` if the metadata entry was found and deleted; otherwise, false.
    * @example
    *
    * class Example {
    * // property declarations are not part of ES6, though they are valid in TypeScript:
    * // static staticProperty;
    * // property;
    *
    * constructor(p) { }
    * static staticMethod(p) { }
    * method(p) { }
    * }
    *
    * // constructor
    * result = Reflect.deleteMetadata("custom:annotation", Example);
    *
    * // property (on constructor)
    * result = Reflect.deleteMetadata("custom:annotation", Example, "staticProperty");
    *
    * // property (on prototype)
    * result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "property");
    *
    * // method (on constructor)
    * result = Reflect.deleteMetadata("custom:annotation", Example, "staticMethod");
    *
    * // method (on prototype)
    * result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "method");
    *
    */
    function deleteMetadata(metadataKey: any, target: any, propertyKey?: string | symbol): boolean {
    if (!IsObject(target)) throw new TypeError();
    if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
    const metadataMap = GetOrCreateMetadataMap(target, propertyKey, /*Create*/ false);
    if (IsUndefined(metadataMap)) return false;
    if (!metadataMap.delete(metadataKey)) return false;
    if (metadataMap.size > 0) return true;
    const targetMetadata = Metadata.get(target);
    targetMetadata.delete(propertyKey);
    if (targetMetadata.size > 0) return true;
    Metadata.delete(target);
    return true;
    }

    exporter("deleteMetadata", deleteMetadata);

    function DecorateConstructor(decorators: ClassDecorator[], target: Function): Function {
    for (let i = decorators.length - 1; i >= 0; --i) {
    const decorator = decorators[i];
    const decorated = decorator(target);
    if (!IsUndefined(decorated) && !IsNull(decorated)) {
    if (!IsConstructor(decorated)) throw new TypeError();
    target = <Function>decorated;
    }
    }
    return target;
    }

    function DecorateProperty(decorators: MemberDecorator[], target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor | undefined): PropertyDescriptor | undefined {
    for (let i = decorators.length - 1; i >= 0; --i) {
    const decorator = decorators[i];
    const decorated = decorator(target, propertyKey, descriptor);
    if (!IsUndefined(decorated) && !IsNull(decorated)) {
    if (!IsObject(decorated)) throw new TypeError();
    descriptor = <PropertyDescriptor>decorated;
    }
    }
    return descriptor;
    }

    // 2.1.1 GetOrCreateMetadataMap(O, P, Create)
    // https://rbuckton.github.io/reflect-metadata/#getorcreatemetadatamap
    function GetOrCreateMetadataMap(O: any, P: string | symbol | undefined, Create: true): Map<any, any>;
    function GetOrCreateMetadataMap(O: any, P: string | symbol | undefined, Create: false): Map<any, any> | undefined;
    function GetOrCreateMetadataMap(O: any, P: string | symbol | undefined, Create: boolean): Map<any, any> | undefined {
    let targetMetadata = Metadata.get(O);
    if (IsUndefined(targetMetadata)) {
    if (!Create) return undefined;
    targetMetadata = new _Map<string | symbol | undefined, Map<any, any>>();
    Metadata.set(O, targetMetadata);
    }
    let metadataMap = targetMetadata.get(P);
    if (IsUndefined(metadataMap)) {
    if (!Create) return undefined;
    metadataMap = new _Map<any, any>();
    targetMetadata.set(P, metadataMap);
    }
    return metadataMap;
    }

    // 3.1.1.1 OrdinaryHasMetadata(MetadataKey, O, P)
    // https://rbuckton.github.io/reflect-metadata/#ordinaryhasmetadata
    function OrdinaryHasMetadata(MetadataKey: any, O: any, P: string | symbol | undefined): boolean {
    const hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);
    if (hasOwn) return true;
    const parent = OrdinaryGetPrototypeOf(O);
    if (!IsNull(parent)) return OrdinaryHasMetadata(MetadataKey, parent, P);
    return false;
    }

    // 3.1.2.1 OrdinaryHasOwnMetadata(MetadataKey, O, P)
    // https://rbuckton.github.io/reflect-metadata/#ordinaryhasownmetadata
    function OrdinaryHasOwnMetadata(MetadataKey: any, O: any, P: string | symbol | undefined): boolean {
    const metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);
    if (IsUndefined(metadataMap)) return false;
    return ToBoolean(metadataMap.has(MetadataKey));
    }

    // 3.1.3.1 OrdinaryGetMetadata(MetadataKey, O, P)
    // https://rbuckton.github.io/reflect-metadata/#ordinarygetmetadata
    function OrdinaryGetMetadata(MetadataKey: any, O: any, P: string | symbol | undefined): any {
    const hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);
    if (hasOwn) return OrdinaryGetOwnMetadata(MetadataKey, O, P);
    const parent = OrdinaryGetPrototypeOf(O);
    if (!IsNull(parent)) return OrdinaryGetMetadata(MetadataKey, parent, P);
    return undefined;
    }

    // 3.1.4.1 OrdinaryGetOwnMetadata(MetadataKey, O, P)
    // https://rbuckton.github.io/reflect-metadata/#ordinarygetownmetadata
    function OrdinaryGetOwnMetadata(MetadataKey: any, O: any, P: string | symbol | undefined): any {
    const metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);
    if (IsUndefined(metadataMap)) return undefined;
    return metadataMap.get(MetadataKey);
    }

    // 3.1.5.1 OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P)
    // https://rbuckton.github.io/reflect-metadata/#ordinarydefineownmetadata
    function OrdinaryDefineOwnMetadata(MetadataKey: any, MetadataValue: any, O: any, P: string | symbol | undefined): void {
    const metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ true);
    metadataMap.set(MetadataKey, MetadataValue);
    }

    // 3.1.6.1 OrdinaryMetadataKeys(O, P)
    // https://rbuckton.github.io/reflect-metadata/#ordinarymetadatakeys
    function OrdinaryMetadataKeys(O: any, P: string | symbol | undefined): any[] {
    const ownKeys = OrdinaryOwnMetadataKeys(O, P);
    const parent = OrdinaryGetPrototypeOf(O);
    if (parent === null) return ownKeys;
    const parentKeys = OrdinaryMetadataKeys(parent, P);
    if (parentKeys.length <= 0) return ownKeys;
    if (ownKeys.length <= 0) return parentKeys;
    const set = new _Set<any>();
    const keys: any[] = [];
    for (const key of ownKeys) {
    const hasKey = set.has(key);
    if (!hasKey) {
    set.add(key);
    keys.push(key);
    }
    }
    for (const key of parentKeys) {
    const hasKey = set.has(key);
    if (!hasKey) {
    set.add(key);
    keys.push(key);
    }
    }
    return keys;
    }

    // 3.1.7.1 OrdinaryOwnMetadataKeys(O, P)
    // https://rbuckton.github.io/reflect-metadata/#ordinaryownmetadatakeys
    function OrdinaryOwnMetadataKeys(O: any, P: string | symbol | undefined): any[] {
    const keys: any[] = [];
    const metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);
    if (IsUndefined(metadataMap)) return keys;
    const keysObj = metadataMap.keys();
    const iterator = GetIterator(keysObj);
    let k = 0;
    while (true) {
    const next = IteratorStep(iterator);
    if (!next) {
    keys.length = k;
    return keys;
    }
    const nextValue = IteratorValue(next);
    try {
    keys[k] = nextValue;
    }
    catch (e) {
    try {
    IteratorClose(iterator);
    }
    finally {
    throw e;
    }
    }
    k++;
    }
    }

    // 6 ECMAScript Data Typ0es and Values
    // https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values
    function Type(x: any): Tag {
    if (x === null) return Tag.Null;
    switch (typeof x) {
    case "undefined": return Tag.Undefined;
    case "boolean": return Tag.Boolean;
    case "string": return Tag.String;
    case "symbol": return Tag.Symbol;
    case "number": return Tag.Number;
    case "object": return x === null ? Tag.Null : Tag.Object;
    default: return Tag.Object;
    }
    }

    // 6.1 ECMAScript Language Types
    // https://tc39.github.io/ecma262/#sec-ecmascript-language-types
    const enum Tag {
    Undefined,
    Null,
    Boolean,
    String,
    Symbol,
    Number,
    Object
    }

    // 6.1.1 The Undefined Type
    // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-undefined-type
    function IsUndefined(x: any): x is undefined {
    return x === undefined;
    }

    // 6.1.2 The Null Type
    // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-null-type
    function IsNull(x: any): x is null {
    return x === null;
    }

    // 6.1.5 The Symbol Type
    // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-symbol-type
    function IsSymbol(x: any): x is symbol {
    return typeof x === "symbol";
    }

    // 6.1.7 The Object Type
    // https://tc39.github.io/ecma262/#sec-object-type
    function IsObject<T>(x: T | undefined | null | boolean | string | symbol | number): x is T {
    return typeof x === "object" ? x !== null : typeof x === "function";
    }

    // 7.1 Type Conversion
    // https://tc39.github.io/ecma262/#sec-type-conversion

    // 7.1.1 ToPrimitive(input [, PreferredType])
    // https://tc39.github.io/ecma262/#sec-toprimitive
    function ToPrimitive(input: any, PreferredType?: Tag): undefined | null | boolean | string | symbol | number {
    switch (Type(input)) {
    case Tag.Undefined: return input;
    case Tag.Null: return input;
    case Tag.Boolean: return input;
    case Tag.String: return input;
    case Tag.Symbol: return input;
    case Tag.Number: return input;
    }
    const hint: "string" | "number" | "default" = PreferredType === Tag.String ? "string" : PreferredType === Tag.Number ? "number" : "default";
    const exoticToPrim = GetMethod(input, toPrimitiveSymbol);
    if (exoticToPrim !== undefined) {
    const result = exoticToPrim.call(input, hint);
    if (IsObject(result)) throw new TypeError();
    return result;
    }
    return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
    }

    // 7.1.1.1 OrdinaryToPrimitive(O, hint)
    // https://tc39.github.io/ecma262/#sec-ordinarytoprimitive
    function OrdinaryToPrimitive(O: any, hint: "string" | "number"): undefined | null | boolean | string | symbol | number {
    if (hint === "string") {
    const toString = O.toString;
    if (IsCallable(toString)) {
    const result = toString.call(O);
    if (!IsObject(result)) return result;
    }
    const valueOf = O.valueOf;
    if (IsCallable(valueOf)) {
    const result = valueOf.call(O);
    if (!IsObject(result)) return result;
    }
    }
    else {
    const valueOf = O.valueOf;
    if (IsCallable(valueOf)) {
    const result = valueOf.call(O);
    if (!IsObject(result)) return result;
    }
    const toString = O.toString;
    if (IsCallable(toString)) {
    const result = toString.call(O);
    if (!IsObject(result)) return result;
    }
    }
    throw new TypeError();
    }

    // 7.1.2 ToBoolean(argument)
    // https://tc39.github.io/ecma262/2016/#sec-toboolean
    function ToBoolean(argument: any): boolean {
    return !!argument;
    }

    // 7.1.12 ToString(argument)
    // https://tc39.github.io/ecma262/#sec-tostring
    function ToString(argument: any): string {
    return "" + argument;
    }

    // 7.1.14 ToPropertyKey(argument)
    // https://tc39.github.io/ecma262/#sec-topropertykey
    function ToPropertyKey(argument: any): string | symbol {
    const key = ToPrimitive(argument, Tag.String);
    if (IsSymbol(key)) return key;
    return ToString(key);
    }

    // 7.2 Testing and Comparison Operations
    // https://tc39.github.io/ecma262/#sec-testing-and-comparison-operations

    // 7.2.2 IsArray(argument)
    // https://tc39.github.io/ecma262/#sec-isarray
    function IsArray(argument: any): argument is any[] {
    return Array.isArray
    ? Array.isArray(argument)
    : argument instanceof Object
    ? argument instanceof Array
    : Object.prototype.toString.call(argument) === "[object Array]";
    }

    // 7.2.3 IsCallable(argument)
    // https://tc39.github.io/ecma262/#sec-iscallable
    function IsCallable(argument: any): argument is Function {
    // NOTE: This is an approximation as we cannot check for [[Call]] internal method.
    return typeof argument === "function";
    }

    // 7.2.4 IsConstructor(argument)
    // https://tc39.github.io/ecma262/#sec-isconstructor
    function IsConstructor(argument: any): argument is Function {
    // NOTE: This is an approximation as we cannot check for [[Construct]] internal method.
    return typeof argument === "function";
    }

    // 7.2.7 IsPropertyKey(argument)
    // https://tc39.github.io/ecma262/#sec-ispropertykey
    function IsPropertyKey(argument: any): argument is string | symbol {
    switch (Type(argument)) {
    case Tag.String: return true;
    case Tag.Symbol: return true;
    default: return false;
    }
    }

    // 7.3 Operations on Objects
    // https://tc39.github.io/ecma262/#sec-operations-on-objects

    // 7.3.9 GetMethod(V, P)
    // https://tc39.github.io/ecma262/#sec-getmethod
    function GetMethod(V: any, P: any): Function | undefined {
    const func = V[P];
    if (func === undefined || func === null) return undefined;
    if (!IsCallable(func)) throw new TypeError();
    return func;
    }

    // 7.4 Operations on Iterator Objects
    // https://tc39.github.io/ecma262/#sec-operations-on-iterator-objects

    function GetIterator<T>(obj: Iterable<T>): Iterator<T> {
    const method = GetMethod(obj, iteratorSymbol);
    if (!IsCallable(method)) throw new TypeError(); // from Call
    const iterator = method.call(obj);
    if (!IsObject(iterator)) throw new TypeError();
    return iterator;
    }

    // 7.4.4 IteratorValue(iterResult)
    // https://tc39.github.io/ecma262/2016/#sec-iteratorvalue
    function IteratorValue<T>(iterResult: IteratorResult<T>): T {
    return iterResult.value;
    }

    // 7.4.5 IteratorStep(iterator)
    // https://tc39.github.io/ecma262/#sec-iteratorstep
    function IteratorStep<T>(iterator: Iterator<T>): IteratorResult<T> | false {
    const result = iterator.next();
    return result.done ? false : result;
    }

    // 7.4.6 IteratorClose(iterator, completion)
    // https://tc39.github.io/ecma262/#sec-iteratorclose
    function IteratorClose<T>(iterator: Iterator<T>) {
    const f = iterator["return"];
    if (f) f.call(iterator);
    }

    // 9.1 Ordinary Object Internal Methods and Internal Slots
    // https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots

    // 9.1.1.1 OrdinaryGetPrototypeOf(O)
    // https://tc39.github.io/ecma262/#sec-ordinarygetprototypeof
    function OrdinaryGetPrototypeOf(O: any): any {
    const proto = Object.getPrototypeOf(O);
    if (typeof O !== "function" || O === functionPrototype) return proto;

    // TypeScript doesn't set __proto__ in ES5, as it's non-standard.
    // Try to determine the superclass constructor. Compatible implementations
    // must either set __proto__ on a subclass constructor to the superclass constructor,
    // or ensure each class has a valid `constructor` property on its prototype that
    // points back to the constructor.

    // If this is not the same as Function.[[Prototype]], then this is definately inherited.
    // This is the case when in ES6 or when using __proto__ in a compatible browser.
    if (proto !== functionPrototype) return proto;

    // If the super prototype is Object.prototype, null, or undefined, then we cannot determine the heritage.
    const prototype = O.prototype;
    const prototypeProto = prototype && Object.getPrototypeOf(prototype);
    if (prototypeProto == null || prototypeProto === Object.prototype) return proto;

    // If the constructor was not a function, then we cannot determine the heritage.
    const constructor = prototypeProto.constructor;
    if (typeof constructor !== "function") return proto;

    // If we have some kind of self-reference, then we cannot determine the heritage.
    if (constructor === O) return proto;

    // we have a pretty good guess at the heritage.
    return constructor;
    }

    // naive Map shim
    function CreateMapPolyfill(): MapConstructor {
    const cacheSentinel = {};
    const arraySentinel: any[] = [];

    class MapIterator<K, V, R extends (K | V | [K, V])> implements IterableIterator<R> {
    private _keys: K[];
    private _values: V[];
    private _index = 0;
    private _selector: (key: K, value: V) => R;
    constructor(keys: K[], values: V[], selector: (key: K, value: V) => R) {
    this._keys = keys;
    this._values = values;
    this._selector = selector;
    }
    "@@iterator"() { return this; }
    [iteratorSymbol]() { return this; }
    next(): IteratorResult<R> {
    const index = this._index;
    if (index >= 0 && index < this._keys.length) {
    const result = this._selector(this._keys[index], this._values[index]);
    if (index + 1 >= this._keys.length) {
    this._index = -1;
    this._keys = arraySentinel;
    this._values = arraySentinel;
    }
    else {
    this._index++;
    }
    return { value: result, done: false };
    }
    return { value: <never>undefined, done: true };
    }
    throw(error: any): IteratorResult<R> {
    if (this._index >= 0) {
    this._index = -1;
    this._keys = arraySentinel;
    this._values = arraySentinel;
    }
    throw error;
    }
    return(value?: R): IteratorResult<R> {
    if (this._index >= 0) {
    this._index = -1;
    this._keys = arraySentinel;
    this._values = arraySentinel;
    }
    return { value: <never>value, done: true };
    }
    }

    return class Map<K, V> {
    private _keys: K[] = [];
    private _values: (V | undefined)[] = [];
    private _cacheKey = cacheSentinel;
    private _cacheIndex = -2;
    get size() { return this._keys.length; }
    has(key: K): boolean { return this._find(key, /*insert*/ false) >= 0; }
    get(key: K): V | undefined {
    const index = this._find(key, /*insert*/ false);
    return index >= 0 ? this._values[index] : undefined;
    }
    set(key: K, value: V): this {
    const index = this._find(key, /*insert*/ true);
    this._values[index] = value;
    return this;
    }
    delete(key: K): boolean {
    const index = this._find(key, /*insert*/ false);
    if (index >= 0) {
    const size = this._keys.length;
    for (let i = index + 1; i < size; i++) {
    this._keys[i - 1] = this._keys[i];
    this._values[i - 1] = this._values[i];
    }
    this._keys.length--;
    this._values.length--;
    if (key === this._cacheKey) {
    this._cacheKey = cacheSentinel;
    this._cacheIndex = -2;
    }
    return true;
    }
    return false;
    }
    clear(): void {
    this._keys.length = 0;
    this._values.length = 0;
    this._cacheKey = cacheSentinel;
    this._cacheIndex = -2;
    }
    keys() { return new MapIterator(this._keys, this._values, getKey); }
    values() { return new MapIterator(this._keys, this._values, getValue); }
    entries() { return new MapIterator(this._keys, this._values, getEntry); }
    "@@iterator"() { return this.entries(); }
    [iteratorSymbol]() { return this.entries(); }
    private _find(key: K, insert?: boolean): number {
    if (this._cacheKey !== key) {
    this._cacheIndex = this._keys.indexOf(this._cacheKey = key);
    }
    if (this._cacheIndex < 0 && insert) {
    this._cacheIndex = this._keys.length;
    this._keys.push(key);
    this._values.push(undefined);
    }
    return this._cacheIndex;
    }
    };

    function getKey<K, V>(key: K, _: V) {
    return key;
    }

    function getValue<K, V>(_: K, value: V) {
    return value;
    }

    function getEntry<K, V>(key: K, value: V) {
    return [key, value] as [K, V];
    }
    }

    // naive Set shim
    function CreateSetPolyfill(): SetConstructor {
    return class Set<T> {
    private _map = new _Map<any, any>();
    get size() { return this._map.size; }
    has(value: T): boolean { return this._map.has(value); }
    add(value: T): Set<T> { return this._map.set(value, value), this; }
    delete(value: T): boolean { return this._map.delete(value); }
    clear(): void { this._map.clear(); }
    keys() { return this._map.keys(); }
    values() { return this._map.values(); }
    entries() { return this._map.entries(); }
    "@@iterator"() { return this.keys(); }
    [iteratorSymbol]() { return this.keys(); }
    };
    }

    // naive WeakMap shim
    function CreateWeakMapPolyfill(): WeakMapConstructor {
    const UUID_SIZE = 16;
    const keys = HashMap.create<boolean>();
    const rootKey = CreateUniqueKey();
    return class WeakMap<K, V> {
    private _key = CreateUniqueKey();
    has(target: K): boolean {
    const table = GetOrCreateWeakMapTable<K>(target, /*create*/ false);
    return table !== undefined ? HashMap.has(table, this._key) : false;
    }
    get(target: K): V {
    const table = GetOrCreateWeakMapTable<K>(target, /*create*/ false);
    return table !== undefined ? HashMap.get(table, this._key) : undefined;
    }
    set(target: K, value: V): WeakMap<K, V> {
    const table = GetOrCreateWeakMapTable<K>(target, /*create*/ true);
    table[this._key] = value;
    return this;
    }
    delete(target: K): boolean {
    const table = GetOrCreateWeakMapTable<K>(target, /*create*/ false);
    return table !== undefined ? delete table[this._key] : false;
    }
    clear(): void {
    // NOTE: not a real clear, just makes the previous data unreachable
    this._key = CreateUniqueKey();
    }
    };

    function CreateUniqueKey(): string {
    let key: string;
    do key = "@@WeakMap@@" + CreateUUID();
    while (HashMap.has(keys, key));
    keys[key] = true;
    return key;
    }

    function GetOrCreateWeakMapTable<K>(target: K, create: true): HashMap<any>;
    function GetOrCreateWeakMapTable<K>(target: K, create: false): HashMap<any> | undefined;
    function GetOrCreateWeakMapTable<K>(target: K, create: boolean): HashMap<any> | undefined {
    if (!hasOwn.call(target, rootKey)) {
    if (!create) return undefined;
    Object.defineProperty(target, rootKey, { value: HashMap.create<any>() });
    }
    return (<any>target)[rootKey];
    }

    function FillRandomBytes(buffer: BufferLike, size: number): BufferLike {
    for (let i = 0; i < size; ++i) buffer[i] = Math.random() * 0xff | 0;
    return buffer;
    }

    function GenRandomBytes(size: number): BufferLike {
    if (typeof Uint8Array === "function") {
    if (typeof crypto !== "undefined") return crypto.getRandomValues(new Uint8Array(size)) as Uint8Array;
    if (typeof msCrypto !== "undefined") return msCrypto.getRandomValues(new Uint8Array(size)) as Uint8Array;
    return FillRandomBytes(new Uint8Array(size), size);
    }
    return FillRandomBytes(new Array(size), size);
    }

    function CreateUUID() {
    const data = GenRandomBytes(UUID_SIZE);
    // mark as random - RFC 4122 § 4.4
    data[6] = data[6] & 0x4f | 0x40;
    data[8] = data[8] & 0xbf | 0x80;
    let result = "";
    for (let offset = 0; offset < UUID_SIZE; ++offset) {
    const byte = data[offset];
    if (offset === 4 || offset === 6 || offset === 8) result += "-";
    if (byte < 16) result += "0";
    result += byte.toString(16).toLowerCase();
    }
    return result;
    }
    }

    // uses a heuristic used by v8 and chakra to force an object into dictionary mode.
    function MakeDictionary<T>(obj: T): T {
    (<any>obj).__ = undefined;
    delete (<any>obj).__;
    return obj;
    }
    });
    }