{"version":3,"file":"chunks/14.f2f3d105d0bdebc1231a.js","mappings":"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","sources":["webpack://@iqx-web/libs/../../node_modules/reflect-metadata/Reflect.js"],"sourcesContent":["/*! *****************************************************************************\nCopyright (C) Microsoft. All rights reserved.\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\nthis file except in compliance with the License. You may obtain a copy of the\nLicense at http://www.apache.org/licenses/LICENSE-2.0\n\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\nMERCHANTABLITY OR NON-INFRINGEMENT.\n\nSee the Apache Version 2.0 License for specific language governing permissions\nand limitations under the License.\n***************************************************************************** */\nvar Reflect;\n(function (Reflect) {\n    // Metadata Proposal\n    // https://rbuckton.github.io/reflect-metadata/\n    (function (factory) {\n        var root = typeof global === \"object\" ? global :\n            typeof self === \"object\" ? self :\n                typeof this === \"object\" ? this :\n                    Function(\"return this;\")();\n        var exporter = makeExporter(Reflect);\n        if (typeof root.Reflect === \"undefined\") {\n            root.Reflect = Reflect;\n        }\n        else {\n            exporter = makeExporter(root.Reflect, exporter);\n        }\n        factory(exporter);\n        function makeExporter(target, previous) {\n            return function (key, value) {\n                if (typeof target[key] !== \"function\") {\n                    Object.defineProperty(target, key, { configurable: true, writable: true, value: value });\n                }\n                if (previous)\n                    previous(key, value);\n            };\n        }\n    })(function (exporter) {\n        var hasOwn = Object.prototype.hasOwnProperty;\n        // feature test for Symbol support\n        var supportsSymbol = typeof Symbol === \"function\";\n        var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== \"undefined\" ? Symbol.toPrimitive : \"@@toPrimitive\";\n        var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== \"undefined\" ? Symbol.iterator : \"@@iterator\";\n        var supportsCreate = typeof Object.create === \"function\"; // feature test for Object.create support\n        var supportsProto = { __proto__: [] } instanceof Array; // feature test for __proto__ support\n        var downLevel = !supportsCreate && !supportsProto;\n        var HashMap = {\n            // create an object in dictionary mode (a.k.a. \"slow\" mode in v8)\n            create: supportsCreate\n                ? function () { return MakeDictionary(Object.create(null)); }\n                : supportsProto\n                    ? function () { return MakeDictionary({ __proto__: null }); }\n                    : function () { return MakeDictionary({}); },\n            has: downLevel\n                ? function (map, key) { return hasOwn.call(map, key); }\n                : function (map, key) { return key in map; },\n            get: downLevel\n                ? function (map, key) { return hasOwn.call(map, key) ? map[key] : undefined; }\n                : function (map, key) { return map[key]; },\n        };\n        // Load global or shim versions of Map, Set, and WeakMap\n        var functionPrototype = Object.getPrototypeOf(Function);\n        var usePolyfill = typeof process === \"object\" && process[\"env\" + \"\"] && process[\"env\" + \"\"][\"REFLECT_METADATA_USE_MAP_POLYFILL\"] === \"true\";\n        var _Map = !usePolyfill && typeof Map === \"function\" && typeof Map.prototype.entries === \"function\" ? Map : CreateMapPolyfill();\n        var _Set = !usePolyfill && typeof Set === \"function\" && typeof Set.prototype.entries === \"function\" ? Set : CreateSetPolyfill();\n        var _WeakMap = !usePolyfill && typeof WeakMap === \"function\" ? WeakMap : CreateWeakMapPolyfill();\n        // [[Metadata]] internal slot\n        // https://rbuckton.github.io/reflect-metadata/#ordinary-object-internal-methods-and-internal-slots\n        var Metadata = new _WeakMap();\n        /**\n         * Applies a set of decorators to a property of a target object.\n         * @param decorators An array of decorators.\n         * @param target The target object.\n         * @param propertyKey (Optional) The property key to decorate.\n         * @param attributes (Optional) The property descriptor for the target key.\n         * @remarks Decorators are applied in reverse order.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     Example = Reflect.decorate(decoratorsArray, Example);\n         *\n         *     // property (on constructor)\n         *     Reflect.decorate(decoratorsArray, Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     Reflect.decorate(decoratorsArray, Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     Object.defineProperty(Example, \"staticMethod\",\n         *         Reflect.decorate(decoratorsArray, Example, \"staticMethod\",\n         *             Object.getOwnPropertyDescriptor(Example, \"staticMethod\")));\n         *\n         *     // method (on prototype)\n         *     Object.defineProperty(Example.prototype, \"method\",\n         *         Reflect.decorate(decoratorsArray, Example.prototype, \"method\",\n         *             Object.getOwnPropertyDescriptor(Example.prototype, \"method\")));\n         *\n         */\n        function decorate(decorators, target, propertyKey, attributes) {\n            if (!IsUndefined(propertyKey)) {\n                if (!IsArray(decorators))\n                    throw new TypeError();\n                if (!IsObject(target))\n                    throw new TypeError();\n                if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))\n                    throw new TypeError();\n                if (IsNull(attributes))\n                    attributes = undefined;\n                propertyKey = ToPropertyKey(propertyKey);\n                return DecorateProperty(decorators, target, propertyKey, attributes);\n            }\n            else {\n                if (!IsArray(decorators))\n                    throw new TypeError();\n                if (!IsConstructor(target))\n                    throw new TypeError();\n                return DecorateConstructor(decorators, target);\n            }\n        }\n        exporter(\"decorate\", decorate);\n        // 4.1.2 Reflect.metadata(metadataKey, metadataValue)\n        // https://rbuckton.github.io/reflect-metadata/#reflect.metadata\n        /**\n         * A default metadata decorator factory that can be used on a class, class member, or parameter.\n         * @param metadataKey The key for the metadata entry.\n         * @param metadataValue The value for the metadata entry.\n         * @returns A decorator function.\n         * @remarks\n         * If `metadataKey` is already defined for the target and target key, the\n         * metadataValue for that key will be overwritten.\n         * @example\n         *\n         *     // constructor\n         *     @Reflect.metadata(key, value)\n         *     class Example {\n         *     }\n         *\n         *     // property (on constructor, TypeScript only)\n         *     class Example {\n         *         @Reflect.metadata(key, value)\n         *         static staticProperty;\n         *     }\n         *\n         *     // property (on prototype, TypeScript only)\n         *     class Example {\n         *         @Reflect.metadata(key, value)\n         *         property;\n         *     }\n         *\n         *     // method (on constructor)\n         *     class Example {\n         *         @Reflect.metadata(key, value)\n         *         static staticMethod() { }\n         *     }\n         *\n         *     // method (on prototype)\n         *     class Example {\n         *         @Reflect.metadata(key, value)\n         *         method() { }\n         *     }\n         *\n         */\n        function metadata(metadataKey, metadataValue) {\n            function decorator(target, propertyKey) {\n                if (!IsObject(target))\n                    throw new TypeError();\n                if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))\n                    throw new TypeError();\n                OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);\n            }\n            return decorator;\n        }\n        exporter(\"metadata\", metadata);\n        /**\n         * Define a unique metadata entry on the target.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param metadataValue A value that contains attached metadata.\n         * @param target The target object on which to define metadata.\n         * @param propertyKey (Optional) The property key for the target.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example);\n         *\n         *     // property (on constructor)\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example.prototype, \"method\");\n         *\n         *     // decorator factory as metadata-producing annotation.\n         *     function MyAnnotation(options): Decorator {\n         *         return (target, key?) => Reflect.defineMetadata(\"custom:annotation\", options, target, key);\n         *     }\n         *\n         */\n        function defineMetadata(metadataKey, metadataValue, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);\n        }\n        exporter(\"defineMetadata\", defineMetadata);\n        /**\n         * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function hasMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryHasMetadata(metadataKey, target, propertyKey);\n        }\n        exporter(\"hasMetadata\", hasMetadata);\n        /**\n         * Gets a value indicating whether the target object has the provided metadata key defined.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns `true` if the metadata key was defined on the target object; otherwise, `false`.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function hasOwnMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);\n        }\n        exporter(\"hasOwnMetadata\", hasOwnMetadata);\n        /**\n         * Gets the metadata value for the provided metadata key on the target object or its prototype chain.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns The metadata value for the metadata key if found; otherwise, `undefined`.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function getMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryGetMetadata(metadataKey, target, propertyKey);\n        }\n        exporter(\"getMetadata\", getMetadata);\n        /**\n         * Gets the metadata value for the provided metadata key on the target object.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns The metadata value for the metadata key if found; otherwise, `undefined`.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function getOwnMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);\n        }\n        exporter(\"getOwnMetadata\", getOwnMetadata);\n        /**\n         * Gets the metadata keys defined on the target object or its prototype chain.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns An array of unique metadata keys.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.getMetadataKeys(Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.getMetadataKeys(Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.getMetadataKeys(Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.getMetadataKeys(Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.getMetadataKeys(Example.prototype, \"method\");\n         *\n         */\n        function getMetadataKeys(target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryMetadataKeys(target, propertyKey);\n        }\n        exporter(\"getMetadataKeys\", getMetadataKeys);\n        /**\n         * Gets the unique metadata keys defined on the target object.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns An array of unique metadata keys.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.getOwnMetadataKeys(Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.getOwnMetadataKeys(Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.getOwnMetadataKeys(Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.getOwnMetadataKeys(Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.getOwnMetadataKeys(Example.prototype, \"method\");\n         *\n         */\n        function getOwnMetadataKeys(target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryOwnMetadataKeys(target, propertyKey);\n        }\n        exporter(\"getOwnMetadataKeys\", getOwnMetadataKeys);\n        /**\n         * Deletes the metadata entry from the target object with the provided key.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns `true` if the metadata entry was found and deleted; otherwise, false.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function deleteMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            var metadataMap = GetOrCreateMetadataMap(target, propertyKey, /*Create*/ false);\n            if (IsUndefined(metadataMap))\n                return false;\n            if (!metadataMap.delete(metadataKey))\n                return false;\n            if (metadataMap.size > 0)\n                return true;\n            var targetMetadata = Metadata.get(target);\n            targetMetadata.delete(propertyKey);\n            if (targetMetadata.size > 0)\n                return true;\n            Metadata.delete(target);\n            return true;\n        }\n        exporter(\"deleteMetadata\", deleteMetadata);\n        function DecorateConstructor(decorators, target) {\n            for (var i = decorators.length - 1; i >= 0; --i) {\n                var decorator = decorators[i];\n                var decorated = decorator(target);\n                if (!IsUndefined(decorated) && !IsNull(decorated)) {\n                    if (!IsConstructor(decorated))\n                        throw new TypeError();\n                    target = decorated;\n                }\n            }\n            return target;\n        }\n        function DecorateProperty(decorators, target, propertyKey, descriptor) {\n            for (var i = decorators.length - 1; i >= 0; --i) {\n                var decorator = decorators[i];\n                var decorated = decorator(target, propertyKey, descriptor);\n                if (!IsUndefined(decorated) && !IsNull(decorated)) {\n                    if (!IsObject(decorated))\n                        throw new TypeError();\n                    descriptor = decorated;\n                }\n            }\n            return descriptor;\n        }\n        function GetOrCreateMetadataMap(O, P, Create) {\n            var targetMetadata = Metadata.get(O);\n            if (IsUndefined(targetMetadata)) {\n                if (!Create)\n                    return undefined;\n                targetMetadata = new _Map();\n                Metadata.set(O, targetMetadata);\n            }\n            var metadataMap = targetMetadata.get(P);\n            if (IsUndefined(metadataMap)) {\n                if (!Create)\n                    return undefined;\n                metadataMap = new _Map();\n                targetMetadata.set(P, metadataMap);\n            }\n            return metadataMap;\n        }\n        // 3.1.1.1 OrdinaryHasMetadata(MetadataKey, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinaryhasmetadata\n        function OrdinaryHasMetadata(MetadataKey, O, P) {\n            var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);\n            if (hasOwn)\n                return true;\n            var parent = OrdinaryGetPrototypeOf(O);\n            if (!IsNull(parent))\n                return OrdinaryHasMetadata(MetadataKey, parent, P);\n            return false;\n        }\n        // 3.1.2.1 OrdinaryHasOwnMetadata(MetadataKey, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinaryhasownmetadata\n        function OrdinaryHasOwnMetadata(MetadataKey, O, P) {\n            var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n            if (IsUndefined(metadataMap))\n                return false;\n            return ToBoolean(metadataMap.has(MetadataKey));\n        }\n        // 3.1.3.1 OrdinaryGetMetadata(MetadataKey, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinarygetmetadata\n        function OrdinaryGetMetadata(MetadataKey, O, P) {\n            var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);\n            if (hasOwn)\n                return OrdinaryGetOwnMetadata(MetadataKey, O, P);\n            var parent = OrdinaryGetPrototypeOf(O);\n            if (!IsNull(parent))\n                return OrdinaryGetMetadata(MetadataKey, parent, P);\n            return undefined;\n        }\n        // 3.1.4.1 OrdinaryGetOwnMetadata(MetadataKey, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinarygetownmetadata\n        function OrdinaryGetOwnMetadata(MetadataKey, O, P) {\n            var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n            if (IsUndefined(metadataMap))\n                return undefined;\n            return metadataMap.get(MetadataKey);\n        }\n        // 3.1.5.1 OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinarydefineownmetadata\n        function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {\n            var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ true);\n            metadataMap.set(MetadataKey, MetadataValue);\n        }\n        // 3.1.6.1 OrdinaryMetadataKeys(O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinarymetadatakeys\n        function OrdinaryMetadataKeys(O, P) {\n            var ownKeys = OrdinaryOwnMetadataKeys(O, P);\n            var parent = OrdinaryGetPrototypeOf(O);\n            if (parent === null)\n                return ownKeys;\n            var parentKeys = OrdinaryMetadataKeys(parent, P);\n            if (parentKeys.length <= 0)\n                return ownKeys;\n            if (ownKeys.length <= 0)\n                return parentKeys;\n            var set = new _Set();\n            var keys = [];\n            for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {\n                var key = ownKeys_1[_i];\n                var hasKey = set.has(key);\n                if (!hasKey) {\n                    set.add(key);\n                    keys.push(key);\n                }\n            }\n            for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {\n                var key = parentKeys_1[_a];\n                var hasKey = set.has(key);\n                if (!hasKey) {\n                    set.add(key);\n                    keys.push(key);\n                }\n            }\n            return keys;\n        }\n        // 3.1.7.1 OrdinaryOwnMetadataKeys(O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinaryownmetadatakeys\n        function OrdinaryOwnMetadataKeys(O, P) {\n            var keys = [];\n            var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n            if (IsUndefined(metadataMap))\n                return keys;\n            var keysObj = metadataMap.keys();\n            var iterator = GetIterator(keysObj);\n            var k = 0;\n            while (true) {\n                var next = IteratorStep(iterator);\n                if (!next) {\n                    keys.length = k;\n                    return keys;\n                }\n                var nextValue = IteratorValue(next);\n                try {\n                    keys[k] = nextValue;\n                }\n                catch (e) {\n                    try {\n                        IteratorClose(iterator);\n                    }\n                    finally {\n                        throw e;\n                    }\n                }\n                k++;\n            }\n        }\n        // 6 ECMAScript Data Typ0es and Values\n        // https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values\n        function Type(x) {\n            if (x === null)\n                return 1 /* Null */;\n            switch (typeof x) {\n                case \"undefined\": return 0 /* Undefined */;\n                case \"boolean\": return 2 /* Boolean */;\n                case \"string\": return 3 /* String */;\n                case \"symbol\": return 4 /* Symbol */;\n                case \"number\": return 5 /* Number */;\n                case \"object\": return x === null ? 1 /* Null */ : 6 /* Object */;\n                default: return 6 /* Object */;\n            }\n        }\n        // 6.1.1 The Undefined Type\n        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-undefined-type\n        function IsUndefined(x) {\n            return x === undefined;\n        }\n        // 6.1.2 The Null Type\n        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-null-type\n        function IsNull(x) {\n            return x === null;\n        }\n        // 6.1.5 The Symbol Type\n        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-symbol-type\n        function IsSymbol(x) {\n            return typeof x === \"symbol\";\n        }\n        // 6.1.7 The Object Type\n        // https://tc39.github.io/ecma262/#sec-object-type\n        function IsObject(x) {\n            return typeof x === \"object\" ? x !== null : typeof x === \"function\";\n        }\n        // 7.1 Type Conversion\n        // https://tc39.github.io/ecma262/#sec-type-conversion\n        // 7.1.1 ToPrimitive(input [, PreferredType])\n        // https://tc39.github.io/ecma262/#sec-toprimitive\n        function ToPrimitive(input, PreferredType) {\n            switch (Type(input)) {\n                case 0 /* Undefined */: return input;\n                case 1 /* Null */: return input;\n                case 2 /* Boolean */: return input;\n                case 3 /* String */: return input;\n                case 4 /* Symbol */: return input;\n                case 5 /* Number */: return input;\n            }\n            var hint = PreferredType === 3 /* String */ ? \"string\" : PreferredType === 5 /* Number */ ? \"number\" : \"default\";\n            var exoticToPrim = GetMethod(input, toPrimitiveSymbol);\n            if (exoticToPrim !== undefined) {\n                var result = exoticToPrim.call(input, hint);\n                if (IsObject(result))\n                    throw new TypeError();\n                return result;\n            }\n            return OrdinaryToPrimitive(input, hint === \"default\" ? \"number\" : hint);\n        }\n        // 7.1.1.1 OrdinaryToPrimitive(O, hint)\n        // https://tc39.github.io/ecma262/#sec-ordinarytoprimitive\n        function OrdinaryToPrimitive(O, hint) {\n            if (hint === \"string\") {\n                var toString_1 = O.toString;\n                if (IsCallable(toString_1)) {\n                    var result = toString_1.call(O);\n                    if (!IsObject(result))\n                        return result;\n                }\n                var valueOf = O.valueOf;\n                if (IsCallable(valueOf)) {\n                    var result = valueOf.call(O);\n                    if (!IsObject(result))\n                        return result;\n                }\n            }\n            else {\n                var valueOf = O.valueOf;\n                if (IsCallable(valueOf)) {\n                    var result = valueOf.call(O);\n                    if (!IsObject(result))\n                        return result;\n                }\n                var toString_2 = O.toString;\n                if (IsCallable(toString_2)) {\n                    var result = toString_2.call(O);\n                    if (!IsObject(result))\n                        return result;\n                }\n            }\n            throw new TypeError();\n        }\n        // 7.1.2 ToBoolean(argument)\n        // https://tc39.github.io/ecma262/2016/#sec-toboolean\n        function ToBoolean(argument) {\n            return !!argument;\n        }\n        // 7.1.12 ToString(argument)\n        // https://tc39.github.io/ecma262/#sec-tostring\n        function ToString(argument) {\n            return \"\" + argument;\n        }\n        // 7.1.14 ToPropertyKey(argument)\n        // https://tc39.github.io/ecma262/#sec-topropertykey\n        function ToPropertyKey(argument) {\n            var key = ToPrimitive(argument, 3 /* String */);\n            if (IsSymbol(key))\n                return key;\n            return ToString(key);\n        }\n        // 7.2 Testing and Comparison Operations\n        // https://tc39.github.io/ecma262/#sec-testing-and-comparison-operations\n        // 7.2.2 IsArray(argument)\n        // https://tc39.github.io/ecma262/#sec-isarray\n        function IsArray(argument) {\n            return Array.isArray\n                ? Array.isArray(argument)\n                : argument instanceof Object\n                    ? argument instanceof Array\n                    : Object.prototype.toString.call(argument) === \"[object Array]\";\n        }\n        // 7.2.3 IsCallable(argument)\n        // https://tc39.github.io/ecma262/#sec-iscallable\n        function IsCallable(argument) {\n            // NOTE: This is an approximation as we cannot check for [[Call]] internal method.\n            return typeof argument === \"function\";\n        }\n        // 7.2.4 IsConstructor(argument)\n        // https://tc39.github.io/ecma262/#sec-isconstructor\n        function IsConstructor(argument) {\n            // NOTE: This is an approximation as we cannot check for [[Construct]] internal method.\n            return typeof argument === \"function\";\n        }\n        // 7.2.7 IsPropertyKey(argument)\n        // https://tc39.github.io/ecma262/#sec-ispropertykey\n        function IsPropertyKey(argument) {\n            switch (Type(argument)) {\n                case 3 /* String */: return true;\n                case 4 /* Symbol */: return true;\n                default: return false;\n            }\n        }\n        // 7.3 Operations on Objects\n        // https://tc39.github.io/ecma262/#sec-operations-on-objects\n        // 7.3.9 GetMethod(V, P)\n        // https://tc39.github.io/ecma262/#sec-getmethod\n        function GetMethod(V, P) {\n            var func = V[P];\n            if (func === undefined || func === null)\n                return undefined;\n            if (!IsCallable(func))\n                throw new TypeError();\n            return func;\n        }\n        // 7.4 Operations on Iterator Objects\n        // https://tc39.github.io/ecma262/#sec-operations-on-iterator-objects\n        function GetIterator(obj) {\n            var method = GetMethod(obj, iteratorSymbol);\n            if (!IsCallable(method))\n                throw new TypeError(); // from Call\n            var iterator = method.call(obj);\n            if (!IsObject(iterator))\n                throw new TypeError();\n            return iterator;\n        }\n        // 7.4.4 IteratorValue(iterResult)\n        // https://tc39.github.io/ecma262/2016/#sec-iteratorvalue\n        function IteratorValue(iterResult) {\n            return iterResult.value;\n        }\n        // 7.4.5 IteratorStep(iterator)\n        // https://tc39.github.io/ecma262/#sec-iteratorstep\n        function IteratorStep(iterator) {\n            var result = iterator.next();\n            return result.done ? false : result;\n        }\n        // 7.4.6 IteratorClose(iterator, completion)\n        // https://tc39.github.io/ecma262/#sec-iteratorclose\n        function IteratorClose(iterator) {\n            var f = iterator[\"return\"];\n            if (f)\n                f.call(iterator);\n        }\n        // 9.1 Ordinary Object Internal Methods and Internal Slots\n        // https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots\n        // 9.1.1.1 OrdinaryGetPrototypeOf(O)\n        // https://tc39.github.io/ecma262/#sec-ordinarygetprototypeof\n        function OrdinaryGetPrototypeOf(O) {\n            var proto = Object.getPrototypeOf(O);\n            if (typeof O !== \"function\" || O === functionPrototype)\n                return proto;\n            // TypeScript doesn't set __proto__ in ES5, as it's non-standard.\n            // Try to determine the superclass constructor. Compatible implementations\n            // must either set __proto__ on a subclass constructor to the superclass constructor,\n            // or ensure each class has a valid `constructor` property on its prototype that\n            // points back to the constructor.\n            // If this is not the same as Function.[[Prototype]], then this is definately inherited.\n            // This is the case when in ES6 or when using __proto__ in a compatible browser.\n            if (proto !== functionPrototype)\n                return proto;\n            // If the super prototype is Object.prototype, null, or undefined, then we cannot determine the heritage.\n            var prototype = O.prototype;\n            var prototypeProto = prototype && Object.getPrototypeOf(prototype);\n            if (prototypeProto == null || prototypeProto === Object.prototype)\n                return proto;\n            // If the constructor was not a function, then we cannot determine the heritage.\n            var constructor = prototypeProto.constructor;\n            if (typeof constructor !== \"function\")\n                return proto;\n            // If we have some kind of self-reference, then we cannot determine the heritage.\n            if (constructor === O)\n                return proto;\n            // we have a pretty good guess at the heritage.\n            return constructor;\n        }\n        // naive Map shim\n        function CreateMapPolyfill() {\n            var cacheSentinel = {};\n            var arraySentinel = [];\n            var MapIterator = /** @class */ (function () {\n                function MapIterator(keys, values, selector) {\n                    this._index = 0;\n                    this._keys = keys;\n                    this._values = values;\n                    this._selector = selector;\n                }\n                MapIterator.prototype[\"@@iterator\"] = function () { return this; };\n                MapIterator.prototype[iteratorSymbol] = function () { return this; };\n                MapIterator.prototype.next = function () {\n                    var index = this._index;\n                    if (index >= 0 && index < this._keys.length) {\n                        var result = this._selector(this._keys[index], this._values[index]);\n                        if (index + 1 >= this._keys.length) {\n                            this._index = -1;\n                            this._keys = arraySentinel;\n                            this._values = arraySentinel;\n                        }\n                        else {\n                            this._index++;\n                        }\n                        return { value: result, done: false };\n                    }\n                    return { value: undefined, done: true };\n                };\n                MapIterator.prototype.throw = function (error) {\n                    if (this._index >= 0) {\n                        this._index = -1;\n                        this._keys = arraySentinel;\n                        this._values = arraySentinel;\n                    }\n                    throw error;\n                };\n                MapIterator.prototype.return = function (value) {\n                    if (this._index >= 0) {\n                        this._index = -1;\n                        this._keys = arraySentinel;\n                        this._values = arraySentinel;\n                    }\n                    return { value: value, done: true };\n                };\n                return MapIterator;\n            }());\n            return /** @class */ (function () {\n                function Map() {\n                    this._keys = [];\n                    this._values = [];\n                    this._cacheKey = cacheSentinel;\n                    this._cacheIndex = -2;\n                }\n                Object.defineProperty(Map.prototype, \"size\", {\n                    get: function () { return this._keys.length; },\n                    enumerable: true,\n                    configurable: true\n                });\n                Map.prototype.has = function (key) { return this._find(key, /*insert*/ false) >= 0; };\n                Map.prototype.get = function (key) {\n                    var index = this._find(key, /*insert*/ false);\n                    return index >= 0 ? this._values[index] : undefined;\n                };\n                Map.prototype.set = function (key, value) {\n                    var index = this._find(key, /*insert*/ true);\n                    this._values[index] = value;\n                    return this;\n                };\n                Map.prototype.delete = function (key) {\n                    var index = this._find(key, /*insert*/ false);\n                    if (index >= 0) {\n                        var size = this._keys.length;\n                        for (var i = index + 1; i < size; i++) {\n                            this._keys[i - 1] = this._keys[i];\n                            this._values[i - 1] = this._values[i];\n                        }\n                        this._keys.length--;\n                        this._values.length--;\n                        if (key === this._cacheKey) {\n                            this._cacheKey = cacheSentinel;\n                            this._cacheIndex = -2;\n                        }\n                        return true;\n                    }\n                    return false;\n                };\n                Map.prototype.clear = function () {\n                    this._keys.length = 0;\n                    this._values.length = 0;\n                    this._cacheKey = cacheSentinel;\n                    this._cacheIndex = -2;\n                };\n                Map.prototype.keys = function () { return new MapIterator(this._keys, this._values, getKey); };\n                Map.prototype.values = function () { return new MapIterator(this._keys, this._values, getValue); };\n                Map.prototype.entries = function () { return new MapIterator(this._keys, this._values, getEntry); };\n                Map.prototype[\"@@iterator\"] = function () { return this.entries(); };\n                Map.prototype[iteratorSymbol] = function () { return this.entries(); };\n                Map.prototype._find = function (key, insert) {\n                    if (this._cacheKey !== key) {\n                        this._cacheIndex = this._keys.indexOf(this._cacheKey = key);\n                    }\n                    if (this._cacheIndex < 0 && insert) {\n                        this._cacheIndex = this._keys.length;\n                        this._keys.push(key);\n                        this._values.push(undefined);\n                    }\n                    return this._cacheIndex;\n                };\n                return Map;\n            }());\n            function getKey(key, _) {\n                return key;\n            }\n            function getValue(_, value) {\n                return value;\n            }\n            function getEntry(key, value) {\n                return [key, value];\n            }\n        }\n        // naive Set shim\n        function CreateSetPolyfill() {\n            return /** @class */ (function () {\n                function Set() {\n                    this._map = new _Map();\n                }\n                Object.defineProperty(Set.prototype, \"size\", {\n                    get: function () { return this._map.size; },\n                    enumerable: true,\n                    configurable: true\n                });\n                Set.prototype.has = function (value) { return this._map.has(value); };\n                Set.prototype.add = function (value) { return this._map.set(value, value), this; };\n                Set.prototype.delete = function (value) { return this._map.delete(value); };\n                Set.prototype.clear = function () { this._map.clear(); };\n                Set.prototype.keys = function () { return this._map.keys(); };\n                Set.prototype.values = function () { return this._map.values(); };\n                Set.prototype.entries = function () { return this._map.entries(); };\n                Set.prototype[\"@@iterator\"] = function () { return this.keys(); };\n                Set.prototype[iteratorSymbol] = function () { return this.keys(); };\n                return Set;\n            }());\n        }\n        // naive WeakMap shim\n        function CreateWeakMapPolyfill() {\n            var UUID_SIZE = 16;\n            var keys = HashMap.create();\n            var rootKey = CreateUniqueKey();\n            return /** @class */ (function () {\n                function WeakMap() {\n                    this._key = CreateUniqueKey();\n                }\n                WeakMap.prototype.has = function (target) {\n                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);\n                    return table !== undefined ? HashMap.has(table, this._key) : false;\n                };\n                WeakMap.prototype.get = function (target) {\n                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);\n                    return table !== undefined ? HashMap.get(table, this._key) : undefined;\n                };\n                WeakMap.prototype.set = function (target, value) {\n                    var table = GetOrCreateWeakMapTable(target, /*create*/ true);\n                    table[this._key] = value;\n                    return this;\n                };\n                WeakMap.prototype.delete = function (target) {\n                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);\n                    return table !== undefined ? delete table[this._key] : false;\n                };\n                WeakMap.prototype.clear = function () {\n                    // NOTE: not a real clear, just makes the previous data unreachable\n                    this._key = CreateUniqueKey();\n                };\n                return WeakMap;\n            }());\n            function CreateUniqueKey() {\n                var key;\n                do\n                    key = \"@@WeakMap@@\" + CreateUUID();\n                while (HashMap.has(keys, key));\n                keys[key] = true;\n                return key;\n            }\n            function GetOrCreateWeakMapTable(target, create) {\n                if (!hasOwn.call(target, rootKey)) {\n                    if (!create)\n                        return undefined;\n                    Object.defineProperty(target, rootKey, { value: HashMap.create() });\n                }\n                return target[rootKey];\n            }\n            function FillRandomBytes(buffer, size) {\n                for (var i = 0; i < size; ++i)\n                    buffer[i] = Math.random() * 0xff | 0;\n                return buffer;\n            }\n            function GenRandomBytes(size) {\n                if (typeof Uint8Array === \"function\") {\n                    if (typeof crypto !== \"undefined\")\n                        return crypto.getRandomValues(new Uint8Array(size));\n                    if (typeof msCrypto !== \"undefined\")\n                        return msCrypto.getRandomValues(new Uint8Array(size));\n                    return FillRandomBytes(new Uint8Array(size), size);\n                }\n                return FillRandomBytes(new Array(size), size);\n            }\n            function CreateUUID() {\n                var data = GenRandomBytes(UUID_SIZE);\n                // mark as random - RFC 4122 § 4.4\n                data[6] = data[6] & 0x4f | 0x40;\n                data[8] = data[8] & 0xbf | 0x80;\n                var result = \"\";\n                for (var offset = 0; offset < UUID_SIZE; ++offset) {\n                    var byte = data[offset];\n                    if (offset === 4 || offset === 6 || offset === 8)\n                        result += \"-\";\n                    if (byte < 16)\n                        result += \"0\";\n                    result += byte.toString(16).toLowerCase();\n                }\n                return result;\n            }\n        }\n        // uses a heuristic used by v8 and chakra to force an object into dictionary mode.\n        function MakeDictionary(obj) {\n            obj.__ = undefined;\n            delete obj.__;\n            return obj;\n        }\n    });\n})(Reflect || (Reflect = {}));\n"],"names":["Reflect","factory","root","g","self","this","Function","exporter","makeExporter","target","previous","key","value","Object","defineProperty","configurable","writable","hasOwn","prototype","hasOwnProperty","supportsSymbol","Symbol","toPrimitiveSymbol","toPrimitive","iteratorSymbol","iterator","supportsCreate","create","supportsProto","__proto__","Array","downLevel","HashMap","MakeDictionary","has","map","call","get","undefined","functionPrototype","getPrototypeOf","usePolyfill","process","_Map","Map","entries","cacheSentinel","arraySentinel","MapIterator","keys","values","selector","_index","_keys","_values","_selector","next","index","length","result","done","throw","error","return","_cacheKey","_cacheIndex","enumerable","_find","set","delete","size","i","clear","getKey","getValue","getEntry","insert","indexOf","push","_","CreateMapPolyfill","_Set","Set","_map","add","Metadata","WeakMap","UUID_SIZE","rootKey","CreateUniqueKey","_key","table","GetOrCreateWeakMapTable","CreateUUID","FillRandomBytes","buffer","Math","random","data","Uint8Array","crypto","getRandomValues","msCrypto","offset","byte","toString","toLowerCase","CreateWeakMapPolyfill","GetOrCreateMetadataMap","O","P","Create","targetMetadata","IsUndefined","metadataMap","OrdinaryHasMetadata","MetadataKey","OrdinaryHasOwnMetadata","parent","OrdinaryGetPrototypeOf","IsNull","OrdinaryGetMetadata","OrdinaryGetOwnMetadata","OrdinaryDefineOwnMetadata","MetadataValue","OrdinaryMetadataKeys","ownKeys","OrdinaryOwnMetadataKeys","parentKeys","_i","ownKeys_1","_a","parentKeys_1","obj","method","GetMethod","IsCallable","TypeError","IsObject","GetIterator","k","IteratorStep","nextValue","e","IteratorClose","Type","x","ToPrimitive","input","PreferredType","hint","exoticToPrim","toString_1","valueOf","toString_2","OrdinaryToPrimitive","ToPropertyKey","argument","ToString","IsArray","isArray","IsConstructor","V","func","f","proto","prototypeProto","constructor","__","decorators","propertyKey","attributes","decorated","decorator","DecorateConstructor","descriptor","DecorateProperty","metadataKey","metadataValue","IsPropertyKey"],"sourceRoot":""}