reflect.ts

/*! *****************************************************************************
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.
***************************************************************************** */
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;

  (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;
    // @ts-ignore
    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", 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;
    }
  });
}