@orion-js/services 3.11.8 → 4.0.0-alpha.2

package/dist/index.cjs

@@ -0,0 +1,1325 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// ../../node_modules/typedi/cjs/token.class.js
+var require_token_class = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.Token = undefined;
+
+  class Token {
+    constructor(name) {
+      this.name = name;
+    }
+  }
+  exports2.Token = Token;
+});
+
+// ../../node_modules/typedi/cjs/error/service-not-found.error.js
+var require_service_not_found_error = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.ServiceNotFoundError = undefined;
+  var token_class_1 = require_token_class();
+
+  class ServiceNotFoundError extends Error {
+    constructor(identifier) {
+      var _a, _b;
+      super();
+      this.name = "ServiceNotFoundError";
+      this.normalizedIdentifier = "<UNKNOWN_IDENTIFIER>";
+      if (typeof identifier === "string") {
+        this.normalizedIdentifier = identifier;
+      } else if (identifier instanceof token_class_1.Token) {
+        this.normalizedIdentifier = `Token<${identifier.name || "UNSET_NAME"}>`;
+      } else if (identifier && (identifier.name || ((_a = identifier.prototype) === null || _a === undefined ? undefined : _a.name))) {
+        this.normalizedIdentifier = `MaybeConstructable<${identifier.name}>` || `MaybeConstructable<${(_b = identifier.prototype) === null || _b === undefined ? undefined : _b.name}>`;
+      }
+    }
+    get message() {
+      return `Service with "${this.normalizedIdentifier}" identifier was not found in the container. ` + `Register it before usage via explicitly calling the "Container.set" function or using the "@Service()" decorator.`;
+    }
+  }
+  exports2.ServiceNotFoundError = ServiceNotFoundError;
+});
+
+// ../../node_modules/typedi/cjs/error/cannot-instantiate-value.error.js
+var require_cannot_instantiate_value_error = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.CannotInstantiateValueError = undefined;
+  var token_class_1 = require_token_class();
+
+  class CannotInstantiateValueError extends Error {
+    constructor(identifier) {
+      var _a, _b;
+      super();
+      this.name = "CannotInstantiateValueError";
+      this.normalizedIdentifier = "<UNKNOWN_IDENTIFIER>";
+      if (typeof identifier === "string") {
+        this.normalizedIdentifier = identifier;
+      } else if (identifier instanceof token_class_1.Token) {
+        this.normalizedIdentifier = `Token<${identifier.name || "UNSET_NAME"}>`;
+      } else if (identifier && (identifier.name || ((_a = identifier.prototype) === null || _a === undefined ? undefined : _a.name))) {
+        this.normalizedIdentifier = `MaybeConstructable<${identifier.name}>` || `MaybeConstructable<${(_b = identifier.prototype) === null || _b === undefined ? undefined : _b.name}>`;
+      }
+    }
+    get message() {
+      return `Cannot instantiate the requested value for the "${this.normalizedIdentifier}" identifier. ` + `The related metadata doesn't contain a factory or a type to instantiate.`;
+    }
+  }
+  exports2.CannotInstantiateValueError = CannotInstantiateValueError;
+});
+
+// ../../node_modules/typedi/cjs/empty.const.js
+var require_empty_const = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.EMPTY_VALUE = undefined;
+  exports2.EMPTY_VALUE = Symbol("EMPTY_VALUE");
+});
+
+// ../../node_modules/typedi/cjs/container-instance.class.js
+var require_container_instance_class = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.ContainerInstance = undefined;
+  var container_class_1 = require_container_class();
+  var service_not_found_error_1 = require_service_not_found_error();
+  var cannot_instantiate_value_error_1 = require_cannot_instantiate_value_error();
+  var token_class_1 = require_token_class();
+  var empty_const_1 = require_empty_const();
+
+  class ContainerInstance {
+    constructor(id) {
+      this.services = [];
+      this.id = id;
+    }
+    has(identifier) {
+      return !!this.findService(identifier);
+    }
+    get(identifier) {
+      const globalContainer = container_class_1.Container.of(undefined);
+      const globalService = globalContainer.findService(identifier);
+      const scopedService = this.findService(identifier);
+      if (globalService && globalService.global === true)
+        return this.getServiceValue(globalService);
+      if (scopedService)
+        return this.getServiceValue(scopedService);
+      if (globalService && this !== globalContainer) {
+        const clonedService = { ...globalService };
+        clonedService.value = empty_const_1.EMPTY_VALUE;
+        this.set(clonedService);
+        const value = this.getServiceValue(clonedService);
+        this.set({ ...clonedService, value });
+        return value;
+      }
+      if (globalService)
+        return this.getServiceValue(globalService);
+      throw new service_not_found_error_1.ServiceNotFoundError(identifier);
+    }
+    getMany(identifier) {
+      return this.findAllServices(identifier).map((service) => this.getServiceValue(service));
+    }
+    set(identifierOrServiceMetadata, value) {
+      if (identifierOrServiceMetadata instanceof Array) {
+        identifierOrServiceMetadata.forEach((data) => this.set(data));
+        return this;
+      }
+      if (typeof identifierOrServiceMetadata === "string" || identifierOrServiceMetadata instanceof token_class_1.Token) {
+        return this.set({
+          id: identifierOrServiceMetadata,
+          type: null,
+          value,
+          factory: undefined,
+          global: false,
+          multiple: false,
+          eager: false,
+          transient: false
+        });
+      }
+      if (typeof identifierOrServiceMetadata === "function") {
+        return this.set({
+          id: identifierOrServiceMetadata,
+          type: identifierOrServiceMetadata,
+          value,
+          factory: undefined,
+          global: false,
+          multiple: false,
+          eager: false,
+          transient: false
+        });
+      }
+      const newService = {
+        id: new token_class_1.Token("UNREACHABLE"),
+        type: null,
+        factory: undefined,
+        value: empty_const_1.EMPTY_VALUE,
+        global: false,
+        multiple: false,
+        eager: false,
+        transient: false,
+        ...identifierOrServiceMetadata
+      };
+      const service = this.findService(newService.id);
+      if (service && service.multiple !== true) {
+        Object.assign(service, newService);
+      } else {
+        this.services.push(newService);
+      }
+      if (newService.eager) {
+        this.get(newService.id);
+      }
+      return this;
+    }
+    remove(identifierOrIdentifierArray) {
+      if (Array.isArray(identifierOrIdentifierArray)) {
+        identifierOrIdentifierArray.forEach((id) => this.remove(id));
+      } else {
+        this.services = this.services.filter((service) => {
+          if (service.id === identifierOrIdentifierArray) {
+            this.destroyServiceInstance(service);
+            return false;
+          }
+          return true;
+        });
+      }
+      return this;
+    }
+    reset(options = { strategy: "resetValue" }) {
+      switch (options.strategy) {
+        case "resetValue":
+          this.services.forEach((service) => this.destroyServiceInstance(service));
+          break;
+        case "resetServices":
+          this.services.forEach((service) => this.destroyServiceInstance(service));
+          this.services = [];
+          break;
+        default:
+          throw new Error("Received invalid reset strategy.");
+      }
+      return this;
+    }
+    findAllServices(identifier) {
+      return this.services.filter((service) => service.id === identifier);
+    }
+    findService(identifier) {
+      return this.services.find((service) => service.id === identifier);
+    }
+    getServiceValue(serviceMetadata) {
+      var _a;
+      let value = empty_const_1.EMPTY_VALUE;
+      if (serviceMetadata.value !== empty_const_1.EMPTY_VALUE) {
+        return serviceMetadata.value;
+      }
+      if (!serviceMetadata.factory && !serviceMetadata.type) {
+        throw new cannot_instantiate_value_error_1.CannotInstantiateValueError(serviceMetadata.id);
+      }
+      if (serviceMetadata.factory) {
+        if (serviceMetadata.factory instanceof Array) {
+          let factoryInstance;
+          try {
+            factoryInstance = this.get(serviceMetadata.factory[0]);
+          } catch (error) {
+            if (error instanceof service_not_found_error_1.ServiceNotFoundError) {
+              factoryInstance = new serviceMetadata.factory[0];
+            } else {
+              throw error;
+            }
+          }
+          value = factoryInstance[serviceMetadata.factory[1]](this, serviceMetadata.id);
+        } else {
+          value = serviceMetadata.factory(this, serviceMetadata.id);
+        }
+      }
+      if (!serviceMetadata.factory && serviceMetadata.type) {
+        const constructableTargetType = serviceMetadata.type;
+        const paramTypes = ((_a = Reflect) === null || _a === undefined ? undefined : _a.getMetadata("design:paramtypes", constructableTargetType)) || [];
+        const params = this.initializeParams(constructableTargetType, paramTypes);
+        params.push(this);
+        value = new constructableTargetType(...params);
+      }
+      if (!serviceMetadata.transient && value !== empty_const_1.EMPTY_VALUE) {
+        serviceMetadata.value = value;
+      }
+      if (value === empty_const_1.EMPTY_VALUE) {
+        throw new cannot_instantiate_value_error_1.CannotInstantiateValueError(serviceMetadata.id);
+      }
+      if (serviceMetadata.type) {
+        this.applyPropertyHandlers(serviceMetadata.type, value);
+      }
+      return value;
+    }
+    initializeParams(target, paramTypes) {
+      return paramTypes.map((paramType, index) => {
+        const paramHandler = container_class_1.Container.handlers.find((handler) => {
+          return (handler.object === target || handler.object === Object.getPrototypeOf(target)) && handler.index === index;
+        });
+        if (paramHandler)
+          return paramHandler.value(this);
+        if (paramType && paramType.name && !this.isPrimitiveParamType(paramType.name)) {
+          return this.get(paramType);
+        }
+        return;
+      });
+    }
+    isPrimitiveParamType(paramTypeName) {
+      return ["string", "boolean", "number", "object"].includes(paramTypeName.toLowerCase());
+    }
+    applyPropertyHandlers(target, instance) {
+      container_class_1.Container.handlers.forEach((handler) => {
+        if (typeof handler.index === "number")
+          return;
+        if (handler.object.constructor !== target && !(target.prototype instanceof handler.object.constructor))
+          return;
+        if (handler.propertyName) {
+          instance[handler.propertyName] = handler.value(this);
+        }
+      });
+    }
+    destroyServiceInstance(serviceMetadata, force = false) {
+      const shouldResetValue = force || !!serviceMetadata.type || !!serviceMetadata.factory;
+      if (shouldResetValue) {
+        if (typeof (serviceMetadata === null || serviceMetadata === undefined ? undefined : serviceMetadata.value)["destroy"] === "function") {
+          try {
+            serviceMetadata.value.destroy();
+          } catch (error) {
+          }
+        }
+        serviceMetadata.value = empty_const_1.EMPTY_VALUE;
+      }
+    }
+  }
+  exports2.ContainerInstance = ContainerInstance;
+});
+
+// ../../node_modules/typedi/cjs/container.class.js
+var require_container_class = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.Container = undefined;
+  var container_instance_class_1 = require_container_instance_class();
+
+  class Container {
+    static of(containerId = "default") {
+      if (containerId === "default")
+        return this.globalInstance;
+      let container = this.instances.find((instance) => instance.id === containerId);
+      if (!container) {
+        container = new container_instance_class_1.ContainerInstance(containerId);
+        this.instances.push(container);
+      }
+      return container;
+    }
+    static has(identifier) {
+      return this.globalInstance.has(identifier);
+    }
+    static get(identifier) {
+      return this.globalInstance.get(identifier);
+    }
+    static getMany(id) {
+      return this.globalInstance.getMany(id);
+    }
+    static set(identifierOrServiceMetadata, value) {
+      this.globalInstance.set(identifierOrServiceMetadata, value);
+      return this;
+    }
+    static remove(identifierOrIdentifierArray) {
+      this.globalInstance.remove(identifierOrIdentifierArray);
+      return this;
+    }
+    static reset(containerId = "default") {
+      if (containerId == "default") {
+        this.globalInstance.reset();
+        this.instances.forEach((instance) => instance.reset());
+      } else {
+        const instance = this.instances.find((instance2) => instance2.id === containerId);
+        if (instance) {
+          instance.reset();
+          this.instances.splice(this.instances.indexOf(instance), 1);
+        }
+      }
+      return this;
+    }
+    static registerHandler(handler) {
+      this.handlers.push(handler);
+      return this;
+    }
+    static import(services) {
+      return this;
+    }
+  }
+  exports2.Container = Container;
+  Container.handlers = [];
+  Container.globalInstance = new container_instance_class_1.ContainerInstance("default");
+  Container.instances = [];
+});
+
+// ../../node_modules/typedi/cjs/error/cannot-inject-value.error.js
+var require_cannot_inject_value_error = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.CannotInjectValueError = undefined;
+
+  class CannotInjectValueError extends Error {
+    constructor(target, propertyName) {
+      super();
+      this.target = target;
+      this.propertyName = propertyName;
+      this.name = "CannotInjectValueError";
+    }
+    get message() {
+      return `Cannot inject value into "${this.target.constructor.name}.${this.propertyName}". ` + `Please make sure you setup reflect-metadata properly and you don't use interfaces without service tokens as injection value.`;
+    }
+  }
+  exports2.CannotInjectValueError = CannotInjectValueError;
+});
+
+// ../../node_modules/typedi/cjs/utils/resolve-to-type-wrapper.util.js
+var require_resolve_to_type_wrapper_util = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.resolveToTypeWrapper = undefined;
+  var token_class_1 = require_token_class();
+  function resolveToTypeWrapper(typeOrIdentifier, target, propertyName, index) {
+    let typeWrapper;
+    if (typeOrIdentifier && typeof typeOrIdentifier === "string" || typeOrIdentifier instanceof token_class_1.Token) {
+      typeWrapper = { eagerType: typeOrIdentifier, lazyType: () => typeOrIdentifier };
+    }
+    if (typeOrIdentifier && typeof typeOrIdentifier === "function") {
+      typeWrapper = { eagerType: null, lazyType: () => typeOrIdentifier() };
+    }
+    if (!typeOrIdentifier && propertyName) {
+      const identifier = Reflect.getMetadata("design:type", target, propertyName);
+      typeWrapper = { eagerType: identifier, lazyType: () => identifier };
+    }
+    if (!typeOrIdentifier && typeof index == "number" && Number.isInteger(index)) {
+      const paramTypes = Reflect.getMetadata("design:paramtypes", target, propertyName);
+      const identifier = paramTypes === null || paramTypes === undefined ? undefined : paramTypes[index];
+      typeWrapper = { eagerType: identifier, lazyType: () => identifier };
+    }
+    return typeWrapper;
+  }
+  exports2.resolveToTypeWrapper = resolveToTypeWrapper;
+});
+
+// ../../node_modules/typedi/cjs/decorators/inject-many.decorator.js
+var require_inject_many_decorator = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.InjectMany = undefined;
+  var container_class_1 = require_container_class();
+  var cannot_inject_value_error_1 = require_cannot_inject_value_error();
+  var resolve_to_type_wrapper_util_1 = require_resolve_to_type_wrapper_util();
+  function InjectMany(typeOrIdentifier) {
+    return function(target, propertyName, index) {
+      const typeWrapper = resolve_to_type_wrapper_util_1.resolveToTypeWrapper(typeOrIdentifier, target, propertyName, index);
+      if (typeWrapper === undefined || typeWrapper.eagerType === undefined || typeWrapper.eagerType === Object) {
+        throw new cannot_inject_value_error_1.CannotInjectValueError(target, propertyName);
+      }
+      container_class_1.Container.registerHandler({
+        object: target,
+        propertyName,
+        index,
+        value: (containerInstance) => {
+          const evaluatedLazyType = typeWrapper.lazyType();
+          if (evaluatedLazyType === undefined || evaluatedLazyType === Object) {
+            throw new cannot_inject_value_error_1.CannotInjectValueError(target, propertyName);
+          }
+          return containerInstance.getMany(evaluatedLazyType);
+        }
+      });
+    };
+  }
+  exports2.InjectMany = InjectMany;
+});
+
+// ../../node_modules/typedi/cjs/decorators/inject.decorator.js
+var require_inject_decorator = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.Inject = undefined;
+  var container_class_1 = require_container_class();
+  var cannot_inject_value_error_1 = require_cannot_inject_value_error();
+  var resolve_to_type_wrapper_util_1 = require_resolve_to_type_wrapper_util();
+  function Inject(typeOrIdentifier) {
+    return function(target, propertyName, index) {
+      const typeWrapper = resolve_to_type_wrapper_util_1.resolveToTypeWrapper(typeOrIdentifier, target, propertyName, index);
+      if (typeWrapper === undefined || typeWrapper.eagerType === undefined || typeWrapper.eagerType === Object) {
+        throw new cannot_inject_value_error_1.CannotInjectValueError(target, propertyName);
+      }
+      container_class_1.Container.registerHandler({
+        object: target,
+        propertyName,
+        index,
+        value: (containerInstance) => {
+          const evaluatedLazyType = typeWrapper.lazyType();
+          if (evaluatedLazyType === undefined || evaluatedLazyType === Object) {
+            throw new cannot_inject_value_error_1.CannotInjectValueError(target, propertyName);
+          }
+          return containerInstance.get(evaluatedLazyType);
+        }
+      });
+    };
+  }
+  exports2.Inject = Inject;
+});
+
+// ../../node_modules/typedi/cjs/decorators/service.decorator.js
+var require_service_decorator = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.Service = undefined;
+  var container_class_1 = require_container_class();
+  var token_class_1 = require_token_class();
+  var empty_const_1 = require_empty_const();
+  function Service(optionsOrServiceIdentifier) {
+    return (targetConstructor) => {
+      const serviceMetadata = {
+        id: targetConstructor,
+        type: targetConstructor,
+        factory: undefined,
+        multiple: false,
+        global: false,
+        eager: false,
+        transient: false,
+        value: empty_const_1.EMPTY_VALUE
+      };
+      if (optionsOrServiceIdentifier instanceof token_class_1.Token || typeof optionsOrServiceIdentifier === "string") {
+        serviceMetadata.id = optionsOrServiceIdentifier;
+      } else if (optionsOrServiceIdentifier) {
+        serviceMetadata.id = optionsOrServiceIdentifier.id || targetConstructor;
+        serviceMetadata.factory = optionsOrServiceIdentifier.factory || undefined;
+        serviceMetadata.multiple = optionsOrServiceIdentifier.multiple || false;
+        serviceMetadata.global = optionsOrServiceIdentifier.global || false;
+        serviceMetadata.eager = optionsOrServiceIdentifier.eager || false;
+        serviceMetadata.transient = optionsOrServiceIdentifier.transient || false;
+      }
+      container_class_1.Container.set(serviceMetadata);
+    };
+  }
+  exports2.Service = Service;
+});
+
+// ../../node_modules/typedi/cjs/index.js
+var require_cjs = __commonJS((exports2) => {
+  var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() {
+      return m[k];
+    } });
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
+        __createBinding(exports3, m, p);
+  };
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.Token = exports2.Container = exports2.ContainerInstance = undefined;
+  var container_class_1 = require_container_class();
+  __exportStar(require_inject_many_decorator(), exports2);
+  __exportStar(require_inject_decorator(), exports2);
+  __exportStar(require_service_decorator(), exports2);
+  __exportStar(require_cannot_inject_value_error(), exports2);
+  __exportStar(require_cannot_instantiate_value_error(), exports2);
+  __exportStar(require_service_not_found_error(), exports2);
+  var container_instance_class_1 = require_container_instance_class();
+  Object.defineProperty(exports2, "ContainerInstance", { enumerable: true, get: function() {
+    return container_instance_class_1.ContainerInstance;
+  } });
+  var container_class_2 = require_container_class();
+  Object.defineProperty(exports2, "Container", { enumerable: true, get: function() {
+    return container_class_2.Container;
+  } });
+  var token_class_1 = require_token_class();
+  Object.defineProperty(exports2, "Token", { enumerable: true, get: function() {
+    return token_class_1.Token;
+  } });
+  exports2.default = container_class_1.Container;
+});
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  getInstance: () => getInstance,
+  Service: () => import_typedi2.Service,
+  Inject: () => import_typedi2.Inject,
+  Container: () => import_typedi2.Container
+});
+module.exports = __toCommonJS(exports_src);
+
+// ../../node_modules/reflect-metadata/Reflect.js
+/*! *****************************************************************************
+Copyright (C) Microsoft. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+var Reflect2;
+(function(Reflect3) {
+  (function(factory) {
+    var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : Function("return this;")();
+    var exporter = makeExporter(Reflect3);
+    if (typeof root.Reflect === "undefined") {
+      root.Reflect = Reflect3;
+    } else {
+      exporter = makeExporter(root.Reflect, exporter);
+    }
+    factory(exporter);
+    function makeExporter(target, previous) {
+      return function(key, value) {
+        if (typeof target[key] !== "function") {
+          Object.defineProperty(target, key, { configurable: true, writable: true, value });
+        }
+        if (previous)
+          previous(key, value);
+      };
+    }
+  })(function(exporter) {
+    var hasOwn = Object.prototype.hasOwnProperty;
+    var supportsSymbol = typeof Symbol === "function";
+    var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
+    var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
+    var supportsCreate = typeof Object.create === "function";
+    var supportsProto = { __proto__: [] } instanceof Array;
+    var downLevel = !supportsCreate && !supportsProto;
+    var HashMap = {
+      create: supportsCreate ? function() {
+        return MakeDictionary(Object.create(null));
+      } : supportsProto ? function() {
+        return MakeDictionary({ __proto__: null });
+      } : function() {
+        return MakeDictionary({});
+      },
+      has: downLevel ? function(map, key) {
+        return hasOwn.call(map, key);
+      } : function(map, key) {
+        return key in map;
+      },
+      get: downLevel ? function(map, key) {
+        return hasOwn.call(map, key) ? map[key] : undefined;
+      } : function(map, key) {
+        return map[key];
+      }
+    };
+    var functionPrototype = Object.getPrototypeOf(Function);
+    var usePolyfill = typeof process === "object" && process.env && process.env["REFLECT_METADATA_USE_MAP_POLYFILL"] === "true";
+    var _Map = !usePolyfill && typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
+    var _Set = !usePolyfill && typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
+    var _WeakMap = !usePolyfill && typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
+    var Metadata = new _WeakMap;
+    function decorate(decorators, target, propertyKey, attributes) {
+      if (!IsUndefined(propertyKey)) {
+        if (!IsArray(decorators))
+          throw new TypeError;
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))
+          throw new TypeError;
+        if (IsNull(attributes))
+          attributes = undefined;
+        propertyKey = ToPropertyKey(propertyKey);
+        return DecorateProperty(decorators, target, propertyKey, attributes);
+      } else {
+        if (!IsArray(decorators))
+          throw new TypeError;
+        if (!IsConstructor(target))
+          throw new TypeError;
+        return DecorateConstructor(decorators, target);
+      }
+    }
+    exporter("decorate", decorate);
+    function metadata(metadataKey, metadataValue) {
+      function decorator(target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
+          throw new TypeError;
+        OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+      }
+      return decorator;
+    }
+    exporter("metadata", metadata);
+    function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
+      if (!IsObject(target))
+        throw new TypeError;
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
+      return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+    }
+    exporter("defineMetadata", defineMetadata);
+    function hasMetadata(metadataKey, target, propertyKey) {
+      if (!IsObject(target))
+        throw new TypeError;
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
+      return OrdinaryHasMetadata(metadataKey, target, propertyKey);
+    }
+    exporter("hasMetadata", hasMetadata);
+    function hasOwnMetadata(metadataKey, target, propertyKey) {
+      if (!IsObject(target))
+        throw new TypeError;
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
+      return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
+    }
+    exporter("hasOwnMetadata", hasOwnMetadata);
+    function getMetadata(metadataKey, target, propertyKey) {
+      if (!IsObject(target))
+        throw new TypeError;
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
+      return OrdinaryGetMetadata(metadataKey, target, propertyKey);
+    }
+    exporter("getMetadata", getMetadata);
+    function getOwnMetadata(metadataKey, target, propertyKey) {
+      if (!IsObject(target))
+        throw new TypeError;
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
+      return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
+    }
+    exporter("getOwnMetadata", getOwnMetadata);
+    function getMetadataKeys(target, propertyKey) {
+      if (!IsObject(target))
+        throw new TypeError;
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
+      return OrdinaryMetadataKeys(target, propertyKey);
+    }
+    exporter("getMetadataKeys", getMetadataKeys);
+    function getOwnMetadataKeys(target, propertyKey) {
+      if (!IsObject(target))
+        throw new TypeError;
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
+      return OrdinaryOwnMetadataKeys(target, propertyKey);
+    }
+    exporter("getOwnMetadataKeys", getOwnMetadataKeys);
+    function deleteMetadata(metadataKey, target, propertyKey) {
+      if (!IsObject(target))
+        throw new TypeError;
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
+      var metadataMap = GetOrCreateMetadataMap(target, propertyKey, false);
+      if (IsUndefined(metadataMap))
+        return false;
+      if (!metadataMap.delete(metadataKey))
+        return false;
+      if (metadataMap.size > 0)
+        return true;
+      var targetMetadata = Metadata.get(target);
+      targetMetadata.delete(propertyKey);
+      if (targetMetadata.size > 0)
+        return true;
+      Metadata.delete(target);
+      return true;
+    }
+    exporter("deleteMetadata", deleteMetadata);
+    function DecorateConstructor(decorators, target) {
+      for (var i = decorators.length - 1;i >= 0; --i) {
+        var decorator = decorators[i];
+        var decorated = decorator(target);
+        if (!IsUndefined(decorated) && !IsNull(decorated)) {
+          if (!IsConstructor(decorated))
+            throw new TypeError;
+          target = decorated;
+        }
+      }
+      return target;
+    }
+    function DecorateProperty(decorators, target, propertyKey, descriptor) {
+      for (var i = decorators.length - 1;i >= 0; --i) {
+        var decorator = decorators[i];
+        var decorated = decorator(target, propertyKey, descriptor);
+        if (!IsUndefined(decorated) && !IsNull(decorated)) {
+          if (!IsObject(decorated))
+            throw new TypeError;
+          descriptor = decorated;
+        }
+      }
+      return descriptor;
+    }
+    function GetOrCreateMetadataMap(O, P, Create) {
+      var targetMetadata = Metadata.get(O);
+      if (IsUndefined(targetMetadata)) {
+        if (!Create)
+          return;
+        targetMetadata = new _Map;
+        Metadata.set(O, targetMetadata);
+      }
+      var metadataMap = targetMetadata.get(P);
+      if (IsUndefined(metadataMap)) {
+        if (!Create)
+          return;
+        metadataMap = new _Map;
+        targetMetadata.set(P, metadataMap);
+      }
+      return metadataMap;
+    }
+    function OrdinaryHasMetadata(MetadataKey, O, P) {
+      var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+      if (hasOwn2)
+        return true;
+      var parent = OrdinaryGetPrototypeOf(O);
+      if (!IsNull(parent))
+        return OrdinaryHasMetadata(MetadataKey, parent, P);
+      return false;
+    }
+    function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
+      var metadataMap = GetOrCreateMetadataMap(O, P, false);
+      if (IsUndefined(metadataMap))
+        return false;
+      return ToBoolean(metadataMap.has(MetadataKey));
+    }
+    function OrdinaryGetMetadata(MetadataKey, O, P) {
+      var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+      if (hasOwn2)
+        return OrdinaryGetOwnMetadata(MetadataKey, O, P);
+      var parent = OrdinaryGetPrototypeOf(O);
+      if (!IsNull(parent))
+        return OrdinaryGetMetadata(MetadataKey, parent, P);
+      return;
+    }
+    function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
+      var metadataMap = GetOrCreateMetadataMap(O, P, false);
+      if (IsUndefined(metadataMap))
+        return;
+      return metadataMap.get(MetadataKey);
+    }
+    function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
+      var metadataMap = GetOrCreateMetadataMap(O, P, true);
+      metadataMap.set(MetadataKey, MetadataValue);
+    }
+    function OrdinaryMetadataKeys(O, P) {
+      var ownKeys = OrdinaryOwnMetadataKeys(O, P);
+      var parent = OrdinaryGetPrototypeOf(O);
+      if (parent === null)
+        return ownKeys;
+      var parentKeys = OrdinaryMetadataKeys(parent, P);
+      if (parentKeys.length <= 0)
+        return ownKeys;
+      if (ownKeys.length <= 0)
+        return parentKeys;
+      var set = new _Set;
+      var keys = [];
+      for (var _i = 0, ownKeys_1 = ownKeys;_i < ownKeys_1.length; _i++) {
+        var key = ownKeys_1[_i];
+        var hasKey = set.has(key);
+        if (!hasKey) {
+          set.add(key);
+          keys.push(key);
+        }
+      }
+      for (var _a = 0, parentKeys_1 = parentKeys;_a < parentKeys_1.length; _a++) {
+        var key = parentKeys_1[_a];
+        var hasKey = set.has(key);
+        if (!hasKey) {
+          set.add(key);
+          keys.push(key);
+        }
+      }
+      return keys;
+    }
+    function OrdinaryOwnMetadataKeys(O, P) {
+      var keys = [];
+      var metadataMap = GetOrCreateMetadataMap(O, P, false);
+      if (IsUndefined(metadataMap))
+        return keys;
+      var keysObj = metadataMap.keys();
+      var iterator = GetIterator(keysObj);
+      var k = 0;
+      while (true) {
+        var next = IteratorStep(iterator);
+        if (!next) {
+          keys.length = k;
+          return keys;
+        }
+        var nextValue = IteratorValue(next);
+        try {
+          keys[k] = nextValue;
+        } catch (e) {
+          try {
+            IteratorClose(iterator);
+          } finally {
+            throw e;
+          }
+        }
+        k++;
+      }
+    }
+    function Type(x) {
+      if (x === null)
+        return 1;
+      switch (typeof x) {
+        case "undefined":
+          return 0;
+        case "boolean":
+          return 2;
+        case "string":
+          return 3;
+        case "symbol":
+          return 4;
+        case "number":
+          return 5;
+        case "object":
+          return x === null ? 1 : 6;
+        default:
+          return 6;
+      }
+    }
+    function IsUndefined(x) {
+      return x === undefined;
+    }
+    function IsNull(x) {
+      return x === null;
+    }
+    function IsSymbol(x) {
+      return typeof x === "symbol";
+    }
+    function IsObject(x) {
+      return typeof x === "object" ? x !== null : typeof x === "function";
+    }
+    function ToPrimitive(input, PreferredType) {
+      switch (Type(input)) {
+        case 0:
+          return input;
+        case 1:
+          return input;
+        case 2:
+          return input;
+        case 3:
+          return input;
+        case 4:
+          return input;
+        case 5:
+          return input;
+      }
+      var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default";
+      var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
+      if (exoticToPrim !== undefined) {
+        var result = exoticToPrim.call(input, hint);
+        if (IsObject(result))
+          throw new TypeError;
+        return result;
+      }
+      return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
+    }
+    function OrdinaryToPrimitive(O, hint) {
+      if (hint === "string") {
+        var toString_1 = O.toString;
+        if (IsCallable(toString_1)) {
+          var result = toString_1.call(O);
+          if (!IsObject(result))
+            return result;
+        }
+        var valueOf = O.valueOf;
+        if (IsCallable(valueOf)) {
+          var result = valueOf.call(O);
+          if (!IsObject(result))
+            return result;
+        }
+      } else {
+        var valueOf = O.valueOf;
+        if (IsCallable(valueOf)) {
+          var result = valueOf.call(O);
+          if (!IsObject(result))
+            return result;
+        }
+        var toString_2 = O.toString;
+        if (IsCallable(toString_2)) {
+          var result = toString_2.call(O);
+          if (!IsObject(result))
+            return result;
+        }
+      }
+      throw new TypeError;
+    }
+    function ToBoolean(argument) {
+      return !!argument;
+    }
+    function ToString(argument) {
+      return "" + argument;
+    }
+    function ToPropertyKey(argument) {
+      var key = ToPrimitive(argument, 3);
+      if (IsSymbol(key))
+        return key;
+      return ToString(key);
+    }
+    function IsArray(argument) {
+      return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
+    }
+    function IsCallable(argument) {
+      return typeof argument === "function";
+    }
+    function IsConstructor(argument) {
+      return typeof argument === "function";
+    }
+    function IsPropertyKey(argument) {
+      switch (Type(argument)) {
+        case 3:
+          return true;
+        case 4:
+          return true;
+        default:
+          return false;
+      }
+    }
+    function GetMethod(V, P) {
+      var func = V[P];
+      if (func === undefined || func === null)
+        return;
+      if (!IsCallable(func))
+        throw new TypeError;
+      return func;
+    }
+    function GetIterator(obj) {
+      var method = GetMethod(obj, iteratorSymbol);
+      if (!IsCallable(method))
+        throw new TypeError;
+      var iterator = method.call(obj);
+      if (!IsObject(iterator))
+        throw new TypeError;
+      return iterator;
+    }
+    function IteratorValue(iterResult) {
+      return iterResult.value;
+    }
+    function IteratorStep(iterator) {
+      var result = iterator.next();
+      return result.done ? false : result;
+    }
+    function IteratorClose(iterator) {
+      var f = iterator["return"];
+      if (f)
+        f.call(iterator);
+    }
+    function OrdinaryGetPrototypeOf(O) {
+      var proto = Object.getPrototypeOf(O);
+      if (typeof O !== "function" || O === functionPrototype)
+        return proto;
+      if (proto !== functionPrototype)
+        return proto;
+      var prototype = O.prototype;
+      var prototypeProto = prototype && Object.getPrototypeOf(prototype);
+      if (prototypeProto == null || prototypeProto === Object.prototype)
+        return proto;
+      var constructor = prototypeProto.constructor;
+      if (typeof constructor !== "function")
+        return proto;
+      if (constructor === O)
+        return proto;
+      return constructor;
+    }
+    function CreateMapPolyfill() {
+      var cacheSentinel = {};
+      var arraySentinel = [];
+      var MapIterator = function() {
+        function MapIterator2(keys, values, selector) {
+          this._index = 0;
+          this._keys = keys;
+          this._values = values;
+          this._selector = selector;
+        }
+        MapIterator2.prototype["@@iterator"] = function() {
+          return this;
+        };
+        MapIterator2.prototype[iteratorSymbol] = function() {
+          return this;
+        };
+        MapIterator2.prototype.next = function() {
+          var index = this._index;
+          if (index >= 0 && index < this._keys.length) {
+            var result = this._selector(this._keys[index], this._values[index]);
+            if (index + 1 >= this._keys.length) {
+              this._index = -1;
+              this._keys = arraySentinel;
+              this._values = arraySentinel;
+            } else {
+              this._index++;
+            }
+            return { value: result, done: false };
+          }
+          return { value: undefined, done: true };
+        };
+        MapIterator2.prototype.throw = function(error) {
+          if (this._index >= 0) {
+            this._index = -1;
+            this._keys = arraySentinel;
+            this._values = arraySentinel;
+          }
+          throw error;
+        };
+        MapIterator2.prototype.return = function(value) {
+          if (this._index >= 0) {
+            this._index = -1;
+            this._keys = arraySentinel;
+            this._values = arraySentinel;
+          }
+          return { value, done: true };
+        };
+        return MapIterator2;
+      }();
+      return function() {
+        function Map2() {
+          this._keys = [];
+          this._values = [];
+          this._cacheKey = cacheSentinel;
+          this._cacheIndex = -2;
+        }
+        Object.defineProperty(Map2.prototype, "size", {
+          get: function() {
+            return this._keys.length;
+          },
+          enumerable: true,
+          configurable: true
+        });
+        Map2.prototype.has = function(key) {
+          return this._find(key, false) >= 0;
+        };
+        Map2.prototype.get = function(key) {
+          var index = this._find(key, false);
+          return index >= 0 ? this._values[index] : undefined;
+        };
+        Map2.prototype.set = function(key, value) {
+          var index = this._find(key, true);
+          this._values[index] = value;
+          return this;
+        };
+        Map2.prototype.delete = function(key) {
+          var index = this._find(key, false);
+          if (index >= 0) {
+            var size = this._keys.length;
+            for (var i = index + 1;i < size; i++) {
+              this._keys[i - 1] = this._keys[i];
+              this._values[i - 1] = this._values[i];
+            }
+            this._keys.length--;
+            this._values.length--;
+            if (key === this._cacheKey) {
+              this._cacheKey = cacheSentinel;
+              this._cacheIndex = -2;
+            }
+            return true;
+          }
+          return false;
+        };
+        Map2.prototype.clear = function() {
+          this._keys.length = 0;
+          this._values.length = 0;
+          this._cacheKey = cacheSentinel;
+          this._cacheIndex = -2;
+        };
+        Map2.prototype.keys = function() {
+          return new MapIterator(this._keys, this._values, getKey);
+        };
+        Map2.prototype.values = function() {
+          return new MapIterator(this._keys, this._values, getValue);
+        };
+        Map2.prototype.entries = function() {
+          return new MapIterator(this._keys, this._values, getEntry);
+        };
+        Map2.prototype["@@iterator"] = function() {
+          return this.entries();
+        };
+        Map2.prototype[iteratorSymbol] = function() {
+          return this.entries();
+        };
+        Map2.prototype._find = function(key, insert) {
+          if (this._cacheKey !== key) {
+            this._cacheIndex = this._keys.indexOf(this._cacheKey = key);
+          }
+          if (this._cacheIndex < 0 && insert) {
+            this._cacheIndex = this._keys.length;
+            this._keys.push(key);
+            this._values.push(undefined);
+          }
+          return this._cacheIndex;
+        };
+        return Map2;
+      }();
+      function getKey(key, _) {
+        return key;
+      }
+      function getValue(_, value) {
+        return value;
+      }
+      function getEntry(key, value) {
+        return [key, value];
+      }
+    }
+    function CreateSetPolyfill() {
+      return function() {
+        function Set2() {
+          this._map = new _Map;
+        }
+        Object.defineProperty(Set2.prototype, "size", {
+          get: function() {
+            return this._map.size;
+          },
+          enumerable: true,
+          configurable: true
+        });
+        Set2.prototype.has = function(value) {
+          return this._map.has(value);
+        };
+        Set2.prototype.add = function(value) {
+          return this._map.set(value, value), this;
+        };
+        Set2.prototype.delete = function(value) {
+          return this._map.delete(value);
+        };
+        Set2.prototype.clear = function() {
+          this._map.clear();
+        };
+        Set2.prototype.keys = function() {
+          return this._map.keys();
+        };
+        Set2.prototype.values = function() {
+          return this._map.values();
+        };
+        Set2.prototype.entries = function() {
+          return this._map.entries();
+        };
+        Set2.prototype["@@iterator"] = function() {
+          return this.keys();
+        };
+        Set2.prototype[iteratorSymbol] = function() {
+          return this.keys();
+        };
+        return Set2;
+      }();
+    }
+    function CreateWeakMapPolyfill() {
+      var UUID_SIZE = 16;
+      var keys = HashMap.create();
+      var rootKey = CreateUniqueKey();
+      return function() {
+        function WeakMap2() {
+          this._key = CreateUniqueKey();
+        }
+        WeakMap2.prototype.has = function(target) {
+          var table = GetOrCreateWeakMapTable(target, false);
+          return table !== undefined ? HashMap.has(table, this._key) : false;
+        };
+        WeakMap2.prototype.get = function(target) {
+          var table = GetOrCreateWeakMapTable(target, false);
+          return table !== undefined ? HashMap.get(table, this._key) : undefined;
+        };
+        WeakMap2.prototype.set = function(target, value) {
+          var table = GetOrCreateWeakMapTable(target, true);
+          table[this._key] = value;
+          return this;
+        };
+        WeakMap2.prototype.delete = function(target) {
+          var table = GetOrCreateWeakMapTable(target, false);
+          return table !== undefined ? delete table[this._key] : false;
+        };
+        WeakMap2.prototype.clear = function() {
+          this._key = CreateUniqueKey();
+        };
+        return WeakMap2;
+      }();
+      function CreateUniqueKey() {
+        var key;
+        do
+          key = "@@WeakMap@@" + CreateUUID();
+        while (HashMap.has(keys, key));
+        keys[key] = true;
+        return key;
+      }
+      function GetOrCreateWeakMapTable(target, create) {
+        if (!hasOwn.call(target, rootKey)) {
+          if (!create)
+            return;
+          Object.defineProperty(target, rootKey, { value: HashMap.create() });
+        }
+        return target[rootKey];
+      }
+      function FillRandomBytes(buffer, size) {
+        for (var i = 0;i < size; ++i)
+          buffer[i] = Math.random() * 255 | 0;
+        return buffer;
+      }
+      function GenRandomBytes(size) {
+        if (typeof Uint8Array === "function") {
+          if (typeof crypto !== "undefined")
+            return crypto.getRandomValues(new Uint8Array(size));
+          if (typeof msCrypto !== "undefined")
+            return msCrypto.getRandomValues(new Uint8Array(size));
+          return FillRandomBytes(new Uint8Array(size), size);
+        }
+        return FillRandomBytes(new Array(size), size);
+      }
+      function CreateUUID() {
+        var data = GenRandomBytes(UUID_SIZE);
+        data[6] = data[6] & 79 | 64;
+        data[8] = data[8] & 191 | 128;
+        var result = "";
+        for (var offset = 0;offset < UUID_SIZE; ++offset) {
+          var byte = data[offset];
+          if (offset === 4 || offset === 6 || offset === 8)
+            result += "-";
+          if (byte < 16)
+            result += "0";
+          result += byte.toString(16).toLowerCase();
+        }
+        return result;
+      }
+    }
+    function MakeDictionary(obj) {
+      obj.__ = undefined;
+      delete obj.__;
+      return obj;
+    }
+  });
+})(Reflect2 || (Reflect2 = {}));
+
+// src/typedi.ts
+var import_typedi = __toESM(require_cjs());
+var import_typedi2 = __toESM(require_cjs());
+function getInstance(service) {
+  return import_typedi.default.get(service);
+}