{
  "version": 3,
  "sources": ["../../../packages/controls/bz-core-controls/utils/reflect-metadata.ts", "../../../packages/controls/bz-core-controls/styles/theme/index.tsx", "../../../packages/controls/bz-core-controls/styles/theme/hooks/theme/index.tsx"],
  "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***************************************************************************** */\nnamespace Reflect {\n  // Metadata Proposal\n  // https://rbuckton.github.io/reflect-metadata/\n\n  type HashMap<V> = Record<string, V>;\n\n  interface BufferLike {\n    [offset: number]: number;\n    length: number;\n  }\n\n  type IteratorResult<T> = { value: T; done: false } | { value: never; done: true };\n\n  interface Iterator<T> {\n    next(value?: any): IteratorResult<T>;\n    throw?(value: any): IteratorResult<T>;\n    return?(value?: T): IteratorResult<T>;\n  }\n\n  interface Iterable<T> {\n    '@@iterator'(): Iterator<T>;\n  }\n\n  interface IterableIterator<T> extends Iterator<T> {\n    '@@iterator'(): IterableIterator<T>;\n  }\n\n  interface Map<K, V> extends Iterable<[K, V]> {\n    size: number;\n    has(key: K): boolean;\n    get(key: K): V;\n    set(key: K, value?: V): this;\n    delete(key: K): boolean;\n    clear(): void;\n    keys(): IterableIterator<K>;\n    values(): IterableIterator<V>;\n    entries(): IterableIterator<[K, V]>;\n  }\n\n  interface MapConstructor {\n    new (): Map<any, any>;\n    new <K, V>(): Map<K, V>;\n    prototype: Map<any, any>;\n  }\n\n  interface Set<T> extends Iterable<T> {\n    size: number;\n    has(value: T): boolean;\n    add(value: T): this;\n    delete(value: T): boolean;\n    clear(): void;\n    keys(): IterableIterator<T>;\n    values(): IterableIterator<T>;\n    entries(): IterableIterator<[T, T]>;\n  }\n\n  interface SetConstructor {\n    new (): Set<any>;\n    new <T>(): Set<T>;\n    prototype: Set<any>;\n  }\n\n  interface WeakMap<K, V> {\n    clear(): void;\n    delete(key: K): boolean;\n    get(key: K): V;\n    has(key: K): boolean;\n    set(key: K, value?: V): WeakMap<K, V>;\n  }\n\n  interface WeakMapConstructor {\n    new (): WeakMap<any, any>;\n    new <K, V>(): WeakMap<K, V>;\n    prototype: WeakMap<any, any>;\n  }\n\n  type MemberDecorator = <T>(\n    target: Object,\n    propertyKey: string | symbol,\n    descriptor?: TypedPropertyDescriptor<T>\n  ) => TypedPropertyDescriptor<T> | void;\n  declare const Symbol: { iterator: symbol; toPrimitive: symbol };\n  declare const Set: SetConstructor;\n  declare const WeakMap: WeakMapConstructor;\n  declare const Map: MapConstructor;\n  declare const global: any;\n  declare const crypto: Crypto;\n  declare const msCrypto: Crypto;\n  declare const process: any;\n\n  /**\n   * Applies a set of decorators to a target object.\n   * @param decorators An array of decorators.\n   * @param target The target object.\n   * @returns The result of applying the provided decorators.\n   * @remarks Decorators are applied in reverse order of their positions in the array.\n   * @example\n   *\n   *     class Example { }\n   *\n   *     // constructor\n   *     Example = Reflect.decorate(decoratorsArray, Example);\n   *\n   */\n  export declare function decorate(decorators: ClassDecorator[], target: Function): Function;\n\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 The property key to decorate.\n   * @param attributes A property descriptor.\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   *         static staticMethod() { }\n   *         method() { }\n   *     }\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  export declare function decorate(\n    decorators: (PropertyDecorator | MethodDecorator)[],\n    target: any,\n    propertyKey: string | symbol,\n    attributes?: PropertyDescriptor | null\n  ): PropertyDescriptor | undefined;\n\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 The property key to decorate.\n   * @param attributes A property descriptor.\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   *         static staticMethod() { }\n   *         method() { }\n   *     }\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  export declare function decorate(\n    decorators: (PropertyDecorator | MethodDecorator)[],\n    target: any,\n    propertyKey: string | symbol,\n    attributes: PropertyDescriptor\n  ): PropertyDescriptor;\n\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  export declare function metadata(\n    metadataKey: any,\n    metadataValue: any\n  ): { (target: Function): void; (target: any, propertyKey: string | symbol): void };\n\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   * @example\n   *\n   *     class Example {\n   *     }\n   *\n   *     // constructor\n   *     Reflect.defineMetadata(\"custom:annotation\", options, Example);\n   *\n   *     // decorator factory as metadata-producing annotation.\n   *     function MyAnnotation(options): ClassDecorator {\n   *         return target => Reflect.defineMetadata(\"custom:annotation\", options, target);\n   *     }\n   *\n   */\n  export declare function defineMetadata(metadataKey: any, metadataValue: any, target: any): void;\n\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 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   *         static staticMethod(p) { }\n   *         method(p) { }\n   *     }\n   *\n   *     // property (on constructor)\n   *     Reflect.defineMetadata(\"custom:annotation\", Number, Example, \"staticProperty\");\n   *\n   *     // property (on prototype)\n   *     Reflect.defineMetadata(\"custom:annotation\", Number, Example.prototype, \"property\");\n   *\n   *     // method (on constructor)\n   *     Reflect.defineMetadata(\"custom:annotation\", Number, Example, \"staticMethod\");\n   *\n   *     // method (on prototype)\n   *     Reflect.defineMetadata(\"custom:annotation\", Number, Example.prototype, \"method\");\n   *\n   *     // decorator factory as metadata-producing annotation.\n   *     function MyAnnotation(options): PropertyDecorator {\n   *         return (target, key) => Reflect.defineMetadata(\"custom:annotation\", options, target, key);\n   *     }\n   *\n   */\n  export declare function defineMetadata(\n    metadataKey: any,\n    metadataValue: any,\n    target: any,\n    propertyKey: string | symbol\n  ): void;\n\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   * @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   *     }\n   *\n   *     // constructor\n   *     result = Reflect.hasMetadata(\"custom:annotation\", Example);\n   *\n   */\n  export declare function hasMetadata(metadataKey: any, target: any): boolean;\n\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 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   *         static staticMethod(p) { }\n   *         method(p) { }\n   *     }\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  export declare function hasMetadata(\n    metadataKey: any,\n    target: any,\n    propertyKey: string | symbol\n  ): boolean;\n\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   * @returns `true` if the metadata key was defined on the target object; otherwise, `false`.\n   * @example\n   *\n   *     class Example {\n   *     }\n   *\n   *     // constructor\n   *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example);\n   *\n   */\n  export declare function hasOwnMetadata(metadataKey: any, target: any): boolean;\n\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 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   *         static staticMethod(p) { }\n   *         method(p) { }\n   *     }\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  export declare function hasOwnMetadata(\n    metadataKey: any,\n    target: any,\n    propertyKey: string | symbol\n  ): boolean;\n\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   * @returns The metadata value for the metadata key if found; otherwise, `undefined`.\n   * @example\n   *\n   *     class Example {\n   *     }\n   *\n   *     // constructor\n   *     result = Reflect.getMetadata(\"custom:annotation\", Example);\n   *\n   */\n  export declare function getMetadata(metadataKey: any, target: any): any;\n\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 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   *         static staticMethod(p) { }\n   *         method(p) { }\n   *     }\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  export declare function getMetadata(\n    metadataKey: any,\n    target: any,\n    propertyKey: string | symbol\n  ): any;\n\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   * @returns The metadata value for the metadata key if found; otherwise, `undefined`.\n   * @example\n   *\n   *     class Example {\n   *     }\n   *\n   *     // constructor\n   *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example);\n   *\n   */\n  export declare function getOwnMetadata(metadataKey: any, target: any): any;\n\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 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   *         static staticMethod(p) { }\n   *         method(p) { }\n   *     }\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  export declare function getOwnMetadata(\n    metadataKey: any,\n    target: any,\n    propertyKey: string | symbol\n  ): any;\n\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   * @returns An array of unique metadata keys.\n   * @example\n   *\n   *     class Example {\n   *     }\n   *\n   *     // constructor\n   *     result = Reflect.getMetadataKeys(Example);\n   *\n   */\n  export declare function getMetadataKeys(target: any): any[];\n\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 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   *         static staticMethod(p) { }\n   *         method(p) { }\n   *     }\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  export declare function getMetadataKeys(target: any, propertyKey: string | symbol): any[];\n\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   * @returns An array of unique metadata keys.\n   * @example\n   *\n   *     class Example {\n   *     }\n   *\n   *     // constructor\n   *     result = Reflect.getOwnMetadataKeys(Example);\n   *\n   */\n  export declare function getOwnMetadataKeys(target: any): any[];\n\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 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   *         static staticMethod(p) { }\n   *         method(p) { }\n   *     }\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  export declare function getOwnMetadataKeys(target: any, propertyKey: string | symbol): any[];\n\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   * @returns `true` if the metadata entry was found and deleted; otherwise, false.\n   * @example\n   *\n   *     class Example {\n   *     }\n   *\n   *     // constructor\n   *     result = Reflect.deleteMetadata(\"custom:annotation\", Example);\n   *\n   */\n  export declare function deleteMetadata(metadataKey: any, target: any): boolean;\n\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 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   *         static staticMethod(p) { }\n   *         method(p) { }\n   *     }\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  export declare function deleteMetadata(\n    metadataKey: any,\n    target: any,\n    propertyKey: string | symbol\n  ): boolean;\n\n  (function (\n    this: any,\n    factory: (\n      exporter: <K extends keyof typeof Reflect>(key: K, value: (typeof Reflect)[K]) => void\n    ) => void\n  ) {\n    const root =\n      typeof global === 'object'\n        ? global\n        : typeof self === 'object'\n          ? self\n          : typeof this === 'object'\n            ? this\n            : Function('return this;')();\n\n    let exporter = makeExporter(Reflect);\n    if (typeof root.Reflect === 'undefined') {\n      root.Reflect = Reflect;\n    } else {\n      exporter = makeExporter(root.Reflect, exporter);\n    }\n\n    factory(exporter);\n\n    function makeExporter(\n      target: typeof Reflect,\n      previous?: <K extends keyof typeof Reflect>(key: K, value: (typeof Reflect)[K]) => void\n    ) {\n      return <K extends keyof typeof Reflect>(key: K, value: (typeof Reflect)[K]) => {\n        if (typeof target[key] !== 'function') {\n          Object.defineProperty(target, key, { configurable: true, writable: true, value });\n        }\n        if (previous) previous(key, value);\n      };\n    }\n  })(function (exporter) {\n    const hasOwn = Object.prototype.hasOwnProperty;\n\n    // feature test for Symbol support\n    const supportsSymbol = typeof Symbol === 'function';\n    const toPrimitiveSymbol =\n      supportsSymbol && typeof Symbol.toPrimitive !== 'undefined'\n        ? Symbol.toPrimitive\n        : '@@toPrimitive';\n    const iteratorSymbol =\n      supportsSymbol && typeof Symbol.iterator !== 'undefined' ? Symbol.iterator : '@@iterator';\n    const supportsCreate = typeof Object.create === 'function'; // feature test for Object.create support\n    const supportsProto = { __proto__: [] } instanceof Array; // feature test for __proto__ support\n    const downLevel = !supportsCreate && !supportsProto;\n\n    const HashMap = {\n      // create an object in dictionary mode (a.k.a. \"slow\" mode in v8)\n      create: supportsCreate\n        ? <V>() => MakeDictionary(Object.create(null) as HashMap<V>)\n        : supportsProto\n          ? <V>() => MakeDictionary({ __proto__: null as any } as HashMap<V>)\n          : <V>() => MakeDictionary({} as HashMap<V>),\n\n      has: downLevel\n        ? <V>(map: HashMap<V>, key: string | number | symbol) => hasOwn.call(map, key)\n        : <V>(map: HashMap<V>, key: string | number | symbol) => key in map,\n\n      get: downLevel\n        ? <V>(map: HashMap<V>, key: string | number | symbol): V | undefined =>\n            hasOwn.call(map, key) ? map[key as string | number] : undefined\n        : <V>(map: HashMap<V>, key: string | number | symbol): V | undefined =>\n            map[key as string | number]\n    };\n\n    // Load global or shim versions of Map, Set, and WeakMap\n    const functionPrototype = Object.getPrototypeOf(Function);\n    const usePolyfill =\n      typeof process === 'object' &&\n      process.env &&\n      process.env['REFLECT_METADATA_USE_MAP_POLYFILL'] === 'true';\n    const _Map: typeof Map =\n      !usePolyfill && typeof Map === 'function' && typeof Map.prototype.entries === 'function'\n        ? Map\n        : CreateMapPolyfill();\n    const _Set: typeof Set =\n      !usePolyfill && typeof Set === 'function' && typeof Set.prototype.entries === 'function'\n        ? Set\n        : CreateSetPolyfill();\n    const _WeakMap: typeof WeakMap =\n      !usePolyfill && typeof WeakMap === 'function' ? WeakMap : CreateWeakMapPolyfill();\n\n    // [[Metadata]] internal slot\n    // https://rbuckton.github.io/reflect-metadata/#ordinary-object-internal-methods-and-internal-slots\n    const Metadata = new _WeakMap<any, Map<string | symbol | undefined, Map<any, any>>>();\n\n    function decorate(decorators: ClassDecorator[], target: Function): Function;\n    function decorate(\n      decorators: (PropertyDecorator | MethodDecorator)[],\n      target: any,\n      propertyKey: string | symbol,\n      attributes?: PropertyDescriptor | null\n    ): PropertyDescriptor | undefined;\n    function decorate(\n      decorators: (PropertyDecorator | MethodDecorator)[],\n      target: any,\n      propertyKey: string | symbol,\n      attributes: PropertyDescriptor\n    ): PropertyDescriptor;\n\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(\n      decorators: (ClassDecorator | MemberDecorator)[],\n      target: any,\n      propertyKey?: string | symbol,\n      attributes?: PropertyDescriptor | null\n    ): PropertyDescriptor | Function | undefined {\n      if (!IsUndefined(propertyKey)) {\n        if (!IsArray(decorators)) throw new TypeError();\n        if (!IsObject(target)) throw new TypeError();\n        if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))\n          throw new TypeError();\n        if (IsNull(attributes)) attributes = undefined;\n        propertyKey = ToPropertyKey(propertyKey);\n        return DecorateProperty(<MemberDecorator[]>decorators, target, propertyKey, attributes);\n      } else {\n        if (!IsArray(decorators)) throw new TypeError();\n        if (!IsConstructor(target)) {\n          console.log(target);\n          throw new TypeError();\n        }\n        return DecorateConstructor(<ClassDecorator[]>decorators, <Function>target);\n      }\n    }\n\n    exporter('decorate', decorate);\n\n    // 4.1.2 Reflect.metadata(metadataKey, metadataValue)\n    // https://rbuckton.github.io/reflect-metadata/#reflect.metadata\n\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: any, metadataValue: any) {\n      function decorator(target: Function): void;\n      function decorator(target: any, propertyKey: string | symbol): void;\n      function decorator(target: any, propertyKey?: string | symbol): void {\n        if (!IsObject(target)) throw new TypeError();\n        if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey)) throw new TypeError();\n        OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);\n      }\n      return decorator;\n    }\n\n    exporter('metadata', metadata);\n\n    // 4.1.3 Reflect.defineMetadata(metadataKey, metadataValue, target [, propertyKey])\n    // https://rbuckton.github.io/reflect-metadata/#reflect.definemetadata\n\n    function defineMetadata(metadataKey: any, metadataValue: any, target: any): void;\n    function defineMetadata(\n      metadataKey: any,\n      metadataValue: any,\n      target: any,\n      propertyKey: string | symbol\n    ): void;\n\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(\n      metadataKey: any,\n      metadataValue: any,\n      target: any,\n      propertyKey?: string | symbol\n    ): void {\n      if (!IsObject(target)) throw new TypeError();\n      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);\n      return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);\n    }\n\n    exporter('defineMetadata', defineMetadata);\n\n    // 4.1.4 Reflect.hasMetadata(metadataKey, target [, propertyKey])\n    // https://rbuckton.github.io/reflect-metadata/#reflect.hasmetadata\n\n    function hasMetadata(metadataKey: any, target: any): boolean;\n    function hasMetadata(metadataKey: any, target: any, propertyKey: string | symbol): boolean;\n\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: any, target: any, propertyKey?: string | symbol): boolean {\n      if (!IsObject(target)) throw new TypeError();\n      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);\n      return OrdinaryHasMetadata(metadataKey, target, propertyKey);\n    }\n\n    exporter('hasMetadata', hasMetadata);\n\n    // 4.1.5 Reflect.hasOwnMetadata(metadataKey, target [, propertyKey])\n    // https://rbuckton.github.io/reflect-metadata/#reflect-hasownmetadata\n\n    function hasOwnMetadata(metadataKey: any, target: any): boolean;\n    function hasOwnMetadata(metadataKey: any, target: any, propertyKey: string | symbol): boolean;\n\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: any, target: any, propertyKey?: string | symbol): boolean {\n      if (!IsObject(target)) throw new TypeError();\n      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);\n      return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);\n    }\n\n    exporter('hasOwnMetadata', hasOwnMetadata);\n\n    // 4.1.6 Reflect.getMetadata(metadataKey, target [, propertyKey])\n    // https://rbuckton.github.io/reflect-metadata/#reflect-getmetadata\n\n    function getMetadata(metadataKey: any, target: any): any;\n    function getMetadata(metadataKey: any, target: any, propertyKey: string | symbol): any;\n\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: any, target: any, propertyKey?: string | symbol): any {\n      if (!IsObject(target)) throw new TypeError();\n      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);\n      return OrdinaryGetMetadata(metadataKey, target, propertyKey);\n    }\n\n    exporter('getMetadata', getMetadata);\n\n    // 4.1.7 Reflect.getOwnMetadata(metadataKey, target [, propertyKey])\n    // https://rbuckton.github.io/reflect-metadata/#reflect-getownmetadata\n\n    function getOwnMetadata(metadataKey: any, target: any): any;\n    function getOwnMetadata(metadataKey: any, target: any, propertyKey: string | symbol): any;\n\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: any, target: any, propertyKey?: string | symbol): any {\n      if (!IsObject(target)) throw new TypeError();\n      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);\n      return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);\n    }\n\n    exporter('getOwnMetadata', getOwnMetadata);\n\n    // 4.1.8 Reflect.getMetadataKeys(target [, propertyKey])\n    // https://rbuckton.github.io/reflect-metadata/#reflect-getmetadatakeys\n\n    function getMetadataKeys(target: any): any[];\n    function getMetadataKeys(target: any, propertyKey: string | symbol): any[];\n\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: any, propertyKey?: string | symbol): any[] {\n      if (!IsObject(target)) throw new TypeError();\n      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);\n      return OrdinaryMetadataKeys(target, propertyKey);\n    }\n\n    exporter('getMetadataKeys', getMetadataKeys);\n\n    // 4.1.9 Reflect.getOwnMetadataKeys(target [, propertyKey])\n    // https://rbuckton.github.io/reflect-metadata/#reflect-getownmetadata\n\n    function getOwnMetadataKeys(target: any): any[];\n    function getOwnMetadataKeys(target: any, propertyKey: string | symbol): any[];\n\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: any, propertyKey?: string | symbol): any[] {\n      if (!IsObject(target)) throw new TypeError();\n      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);\n      return OrdinaryOwnMetadataKeys(target, propertyKey);\n    }\n\n    exporter('getOwnMetadataKeys', getOwnMetadataKeys);\n\n    // 4.1.10 Reflect.deleteMetadata(metadataKey, target [, propertyKey])\n    // https://rbuckton.github.io/reflect-metadata/#reflect-deletemetadata\n\n    function deleteMetadata(metadataKey: any, target: any): boolean;\n    function deleteMetadata(metadataKey: any, target: any, propertyKey: string | symbol): boolean;\n\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: any, target: any, propertyKey?: string | symbol): boolean {\n      if (!IsObject(target)) throw new TypeError();\n      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);\n      const metadataMap = GetOrCreateMetadataMap(target, propertyKey, /*Create*/ false);\n      if (IsUndefined(metadataMap)) return false;\n      if (!metadataMap.delete(metadataKey)) return false;\n      if (metadataMap.size > 0) return true;\n      const targetMetadata = Metadata.get(target);\n      targetMetadata.delete(propertyKey);\n      if (targetMetadata.size > 0) return true;\n      Metadata.delete(target);\n      return true;\n    }\n\n    exporter('deleteMetadata', deleteMetadata);\n\n    function DecorateConstructor(decorators: ClassDecorator[], target: Function): Function {\n      for (let i = decorators.length - 1; i >= 0; --i) {\n        const decorator = decorators[i];\n        const decorated = decorator(target);\n        if (!IsUndefined(decorated) && !IsNull(decorated)) {\n          if (!IsConstructor(decorated)) {\n            // Chris McV - hack to work with Mobx\n            //throw new TypeError();\n          }\n          target = <Function>decorated;\n        }\n      }\n      return target;\n    }\n\n    function DecorateProperty(\n      decorators: MemberDecorator[],\n      target: any,\n      propertyKey: string | symbol,\n      descriptor: PropertyDescriptor | undefined\n    ): PropertyDescriptor | undefined {\n      for (let i = decorators.length - 1; i >= 0; --i) {\n        const decorator = decorators[i];\n        const decorated = decorator(target, propertyKey, descriptor);\n        if (!IsUndefined(decorated) && !IsNull(decorated)) {\n          if (!IsObject(decorated)) throw new TypeError();\n          descriptor = <PropertyDescriptor>decorated;\n        }\n      }\n      return descriptor;\n    }\n\n    // 2.1.1 GetOrCreateMetadataMap(O, P, Create)\n    // https://rbuckton.github.io/reflect-metadata/#getorcreatemetadatamap\n    function GetOrCreateMetadataMap(\n      O: any,\n      P: string | symbol | undefined,\n      Create: true\n    ): Map<any, any>;\n    function GetOrCreateMetadataMap(\n      O: any,\n      P: string | symbol | undefined,\n      Create: false\n    ): Map<any, any> | undefined;\n    function GetOrCreateMetadataMap(\n      O: any,\n      P: string | symbol | undefined,\n      Create: boolean\n    ): Map<any, any> | undefined {\n      let targetMetadata = Metadata.get(O);\n      if (IsUndefined(targetMetadata)) {\n        if (!Create) return undefined;\n        targetMetadata = new _Map<string | symbol | undefined, Map<any, any>>();\n        Metadata.set(O, targetMetadata);\n      }\n      let metadataMap = targetMetadata.get(P);\n      if (IsUndefined(metadataMap)) {\n        if (!Create) return undefined;\n        metadataMap = new _Map<any, any>();\n        targetMetadata.set(P, metadataMap);\n      }\n      return metadataMap;\n    }\n\n    // 3.1.1.1 OrdinaryHasMetadata(MetadataKey, O, P)\n    // https://rbuckton.github.io/reflect-metadata/#ordinaryhasmetadata\n    function OrdinaryHasMetadata(\n      MetadataKey: any,\n      O: any,\n      P: string | symbol | undefined\n    ): boolean {\n      const hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);\n      if (hasOwn) return true;\n      const parent = OrdinaryGetPrototypeOf(O);\n      if (!IsNull(parent)) return OrdinaryHasMetadata(MetadataKey, parent, P);\n      return false;\n    }\n\n    // 3.1.2.1 OrdinaryHasOwnMetadata(MetadataKey, O, P)\n    // https://rbuckton.github.io/reflect-metadata/#ordinaryhasownmetadata\n    function OrdinaryHasOwnMetadata(\n      MetadataKey: any,\n      O: any,\n      P: string | symbol | undefined\n    ): boolean {\n      const metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n      if (IsUndefined(metadataMap)) return false;\n      return ToBoolean(metadataMap.has(MetadataKey));\n    }\n\n    // 3.1.3.1 OrdinaryGetMetadata(MetadataKey, O, P)\n    // https://rbuckton.github.io/reflect-metadata/#ordinarygetmetadata\n    function OrdinaryGetMetadata(MetadataKey: any, O: any, P: string | symbol | undefined): any {\n      const hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);\n      if (hasOwn) return OrdinaryGetOwnMetadata(MetadataKey, O, P);\n      const parent = OrdinaryGetPrototypeOf(O);\n      if (!IsNull(parent)) return OrdinaryGetMetadata(MetadataKey, parent, P);\n      return undefined;\n    }\n\n    // 3.1.4.1 OrdinaryGetOwnMetadata(MetadataKey, O, P)\n    // https://rbuckton.github.io/reflect-metadata/#ordinarygetownmetadata\n    function OrdinaryGetOwnMetadata(MetadataKey: any, O: any, P: string | symbol | undefined): any {\n      const metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n      if (IsUndefined(metadataMap)) return undefined;\n      return metadataMap.get(MetadataKey);\n    }\n\n    // 3.1.5.1 OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P)\n    // https://rbuckton.github.io/reflect-metadata/#ordinarydefineownmetadata\n    function OrdinaryDefineOwnMetadata(\n      MetadataKey: any,\n      MetadataValue: any,\n      O: any,\n      P: string | symbol | undefined\n    ): void {\n      const metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ true);\n      metadataMap.set(MetadataKey, MetadataValue);\n    }\n\n    // 3.1.6.1 OrdinaryMetadataKeys(O, P)\n    // https://rbuckton.github.io/reflect-metadata/#ordinarymetadatakeys\n    function OrdinaryMetadataKeys(O: any, P: string | symbol | undefined): any[] {\n      const ownKeys = OrdinaryOwnMetadataKeys(O, P);\n      const parent = OrdinaryGetPrototypeOf(O);\n      if (parent === null) return ownKeys;\n      const parentKeys = OrdinaryMetadataKeys(parent, P);\n      if (parentKeys.length <= 0) return ownKeys;\n      if (ownKeys.length <= 0) return parentKeys;\n      const set = new _Set<any>();\n      const keys: any[] = [];\n      for (const key of ownKeys) {\n        const hasKey = set.has(key);\n        if (!hasKey) {\n          set.add(key);\n          keys.push(key);\n        }\n      }\n      for (const key of parentKeys) {\n        const hasKey = set.has(key);\n        if (!hasKey) {\n          set.add(key);\n          keys.push(key);\n        }\n      }\n      return keys;\n    }\n\n    // 3.1.7.1 OrdinaryOwnMetadataKeys(O, P)\n    // https://rbuckton.github.io/reflect-metadata/#ordinaryownmetadatakeys\n    function OrdinaryOwnMetadataKeys(O: any, P: string | symbol | undefined): any[] {\n      const keys: any[] = [];\n      const metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n      if (IsUndefined(metadataMap)) return keys;\n      const keysObj = metadataMap.keys();\n      const iterator = GetIterator(keysObj);\n      let k = 0;\n      while (true) {\n        const next = IteratorStep(iterator);\n        if (!next) {\n          keys.length = k;\n          return keys;\n        }\n        const nextValue = IteratorValue(next);\n        try {\n          keys[k] = nextValue;\n        } catch (e) {\n          try {\n            IteratorClose(iterator);\n          } finally {\n            throw e;\n          }\n        }\n        k++;\n      }\n    }\n\n    // 6 ECMAScript Data Typ0es and Values\n    // https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values\n    function Type(x: any): Tag {\n      if (x === null) return Tag.Null;\n      switch (typeof x) {\n        case 'undefined':\n          return Tag.Undefined;\n        case 'boolean':\n          return Tag.Boolean;\n        case 'string':\n          return Tag.String;\n        case 'symbol':\n          return Tag.Symbol;\n        case 'number':\n          return Tag.Number;\n        case 'object':\n          return x === null ? Tag.Null : Tag.Object;\n        default:\n          return Tag.Object;\n      }\n    }\n\n    // 6.1 ECMAScript Language Types\n    // https://tc39.github.io/ecma262/#sec-ecmascript-language-types\n    const enum Tag {\n      Undefined,\n      Null,\n      Boolean,\n      String,\n      Symbol,\n      Number,\n      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: any): x is undefined {\n      return x === undefined;\n    }\n\n    // 6.1.2 The Null Type\n    // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-null-type\n    function IsNull(x: any): x is null {\n      return x === null;\n    }\n\n    // 6.1.5 The Symbol Type\n    // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-symbol-type\n    function IsSymbol(x: any): x is symbol {\n      return typeof x === 'symbol';\n    }\n\n    // 6.1.7 The Object Type\n    // https://tc39.github.io/ecma262/#sec-object-type\n    function IsObject<T>(x: T | undefined | null | boolean | string | symbol | number): x is T {\n      return typeof x === 'object' ? x !== null : typeof x === 'function';\n    }\n\n    // 7.1 Type Conversion\n    // https://tc39.github.io/ecma262/#sec-type-conversion\n\n    // 7.1.1 ToPrimitive(input [, PreferredType])\n    // https://tc39.github.io/ecma262/#sec-toprimitive\n    function ToPrimitive(\n      input: any,\n      PreferredType?: Tag\n    ): undefined | null | boolean | string | symbol | number {\n      switch (Type(input)) {\n        case Tag.Undefined:\n          return input;\n        case Tag.Null:\n          return input;\n        case Tag.Boolean:\n          return input;\n        case Tag.String:\n          return input;\n        case Tag.Symbol:\n          return input;\n        case Tag.Number:\n          return input;\n      }\n      const hint: 'string' | 'number' | 'default' =\n        PreferredType === Tag.String\n          ? 'string'\n          : PreferredType === Tag.Number\n            ? 'number'\n            : 'default';\n      const exoticToPrim = GetMethod(input, toPrimitiveSymbol);\n      if (exoticToPrim !== undefined) {\n        const result = exoticToPrim.call(input, hint);\n        if (IsObject(result)) throw new TypeError();\n        return result;\n      }\n      return OrdinaryToPrimitive(input, hint === 'default' ? 'number' : hint);\n    }\n\n    // 7.1.1.1 OrdinaryToPrimitive(O, hint)\n    // https://tc39.github.io/ecma262/#sec-ordinarytoprimitive\n    function OrdinaryToPrimitive(\n      O: any,\n      hint: 'string' | 'number'\n    ): undefined | null | boolean | string | symbol | number {\n      if (hint === 'string') {\n        const toString = O.toString;\n        if (IsCallable(toString)) {\n          const result = toString.call(O);\n          if (!IsObject(result)) return result;\n        }\n        const valueOf = O.valueOf;\n        if (IsCallable(valueOf)) {\n          const result = valueOf.call(O);\n          if (!IsObject(result)) return result;\n        }\n      } else {\n        const valueOf = O.valueOf;\n        if (IsCallable(valueOf)) {\n          const result = valueOf.call(O);\n          if (!IsObject(result)) return result;\n        }\n        const toString = O.toString;\n        if (IsCallable(toString)) {\n          const result = toString.call(O);\n          if (!IsObject(result)) return result;\n        }\n      }\n      throw new TypeError();\n    }\n\n    // 7.1.2 ToBoolean(argument)\n    // https://tc39.github.io/ecma262/2016/#sec-toboolean\n    function ToBoolean(argument: any): boolean {\n      return !!argument;\n    }\n\n    // 7.1.12 ToString(argument)\n    // https://tc39.github.io/ecma262/#sec-tostring\n    function ToString(argument: any): string {\n      return '' + argument;\n    }\n\n    // 7.1.14 ToPropertyKey(argument)\n    // https://tc39.github.io/ecma262/#sec-topropertykey\n    function ToPropertyKey(argument: any): string | symbol {\n      const key = ToPrimitive(argument, Tag.String);\n      if (IsSymbol(key)) return key;\n      return ToString(key);\n    }\n\n    // 7.2 Testing and Comparison Operations\n    // https://tc39.github.io/ecma262/#sec-testing-and-comparison-operations\n\n    // 7.2.2 IsArray(argument)\n    // https://tc39.github.io/ecma262/#sec-isarray\n    function IsArray(argument: any): argument is any[] {\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\n    // 7.2.3 IsCallable(argument)\n    // https://tc39.github.io/ecma262/#sec-iscallable\n    function IsCallable(argument: any): argument is Function {\n      // NOTE: This is an approximation as we cannot check for [[Call]] internal method.\n      return typeof argument === 'function';\n    }\n\n    // 7.2.4 IsConstructor(argument)\n    // https://tc39.github.io/ecma262/#sec-isconstructor\n    function IsConstructor(argument: any): argument is Function {\n      // NOTE: This is an approximation as we cannot check for [[Construct]] internal method.\n      return typeof argument === 'function';\n    }\n\n    // 7.2.7 IsPropertyKey(argument)\n    // https://tc39.github.io/ecma262/#sec-ispropertykey\n    function IsPropertyKey(argument: any): argument is string | symbol {\n      switch (Type(argument)) {\n        case Tag.String:\n          return true;\n        case Tag.Symbol:\n          return true;\n        default:\n          return false;\n      }\n    }\n\n    // 7.3 Operations on Objects\n    // https://tc39.github.io/ecma262/#sec-operations-on-objects\n\n    // 7.3.9 GetMethod(V, P)\n    // https://tc39.github.io/ecma262/#sec-getmethod\n    function GetMethod(V: any, P: any): Function | undefined {\n      const func = V[P];\n      if (func === undefined || func === null) return undefined;\n      if (!IsCallable(func)) throw new TypeError();\n      return func;\n    }\n\n    // 7.4 Operations on Iterator Objects\n    // https://tc39.github.io/ecma262/#sec-operations-on-iterator-objects\n\n    function GetIterator<T>(obj: Iterable<T>): Iterator<T> {\n      const method = GetMethod(obj, iteratorSymbol);\n      if (!IsCallable(method)) throw new TypeError(); // from Call\n      const iterator = method.call(obj);\n      if (!IsObject(iterator)) throw new TypeError();\n      return iterator;\n    }\n\n    // 7.4.4 IteratorValue(iterResult)\n    // https://tc39.github.io/ecma262/2016/#sec-iteratorvalue\n    function IteratorValue<T>(iterResult: IteratorResult<T>): T {\n      return iterResult.value;\n    }\n\n    // 7.4.5 IteratorStep(iterator)\n    // https://tc39.github.io/ecma262/#sec-iteratorstep\n    function IteratorStep<T>(iterator: Iterator<T>): IteratorResult<T> | false {\n      const result = iterator.next();\n      return result.done ? false : result;\n    }\n\n    // 7.4.6 IteratorClose(iterator, completion)\n    // https://tc39.github.io/ecma262/#sec-iteratorclose\n    function IteratorClose<T>(iterator: Iterator<T>) {\n      const f = iterator['return'];\n      if (f) f.call(iterator);\n    }\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\n    // 9.1.1.1 OrdinaryGetPrototypeOf(O)\n    // https://tc39.github.io/ecma262/#sec-ordinarygetprototypeof\n    function OrdinaryGetPrototypeOf(O: any): any {\n      const proto = Object.getPrototypeOf(O);\n      if (typeof O !== 'function' || O === functionPrototype) return proto;\n\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\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) return proto;\n\n      // If the super prototype is Object.prototype, null, or undefined, then we cannot determine the heritage.\n      const prototype = O.prototype;\n      const prototypeProto = prototype && Object.getPrototypeOf(prototype);\n      if (prototypeProto == null || prototypeProto === Object.prototype) return proto;\n\n      // If the constructor was not a function, then we cannot determine the heritage.\n      const constructor = prototypeProto.constructor;\n      if (typeof constructor !== 'function') return proto;\n\n      // If we have some kind of self-reference, then we cannot determine the heritage.\n      if (constructor === O) return proto;\n\n      // we have a pretty good guess at the heritage.\n      return constructor;\n    }\n\n    // naive Map shim\n    function CreateMapPolyfill(): MapConstructor {\n      const cacheSentinel = {};\n      const arraySentinel: any[] = [];\n\n      class MapIterator<K, V, R extends K | V | [K, V]> implements IterableIterator<R> {\n        private _keys: K[];\n        private _values: V[];\n        private _index = 0;\n        private _selector: (key: K, value: V) => R;\n        constructor(keys: K[], values: V[], selector: (key: K, value: V) => R) {\n          this._keys = keys;\n          this._values = values;\n          this._selector = selector;\n        }\n        '@@iterator'() {\n          return this;\n        }\n        [iteratorSymbol]() {\n          return this;\n        }\n        next(): IteratorResult<R> {\n          const index = this._index;\n          if (index >= 0 && index < this._keys.length) {\n            const 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            } else {\n              this._index++;\n            }\n            return { value: result, done: false };\n          }\n          return { value: <never>undefined, done: true };\n        }\n        throw(error: any): IteratorResult<R> {\n          if (this._index >= 0) {\n            this._index = -1;\n            this._keys = arraySentinel;\n            this._values = arraySentinel;\n          }\n          throw error;\n        }\n        return(value?: R): IteratorResult<R> {\n          if (this._index >= 0) {\n            this._index = -1;\n            this._keys = arraySentinel;\n            this._values = arraySentinel;\n          }\n          return { value: <never>value, done: true };\n        }\n      }\n\n      return class Map<K, V> {\n        private _keys: K[] = [];\n        private _values: (V | undefined)[] = [];\n        private _cacheKey = cacheSentinel;\n        private _cacheIndex = -2;\n        get size() {\n          return this._keys.length;\n        }\n        has(key: K): boolean {\n          return this._find(key, /*insert*/ false) >= 0;\n        }\n        get(key: K): V | undefined {\n          const index = this._find(key, /*insert*/ false);\n          return index >= 0 ? this._values[index] : undefined;\n        }\n        set(key: K, value: V): this {\n          const index = this._find(key, /*insert*/ true);\n          this._values[index] = value;\n          return this;\n        }\n        delete(key: K): boolean {\n          const index = this._find(key, /*insert*/ false);\n          if (index >= 0) {\n            const size = this._keys.length;\n            for (let i = index + 1; i < size; i++) {\n              this._keys[i - 1] = this._keys[i];\n              this._values[i - 1] = this._values[i];\n            }\n            this._keys.length--;\n            this._values.length--;\n            if (key === this._cacheKey) {\n              this._cacheKey = cacheSentinel;\n              this._cacheIndex = -2;\n            }\n            return true;\n          }\n          return false;\n        }\n        clear(): void {\n          this._keys.length = 0;\n          this._values.length = 0;\n          this._cacheKey = cacheSentinel;\n          this._cacheIndex = -2;\n        }\n        keys() {\n          return new MapIterator(this._keys, this._values, getKey);\n        }\n        values() {\n          return new MapIterator(this._keys, this._values, getValue);\n        }\n        entries() {\n          return new MapIterator(this._keys, this._values, getEntry);\n        }\n        '@@iterator'() {\n          return this.entries();\n        }\n        [iteratorSymbol]() {\n          return this.entries();\n        }\n        private _find(key: K, insert?: boolean): number {\n          if (this._cacheKey !== key) {\n            this._cacheIndex = this._keys.indexOf((this._cacheKey = key));\n          }\n          if (this._cacheIndex < 0 && insert) {\n            this._cacheIndex = this._keys.length;\n            this._keys.push(key);\n            this._values.push(undefined);\n          }\n          return this._cacheIndex;\n        }\n      };\n\n      function getKey<K, V>(key: K, _: V) {\n        return key;\n      }\n\n      function getValue<K, V>(_: K, value: V) {\n        return value;\n      }\n\n      function getEntry<K, V>(key: K, value: V) {\n        return [key, value] as [K, V];\n      }\n    }\n\n    // naive Set shim\n    function CreateSetPolyfill(): SetConstructor {\n      return class Set<T> {\n        private _map = new _Map<any, any>();\n        get size() {\n          return this._map.size;\n        }\n        has(value: T): boolean {\n          return this._map.has(value);\n        }\n        add(value: T): Set<T> {\n          return this._map.set(value, value), this;\n        }\n        delete(value: T): boolean {\n          return this._map.delete(value);\n        }\n        clear(): void {\n          this._map.clear();\n        }\n        keys() {\n          return this._map.keys();\n        }\n        values() {\n          return this._map.values();\n        }\n        entries() {\n          return this._map.entries();\n        }\n        '@@iterator'() {\n          return this.keys();\n        }\n        [iteratorSymbol]() {\n          return this.keys();\n        }\n      };\n    }\n\n    // naive WeakMap shim\n    function CreateWeakMapPolyfill(): WeakMapConstructor {\n      const UUID_SIZE = 16;\n      const keys = HashMap.create<boolean>();\n      const rootKey = CreateUniqueKey();\n      return class WeakMap<K, V> {\n        private _key = CreateUniqueKey();\n        has(target: K): boolean {\n          const table = GetOrCreateWeakMapTable<K>(target, /*create*/ false);\n          return table !== undefined ? HashMap.has(table, this._key) : false;\n        }\n        get(target: K): V {\n          const table = GetOrCreateWeakMapTable<K>(target, /*create*/ false);\n          return table !== undefined ? HashMap.get(table, this._key) : undefined;\n        }\n        set(target: K, value: V): WeakMap<K, V> {\n          const table = GetOrCreateWeakMapTable<K>(target, /*create*/ true);\n          table[this._key] = value;\n          return this;\n        }\n        delete(target: K): boolean {\n          const table = GetOrCreateWeakMapTable<K>(target, /*create*/ false);\n          return table !== undefined ? delete table[this._key] : false;\n        }\n        clear(): void {\n          // NOTE: not a real clear, just makes the previous data unreachable\n          this._key = CreateUniqueKey();\n        }\n      };\n\n      function CreateUniqueKey(): string {\n        let key: string;\n        do key = '@@WeakMap@@' + CreateUUID();\n        while (HashMap.has(keys, key));\n        keys[key] = true;\n        return key;\n      }\n\n      function GetOrCreateWeakMapTable<K>(target: K, create: true): HashMap<any>;\n      function GetOrCreateWeakMapTable<K>(target: K, create: false): HashMap<any> | undefined;\n      function GetOrCreateWeakMapTable<K>(target: K, create: boolean): HashMap<any> | undefined {\n        if (!hasOwn.call(target, rootKey)) {\n          if (!create) return undefined;\n          Object.defineProperty(target, rootKey, { value: HashMap.create<any>() });\n        }\n        return (<any>target)[rootKey];\n      }\n\n      function FillRandomBytes(buffer: BufferLike, size: number): BufferLike {\n        for (let i = 0; i < size; ++i) buffer[i] = (Math.random() * 0xff) | 0;\n        return buffer;\n      }\n\n      function GenRandomBytes(size: number): BufferLike {\n        if (typeof Uint8Array === 'function') {\n          if (typeof crypto !== 'undefined')\n            return crypto.getRandomValues(new Uint8Array(size)) as Uint8Array;\n          if (typeof msCrypto !== 'undefined')\n            return msCrypto.getRandomValues(new Uint8Array(size)) as Uint8Array;\n          return FillRandomBytes(new Uint8Array(size), size);\n        }\n        return FillRandomBytes(new Array(size), size);\n      }\n\n      function CreateUUID() {\n        const data = GenRandomBytes(UUID_SIZE);\n        // mark as random - RFC 4122 \u00A7 4.4\n        data[6] = (data[6] & 0x4f) | 0x40;\n        data[8] = (data[8] & 0xbf) | 0x80;\n        let result = '';\n        for (let offset = 0; offset < UUID_SIZE; ++offset) {\n          const byte = data[offset];\n          if (offset === 4 || offset === 6 || offset === 8) result += '-';\n          if (byte < 16) result += '0';\n          result += byte.toString(16).toLowerCase();\n        }\n        return result;\n      }\n    }\n\n    // uses a heuristic used by v8 and chakra to force an object into dictionary mode.\n    function MakeDictionary<T>(obj: T): T {\n      (<any>obj).__ = undefined;\n      delete (<any>obj).__;\n      return obj;\n    }\n  });\n}\n", "// applies tailwind themes using css variables\nimport type React from 'react';\n\nimport { observer } from 'mobx-react';\n\nimport useTheme from './hooks/theme';\nimport { defaultTheme, useBzThemeStore } from './store/theme';\nimport type { ITheme } from './store/theme';\n\nexport interface IProps {\n  theme?: Partial<ITheme>;\n}\n\nconst BzTheme: React.FC<IProps> = observer((props) => {\n  useTheme(props.theme ?? defaultTheme);\n\n  return null;\n});\n\nexport const BzChangableTheme: React.FC = observer(() => {\n  const { theme } = useBzThemeStore();\n  useTheme(theme ?? defaultTheme);\n\n  return null;\n});\n\nexport default BzTheme;\n", "// applies tailwind themes using css variables\nimport React from 'react';\n\nimport type { IThemeValues } from '../../store/theme';\n\nconst shades = Object.freeze([50, 100, 200, 300, 400, 500, 600, 700, 800, 900] as const);\n\nconst useSetThemeVariable = (portion: keyof IThemeValues, colour?: string) => {\n  React.useEffect(() => {\n    if (!colour) {\n      return;\n    }\n\n    shades.forEach((i) => {\n      document.documentElement.style.setProperty(\n        `--color-${portion}-${i}`,\n        `var(--color-${colour}-${i})`\n      );\n    });\n  }, [portion, colour]);\n};\n\nconst useTheme = (theme: Partial<IThemeValues>) => {\n  const { accent, primary, secondary } = theme;\n\n  useSetThemeVariable('primary', primary);\n  useSetThemeVariable('secondary', secondary);\n  useSetThemeVariable('accent', accent);\n};\n\nexport default useTheme;\n"],
  "mappings": "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",
  "names": ["init_virtual_process_polyfill", "init_buffer", "Reflect", "factory", "root", "exporter", "makeExporter", "target", "previous", "key", "value", "__name", "hasOwn", "supportsSymbol", "toPrimitiveSymbol", "iteratorSymbol", "supportsCreate", "supportsProto", "downLevel", "HashMap", "MakeDictionary", "map", "functionPrototype", "usePolyfill", "_Map", "CreateMapPolyfill", "_Set", "CreateSetPolyfill", "_WeakMap", "CreateWeakMapPolyfill", "Metadata", "decorate", "decorators", "propertyKey", "attributes", "IsUndefined", "IsArray", "IsConstructor", "DecorateConstructor", "IsObject", "IsNull", "ToPropertyKey", "DecorateProperty", "metadata", "metadataKey", "metadataValue", "decorator", "IsPropertyKey", "OrdinaryDefineOwnMetadata", "defineMetadata", "hasMetadata", "OrdinaryHasMetadata", "hasOwnMetadata", "OrdinaryHasOwnMetadata", "getMetadata", "OrdinaryGetMetadata", "getOwnMetadata", "OrdinaryGetOwnMetadata", "getMetadataKeys", "OrdinaryMetadataKeys", "getOwnMetadataKeys", "OrdinaryOwnMetadataKeys", "deleteMetadata", "metadataMap", "GetOrCreateMetadataMap", "targetMetadata", "i", "decorated", "descriptor", "O", "P", "Create", "MetadataKey", "parent", "OrdinaryGetPrototypeOf", "ToBoolean", "MetadataValue", "ownKeys", "parentKeys", "set", "keys", "keysObj", "iterator", "GetIterator", "k", "next", "IteratorStep", "nextValue", "IteratorValue", "e", "IteratorClose", "Type", "x", "Tag", "IsSymbol", "ToPrimitive", "input", "PreferredType", "hint", "exoticToPrim", "GetMethod", "result", "OrdinaryToPrimitive", "toString", "IsCallable", "valueOf", "argument", "ToString", "V", "func", "obj", "method", "iterResult", "f", "proto", "prototype", "prototypeProto", "constructor", "cacheSentinel", "arraySentinel", "MapIterator", "values", "selector", "index", "error", "size", "getKey", "getValue", "getEntry", "insert", "_", "rootKey", "CreateUniqueKey", "table", "GetOrCreateWeakMapTable", "CreateUUID", "create", "FillRandomBytes", "buffer", "GenRandomBytes", "data", "offset", "byte", "init_virtual_process_polyfill", "init_buffer", "init_virtual_process_polyfill", "init_buffer", "import_react", "shades", "useSetThemeVariable", "__name", "portion", "colour", "React", "i", "useTheme", "theme", "accent", "primary", "secondary", "theme_default", "BzTheme", "observer", "props", "theme_default", "defaultTheme", "BzChangableTheme", "theme", "useBzThemeStore"]
}