1 line
65 KiB
Plaintext
1 line
65 KiB
Plaintext
{"version":3,"file":"reflect-metadata.min.js","sources":["../../src/vue-easy-dnd/reflect-metadata.js"],"sourcesContent":["/* eslint-disable */\n/*eslint no-unused-vars: \"off\" */\n/*! *****************************************************************************\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***************************************************************************** */\nexport {Reflect};\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","global","self","_typeof","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","env","_Map","Map","entries","CreateMapPolyfill","_Set","Set","CreateSetPolyfill","Metadata","WeakMap","CreateWeakMapPolyfill","decorate","decorators","propertyKey","attributes","IsUndefined","IsArray","TypeError","IsConstructor","DecorateConstructor","IsObject","IsNull","DecorateProperty","ToPropertyKey","metadata","metadataKey","metadataValue","decorator","IsPropertyKey","OrdinaryDefineOwnMetadata","defineMetadata","hasMetadata","OrdinaryHasMetadata","hasOwnMetadata","OrdinaryHasOwnMetadata","getMetadata","OrdinaryGetMetadata","getOwnMetadata","OrdinaryGetOwnMetadata","getMetadataKeys","OrdinaryMetadataKeys","getOwnMetadataKeys","OrdinaryOwnMetadataKeys","deleteMetadata","metadataMap","GetOrCreateMetadataMap","delete","size","targetMetadata","i","length","decorated","descriptor","O","P","Create","set","MetadataKey","parent","OrdinaryGetPrototypeOf","ToBoolean","MetadataValue","ownKeys","parentKeys","keys","_i","ownKeys_1","add","push","_a","parentKeys_1","GetIterator","k","next","IteratorStep","nextValue","IteratorValue","e","IteratorClose","Type","x","IsSymbol","ToPrimitive","input","PreferredType","hint","exoticToPrim","GetMethod","result","OrdinaryToPrimitive","toString_1","toString","IsCallable","valueOf","toString_2","argument","ToString","isArray","V","func","obj","method","iterResult","done","f","proto","prototypeProto","constructor","cacheSentinel","arraySentinel","MapIterator","values","selector","_index","_keys","_values","_selector","index","throw","error","return","_cacheKey","_cacheIndex","enumerable","_find","clear","getKey","getValue","getEntry","insert","indexOf","_","_map","UUID_SIZE","rootKey","CreateUniqueKey","_key","table","GetOrCreateWeakMapTable","CreateUUID","FillRandomBytes","buffer","Math","random","GenRandomBytes","Uint8Array","crypto","getRandomValues","msCrypto","data","offset","byte","toLowerCase","__"],"mappings":"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"} |