{"version":3,"file":"index.mjs","sources":["../node_modules/reflect-metadata/Reflect.js","../src/reflection.ts","../src/flat-object.ts","../src/rfdc.ts","../src/flat-serializer.ts","../src/flat-property.ts","../src/flat-collection.ts","../src/flat.ts"],"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 globalThis === \"object\" ? globalThis :\n            typeof global === \"object\" ? global :\n                typeof self === \"object\" ? self :\n                    typeof this === \"object\" ? this :\n                        sloppyModeThis();\n        var exporter = makeExporter(Reflect);\n        if (typeof root.Reflect !== \"undefined\") {\n            exporter = makeExporter(root.Reflect, exporter);\n        }\n        factory(exporter, root);\n        if (typeof root.Reflect === \"undefined\") {\n            root.Reflect = Reflect;\n        }\n        function makeExporter(target, previous) {\n            return function (key, value) {\n                Object.defineProperty(target, key, { configurable: true, writable: true, value: value });\n                if (previous)\n                    previous(key, value);\n            };\n        }\n        function functionThis() {\n            try {\n                return Function(\"return this;\")();\n            }\n            catch (_) { }\n        }\n        function indirectEvalThis() {\n            try {\n                return (void 0, eval)(\"(function() { return this; })()\");\n            }\n            catch (_) { }\n        }\n        function sloppyModeThis() {\n            return functionThis() || indirectEvalThis();\n        }\n    })(function (exporter, root) {\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 _Map = typeof Map === \"function\" && typeof Map.prototype.entries === \"function\" ? Map : CreateMapPolyfill();\n        var _Set = typeof Set === \"function\" && typeof Set.prototype.entries === \"function\" ? Set : CreateSetPolyfill();\n        var _WeakMap = typeof WeakMap === \"function\" ? WeakMap : CreateWeakMapPolyfill();\n        var registrySymbol = supportsSymbol ? Symbol.for(\"@reflect-metadata:registry\") : undefined;\n        var metadataRegistry = GetOrCreateMetadataRegistry();\n        var metadataProvider = CreateMetadataProvider(metadataRegistry);\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            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            var provider = GetMetadataProvider(target, propertyKey, /*Create*/ false);\n            if (IsUndefined(provider))\n                return false;\n            return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);\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        // 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 provider = GetMetadataProvider(O, P, /*Create*/ false);\n            if (IsUndefined(provider))\n                return false;\n            return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));\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 provider = GetMetadataProvider(O, P, /*Create*/ false);\n            if (IsUndefined(provider))\n                return;\n            return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);\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 provider = GetMetadataProvider(O, P, /*Create*/ true);\n            provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);\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 provider = GetMetadataProvider(O, P, /*create*/ false);\n            if (!provider) {\n                return [];\n            }\n            return provider.OrdinaryOwnMetadataKeys(O, P);\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        function SameValueZero(x, y) {\n            return x === y || x !== x && y !== y;\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        // Global metadata registry\n        // - Allows `import \"reflect-metadata\"` and `import \"reflect-metadata/no-conflict\"` to interoperate.\n        // - Uses isolated metadata if `Reflect` is frozen before the registry can be installed.\n        /**\n         * Creates a registry used to allow multiple `reflect-metadata` providers.\n         */\n        function CreateMetadataRegistry() {\n            var fallback;\n            if (!IsUndefined(registrySymbol) &&\n                typeof root.Reflect !== \"undefined\" &&\n                !(registrySymbol in root.Reflect) &&\n                typeof root.Reflect.defineMetadata === \"function\") {\n                // interoperate with older version of `reflect-metadata` that did not support a registry.\n                fallback = CreateFallbackProvider(root.Reflect);\n            }\n            var first;\n            var second;\n            var rest;\n            var targetProviderMap = new _WeakMap();\n            var registry = {\n                registerProvider: registerProvider,\n                getProvider: getProvider,\n                setProvider: setProvider,\n            };\n            return registry;\n            function registerProvider(provider) {\n                if (!Object.isExtensible(registry)) {\n                    throw new Error(\"Cannot add provider to a frozen registry.\");\n                }\n                switch (true) {\n                    case fallback === provider: break;\n                    case IsUndefined(first):\n                        first = provider;\n                        break;\n                    case first === provider: break;\n                    case IsUndefined(second):\n                        second = provider;\n                        break;\n                    case second === provider: break;\n                    default:\n                        if (rest === undefined)\n                            rest = new _Set();\n                        rest.add(provider);\n                        break;\n                }\n            }\n            function getProviderNoCache(O, P) {\n                if (!IsUndefined(first)) {\n                    if (first.isProviderFor(O, P))\n                        return first;\n                    if (!IsUndefined(second)) {\n                        if (second.isProviderFor(O, P))\n                            return first;\n                        if (!IsUndefined(rest)) {\n                            var iterator = GetIterator(rest);\n                            while (true) {\n                                var next = IteratorStep(iterator);\n                                if (!next) {\n                                    return undefined;\n                                }\n                                var provider = IteratorValue(next);\n                                if (provider.isProviderFor(O, P)) {\n                                    IteratorClose(iterator);\n                                    return provider;\n                                }\n                            }\n                        }\n                    }\n                }\n                if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {\n                    return fallback;\n                }\n                return undefined;\n            }\n            function getProvider(O, P) {\n                var providerMap = targetProviderMap.get(O);\n                var provider;\n                if (!IsUndefined(providerMap)) {\n                    provider = providerMap.get(P);\n                }\n                if (!IsUndefined(provider)) {\n                    return provider;\n                }\n                provider = getProviderNoCache(O, P);\n                if (!IsUndefined(provider)) {\n                    if (IsUndefined(providerMap)) {\n                        providerMap = new _Map();\n                        targetProviderMap.set(O, providerMap);\n                    }\n                    providerMap.set(P, provider);\n                }\n                return provider;\n            }\n            function hasProvider(provider) {\n                if (IsUndefined(provider))\n                    throw new TypeError();\n                return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);\n            }\n            function setProvider(O, P, provider) {\n                if (!hasProvider(provider)) {\n                    throw new Error(\"Metadata provider not registered.\");\n                }\n                var existingProvider = getProvider(O, P);\n                if (existingProvider !== provider) {\n                    if (!IsUndefined(existingProvider)) {\n                        return false;\n                    }\n                    var providerMap = targetProviderMap.get(O);\n                    if (IsUndefined(providerMap)) {\n                        providerMap = new _Map();\n                        targetProviderMap.set(O, providerMap);\n                    }\n                    providerMap.set(P, provider);\n                }\n                return true;\n            }\n        }\n        /**\n         * Gets or creates the shared registry of metadata providers.\n         */\n        function GetOrCreateMetadataRegistry() {\n            var metadataRegistry;\n            if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {\n                metadataRegistry = root.Reflect[registrySymbol];\n            }\n            if (IsUndefined(metadataRegistry)) {\n                metadataRegistry = CreateMetadataRegistry();\n            }\n            if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {\n                Object.defineProperty(root.Reflect, registrySymbol, {\n                    enumerable: false,\n                    configurable: false,\n                    writable: false,\n                    value: metadataRegistry\n                });\n            }\n            return metadataRegistry;\n        }\n        function CreateMetadataProvider(registry) {\n            // [[Metadata]] internal slot\n            // https://rbuckton.github.io/reflect-metadata/#ordinary-object-internal-methods-and-internal-slots\n            var metadata = new _WeakMap();\n            var provider = {\n                isProviderFor: function (O, P) {\n                    var targetMetadata = metadata.get(O);\n                    if (IsUndefined(targetMetadata))\n                        return false;\n                    return targetMetadata.has(P);\n                },\n                OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata,\n                OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata,\n                OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata,\n                OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys,\n                OrdinaryDeleteMetadata: OrdinaryDeleteMetadata,\n            };\n            metadataRegistry.registerProvider(provider);\n            return provider;\n            function GetOrCreateMetadataMap(O, P, Create) {\n                var targetMetadata = metadata.get(O);\n                var createdTargetMetadata = false;\n                if (IsUndefined(targetMetadata)) {\n                    if (!Create)\n                        return undefined;\n                    targetMetadata = new _Map();\n                    metadata.set(O, targetMetadata);\n                    createdTargetMetadata = true;\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                    if (!registry.setProvider(O, P, provider)) {\n                        targetMetadata.delete(P);\n                        if (createdTargetMetadata) {\n                            metadata.delete(O);\n                        }\n                        throw new Error(\"Wrong provider for target.\");\n                    }\n                }\n                return metadataMap;\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.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.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            function OrdinaryDeleteMetadata(MetadataKey, O, P) {\n                var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n                if (IsUndefined(metadataMap))\n                    return false;\n                if (!metadataMap.delete(MetadataKey))\n                    return false;\n                if (metadataMap.size === 0) {\n                    var targetMetadata = metadata.get(O);\n                    if (!IsUndefined(targetMetadata)) {\n                        targetMetadata.delete(P);\n                        if (targetMetadata.size === 0) {\n                            metadata.delete(targetMetadata);\n                        }\n                    }\n                }\n                return true;\n            }\n        }\n        function CreateFallbackProvider(reflect) {\n            var defineMetadata = reflect.defineMetadata, hasOwnMetadata = reflect.hasOwnMetadata, getOwnMetadata = reflect.getOwnMetadata, getOwnMetadataKeys = reflect.getOwnMetadataKeys, deleteMetadata = reflect.deleteMetadata;\n            var metadataOwner = new _WeakMap();\n            var provider = {\n                isProviderFor: function (O, P) {\n                    var metadataPropertySet = metadataOwner.get(O);\n                    if (!IsUndefined(metadataPropertySet)) {\n                        return metadataPropertySet.has(P);\n                    }\n                    if (getOwnMetadataKeys(O, P).length) {\n                        if (IsUndefined(metadataPropertySet)) {\n                            metadataPropertySet = new _Set();\n                            metadataOwner.set(O, metadataPropertySet);\n                        }\n                        metadataPropertySet.add(P);\n                        return true;\n                    }\n                    return false;\n                },\n                OrdinaryDefineOwnMetadata: defineMetadata,\n                OrdinaryHasOwnMetadata: hasOwnMetadata,\n                OrdinaryGetOwnMetadata: getOwnMetadata,\n                OrdinaryOwnMetadataKeys: getOwnMetadataKeys,\n                OrdinaryDeleteMetadata: deleteMetadata,\n            };\n            return provider;\n        }\n        /**\n         * Gets the metadata provider for an object. If the object has no metadata provider and this is for a create operation,\n         * then this module's metadata provider is assigned to the object.\n         */\n        function GetMetadataProvider(O, P, Create) {\n            var registeredProvider = metadataRegistry.getProvider(O, P);\n            if (!IsUndefined(registeredProvider)) {\n                return registeredProvider;\n            }\n            if (Create) {\n                if (metadataRegistry.setProvider(O, P, metadataProvider)) {\n                    return metadataProvider;\n                }\n                throw new Error(\"Illegal state.\");\n            }\n            return undefined;\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            var Map = /** @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 (SameValueZero(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 (!SameValueZero(this._cacheKey, key)) {\n                        this._cacheIndex = -1;\n                        for (var i = 0; i < this._keys.length; i++) {\n                            if (SameValueZero(this._keys[i], key)) {\n                                this._cacheIndex = i;\n                                break;\n                            }\n                        }\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            return Map;\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            var Set = /** @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.keys(); };\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            return Set;\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","import { TSFlatCollectionMetadata } from './flat-collection';\nimport { TSFlatObjectMetadata } from './flat-object';\nimport { TSFlatPropertyMetadata } from './flat-property';\nimport { Type } from './helpers';\nimport 'reflect-metadata';\n\nexport class Reflection {\n  static apiMap = 'api:map:';\n  static apiMapFlatObject = `${Reflection.apiMap}TSFlatObject`;\n  static apiMapFlatProperty = `${Reflection.apiMap}TSFlatProperty`;\n  static apiMapCollection = `${Reflection.apiMap}TSFlatCollection`;\n\n  private static getApiMapFlatPropertyKey(target: object, propertyKey: string): string {\n    return `${Reflection.apiMapFlatProperty}.${target.constructor.name}.${propertyKey}`;\n  }\n\n  private static getApiMapFlatCollectionKey(target: object, propertyKey: string): string {\n    return `${Reflection.apiMapCollection}.${target.constructor.name}.${propertyKey}`;\n  }\n\n  static getFlatPropertyMetadata(target: Type<any>, propertyKey: string): TSFlatPropertyMetadata | undefined {\n    if (!target) {\n      return undefined;\n    }\n\n    const key = Reflection.getApiMapFlatPropertyKey(target, propertyKey);\n    return Reflect.getMetadata(key, target);\n  }\n\n  static getFlatCollectionMetadata(target: Type<any>, propertyKey: string): TSFlatCollectionMetadata | undefined {\n    if (!target) {\n      return undefined;\n    }\n\n    const key = Reflection.getApiMapFlatCollectionKey(target, propertyKey);\n    return Reflect.getMetadata(key, target);\n  }\n\n  static getFlatObjectMetadata(type: Type<any>): TSFlatObjectMetadata | undefined {\n    return type ? (Reflect.getMetadata(Reflection.apiMapFlatObject, type) as TSFlatObjectMetadata) : undefined;\n  }\n\n  static setFlatPropertyMetadata(value: TSFlatPropertyMetadata, target: Type<any>, propertyKey: string): void {\n    if (!target) {\n      return;\n    }\n\n    const key = Reflection.getApiMapFlatPropertyKey(target, propertyKey);\n    Reflect.defineMetadata(key, value, target);\n  }\n\n  static setFlatCollectionMetadata(value: TSFlatCollectionMetadata, target: Type<any>, propertyKey: string): void {\n    if (!target) {\n      return;\n    }\n\n    const key = Reflection.getApiMapFlatCollectionKey(target, propertyKey);\n    Reflect.defineMetadata(key, value, target);\n  }\n\n  static setFlatObject(value: TSFlatObjectMetadata, target: Type<any>): void {\n    if (!target) {\n      return;\n    }\n\n    Reflect.defineMetadata(Reflection.apiMapFlatObject, value, target);\n  }\n}\n","import { Type } from './helpers';\nimport { Reflection } from './reflection';\n\nexport const registeredTSFlatObjects: Map<string, Type<any>> = new Map();\n\nexport interface TSFlatObjectMetadata {\n  constructorParams: Array<unknown>;\n}\n\nexport interface TSFlatObjectProperties {\n  constructorParams?: Array<unknown>;\n}\n\nexport const TSFlatObject = (options?: TSFlatObjectProperties): Function => {\n  return (target: Type<any>) => {\n    registerTSFlatObject(target, options);\n  };\n};\n\nexport function registerTSFlatObject(target: Type<any>, options?: TSFlatObjectProperties): void {\n  const constructorParams = options?.constructorParams ?? [];\n  Reflection.setFlatObject(\n    {\n      constructorParams,\n    },\n    target,\n  );\n  registeredTSFlatObjects.set(target.name, target);\n}\n","/*\n    This script was created based on https://github.com/davidmarkclements/rfdc\n    The modifications (and probably new bugs) are thanks to this project, so enjoy :]\n    Probably on the future I'll move this file into a new repository.\n */\nimport { getFlatPropertyMetadata } from './flat-serializer';\nimport { Type } from './helpers';\n\nfunction copyBuffer(cur) {\n  if (cur instanceof Buffer) {\n    return Buffer.from(cur);\n  }\n\n  return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);\n}\n\nexport type CustomWayOfCloningObjectMap = Map<Type<any>, (obj: any) => any>;\n\nexport type RFDCOptions = {\n  customWayOfCloningObject?: CustomWayOfCloningObjectMap;\n};\n\nexport function rfdc(opts?: RFDCOptions) {\n  const refs = [];\n  const refsNew = [];\n\n  return clone;\n\n  function cloneArray(a, fn) {\n    const keys = Object.keys(a);\n    const a2 = new Array(keys.length);\n    for (let i = 0; i < keys.length; i++) {\n      const k = keys[i];\n      const cur = a[k];\n      if (typeof cur !== 'object' || cur === null) {\n        a2[k] = cur;\n      } else if (cur instanceof Date) {\n        a2[k] = new Date(cur);\n      } else if (ArrayBuffer.isView(cur)) {\n        a2[k] = copyBuffer(cur);\n      } else {\n        const index = refs.indexOf(cur);\n        if (index !== -1) {\n          a2[k] = refsNew[index];\n        } else {\n          a2[k] = fn(cur);\n        }\n      }\n    }\n    return a2;\n  }\n\n  function clone(o) {\n    if (typeof o !== 'object' || o === null) return o;\n    if (opts?.customWayOfCloningObject?.has(o.constructor.prototype)) return opts.customWayOfCloningObject.get(o.constructor.prototype)(o);\n    if (o instanceof Date) return new Date(o);\n    if (Array.isArray(o)) return cloneArray(o, clone);\n    if (o instanceof Map) return new Map(cloneArray(Array.from(o), clone));\n    if (o instanceof Set) return new Set(cloneArray(Array.from(o), clone));\n    const o2 = Object.create(Object.getPrototypeOf(o));\n    refs.push(o);\n    refsNew.push(o2);\n    for (const k in o) {\n      const propertyMetadata = getFlatPropertyMetadata(o, k);\n\n      if (Object.hasOwnProperty.call(o, k) === false || propertyMetadata?.ignore === true) continue;\n      const cur = o[k];\n      if (typeof cur !== 'object' || cur === null) {\n        o2[k] = cur;\n      } else if (opts?.customWayOfCloningObject?.has(cur.constructor)) {\n        o2[k] = opts.customWayOfCloningObject.get(cur.constructor)(cur);\n      } else if (cur instanceof Date) {\n        o2[k] = new Date(cur);\n      } else if (cur instanceof Map) {\n        o2[k] = new Map(cloneArray(Array.from(cur), clone));\n      } else if (cur instanceof Set) {\n        o2[k] = new Set(cloneArray(Array.from(cur), clone));\n      } else if (ArrayBuffer.isView(cur)) {\n        o2[k] = copyBuffer(cur);\n      } else {\n        const i = refs.indexOf(cur);\n        if (i !== -1) {\n          o2[k] = refsNew[i];\n        } else {\n          o2[k] = clone(cur);\n        }\n      }\n    }\n    refs.pop();\n    refsNew.pop();\n    return o2;\n  }\n}\n","import { CollectionType, CollectionTypeString, TSFlatCollectionMetadata } from './flat-collection';\nimport { registeredTSFlatObjects } from './flat-object';\nimport { TSFlatPropertyMetadata } from './flat-property';\nimport { Reflection } from './reflection';\nimport { RFDCOptions, rfdc } from './rfdc';\n\nexport type StringifyOptions = {\n  rFDCOptions?: RFDCOptions;\n};\n\nfunction getId(index: number): string {\n  return `#_${index}_#`;\n}\n\nfunction getIndex(id: string): number {\n  return parseInt(id.split('#_')[1], 10);\n}\n\nfunction isId(str: string): boolean {\n  const regex = /^#_(\\d+)_#$/gm;\n  return regex.exec(str) != null;\n}\n\nfunction addItem(value: any, input: any[], positionsByObj: Map<any, number>) {\n  const index = input.push(value) - 1;\n  positionsByObj.set(value, index);\n  return index;\n}\n\nexport const ATTR_CLASS_NAME = '__class__';\n\nfunction formatValue(value: any) {\n  if (value != null && typeof value === 'object' && registeredTSFlatObjects.has(value.constructor.name)) {\n    value[ATTR_CLASS_NAME] = value.constructor.name;\n    return value;\n  }\n\n  return value;\n}\n\nfunction convertCollectionToArray(value: CollectionType, currentCollectionType: CollectionTypeString) {\n  if (value == null) return value;\n\n  switch (currentCollectionType) {\n    case 'array': {\n      return value;\n    }\n    case 'set': {\n      return Array.from(value.values());\n    }\n    case 'map': {\n      return Array.from(value.entries());\n    }\n    case 'dictionary': {\n      const array = [];\n      for (const key of Object.keys(value)) {\n        array.push({\n          key,\n          value: value[key],\n        });\n      }\n      return array;\n    }\n  }\n}\n\nfunction convertArrayToOriginalCollectionType(value: CollectionType, currentCollectionType: CollectionTypeString) {\n  if (value == null) return value;\n\n  const array = value as Array<any>;\n\n  switch (currentCollectionType) {\n    case 'array': {\n      return value;\n    }\n    case 'set': {\n      return new Set(array);\n    }\n    case 'map': {\n      return new Map(array);\n    }\n    case 'dictionary': {\n      const obj: any = {};\n\n      array.forEach(item => {\n        obj[item.key] = item.value;\n      });\n\n      return obj;\n    }\n  }\n}\n\n/**\n * Get the flatPropertyMetadata searching on the object and on object's parent.\n */\nexport function getFlatPropertyMetadata(obj: any, propertyKey: string): TSFlatPropertyMetadata {\n  let propertyMetadata: TSFlatPropertyMetadata = null;\n\n  do {\n    propertyMetadata = Reflection.getFlatPropertyMetadata(obj.constructor.prototype, propertyKey);\n    obj = Object.getPrototypeOf(obj);\n  } while (propertyMetadata == null && obj.constructor.name != 'Object');\n\n  return propertyMetadata;\n}\n\n/**\n * Get the flatCollectionMetadata searching on the object and on object's parent.\n */\nfunction getFlatCollectionMetadata(obj: any, propertyKey: string): TSFlatCollectionMetadata {\n  let collectionMetadata: TSFlatCollectionMetadata = null;\n\n  do {\n    collectionMetadata = Reflection.getFlatCollectionMetadata(obj.constructor.prototype, propertyKey);\n    obj = Object.getPrototypeOf(obj);\n  } while (collectionMetadata == null && obj.constructor.name != 'Object');\n\n  return collectionMetadata;\n}\n\nexport function stringify(obj: any, options?: StringifyOptions): string {\n  const cloner = rfdc(options?.rFDCOptions);\n  obj = cloner(obj);\n\n  const positionsByObj = new Map<any, number>();\n  const inputArray: any[] = [];\n  const outputArray: any[] = [];\n  let i = 0;\n  let first = true;\n\n  addItem(obj, inputArray, positionsByObj);\n\n  while (i < inputArray.length) {\n    first = true;\n    outputArray.push(\n      JSON.stringify(inputArray[i++], (key, value) => {\n        if (first) {\n          if (value != null && typeof value === 'object' && !(value instanceof Array)) {\n            for (const childKey of Object.keys(value)) {\n              const propertyMetadata = getFlatPropertyMetadata(value, childKey);\n              const collectionMetadata = getFlatCollectionMetadata(value, childKey);\n\n              if (propertyMetadata != null && propertyMetadata.beforeStringify) {\n                value[childKey] = propertyMetadata.beforeStringify(value[childKey]);\n              }\n\n              if (collectionMetadata != null) {\n                value[childKey] = convertCollectionToArray(value[childKey], collectionMetadata.collectionType);\n              }\n            }\n          }\n\n          first = false;\n          return formatValue(value);\n        }\n\n        if (value == null) return value;\n\n        if (typeof value === 'object') {\n          if (positionsByObj.has(value)) {\n            return getId(positionsByObj.get(value));\n          }\n\n          return getId(addItem(formatValue(value), inputArray, positionsByObj));\n        }\n\n        return formatValue(value);\n      }),\n    );\n  }\n\n  return `[${outputArray.join(',')}]`;\n}\n\nexport function parse<T>(str: string): T {\n  const array: any[] = JSON.parse(str);\n\n  if (typeof array[0] !== 'object') return array[0];\n\n  // Restore the type of the object\n  array.forEach((item, index) => {\n    if (item != null && typeof item === 'object') {\n      const className = item[ATTR_CLASS_NAME];\n\n      if (className != null && registeredTSFlatObjects.has(className)) {\n        const prototype = registeredTSFlatObjects.get(className).prototype;\n        const tempObj = Object.create(prototype);\n        const metadata = Reflection.getFlatObjectMetadata(tempObj.constructor);\n        array[index] = Object.assign(new tempObj.constructor(...metadata.constructorParams), item);\n      }\n    }\n  });\n\n  // Restore references\n  array.forEach(item => {\n    if (item != null && typeof item === 'object') {\n      for (const key of Object.keys(item)) {\n        if (isId(item[key])) {\n          const indexOnFlat = getIndex(item[key]);\n          item[key] = array[indexOnFlat];\n        }\n      }\n    }\n  });\n\n  afterParse(array[0]);\n\n  array.forEach(item => {\n    if (item != null) {\n      // ATTR_CLASS_NAME is not needed anymore\n      delete item[ATTR_CLASS_NAME];\n    }\n  });\n\n  return array[0];\n}\n\nfunction afterParse(obj: any, alreadyVisited: Set<any> = new Set()) {\n  if (obj == null) return;\n\n  for (const key of Object.keys(obj)) {\n    if (obj[key] != null && typeof obj[key] === 'object') {\n      if (alreadyVisited.has(obj[key])) continue;\n      alreadyVisited.add(obj[key]);\n      afterParse(obj[key], alreadyVisited);\n    }\n\n    const propertyMetadata = getFlatPropertyMetadata(obj, key);\n    const collectionMetadata = getFlatCollectionMetadata(obj, key);\n\n    if (propertyMetadata != null && propertyMetadata.afterParse) {\n      obj[key] = propertyMetadata.afterParse(obj[key]);\n    }\n\n    if (collectionMetadata != null) {\n      obj[key] = convertArrayToOriginalCollectionType(obj[key], collectionMetadata.collectionType);\n    }\n  }\n}\n","import { Type } from './helpers';\nimport { Reflection } from './reflection';\n\nexport type PropertyTransformer = (property: any) => any;\n\nexport interface TSFlatPropertyMetadata {\n  beforeStringify?: PropertyTransformer;\n  afterParse?: PropertyTransformer;\n  ignore?: boolean;\n}\n\nexport type TSFlatPropertyOptions = TSFlatPropertyMetadata;\n\nexport const TSFlatProperty = (options?: TSFlatPropertyOptions): Function => {\n  return (target: Type<any>, key: string) => {\n    registerTSFlatProperty(target, key, options);\n  };\n};\n\nexport function registerTSFlatProperty<T>(target: Type<T>, propertyName: keyof T, options?: TSFlatPropertyOptions): void {\n  Reflection.setFlatPropertyMetadata(\n    {\n      beforeStringify: options?.beforeStringify,\n      afterParse: options?.afterParse,\n      ignore: options?.ignore,\n    },\n    target,\n    propertyName as string,\n  );\n}\n","import { Type } from './helpers';\nimport { Reflection } from './reflection';\n\nexport type CollectionTypeString = 'array' | 'dictionary' | 'map' | 'set';\nexport type CollectionType = Array<any> | { [key: string]: any } | Map<any, any> | Set<any>;\n\nexport type CollectionTransformerEach = (item: any, key: any, collection: CollectionType) => any;\n\nexport interface TSFlatCollectionMetadata {\n  collectionType: CollectionTypeString;\n}\n\nexport type TSFlatCollectionOptions = TSFlatCollectionMetadata;\n\nexport const TSFlatCollection = (options: TSFlatCollectionOptions): Function => {\n  return (target: Type<any>, key: string) => {\n    registerTSFlatCollection(target, key, options);\n  };\n};\n\nexport function registerTSFlatCollection<T>(target: Type<T>, propertyName: keyof T, options: TSFlatCollectionOptions): void {\n  Reflection.setFlatCollectionMetadata(\n    {\n      collectionType: options.collectionType,\n    },\n    target,\n    propertyName as string,\n  );\n}\n","import { TSFlatCollectionOptions, registerTSFlatCollection } from './flat-collection';\nimport { TSFlatObjectProperties, registerTSFlatObject } from './flat-object';\nimport { TSFlatPropertyOptions, registerTSFlatProperty } from './flat-property';\nimport { Type } from './helpers';\n\nexport type FlatObjectRegistration<T> = {\n  target: Type<T>;\n  options?: TSFlatObjectProperties;\n};\n\nexport type FlatPropertyRegistration<T> = {\n  propertyName: keyof T;\n  options?: TSFlatPropertyOptions;\n};\n\nexport type FlatCollectionRegistration<T> = {\n  collectionName: keyof T;\n  options: TSFlatCollectionOptions;\n};\n\nexport type FlatItem<T> = FlatPropertyRegistration<T> | FlatCollectionRegistration<T>;\n\nexport function registerTSFlat<T>(objectRegistration: FlatObjectRegistration<T>, ...items: FlatItem<T>[]) {\n  registerTSFlatObject(objectRegistration.target, objectRegistration.options);\n\n  if (items) {\n    for (const item of items) {\n      if ('collectionName' in item) {\n        registerTSFlatCollection(objectRegistration.target.prototype, item.collectionName, item.options);\n      } else if ('propertyName' in item) {\n        registerTSFlatProperty(objectRegistration.target.prototype, item.propertyName, item.options);\n      }\n    }\n  }\n}\n"],"names":["Reflect","factory","root","globalThis","global","self","this","Function","_","functionThis","eval","indirectEvalThis","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","_Map","Map","entries","CreateMapPolyfill","_Set","Set","CreateSetPolyfill","_WeakMap","WeakMap","CreateWeakMapPolyfill","registrySymbol","for","metadataRegistry","GetOrCreateMetadataRegistry","metadataProvider","CreateMetadataProvider","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","provider","GetMetadataProvider","OrdinaryDeleteMetadata","i","length","decorated","descriptor","MetadataKey","O","P","parent","OrdinaryGetPrototypeOf","ToBoolean","MetadataValue","ownKeys","parentKeys","set","keys","_i","ownKeys_1","add","push","_a","parentKeys_1","Type","x","IsSymbol","ToPrimitive","input","PreferredType","hint","exoticToPrim","GetMethod","result","OrdinaryToPrimitive","toString_1","toString","IsCallable","valueOf","toString_2","argument","ToString","isArray","SameValueZero","y","V","func","GetIterator","obj","method","IteratorValue","iterResult","IteratorStep","next","done","IteratorClose","f","proto","prototypeProto","constructor","CreateMetadataRegistry","fallback","first","second","rest","CreateFallbackProvider","targetProviderMap","registry","registerProvider","getProvider","setProvider","isExtensible","Error","getProviderNoCache","isProviderFor","providerMap","hasProvider","existingProvider","enumerable","targetMetadata","GetOrCreateMetadataMap","Create","createdTargetMetadata","metadataMap","delete","k","nextValue","e","size","reflect","metadataOwner","metadataPropertySet","registeredProvider","cacheSentinel","arraySentinel","MapIterator","values","selector","_index","_keys","_values","_selector","index","throw","error","return","_cacheKey","_cacheIndex","_find","clear","getKey","getValue","getEntry","insert","_map","UUID_SIZE","rootKey","CreateUniqueKey","_key","table","GetOrCreateWeakMapTable","CreateUUID","FillRandomBytes","buffer","Math","random","GenRandomBytes","Uint8Array","crypto","getRandomValues","msCrypto","data","offset","byte","toLowerCase","__","Reflection","static","apiMap","apiMapFlatProperty","name","apiMapCollection","getApiMapFlatPropertyKey","getApiMapFlatCollectionKey","type","apiMapFlatObject","registeredTSFlatObjects","TSFlatObject","options","registerTSFlatObject","constructorParams","setFlatObject","copyBuffer","cur","Buffer","from","slice","byteOffset","getId","isId","str","exec","addItem","positionsByObj","ATTR_CLASS_NAME","formatValue","convertCollectionToArray","currentCollectionType","array","convertArrayToOriginalCollectionType","forEach","item","getFlatPropertyMetadata","propertyMetadata","getFlatCollectionMetadata","collectionMetadata","stringify","cloner","opts","refs","refsNew","clone","o","customWayOfCloningObject","Date","cloneArray","o2","ignore","ArrayBuffer","isView","indexOf","pop","a","fn","a2","rfdc","rFDCOptions","inputArray","outputArray","JSON","childKey","beforeStringify","collectionType","join","parse","className","tempObj","getFlatObjectMetadata","assign","indexOnFlat","id","parseInt","split","afterParse","alreadyVisited","TSFlatProperty","registerTSFlatProperty","propertyName","setFlatPropertyMetadata","TSFlatCollection","registerTSFlatCollection","setFlatCollectionMetadata","registerTSFlat","objectRegistration","items","collectionName"],"mappings":";;;;;;;;;;;;;;AAcA,IAAIA,WACJ,SAAWA,UAGP,SAAWC,SACP,IAAIC,KAA6B,iBAAfC,WAA0BA,WACtB,iBAAXC,OAAsBA,OACT,iBAATC,KAAoBA,KACP,iBAATC,KAAoBA,KAiBvC,WACI,IACI,OAAOC,SAAS,eAATA,EACV,CACD,MAAOC,GAAM,CAChB,CAQUC,IAPX,WACI,IACI,OAAO,EAASC,MAAM,kCACzB,CACD,MAAOF,GAAM,CAChB,CAE4BG,GA5BzBC,SAAWC,aAAab,SAQ5B,SAASa,aAAaC,OAAQC,UAC1B,OAAO,SAAUC,IAAKC,OAClBC,OAAOC,eAAeL,OAAQE,IAAK,CAAEI,cAAc,EAAMC,UAAU,EAAMJ,MAAOA,QAC5EF,UACAA,SAASC,IAAKC,MAClC,CACS,MAb2B,IAAjBf,KAAKF,UACZY,SAAWC,aAAaX,KAAKF,QAASY,WA4B3C,SAAUA,SAAUV,MACnB,IAAIoB,OAASJ,OAAOK,UAAUC,eAE1BC,eAAmC,mBAAXC,OACxBC,kBAAoBF,qBAAgD,IAAvBC,OAAOE,YAA8BF,OAAOE,YAAc,gBACvGC,eAAiBJ,qBAA6C,IAApBC,OAAOI,SAA2BJ,OAAOI,SAAW,aAC9FC,eAA0C,mBAAlBb,OAAOc,OAC/BC,cAAgB,CAAEC,UAAW,cAAgBC,MAC7CC,WAAaL,iBAAmBE,cAChCI,QAAU,CAEVL,OAAQD,eACF,WAAc,OAAOO,eAAepB,OAAOc,OAAO,MAAS,EAC3DC,cACI,WAAc,OAAOK,eAAe,CAAEJ,UAAW,MAAU,EAC3D,WAAc,OAAOI,eAAe,CAAE,EAAI,EACpDC,IAAKH,UACC,SAAUI,IAAKxB,KAAO,OAAOM,OAAOmB,KAAKD,IAAKxB,IAAO,EACrD,SAAUwB,IAAKxB,KAAO,OAAOA,OAAOwB,GAAM,EAChDE,IAAKN,UACC,SAAUI,IAAKxB,KAAO,OAAOM,OAAOmB,KAAKD,IAAKxB,KAAOwB,IAAIxB,UAAO2B,CAAY,EAC5E,SAAUH,IAAKxB,KAAO,OAAOwB,IAAIxB,IAAO,GAG9C4B,kBAAoB1B,OAAO2B,eAAetC,UAC1CuC,KAAsB,mBAARC,KAAuD,mBAA1BA,IAAIxB,UAAUyB,QAAyBD,IAAME,oBACxFC,KAAsB,mBAARC,KAAuD,mBAA1BA,IAAI5B,UAAUyB,QAAyBG,IAAMC,oBACxFC,SAA8B,mBAAZC,QAAyBA,QAAUC,wBACrDC,eAAiB/B,eAAiBC,OAAO+B,IAAI,mCAAgCd,EAC7Ee,iBAAmBC,8BACnBC,iBAAmBC,uBAAuBH,kBAwC9C,SAASI,SAASC,WAAYjD,OAAQkD,YAAaC,YAC/C,GAAKC,YAAYF,aAYZ,CACD,IAAKG,QAAQJ,YACT,MAAM,IAAIK,UACd,IAAKC,cAAcvD,QACf,MAAM,IAAIsD,UACd,OAAOE,oBAAoBP,WAAYjD,OAC1C,CAjBG,IAAKqD,QAAQJ,YACT,MAAM,IAAIK,UACd,IAAKG,SAASzD,QACV,MAAM,IAAIsD,UACd,IAAKG,SAASN,cAAgBC,YAAYD,cAAgBO,OAAOP,YAC7D,MAAM,IAAIG,UAId,OAHII,OAAOP,cACPA,gBAAatB,GAEV8B,iBAAiBV,WAAYjD,OADpCkD,YAAcU,cAAcV,aAC6BC,WAShE,CA4CD,SAASU,SAASC,YAAaC,eAC3B,SAASC,UAAUhE,OAAQkD,aACvB,IAAKO,SAASzD,QACV,MAAM,IAAIsD,UACd,IAAKF,YAAYF,eAAiBe,cAAcf,aAC5C,MAAM,IAAII,UACdY,0BAA0BJ,YAAaC,cAAe/D,OAAQkD,YACjE,CACD,OAAOc,SACV,CAyCD,SAASG,eAAeL,YAAaC,cAAe/D,OAAQkD,aACxD,IAAKO,SAASzD,QACV,MAAM,IAAIsD,UAGd,OAFKF,YAAYF,eACbA,YAAcU,cAAcV,cACzBgB,0BAA0BJ,YAAaC,cAAe/D,OAAQkD,YACxE,CAoCD,SAASkB,YAAYN,YAAa9D,OAAQkD,aACtC,IAAKO,SAASzD,QACV,MAAM,IAAIsD,UAGd,OAFKF,YAAYF,eACbA,YAAcU,cAAcV,cACzBmB,oBAAoBP,YAAa9D,OAAQkD,YACnD,CAoCD,SAASoB,eAAeR,YAAa9D,OAAQkD,aACzC,IAAKO,SAASzD,QACV,MAAM,IAAIsD,UAGd,OAFKF,YAAYF,eACbA,YAAcU,cAAcV,cACzBqB,uBAAuBT,YAAa9D,OAAQkD,YACtD,CAoCD,SAASsB,YAAYV,YAAa9D,OAAQkD,aACtC,IAAKO,SAASzD,QACV,MAAM,IAAIsD,UAGd,OAFKF,YAAYF,eACbA,YAAcU,cAAcV,cACzBuB,oBAAoBX,YAAa9D,OAAQkD,YACnD,CAoCD,SAASwB,eAAeZ,YAAa9D,OAAQkD,aACzC,IAAKO,SAASzD,QACV,MAAM,IAAIsD,UAGd,OAFKF,YAAYF,eACbA,YAAcU,cAAcV,cACzByB,uBAAuBb,YAAa9D,OAAQkD,YACtD,CAmCD,SAAS0B,gBAAgB5E,OAAQkD,aAC7B,IAAKO,SAASzD,QACV,MAAM,IAAIsD,UAGd,OAFKF,YAAYF,eACbA,YAAcU,cAAcV,cACzB2B,qBAAqB7E,OAAQkD,YACvC,CAmCD,SAAS4B,mBAAmB9E,OAAQkD,aAChC,IAAKO,SAASzD,QACV,MAAM,IAAIsD,UAGd,OAFKF,YAAYF,eACbA,YAAcU,cAAcV,cACzB6B,wBAAwB/E,OAAQkD,YAC1C,CAoCD,SAAS8B,eAAelB,YAAa9D,OAAQkD,aACzC,IAAKO,SAASzD,QACV,MAAM,IAAIsD,UAGd,GAFKF,YAAYF,eACbA,YAAcU,cAAcV,eAC3BO,SAASzD,QACV,MAAM,IAAIsD,UACTF,YAAYF,eACbA,YAAcU,cAAcV,cAChC,IAAI+B,SAAWC,oBAAoBlF,OAAQkD,aAAwB,GACnE,OAAIE,YAAY6B,WAETA,SAASE,uBAAuBrB,YAAa9D,OAAQkD,YAC/D,CAED,SAASM,oBAAoBP,WAAYjD,QACrC,IAAK,IAAIoF,EAAInC,WAAWoC,OAAS,EAAGD,GAAK,IAAKA,EAAG,CAC7C,IACIE,WAAYtB,EADAf,WAAWmC,IACDpF,QAC1B,IAAKoD,YAAYkC,aAAe5B,OAAO4B,WAAY,CAC/C,IAAK/B,cAAc+B,WACf,MAAM,IAAIhC,UACdtD,OAASsF,SACZ,CACJ,CACD,OAAOtF,MACV,CACD,SAAS2D,iBAAiBV,WAAYjD,OAAQkD,YAAaqC,YACvD,IAAK,IAAIH,EAAInC,WAAWoC,OAAS,EAAGD,GAAK,IAAKA,EAAG,CAC7C,IACIE,WAAYtB,EADAf,WAAWmC,IACDpF,OAAQkD,YAAaqC,YAC/C,IAAKnC,YAAYkC,aAAe5B,OAAO4B,WAAY,CAC/C,IAAK7B,SAAS6B,WACV,MAAM,IAAIhC,UACdiC,WAAaD,SAChB,CACJ,CACD,OAAOC,UACV,CAGD,SAASlB,oBAAoBmB,YAAaC,EAAGC,GAEzC,GADanB,uBAAuBiB,YAAaC,EAAGC,GAEhD,OAAO,EACX,IAAIC,OAASC,uBAAuBH,GACpC,OAAK/B,OAAOiC,SACDtB,oBAAoBmB,YAAaG,OAAQD,EAEvD,CAGD,SAASnB,uBAAuBiB,YAAaC,EAAGC,GAC5C,IAAIT,SAAWC,oBAAoBO,EAAGC,GAAc,GACpD,OAAItC,YAAY6B,WAETY,UAAUZ,SAASV,uBAAuBiB,YAAaC,EAAGC,GACpE,CAGD,SAASjB,oBAAoBe,YAAaC,EAAGC,GAEzC,GADanB,uBAAuBiB,YAAaC,EAAGC,GAEhD,OAAOf,uBAAuBa,YAAaC,EAAGC,GAClD,IAAIC,OAASC,uBAAuBH,GACpC,OAAK/B,OAAOiC,aAAZ,EACWlB,oBAAoBe,YAAaG,OAAQD,EAEvD,CAGD,SAASf,uBAAuBa,YAAaC,EAAGC,GAC5C,IAAIT,SAAWC,oBAAoBO,EAAGC,GAAc,GACpD,IAAItC,YAAY6B,UAEhB,OAAOA,SAASN,uBAAuBa,YAAaC,EAAGC,EAC1D,CAGD,SAASxB,0BAA0BsB,YAAaM,cAAeL,EAAGC,GAC/CR,oBAAoBO,EAAGC,GAAc,GAC3CxB,0BAA0BsB,YAAaM,cAAeL,EAAGC,EACrE,CAGD,SAASb,qBAAqBY,EAAGC,GAC7B,IAAIK,QAAUhB,wBAAwBU,EAAGC,GACrCC,OAASC,uBAAuBH,GACpC,GAAe,OAAXE,OACA,OAAOI,QACX,IAAIC,WAAanB,qBAAqBc,OAAQD,GAC9C,GAAIM,WAAWX,QAAU,EACrB,OAAOU,QACX,GAAIA,QAAQV,QAAU,EAClB,OAAOW,WAGX,IAFA,IAAIC,IAAM,IAAI7D,KACV8D,KAAO,GACFC,GAAK,EAAGC,UAAYL,QAASI,GAAKC,UAAUf,OAAQc,KAAM,CAC/D,IAAIjG,IAAMkG,UAAUD,IACPF,IAAIxE,IAAIvB,OAEjB+F,IAAII,IAAInG,KACRgG,KAAKI,KAAKpG,KAEjB,CACD,IAAK,IAAIqG,GAAK,EAAGC,aAAeR,WAAYO,GAAKC,aAAanB,OAAQkB,KAAM,CACpErG,IAAMsG,aAAaD,IACVN,IAAIxE,IAAIvB,OAEjB+F,IAAII,IAAInG,KACRgG,KAAKI,KAAKpG,KAEjB,CACD,OAAOgG,IACV,CAGD,SAASnB,wBAAwBU,EAAGC,GAChC,IAAIT,SAAWC,oBAAoBO,EAAGC,GAAc,GACpD,OAAKT,SAGEA,SAASF,wBAAwBU,EAAGC,GAFhC,EAGd,CAGD,SAASe,KAAKC,GACV,GAAU,OAANA,EACA,OAAO,EACX,cAAeA,GACX,IAAK,YAAa,OAAO,EACzB,IAAK,UAAW,OAAO,EACvB,IAAK,SAAU,OAAO,EACtB,IAAK,SAAU,OAAO,EACtB,IAAK,SAAU,OAAO,EACtB,IAAK,SAAU,OAAa,OAANA,EAAa,EAAe,EAClD,QAAS,OAAO,EAEvB,CAGD,SAAStD,YAAYsD,GACjB,YAAa7E,IAAN6E,CACV,CAGD,SAAShD,OAAOgD,GACZ,OAAa,OAANA,CACV,CAGD,SAASC,SAASD,GACd,MAAoB,iBAANA,CACjB,CAGD,SAASjD,SAASiD,GACd,MAAoB,iBAANA,EAAuB,OAANA,EAA0B,mBAANA,CACtD,CAKD,SAASE,YAAYC,MAAOC,eACxB,OAAQL,KAAKI,QACT,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EAAgB,OAAOA,MAEhC,IAAIE,KAAyB,IAAlBD,cAAmC,SAA6B,IAAlBA,cAAmC,SAAW,UACnGE,aAAeC,UAAUJ,MAAOhG,mBACpC,QAAqBgB,IAAjBmF,aAA4B,CAC5B,IAAIE,OAASF,aAAarF,KAAKkF,MAAOE,MACtC,GAAItD,SAASyD,QACT,MAAM,IAAI5D,UACd,OAAO4D,MACV,CACD,OAAOC,oBAAoBN,MAAgB,YAATE,KAAqB,SAAWA,KACrE,CAGD,SAASI,oBAAoB1B,EAAGsB,MAC5B,GAAa,WAATA,KAAmB,CACnB,IAAIK,WAAa3B,EAAE4B,SACnB,GAAIC,WAAWF,YAEX,IAAK3D,SADDyD,OAASE,WAAWzF,KAAK8D,IAEzB,OAAOyB,OAGf,GAAII,WADAC,QAAU9B,EAAE8B,SAGZ,IAAK9D,SADDyD,OAASK,QAAQ5F,KAAK8D,IAEtB,OAAOyB,MAElB,KACI,CACD,IAAIK,QACJ,GAAID,WADAC,QAAU9B,EAAE8B,SAGZ,IAAK9D,SADDyD,OAASK,QAAQ5F,KAAK8D,IAEtB,OAAOyB,OAEf,IAEQA,OAFJM,WAAa/B,EAAE4B,SACnB,GAAIC,WAAWE,YAEX,IAAK/D,SADDyD,OAASM,WAAW7F,KAAK8D,IAEzB,OAAOyB,MAElB,CACD,MAAM,IAAI5D,SACb,CAGD,SAASuC,UAAU4B,UACf,QAASA,QACZ,CAGD,SAASC,SAASD,UACd,MAAO,GAAKA,QACf,CAGD,SAAS7D,cAAc6D,UACnB,IAAIvH,IAAM0G,YAAYa,SAAU,GAChC,OAAId,SAASzG,KACFA,IACJwH,SAASxH,IACnB,CAKD,SAASmD,QAAQoE,UACb,OAAOpG,MAAMsG,QACPtG,MAAMsG,QAAQF,UACdA,oBAAoBrH,OAChBqH,oBAAoBpG,MACyB,mBAA7CjB,OAAOK,UAAU4G,SAAS1F,KAAK8F,SAC5C,CAGD,SAASH,WAAWG,UAEhB,MAA2B,mBAAbA,QACjB,CAGD,SAASlE,cAAckE,UAEnB,MAA2B,mBAAbA,QACjB,CAGD,SAASxD,cAAcwD,UACnB,OAAQhB,KAAKgB,WACT,KAAK,EACL,KAAK,EAAgB,OAAO,EAC5B,QAAS,OAAO,EAEvB,CACD,SAASG,cAAclB,EAAGmB,GACtB,OAAOnB,IAAMmB,GAAKnB,GAAMA,GAAKmB,GAAMA,CACtC,CAKD,SAASZ,UAAUa,EAAGpC,GAClB,IAAIqC,KAAOD,EAAEpC,GACb,GAAIqC,WAAJ,CAEA,IAAKT,WAAWS,MACZ,MAAM,IAAIzE,UACd,OAAOyE,IAHa,CAIvB,CAGD,SAASC,YAAYC,KACjB,IAAIC,OAASjB,UAAUgB,IAAKlH,gBAC5B,IAAKuG,WAAWY,QACZ,MAAM,IAAI5E,UACd,IAAItC,SAAWkH,OAAOvG,KAAKsG,KAC3B,IAAKxE,SAASzC,UACV,MAAM,IAAIsC,UACd,OAAOtC,QACV,CAGD,SAASmH,cAAcC,YACnB,OAAOA,WAAWjI,KACrB,CAGD,SAASkI,aAAarH,UAClB,IAAIkG,OAASlG,SAASsH,OACtB,OAAOpB,OAAOqB,MAAerB,MAChC,CAGD,SAASsB,cAAcxH,UACnB,IAAIyH,EAAIzH,SAAiB,OACrByH,GACAA,EAAE9G,KAAKX,SACd,CAKD,SAAS4E,uBAAuBH,GAC5B,IAAIiD,MAAQtI,OAAO2B,eAAe0D,GAClC,GAAiB,mBAANA,GAAoBA,IAAM3D,kBACjC,OAAO4G,MAQX,GAAIA,QAAU5G,kBACV,OAAO4G,MAEX,IAAIjI,UAAYgF,EAAEhF,UACdkI,eAAiBlI,WAAaL,OAAO2B,eAAetB,WACxD,GAAsB,MAAlBkI,gBAA0BA,iBAAmBvI,OAAOK,UACpD,OAAOiI,MAEX,IAAIE,YAAcD,eAAeC,YACjC,MAA2B,mBAAhBA,aAGPA,cAAgBnD,EAFTiD,MAKJE,WACV,CAOD,SAASC,yBACL,IAAIC,SAQAC,MACAC,OACAC,KATC7F,YAAYV,sBACW,IAAjBtD,KAAKF,SACVwD,kBAAkBtD,KAAKF,SACc,mBAAhCE,KAAKF,QAAQiF,iBAEpB2E,SAAWI,uBAAuB9J,KAAKF,UAK3C,IAAIiK,kBAAoB,IAAI5G,SACxB6G,SAAW,CACXC,iBAAkBA,iBAClBC,YAAaA,YACbC,YAAaA,aAEjB,OAAOH,SACP,SAASC,iBAAiBpE,UACtB,IAAK7E,OAAOoJ,aAAaJ,UACrB,MAAM,IAAIK,MAAM,6CAEpB,QAAQ,GACJ,KAAKX,WAAa7D,SAAU,MAC5B,KAAK7B,YAAY2F,OACbA,MAAQ9D,SACR,MACJ,KAAK8D,QAAU9D,SAAU,MACzB,KAAK7B,YAAY4F,QACbA,OAAS/D,SACT,MACJ,KAAK+D,SAAW/D,SAAU,MAC1B,aACiBpD,IAAToH,OACAA,KAAO,IAAI7G,MACf6G,KAAK5C,IAAIpB,UAGpB,CACD,SAASyE,mBAAmBjE,EAAGC,GAC3B,IAAKtC,YAAY2F,OAAQ,CACrB,GAAIA,MAAMY,cAAclE,EAAGC,GACvB,OAAOqD,MACX,IAAK3F,YAAY4F,QAAS,CACtB,GAAIA,OAAOW,cAAclE,EAAGC,GACxB,OAAOqD,MACX,IAAK3F,YAAY6F,MAEb,IADA,IAAIjI,SAAWgH,YAAYiB,QACd,CACT,IAAIX,KAAOD,aAAarH,UACxB,IAAKsH,KACD,OAEJ,IAAIrD,SAAWkD,cAAcG,MAC7B,GAAIrD,SAAS0E,cAAclE,EAAGC,GAE1B,OADA8C,cAAcxH,UACPiE,QAEd,CAER,CACJ,CACD,IAAK7B,YAAY0F,WAAaA,SAASa,cAAclE,EAAGC,GACpD,OAAOoD,QAGd,CACD,SAASQ,YAAY7D,EAAGC,GACpB,IACIT,SADA2E,YAAcT,kBAAkBvH,IAAI6D,GAKxC,OAHKrC,YAAYwG,eACb3E,SAAW2E,YAAYhI,IAAI8D,IAE1BtC,YAAY6B,WAIZ7B,YADL6B,SAAWyE,mBAAmBjE,EAAGC,MAEzBtC,YAAYwG,eACZA,YAAc,IAAI5H,KAClBmH,kBAAkBlD,IAAIR,EAAGmE,cAE7BA,YAAY3D,IAAIP,EAAGT,WAEhBA,UAVIA,QAWd,CACD,SAAS4E,YAAY5E,UACjB,GAAI7B,YAAY6B,UACZ,MAAM,IAAI3B,UACd,OAAOyF,QAAU9D,UAAY+D,SAAW/D,WAAa7B,YAAY6F,OAASA,KAAKxH,IAAIwD,SACtF,CACD,SAASsE,YAAY9D,EAAGC,EAAGT,UACvB,IAAK4E,YAAY5E,UACb,MAAM,IAAIwE,MAAM,qCAEpB,IAAIK,iBAAmBR,YAAY7D,EAAGC,GACtC,GAAIoE,mBAAqB7E,SAAU,CAC/B,IAAK7B,YAAY0G,kBACb,OAAO,EAEX,IAAIF,YAAcT,kBAAkBvH,IAAI6D,GACpCrC,YAAYwG,eACZA,YAAc,IAAI5H,KAClBmH,kBAAkBlD,IAAIR,EAAGmE,cAE7BA,YAAY3D,IAAIP,EAAGT,SACtB,CACD,OAAO,CACV,CACJ,CAID,SAASpC,8BACL,IAAID,iBAeJ,OAdKQ,YAAYV,iBAAmBe,SAASrE,KAAKF,UAAYkB,OAAOoJ,aAAapK,KAAKF,WACnF0D,iBAAmBxD,KAAKF,QAAQwD,iBAEhCU,YAAYR,oBACZA,iBAAmBiG,2BAElBzF,YAAYV,iBAAmBe,SAASrE,KAAKF,UAAYkB,OAAOoJ,aAAapK,KAAKF,UACnFkB,OAAOC,eAAejB,KAAKF,QAASwD,eAAgB,CAChDqH,YAAY,EACZzJ,cAAc,EACdC,UAAU,EACVJ,MAAOyC,mBAGRA,gBACV,CACD,SAASG,uBAAuBqG,UAG5B,IAAIvF,SAAW,IAAItB,SACf0C,SAAW,CACX0E,cAAe,SAAUlE,EAAGC,GACxB,IAAIsE,eAAiBnG,SAASjC,IAAI6D,GAClC,OAAIrC,YAAY4G,iBAETA,eAAevI,IAAIiE,EAC7B,EACDxB,0BAA2BA,0BAC3BK,uBAAwBA,uBACxBI,uBAAwBA,uBACxBI,wBAAyBA,wBACzBI,uBAAwBA,wBAG5B,OADAvC,iBAAiByG,iBAAiBpE,UAC3BA,SACP,SAASgF,uBAAuBxE,EAAGC,EAAGwE,QAClC,IAAIF,eAAiBnG,SAASjC,IAAI6D,GAC9B0E,uBAAwB,EAC5B,GAAI/G,YAAY4G,gBAAiB,CAC7B,IAAKE,OACD,OACJF,eAAiB,IAAIhI,KACrB6B,SAASoC,IAAIR,EAAGuE,gBAChBG,uBAAwB,CAC3B,CACD,IAAIC,YAAcJ,eAAepI,IAAI8D,GACrC,GAAItC,YAAYgH,aAAc,CAC1B,IAAKF,OACD,OAGJ,GAFAE,YAAc,IAAIpI,KAClBgI,eAAe/D,IAAIP,EAAG0E,cACjBhB,SAASG,YAAY9D,EAAGC,EAAGT,UAK5B,MAJA+E,eAAeK,OAAO3E,GAClByE,uBACAtG,SAASwG,OAAO5E,GAEd,IAAIgE,MAAM,6BAEvB,CACD,OAAOW,WACV,CAGD,SAAS7F,uBAAuBiB,YAAaC,EAAGC,GAC5C,IAAI0E,YAAcH,uBAAuBxE,EAAGC,GAAc,GAC1D,OAAItC,YAAYgH,cAETvE,UAAUuE,YAAY3I,IAAI+D,aACpC,CAGD,SAASb,uBAAuBa,YAAaC,EAAGC,GAC5C,IAAI0E,YAAcH,uBAAuBxE,EAAGC,GAAc,GAC1D,IAAItC,YAAYgH,aAEhB,OAAOA,YAAYxI,IAAI4D,YAC1B,CAGD,SAAStB,0BAA0BsB,YAAaM,cAAeL,EAAGC,GAC5CuE,uBAAuBxE,EAAGC,GAAc,GAC9CO,IAAIT,YAAaM,cAChC,CAGD,SAASf,wBAAwBU,EAAGC,GAChC,IAAIQ,KAAO,GACPkE,YAAcH,uBAAuBxE,EAAGC,GAAc,GAC1D,GAAItC,YAAYgH,aACZ,OAAOlE,KAIX,IAHA,IACIlF,SAAWgH,YADDoC,YAAYlE,QAEtBoE,EAAI,IACK,CACT,IAAIhC,KAAOD,aAAarH,UACxB,IAAKsH,KAED,OADApC,KAAKb,OAASiF,EACPpE,KAEX,IAAIqE,UAAYpC,cAAcG,MAC9B,IACIpC,KAAKoE,GAAKC,SACb,CACD,MAAOC,GACH,IACIhC,cAAcxH,SACjB,CACO,QACJ,MAAMwJ,CACT,CACJ,CACDF,GACH,CACJ,CACD,SAASnF,uBAAuBK,YAAaC,EAAGC,GAC5C,IAAI0E,YAAcH,uBAAuBxE,EAAGC,GAAc,GAC1D,GAAItC,YAAYgH,aACZ,OAAO,EACX,IAAKA,YAAYC,OAAO7E,aACpB,OAAO,EACX,GAAyB,IAArB4E,YAAYK,KAAY,CACxB,IAAIT,eAAiBnG,SAASjC,IAAI6D,GAC7BrC,YAAY4G,kBACbA,eAAeK,OAAO3E,GACM,IAAxBsE,eAAeS,MACf5G,SAASwG,OAAOL,gBAG3B,CACD,OAAO,CACV,CACJ,CACD,SAASd,uBAAuBwB,SAC5B,IAAIvG,eAAiBuG,QAAQvG,eAAgBG,eAAiBoG,QAAQpG,eAAgBI,eAAiBgG,QAAQhG,eAAgBI,mBAAqB4F,QAAQ5F,mBAAoBE,eAAiB0F,QAAQ1F,eACrM2F,cAAgB,IAAIpI,SAuBxB,MAtBe,CACXoH,cAAe,SAAUlE,EAAGC,GACxB,IAAIkF,oBAAsBD,cAAc/I,IAAI6D,GAC5C,OAAKrC,YAAYwH,uBAGb9F,mBAAmBW,EAAGC,GAAGL,SACrBjC,YAAYwH,uBACZA,oBAAsB,IAAIxI,KAC1BuI,cAAc1E,IAAIR,EAAGmF,sBAEzBA,oBAAoBvE,IAAIX,IACjB,GARAkF,oBAAoBnJ,IAAIiE,EAWtC,EACDxB,0BAA2BC,eAC3BI,uBAAwBD,eACxBK,uBAAwBD,eACxBK,wBAAyBD,mBACzBK,uBAAwBH,eAG/B,CAKD,SAASE,oBAAoBO,EAAGC,EAAGwE,QAC/B,IAAIW,mBAAqBjI,iBAAiB0G,YAAY7D,EAAGC,GACzD,IAAKtC,YAAYyH,oBACb,OAAOA,mBAEX,GAAIX,OAAQ,CACR,GAAItH,iBAAiB2G,YAAY9D,EAAGC,EAAG5C,kBACnC,OAAOA,iBAEX,MAAM,IAAI2G,MAAM,iBACnB,CAEJ,CAED,SAAStH,oBACL,IAAI2I,cAAgB,CAAA,EAChBC,cAAgB,GAChBC,YAA6B,WAC7B,SAASA,YAAY9E,KAAM+E,OAAQC,UAC/B1L,KAAK2L,OAAS,EACd3L,KAAK4L,MAAQlF,KACb1G,KAAK6L,QAAUJ,OACfzL,KAAK8L,UAAYJ,QACpB,CAmCD,OAlCAF,YAAYvK,UAAU,cAAgB,WAAc,OAAOjB,MAC3DwL,YAAYvK,UAAUM,gBAAkB,WAAc,OAAOvB,MAC7DwL,YAAYvK,UAAU6H,KAAO,WACzB,IAAIiD,MAAQ/L,KAAK2L,OACjB,GAAII,OAAS,GAAKA,MAAQ/L,KAAK4L,MAAM/F,OAAQ,CACzC,IAAI6B,OAAS1H,KAAK8L,UAAU9L,KAAK4L,MAAMG,OAAQ/L,KAAK6L,QAAQE,QAS5D,OARIA,MAAQ,GAAK/L,KAAK4L,MAAM/F,QACxB7F,KAAK2L,QAAU,EACf3L,KAAK4L,MAAQL,cACbvL,KAAK6L,QAAUN,eAGfvL,KAAK2L,SAEF,CAAEhL,MAAO+G,OAAQqB,MAAM,EACjC,CACD,MAAO,CAAEpI,WAAO0B,EAAW0G,MAAM,EACrD,EACgByC,YAAYvK,UAAU+K,MAAQ,SAAUC,OAMpC,MALIjM,KAAK2L,QAAU,IACf3L,KAAK2L,QAAU,EACf3L,KAAK4L,MAAQL,cACbvL,KAAK6L,QAAUN,eAEbU,KAC1B,EACgBT,YAAYvK,UAAUiL,OAAS,SAAUvL,OAMrC,OALIX,KAAK2L,QAAU,IACf3L,KAAK2L,QAAU,EACf3L,KAAK4L,MAAQL,cACbvL,KAAK6L,QAAUN,eAEZ,CAAE5K,MAAOA,MAAOoI,MAAM,EACjD,EACuByC,WACV,CA1Cc,GAiHf,OAtEyB,WACrB,SAAS/I,MACLzC,KAAK4L,MAAQ,GACb5L,KAAK6L,QAAU,GACf7L,KAAKmM,UAAYb,cACjBtL,KAAKoM,aAAe,CACvB,CA8DD,OA7DAxL,OAAOC,eAAe4B,IAAIxB,UAAW,OAAQ,CACzCmB,IAAK,WAAc,OAAOpC,KAAK4L,MAAM/F,MAAS,EAC9C0E,YAAY,EACZzJ,cAAc,IAElB2B,IAAIxB,UAAUgB,IAAM,SAAUvB,KAAO,OAAOV,KAAKqM,MAAM3L,KAAgB,IAAU,CAAE,EACnF+B,IAAIxB,UAAUmB,IAAM,SAAU1B,KAC1B,IAAIqL,MAAQ/L,KAAKqM,MAAM3L,KAAgB,GACvC,OAAOqL,OAAS,EAAI/L,KAAK6L,QAAQE,YAAS1J,CAC9D,EACgBI,IAAIxB,UAAUwF,IAAM,SAAU/F,IAAKC,OAC/B,IAAIoL,MAAQ/L,KAAKqM,MAAM3L,KAAgB,GAEvC,OADAV,KAAK6L,QAAQE,OAASpL,MACfX,IAC3B,EACgByC,IAAIxB,UAAU4J,OAAS,SAAUnK,KAC7B,IAAIqL,MAAQ/L,KAAKqM,MAAM3L,KAAgB,GACvC,GAAIqL,OAAS,EAAG,CAEZ,IADA,IAAId,KAAOjL,KAAK4L,MAAM/F,OACbD,EAAImG,MAAQ,EAAGnG,EAAIqF,KAAMrF,IAC9B5F,KAAK4L,MAAMhG,EAAI,GAAK5F,KAAK4L,MAAMhG,GAC/B5F,KAAK6L,QAAQjG,EAAI,GAAK5F,KAAK6L,QAAQjG,GAQvC,OANA5F,KAAK4L,MAAM/F,SACX7F,KAAK6L,QAAQhG,SACTuC,cAAc1H,IAAKV,KAAKmM,aACxBnM,KAAKmM,UAAYb,cACjBtL,KAAKoM,aAAe,IAEjB,CACV,CACD,OAAO,CAC3B,EACgB3J,IAAIxB,UAAUqL,MAAQ,WAClBtM,KAAK4L,MAAM/F,OAAS,EACpB7F,KAAK6L,QAAQhG,OAAS,EACtB7F,KAAKmM,UAAYb,cACjBtL,KAAKoM,aAAe,CACxC,EACgB3J,IAAIxB,UAAUyF,KAAO,WAAc,OAAO,IAAI8E,YAAYxL,KAAK4L,MAAO5L,KAAK6L,QAASU,OAAQ,EAC5F9J,IAAIxB,UAAUwK,OAAS,WAAc,OAAO,IAAID,YAAYxL,KAAK4L,MAAO5L,KAAK6L,QAASW,SAAU,EAChG/J,IAAIxB,UAAUyB,QAAU,WAAc,OAAO,IAAI8I,YAAYxL,KAAK4L,MAAO5L,KAAK6L,QAASY,SAAU,EACjGhK,IAAIxB,UAAU,cAAgB,WAAc,OAAOjB,KAAK0C,WACxDD,IAAIxB,UAAUM,gBAAkB,WAAc,OAAOvB,KAAK0C,WAC1DD,IAAIxB,UAAUoL,MAAQ,SAAU3L,IAAKgM,QACjC,IAAKtE,cAAcpI,KAAKmM,UAAWzL,KAAM,CACrCV,KAAKoM,aAAe,EACpB,IAAK,IAAIxG,EAAI,EAAGA,EAAI5F,KAAK4L,MAAM/F,OAAQD,IACnC,GAAIwC,cAAcpI,KAAK4L,MAAMhG,GAAIlF,KAAM,CACnCV,KAAKoM,YAAcxG,EACnB,KACH,CAER,CAMD,OALI5F,KAAKoM,YAAc,GAAKM,SACxB1M,KAAKoM,YAAcpM,KAAK4L,MAAM/F,OAC9B7F,KAAK4L,MAAM9E,KAAKpG,KAChBV,KAAK6L,QAAQ/E,UAAKzE,IAEfrC,KAAKoM,WAChC,EACuB3J,GACV,CArEM,GAuEP,SAAS8J,OAAO7L,IAAKR,GACjB,OAAOQ,GACV,CACD,SAAS8L,SAAStM,EAAGS,OACjB,OAAOA,KACV,CACD,SAAS8L,SAAS/L,IAAKC,OACnB,MAAO,CAACD,IAAKC,MAChB,CACJ,CAED,SAASmC,oBAqBL,OApByB,WACrB,SAASD,MACL7C,KAAK2M,KAAO,IAAInK,IACnB,CAeD,OAdA5B,OAAOC,eAAegC,IAAI5B,UAAW,OAAQ,CACzCmB,IAAK,WAAc,OAAOpC,KAAK2M,KAAK1B,IAAO,EAC3CV,YAAY,EACZzJ,cAAc,IAElB+B,IAAI5B,UAAUgB,IAAM,SAAUtB,OAAS,OAAOX,KAAK2M,KAAK1K,IAAItB,MAAO,EACnEkC,IAAI5B,UAAU4F,IAAM,SAAUlG,OAAS,OAAOX,KAAK2M,KAAKlG,IAAI9F,MAAOA,OAAQX,IAAK,EAChF6C,IAAI5B,UAAU4J,OAAS,SAAUlK,OAAS,OAAOX,KAAK2M,KAAK9B,OAAOlK,MAAO,EACzEkC,IAAI5B,UAAUqL,MAAQ,WAActM,KAAK2M,KAAKL,SAC9CzJ,IAAI5B,UAAUyF,KAAO,WAAc,OAAO1G,KAAK2M,KAAKjG,QACpD7D,IAAI5B,UAAUwK,OAAS,WAAc,OAAOzL,KAAK2M,KAAKjG,QACtD7D,IAAI5B,UAAUyB,QAAU,WAAc,OAAO1C,KAAK2M,KAAKjK,WACvDG,IAAI5B,UAAU,cAAgB,WAAc,OAAOjB,KAAK0G,QACxD7D,IAAI5B,UAAUM,gBAAkB,WAAc,OAAOvB,KAAK0G,QACnD7D,GACV,CAnBM,EAqBV,CAED,SAASI,wBACL,IAAI2J,UAAY,GACZlG,KAAO3E,QAAQL,SACfmL,QAAUC,kBACd,OAAsB,WAClB,SAAS9J,UACLhD,KAAK+M,KAAOD,iBACf,CAsBD,OArBA9J,QAAQ/B,UAAUgB,IAAM,SAAUzB,QAC9B,IAAIwM,MAAQC,wBAAwBzM,QAAmB,GACvD,YAAiB6B,IAAV2K,OAAsBjL,QAAQE,IAAI+K,MAAOhN,KAAK+M,KACzE,EACgB/J,QAAQ/B,UAAUmB,IAAM,SAAU5B,QAC9B,IAAIwM,MAAQC,wBAAwBzM,QAAmB,GACvD,YAAiB6B,IAAV2K,MAAsBjL,QAAQK,IAAI4K,MAAOhN,KAAK+M,WAAQ1K,CACjF,EACgBW,QAAQ/B,UAAUwF,IAAM,SAAUjG,OAAQG,OAGtC,OAFYsM,wBAAwBzM,QAAmB,GACjDR,KAAK+M,MAAQpM,MACZX,IAC3B,EACgBgD,QAAQ/B,UAAU4J,OAAS,SAAUrK,QACjC,IAAIwM,MAAQC,wBAAwBzM,QAAmB,GACvD,YAAiB6B,IAAV2K,cAA6BA,MAAMhN,KAAK+M,KACnE,EACgB/J,QAAQ/B,UAAUqL,MAAQ,WAEtBtM,KAAK+M,KAAOD,iBAChC,EACuB9J,OACvB,IACY,SAAS8J,kBACL,IAAIpM,IACJ,GACIA,IAAM,cAAgBwM,mBACnBnL,QAAQE,IAAIyE,KAAMhG,MAEzB,OADAgG,KAAKhG,MAAO,EACLA,GACV,CACD,SAASuM,wBAAwBzM,OAAQkB,QACrC,IAAKV,OAAOmB,KAAK3B,OAAQqM,SAAU,CAC/B,IAAKnL,OACD,OACJd,OAAOC,eAAeL,OAAQqM,QAAS,CAAElM,MAAOoB,QAAQL,UAC3D,CACD,OAAOlB,OAAOqM,QACjB,CACD,SAASM,gBAAgBC,OAAQnC,MAC7B,IAAK,IAAIrF,EAAI,EAAGA,EAAIqF,OAAQrF,EACxBwH,OAAOxH,GAAqB,IAAhByH,KAAKC,SAAkB,EACvC,OAAOF,MACV,CACD,SAASG,eAAetC,MACpB,MAA0B,mBAAfuC,WACe,oBAAXC,OACAA,OAAOC,gBAAgB,IAAIF,WAAWvC,OACzB,oBAAb0C,SACAA,SAASD,gBAAgB,IAAIF,WAAWvC,OAC5CkC,gBAAgB,IAAIK,WAAWvC,MAAOA,MAE1CkC,gBAAgB,IAAItL,MAAMoJ,MAAOA,KAC3C,CACD,SAASiC,aACL,IAAIU,KAAOL,eAAeX,WAE1BgB,KAAK,GAAe,GAAVA,KAAK,GAAY,GAC3BA,KAAK,GAAe,IAAVA,KAAK,GAAY,IAE3B,IADA,IAAIlG,OAAS,GACJmG,OAAS,EAAGA,OAASjB,YAAaiB,OAAQ,CAC/C,IAAIC,KAAOF,KAAKC,QACD,IAAXA,QAA2B,IAAXA,QAA2B,IAAXA,SAChCnG,QAAU,KACVoG,KAAO,KACPpG,QAAU,KACdA,QAAUoG,KAAKjG,SAAS,IAAIkG,aAC/B,CACD,OAAOrG,MACV,CACJ,CAED,SAAS1F,eAAeyG,KAGpB,OAFAA,IAAIuF,QAAK3L,SACFoG,IAAIuF,GACJvF,GACV,CA7uCDnI,SAAS,WAAYkD,UAqDrBlD,SAAS,WAAY+D,UA+CrB/D,SAAS,iBAAkBqE,gBA0C3BrE,SAAS,cAAesE,aA0CxBtE,SAAS,iBAAkBwE,gBA0C3BxE,SAAS,cAAe0E,aA0CxB1E,SAAS,iBAAkB4E,gBAyC3B5E,SAAS,kBAAmB8E,iBAyC5B9E,SAAS,qBAAsBgF,oBAiD/BhF,SAAS,iBAAkBkF,eA+1BnC,CAn2CQ7F,CAAQW,SAAUV,WACU,IAAjBA,KAAKF,UACZE,KAAKF,QAAUA,QAwBtB,CApCD,EA82CH,CAj3CD,CAi3CGA,YAAYA,UAAU,CAAA,UC13CZuO,WACXC,cAAgB,WAChBA,wBAA0B,GAAGD,WAAWE,qBACxCD,0BAA4B,GAAGD,WAAWE,uBAC1CD,wBAA0B,GAAGD,WAAWE,yBAEhCD,gCAAgC1N,OAAgBkD,aACtD,MAAO,GAAGuK,WAAWG,sBAAsB5N,OAAO4I,YAAYiF,QAAQ3K,aACvE,CAEOwK,kCAAkC1N,OAAgBkD,aACxD,MAAO,GAAGuK,WAAWK,oBAAoB9N,OAAO4I,YAAYiF,QAAQ3K,aACrE,CAEDwK,+BAA+B1N,OAAmBkD,aAChD,IAAKlD,OACH,OAGF,MAAME,IAAMuN,WAAWM,yBAAyB/N,OAAQkD,aACxD,OAAOhE,QAAQsF,YAAYtE,IAAKF,OACjC,CAED0N,iCAAiC1N,OAAmBkD,aAClD,IAAKlD,OACH,OAGF,MAAME,IAAMuN,WAAWO,2BAA2BhO,OAAQkD,aAC1D,OAAOhE,QAAQsF,YAAYtE,IAAKF,OACjC,CAED0N,6BAA6BO,MAC3B,OAAOA,KAAQ/O,QAAQsF,YAAYiJ,WAAWS,iBAAkBD,WAAiCpM,CAClG,CAED6L,+BAA+BvN,MAA+BH,OAAmBkD,aAC/E,IAAKlD,OACH,OAGF,MAAME,IAAMuN,WAAWM,yBAAyB/N,OAAQkD,aACxDhE,QAAQiF,eAAejE,IAAKC,MAAOH,OACpC,CAED0N,iCAAiCvN,MAAiCH,OAAmBkD,aACnF,IAAKlD,OACH,OAGF,MAAME,IAAMuN,WAAWO,2BAA2BhO,OAAQkD,aAC1DhE,QAAQiF,eAAejE,IAAKC,MAAOH,OACpC,CAED0N,qBAAqBvN,MAA6BH,QAC3CA,QAILd,QAAQiF,eAAesJ,WAAWS,iBAAkB/N,MAAOH,OAC5D,EC/DI,MAAMmO,wBAAkD,IAAIlM,IAUtDmM,aAAgBC,SACnBrO,SACNsO,qBAAqBtO,OAAQqO,QAAQ,EAIzB,SAAAC,qBAAqBtO,OAAmBqO,SACtD,MAAME,kBAAoBF,SAASE,mBAAqB,GACxDd,WAAWe,cACT,CACED,qCAEFvO,QAEFmO,wBAAwBlI,IAAIjG,OAAO6N,KAAM7N,OAC3C,CCpBA,SAASyO,WAAWC,KAClB,OAAIA,eAAeC,OACVA,OAAOC,KAAKF,KAGd,IAAIA,IAAI9F,YAAY8F,IAAI9B,OAAOiC,QAASH,IAAII,WAAYJ,IAAIrJ,OACrE,CCJA,SAAS0J,MAAMxD,OACb,MAAO,KAAKA,SACd,CAMA,SAASyD,KAAKC,KAEZ,OAA0B,MADZ,gBACDC,KAAKD,IACpB,CAEA,SAASE,QAAQhP,MAAY0G,MAAcuI,gBACzC,MAAM7D,MAAQ1E,MAAMP,KAAKnG,OAAS,EAElC,OADAiP,eAAenJ,IAAI9F,MAAOoL,OACnBA,KACT,CAEO,MAAM8D,gBAAkB,YAE/B,SAASC,YAAYnP,OACnB,OAAa,MAATA,OAAkC,iBAAVA,OAAsBgO,wBAAwB1M,IAAItB,MAAMyI,YAAYiF,OAC9F1N,MAAMkP,iBAAmBlP,MAAMyI,YAAYiF,KACpC1N,OAGFA,KACT,CAEA,SAASoP,yBAAyBpP,MAAuBqP,uBACvD,GAAa,MAATrP,MAAe,OAAOA,MAE1B,OAAQqP,uBACN,IAAK,QACH,OAAOrP,MAET,IAAK,MACH,OAAOkB,MAAMuN,KAAKzO,MAAM8K,UAE1B,IAAK,MACH,OAAO5J,MAAMuN,KAAKzO,MAAM+B,WAE1B,IAAK,aAAc,CACjB,MAAMuN,MAAQ,GACd,IAAK,MAAMvP,OAAOE,OAAO8F,KAAK/F,OAC5BsP,MAAMnJ,KAAK,CACTpG,QACAC,MAAOA,MAAMD,OAGjB,OAAOuP,KACR,EAEL,CAEA,SAASC,qCAAqCvP,MAAuBqP,uBACnE,GAAa,MAATrP,MAAe,OAAOA,MAE1B,MAAMsP,MAAQtP,MAEd,OAAQqP,uBACN,IAAK,QACH,OAAOrP,MAET,IAAK,MACH,OAAO,IAAIkC,IAAIoN,OAEjB,IAAK,MACH,OAAO,IAAIxN,IAAIwN,OAEjB,IAAK,aAAc,CACjB,MAAMxH,IAAW,CAAA,EAMjB,OAJAwH,MAAME,SAAQC,OACZ3H,IAAI2H,KAAK1P,KAAO0P,KAAKzP,KAAK,IAGrB8H,GACR,EAEL,CAKgB,SAAA4H,wBAAwB5H,IAAU/E,aAChD,IAAI4M,iBAA2C,KAE/C,GACEA,iBAAmBrC,WAAWoC,wBAAwB5H,IAAIW,YAAYnI,UAAWyC,aACjF+E,IAAM7H,OAAO2B,eAAekG,WACD,MAApB6H,kBAAoD,UAAxB7H,IAAIW,YAAYiF,MAErD,OAAOiC,gBACT,CAKA,SAASC,0BAA0B9H,IAAU/E,aAC3C,IAAI8M,mBAA+C,KAEnD,GACEA,mBAAqBvC,WAAWsC,0BAA0B9H,IAAIW,YAAYnI,UAAWyC,aACrF+E,IAAM7H,OAAO2B,eAAekG,WACC,MAAtB+H,oBAAsD,UAAxB/H,IAAIW,YAAYiF,MAEvD,OAAOmC,kBACT,CAEgB,SAAAC,UAAUhI,IAAUoG,SAClC,MAAM6B,ODpGF,SAAeC,MACnB,MAAMC,KAAO,GACPC,QAAU,GAEhB,OA0BA,SAASC,MAAMC,GACb,GAAiB,iBAANA,GAAwB,OAANA,EAAY,OAAOA,EAChD,GAAIJ,MAAMK,0BAA0B/O,IAAI8O,EAAE3H,YAAYnI,WAAY,OAAO0P,KAAKK,yBAAyB5O,IAAI2O,EAAE3H,YAAYnI,UAAhD0P,CAA2DI,GACpI,GAAIA,aAAaE,KAAM,OAAO,IAAIA,KAAKF,GACvC,GAAIlP,MAAMsG,QAAQ4I,GAAI,OAAOG,WAAWH,EAAGD,OAC3C,GAAIC,aAAatO,IAAK,OAAO,IAAIA,IAAIyO,WAAWrP,MAAMuN,KAAK2B,GAAID,QAC/D,GAAIC,aAAalO,IAAK,OAAO,IAAIA,IAAIqO,WAAWrP,MAAMuN,KAAK2B,GAAID,QAC/D,MAAMK,GAAKvQ,OAAOc,OAAOd,OAAO2B,eAAewO,IAC/CH,KAAK9J,KAAKiK,GACVF,QAAQ/J,KAAKqK,IACb,IAAK,MAAMrG,KAAKiG,EAAG,CACjB,MAAMT,iBAAmBD,wBAAwBU,EAAGjG,GAEpD,IAAyC,IAArClK,OAAOM,eAAeiB,KAAK4O,EAAGjG,KAA6C,IAA7BwF,kBAAkBc,OAAiB,SACrF,MAAMlC,IAAM6B,EAAEjG,GACd,GAAmB,iBAARoE,KAA4B,OAARA,IAC7BiC,GAAGrG,GAAKoE,SACH,GAAIyB,MAAMK,0BAA0B/O,IAAIiN,IAAI9F,aACjD+H,GAAGrG,GAAK6F,KAAKK,yBAAyB5O,IAAI8M,IAAI9F,YAAtCuH,CAAmDzB,UACtD,GAAIA,eAAe+B,KACxBE,GAAGrG,GAAK,IAAImG,KAAK/B,UACZ,GAAIA,eAAezM,IACxB0O,GAAGrG,GAAK,IAAIrI,IAAIyO,WAAWrP,MAAMuN,KAAKF,KAAM4B,aACvC,GAAI5B,eAAerM,IACxBsO,GAAGrG,GAAK,IAAIjI,IAAIqO,WAAWrP,MAAMuN,KAAKF,KAAM4B,aACvC,GAAIO,YAAYC,OAAOpC,KAC5BiC,GAAGrG,GAAKmE,WAAWC,SACd,CACL,MAAMtJ,EAAIgL,KAAKW,QAAQrC,KAErBiC,GAAGrG,IADM,IAAPlF,EACMiL,QAAQjL,GAERkL,MAAM5B,IAEjB,CACF,CAGD,OAFA0B,KAAKY,MACLX,QAAQW,MACDL,EACR,EA/DD,SAASD,WAAWO,EAAGC,IACrB,MAAMhL,KAAO9F,OAAO8F,KAAK+K,GACnBE,GAAK,IAAI9P,MAAM6E,KAAKb,QAC1B,IAAK,IAAID,EAAI,EAAGA,EAAIc,KAAKb,OAAQD,IAAK,CACpC,MAAMkF,EAAIpE,KAAKd,GACTsJ,IAAMuC,EAAE3G,GACd,GAAmB,iBAARoE,KAA4B,OAARA,IAC7ByC,GAAG7G,GAAKoE,SACH,GAAIA,eAAe+B,KACxBU,GAAG7G,GAAK,IAAImG,KAAK/B,UACZ,GAAImC,YAAYC,OAAOpC,KAC5ByC,GAAG7G,GAAKmE,WAAWC,SACd,CACL,MAAMnD,MAAQ6E,KAAKW,QAAQrC,KAEzByC,GAAG7G,IADU,IAAXiB,MACM8E,QAAQ9E,OAER2F,GAAGxC,IAEd,CACF,CACD,OAAOyC,EACR,CA0CH,CC8BiBC,CAAK/C,SAASgD,aAC7BpJ,IAAMiI,OAAOjI,KAEb,MAAMmH,eAAiB,IAAInN,IACrBqP,WAAoB,GACpBC,YAAqB,GAC3B,IAAInM,EAAI,EACJ2D,OAAQ,EAIZ,IAFAoG,QAAQlH,IAAKqJ,WAAYlC,gBAElBhK,EAAIkM,WAAWjM,QACpB0D,OAAQ,EACRwI,YAAYjL,KACVkL,KAAKvB,UAAUqB,WAAWlM,MAAM,CAAClF,IAAKC,SACpC,GAAI4I,MAAO,CACT,GAAa,MAAT5I,OAAkC,iBAAVA,SAAwBA,iBAAiBkB,OACnE,IAAK,MAAMoQ,YAAYrR,OAAO8F,KAAK/F,OAAQ,CACzC,MAAM2P,iBAAmBD,wBAAwB1P,MAAOsR,UAClDzB,mBAAqBD,0BAA0B5P,MAAOsR,UAEpC,MAApB3B,kBAA4BA,iBAAiB4B,kBAC/CvR,MAAMsR,UAAY3B,iBAAiB4B,gBAAgBvR,MAAMsR,YAGjC,MAAtBzB,qBACF7P,MAAMsR,UAAYlC,yBAAyBpP,MAAMsR,UAAWzB,mBAAmB2B,gBAElF,CAIH,OADA5I,OAAQ,EACDuG,YAAYnP,MACpB,CAED,OAAa,MAATA,MAAsBA,MAEL,iBAAVA,MACLiP,eAAe3N,IAAItB,OACd4O,MAAMK,eAAexN,IAAIzB,QAG3B4O,MAAMI,QAAQG,YAAYnP,OAAQmR,WAAYlC,iBAGhDE,YAAYnP,MAAM,KAK/B,MAAO,IAAIoR,YAAYK,KAAK,OAC9B,CAEM,SAAUC,MAAS5C,KACvB,MAAMQ,MAAe+B,KAAKK,MAAM5C,KAEhC,MAAwB,iBAAbQ,MAAM,KAGjBA,MAAME,SAAQ,CAACC,KAAMrE,SACnB,GAAY,MAARqE,MAAgC,iBAATA,KAAmB,CAC5C,MAAMkC,UAAYlC,KAAKP,iBAEvB,GAAiB,MAAbyC,WAAqB3D,wBAAwB1M,IAAIqQ,WAAY,CAC/D,MAAMrR,UAAY0N,wBAAwBvM,IAAIkQ,WAAWrR,UACnDsR,QAAU3R,OAAOc,OAAOT,WACxBoD,SAAW4J,WAAWuE,sBAAsBD,QAAQnJ,aAC1D6G,MAAMlE,OAASnL,OAAO6R,OAAO,IAAIF,QAAQnJ,eAAe/E,SAAS0K,mBAAoBqB,KACtF,CACF,KAIHH,MAAME,SAAQC,OACZ,GAAY,MAARA,MAAgC,iBAATA,KACzB,IAAK,MAAM1P,OAAOE,OAAO8F,KAAK0J,MAC5B,GAAIZ,KAAKY,KAAK1P,MAAO,CACnB,MAAMgS,aAzLEC,GAyLqBvC,KAAK1P,KAxLnCkS,SAASD,GAAGE,MAAM,MAAM,GAAI,KAyL3BzC,KAAK1P,KAAOuP,MAAMyC,YACnB,CA3LT,IAAkBC,EA6Lb,IAGHG,WAAW7C,MAAM,IAEjBA,MAAME,SAAQC,OACA,MAARA,aAEKA,KAAKP,gBACb,KAlCsCI,MAAM,EAsCjD,CAEA,SAAS6C,WAAWrK,IAAUsK,eAA2B,IAAIlQ,KAC3D,GAAW,MAAP4F,IAEJ,IAAK,MAAM/H,OAAOE,OAAO8F,KAAK+B,KAAM,CAClC,GAAgB,MAAZA,IAAI/H,MAAoC,iBAAb+H,IAAI/H,KAAmB,CACpD,GAAIqS,eAAe9Q,IAAIwG,IAAI/H,MAAO,SAClCqS,eAAelM,IAAI4B,IAAI/H,MACvBoS,WAAWrK,IAAI/H,KAAMqS,eACtB,CAED,MAAMzC,iBAAmBD,wBAAwB5H,IAAK/H,KAChD8P,mBAAqBD,0BAA0B9H,IAAK/H,KAElC,MAApB4P,kBAA4BA,iBAAiBwC,aAC/CrK,IAAI/H,KAAO4P,iBAAiBwC,WAAWrK,IAAI/H,OAGnB,MAAtB8P,qBACF/H,IAAI/H,KAAOwP,qCAAqCzH,IAAI/H,KAAM8P,mBAAmB2B,gBAEhF,CACH,CClOa,MAAAa,eAAkBnE,SACtB,CAACrO,OAAmBE,OACzBuS,uBAAuBzS,OAAQE,IAAKmO,QAAQ,WAIhCoE,uBAA0BzS,OAAiB0S,aAAuBrE,SAChFZ,WAAWkF,wBACT,CACEjB,gBAAiBrD,SAASqD,gBAC1BY,WAAYjE,SAASiE,WACrB1B,OAAQvC,SAASuC,QAEnB5Q,OACA0S,aAEJ,CCfa,MAAAE,iBAAoBvE,SACxB,CAACrO,OAAmBE,OACzB2S,yBAAyB7S,OAAQE,IAAKmO,QAAQ,WAIlCwE,yBAA4B7S,OAAiB0S,aAAuBrE,SAClFZ,WAAWqF,0BACT,CACEnB,eAAgBtD,QAAQsD,gBAE1B3R,OACA0S,aAEJ,UCNgBK,eAAkBC,sBAAkDC,OAGlF,GAFA3E,qBAAqB0E,mBAAmBhT,OAAQgT,mBAAmB3E,SAE/D4E,MACF,IAAK,MAAMrD,QAAQqD,MACb,mBAAoBrD,KACtBiD,yBAAyBG,mBAAmBhT,OAAOS,UAAWmP,KAAKsD,eAAgBtD,KAAKvB,SAC/E,iBAAkBuB,MAC3B6C,uBAAuBO,mBAAmBhT,OAAOS,UAAWmP,KAAK8C,aAAc9C,KAAKvB,QAI5F","x_google_ignoreList":[0]}