@orion-js/services 4.0.0-next.2 → 4.0.0-next.3

package/dist/index.js

@@ -1,14 +1,11 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
 // node_modules/.pnpm/reflect-metadata@0.1.14/node_modules/reflect-metadata/Reflect.js
-var Reflect2;
-(function(Reflect3) {
+var Reflect;
+(function(Reflect2) {
   (function(factory) {
     var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : Function("return this;")();
-    var exporter = makeExporter(Reflect3);
+    var exporter = makeExporter(Reflect2);
     if (typeof root.Reflect === "undefined") {
-      root.Reflect = Reflect3;
+      root.Reflect = Reflect2;
     } else {
       exporter = makeExporter(root.Reflect, exporter);
     }
@@ -16,34 +13,26 @@ var Reflect2;
     function makeExporter(target, previous) {
       return function(key, value) {
         if (typeof target[key] !== "function") {
-          Object.defineProperty(target, key, {
-            configurable: true,
-            writable: true,
-            value
-          });
+          Object.defineProperty(target, key, { configurable: true, writable: true, value });
         }
-        if (previous) previous(key, value);
+        if (previous)
+          previous(key, value);
       };
     }
-    __name(makeExporter, "makeExporter");
   })(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 supportsProto = { __proto__: [] } instanceof Array;
     var downLevel = !supportsCreate && !supportsProto;
     var HashMap = {
       // create an object in dictionary mode (a.k.a. "slow" mode in v8)
       create: supportsCreate ? function() {
         return MakeDictionary(/* @__PURE__ */ Object.create(null));
       } : supportsProto ? function() {
-        return MakeDictionary({
-          __proto__: null
-        });
+        return MakeDictionary({ __proto__: null });
       } : function() {
         return MakeDictionary({});
       },
@@ -66,148 +55,167 @@ var Reflect2;
     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 = void 0;
+        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 = void 0;
         propertyKey = ToPropertyKey(propertyKey);
         return DecorateProperty(decorators, target, propertyKey, attributes);
       } else {
-        if (!IsArray(decorators)) throw new TypeError();
-        if (!IsConstructor(target)) throw new TypeError();
+        if (!IsArray(decorators))
+          throw new TypeError();
+        if (!IsConstructor(target))
+          throw new TypeError();
         return DecorateConstructor(decorators, target);
       }
     }
-    __name(decorate, "decorate");
     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();
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
+          throw new TypeError();
         OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
       }
-      __name(decorator, "decorator");
       return decorator;
     }
-    __name(metadata, "metadata");
     exporter("metadata", metadata);
     function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
-      if (!IsObject(target)) throw new TypeError();
-      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+      if (!IsObject(target))
+        throw new TypeError();
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
       return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
     }
-    __name(defineMetadata, "defineMetadata");
     exporter("defineMetadata", defineMetadata);
     function hasMetadata(metadataKey, target, propertyKey) {
-      if (!IsObject(target)) throw new TypeError();
-      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+      if (!IsObject(target))
+        throw new TypeError();
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
       return OrdinaryHasMetadata(metadataKey, target, propertyKey);
     }
-    __name(hasMetadata, "hasMetadata");
     exporter("hasMetadata", hasMetadata);
     function hasOwnMetadata(metadataKey, target, propertyKey) {
-      if (!IsObject(target)) throw new TypeError();
-      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+      if (!IsObject(target))
+        throw new TypeError();
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
       return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
     }
-    __name(hasOwnMetadata, "hasOwnMetadata");
     exporter("hasOwnMetadata", hasOwnMetadata);
     function getMetadata(metadataKey, target, propertyKey) {
-      if (!IsObject(target)) throw new TypeError();
-      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+      if (!IsObject(target))
+        throw new TypeError();
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
       return OrdinaryGetMetadata(metadataKey, target, propertyKey);
     }
-    __name(getMetadata, "getMetadata");
     exporter("getMetadata", getMetadata);
     function getOwnMetadata(metadataKey, target, propertyKey) {
-      if (!IsObject(target)) throw new TypeError();
-      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+      if (!IsObject(target))
+        throw new TypeError();
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
       return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
     }
-    __name(getOwnMetadata, "getOwnMetadata");
     exporter("getOwnMetadata", getOwnMetadata);
     function getMetadataKeys(target, propertyKey) {
-      if (!IsObject(target)) throw new TypeError();
-      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+      if (!IsObject(target))
+        throw new TypeError();
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
       return OrdinaryMetadataKeys(target, propertyKey);
     }
-    __name(getMetadataKeys, "getMetadataKeys");
     exporter("getMetadataKeys", getMetadataKeys);
     function getOwnMetadataKeys(target, propertyKey) {
-      if (!IsObject(target)) throw new TypeError();
-      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+      if (!IsObject(target))
+        throw new TypeError();
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
       return OrdinaryOwnMetadataKeys(target, propertyKey);
     }
-    __name(getOwnMetadataKeys, "getOwnMetadataKeys");
     exporter("getOwnMetadataKeys", getOwnMetadataKeys);
     function deleteMetadata(metadataKey, target, propertyKey) {
-      if (!IsObject(target)) throw new TypeError();
-      if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
+      if (!IsObject(target))
+        throw new TypeError();
+      if (!IsUndefined(propertyKey))
+        propertyKey = ToPropertyKey(propertyKey);
       var metadataMap = GetOrCreateMetadataMap(
         target,
         propertyKey,
         /*Create*/
         false
       );
-      if (IsUndefined(metadataMap)) return false;
-      if (!metadataMap.delete(metadataKey)) return false;
-      if (metadataMap.size > 0) return true;
+      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;
+      if (targetMetadata.size > 0)
+        return true;
       Metadata.delete(target);
       return true;
     }
-    __name(deleteMetadata, "deleteMetadata");
     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();
+          if (!IsConstructor(decorated))
+            throw new TypeError();
           target = decorated;
         }
       }
       return target;
     }
-    __name(DecorateConstructor, "DecorateConstructor");
     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();
+          if (!IsObject(decorated))
+            throw new TypeError();
           descriptor = decorated;
         }
       }
       return descriptor;
     }
-    __name(DecorateProperty, "DecorateProperty");
     function GetOrCreateMetadataMap(O, P, Create) {
       var targetMetadata = Metadata.get(O);
       if (IsUndefined(targetMetadata)) {
-        if (!Create) return void 0;
+        if (!Create)
+          return void 0;
         targetMetadata = new _Map();
         Metadata.set(O, targetMetadata);
       }
       var metadataMap = targetMetadata.get(P);
       if (IsUndefined(metadataMap)) {
-        if (!Create) return void 0;
+        if (!Create)
+          return void 0;
         metadataMap = new _Map();
         targetMetadata.set(P, metadataMap);
       }
       return metadataMap;
     }
-    __name(GetOrCreateMetadataMap, "GetOrCreateMetadataMap");
     function OrdinaryHasMetadata(MetadataKey, O, P) {
       var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
-      if (hasOwn2) return true;
+      if (hasOwn2)
+        return true;
       var parent = OrdinaryGetPrototypeOf(O);
-      if (!IsNull(parent)) return OrdinaryHasMetadata(MetadataKey, parent, P);
+      if (!IsNull(parent))
+        return OrdinaryHasMetadata(MetadataKey, parent, P);
       return false;
     }
-    __name(OrdinaryHasMetadata, "OrdinaryHasMetadata");
     function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
       var metadataMap = GetOrCreateMetadataMap(
         O,
@@ -215,18 +223,19 @@ var Reflect2;
         /*Create*/
         false
       );
-      if (IsUndefined(metadataMap)) return false;
+      if (IsUndefined(metadataMap))
+        return false;
       return ToBoolean(metadataMap.has(MetadataKey));
     }
-    __name(OrdinaryHasOwnMetadata, "OrdinaryHasOwnMetadata");
     function OrdinaryGetMetadata(MetadataKey, O, P) {
       var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
-      if (hasOwn2) return OrdinaryGetOwnMetadata(MetadataKey, O, P);
+      if (hasOwn2)
+        return OrdinaryGetOwnMetadata(MetadataKey, O, P);
       var parent = OrdinaryGetPrototypeOf(O);
-      if (!IsNull(parent)) return OrdinaryGetMetadata(MetadataKey, parent, P);
+      if (!IsNull(parent))
+        return OrdinaryGetMetadata(MetadataKey, parent, P);
       return void 0;
     }
-    __name(OrdinaryGetMetadata, "OrdinaryGetMetadata");
     function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
       var metadataMap = GetOrCreateMetadataMap(
         O,
@@ -234,10 +243,10 @@ var Reflect2;
         /*Create*/
         false
       );
-      if (IsUndefined(metadataMap)) return void 0;
+      if (IsUndefined(metadataMap))
+        return void 0;
       return metadataMap.get(MetadataKey);
     }
-    __name(OrdinaryGetOwnMetadata, "OrdinaryGetOwnMetadata");
     function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
       var metadataMap = GetOrCreateMetadataMap(
         O,
@@ -247,14 +256,16 @@ var Reflect2;
       );
       metadataMap.set(MetadataKey, MetadataValue);
     }
-    __name(OrdinaryDefineOwnMetadata, "OrdinaryDefineOwnMetadata");
     function OrdinaryMetadataKeys(O, P) {
       var ownKeys = OrdinaryOwnMetadataKeys(O, P);
       var parent = OrdinaryGetPrototypeOf(O);
-      if (parent === null) return ownKeys;
+      if (parent === null)
+        return ownKeys;
       var parentKeys = OrdinaryMetadataKeys(parent, P);
-      if (parentKeys.length <= 0) return ownKeys;
-      if (ownKeys.length <= 0) return parentKeys;
+      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++) {
@@ -275,7 +286,6 @@ var Reflect2;
       }
       return keys;
     }
-    __name(OrdinaryMetadataKeys, "OrdinaryMetadataKeys");
     function OrdinaryOwnMetadataKeys(O, P) {
       var keys = [];
       var metadataMap = GetOrCreateMetadataMap(
@@ -284,7 +294,8 @@ var Reflect2;
         /*Create*/
         false
       );
-      if (IsUndefined(metadataMap)) return keys;
+      if (IsUndefined(metadataMap))
+        return keys;
       var keysObj = metadataMap.keys();
       var iterator = GetIterator(keysObj);
       var k = 0;
@@ -307,9 +318,9 @@ var Reflect2;
         k++;
       }
     }
-    __name(OrdinaryOwnMetadataKeys, "OrdinaryOwnMetadataKeys");
     function Type(x) {
-      if (x === null) return 1;
+      if (x === null)
+        return 1;
       switch (typeof x) {
         case "undefined":
           return 0;
@@ -327,23 +338,18 @@ var Reflect2;
           return 6;
       }
     }
-    __name(Type, "Type");
     function IsUndefined(x) {
       return x === void 0;
     }
-    __name(IsUndefined, "IsUndefined");
     function IsNull(x) {
       return x === null;
     }
-    __name(IsNull, "IsNull");
     function IsSymbol(x) {
       return typeof x === "symbol";
     }
-    __name(IsSymbol, "IsSymbol");
     function IsObject(x) {
       return typeof x === "object" ? x !== null : typeof x === "function";
     }
-    __name(IsObject, "IsObject");
     function ToPrimitive(input, PreferredType) {
       switch (Type(input)) {
         case 0:
@@ -363,69 +369,67 @@ var Reflect2;
       var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
       if (exoticToPrim !== void 0) {
         var result = exoticToPrim.call(input, hint);
-        if (IsObject(result)) throw new TypeError();
+        if (IsObject(result))
+          throw new TypeError();
         return result;
       }
       return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
     }
-    __name(ToPrimitive, "ToPrimitive");
     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;
+          if (!IsObject(result))
+            return result;
         }
         var valueOf = O.valueOf;
         if (IsCallable(valueOf)) {
           var result = valueOf.call(O);
-          if (!IsObject(result)) return result;
+          if (!IsObject(result))
+            return result;
         }
       } else {
         var valueOf = O.valueOf;
         if (IsCallable(valueOf)) {
           var result = valueOf.call(O);
-          if (!IsObject(result)) return result;
+          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;
+          if (!IsObject(result))
+            return result;
         }
       }
       throw new TypeError();
     }
-    __name(OrdinaryToPrimitive, "OrdinaryToPrimitive");
     function ToBoolean(argument) {
       return !!argument;
     }
-    __name(ToBoolean, "ToBoolean");
     function ToString(argument) {
       return "" + argument;
     }
-    __name(ToString, "ToString");
     function ToPropertyKey(argument) {
       var key = ToPrimitive(
         argument,
         3
         /* String */
       );
-      if (IsSymbol(key)) return key;
+      if (IsSymbol(key))
+        return key;
       return ToString(key);
     }
-    __name(ToPropertyKey, "ToPropertyKey");
     function IsArray(argument) {
       return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
     }
-    __name(IsArray, "IsArray");
     function IsCallable(argument) {
       return typeof argument === "function";
     }
-    __name(IsCallable, "IsCallable");
     function IsConstructor(argument) {
       return typeof argument === "function";
     }
-    __name(IsConstructor, "IsConstructor");
     function IsPropertyKey(argument) {
       switch (Type(argument)) {
         case 3:
@@ -436,49 +440,52 @@ var Reflect2;
           return false;
       }
     }
-    __name(IsPropertyKey, "IsPropertyKey");
     function GetMethod(V, P) {
       var func = V[P];
-      if (func === void 0 || func === null) return void 0;
-      if (!IsCallable(func)) throw new TypeError();
+      if (func === void 0 || func === null)
+        return void 0;
+      if (!IsCallable(func))
+        throw new TypeError();
       return func;
     }
-    __name(GetMethod, "GetMethod");
     function GetIterator(obj) {
       var method = GetMethod(obj, iteratorSymbol);
-      if (!IsCallable(method)) throw new TypeError();
+      if (!IsCallable(method))
+        throw new TypeError();
       var iterator = method.call(obj);
-      if (!IsObject(iterator)) throw new TypeError();
+      if (!IsObject(iterator))
+        throw new TypeError();
       return iterator;
     }
-    __name(GetIterator, "GetIterator");
     function IteratorValue(iterResult) {
       return iterResult.value;
     }
-    __name(IteratorValue, "IteratorValue");
     function IteratorStep(iterator) {
       var result = iterator.next();
       return result.done ? false : result;
     }
-    __name(IteratorStep, "IteratorStep");
     function IteratorClose(iterator) {
       var f = iterator["return"];
-      if (f) f.call(iterator);
+      if (f)
+        f.call(iterator);
     }
-    __name(IteratorClose, "IteratorClose");
     function OrdinaryGetPrototypeOf(O) {
       var proto = Object.getPrototypeOf(O);
-      if (typeof O !== "function" || O === functionPrototype) return proto;
-      if (proto !== functionPrototype) return proto;
+      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;
+      if (prototypeProto == null || prototypeProto === Object.prototype)
+        return proto;
       var constructor = prototypeProto.constructor;
-      if (typeof constructor !== "function") return proto;
-      if (constructor === O) return proto;
+      if (typeof constructor !== "function")
+        return proto;
+      if (constructor === O)
+        return proto;
       return constructor;
     }
-    __name(OrdinaryGetPrototypeOf, "OrdinaryGetPrototypeOf");
     function CreateMapPolyfill() {
       var cacheSentinel = {};
       var arraySentinel = [];
@@ -491,7 +498,6 @@ var Reflect2;
             this._values = values;
             this._selector = selector;
           }
-          __name(MapIterator2, "MapIterator");
           MapIterator2.prototype["@@iterator"] = function() {
             return this;
           };
@@ -509,15 +515,9 @@ var Reflect2;
               } else {
                 this._index++;
               }
-              return {
-                value: result,
-                done: false
-              };
+              return { value: result, done: false };
             }
-            return {
-              value: void 0,
-              done: true
-            };
+            return { value: void 0, done: true };
           };
           MapIterator2.prototype.throw = function(error) {
             if (this._index >= 0) {
@@ -533,10 +533,7 @@ var Reflect2;
               this._keys = arraySentinel;
               this._values = arraySentinel;
             }
-            return {
-              value,
-              done: true
-            };
+            return { value, done: true };
           };
           return MapIterator2;
         }()
@@ -544,28 +541,27 @@ var Reflect2;
       return (
         /** @class */
         function() {
-          function Map1() {
+          function Map2() {
             this._keys = [];
             this._values = [];
             this._cacheKey = cacheSentinel;
             this._cacheIndex = -2;
           }
-          __name(Map1, "Map1");
-          Object.defineProperty(Map1.prototype, "size", {
-            get: /* @__PURE__ */ __name(function() {
+          Object.defineProperty(Map2.prototype, "size", {
+            get: function() {
               return this._keys.length;
-            }, "get"),
+            },
             enumerable: true,
             configurable: true
           });
-          Map1.prototype.has = function(key) {
+          Map2.prototype.has = function(key) {
             return this._find(
               key,
               /*insert*/
               false
             ) >= 0;
           };
-          Map1.prototype.get = function(key) {
+          Map2.prototype.get = function(key) {
             var index = this._find(
               key,
               /*insert*/
@@ -573,7 +569,7 @@ var Reflect2;
             );
             return index >= 0 ? this._values[index] : void 0;
           };
-          Map1.prototype.set = function(key, value) {
+          Map2.prototype.set = function(key, value) {
             var index = this._find(
               key,
               /*insert*/
@@ -582,7 +578,7 @@ var Reflect2;
             this._values[index] = value;
             return this;
           };
-          Map1.prototype.delete = function(key) {
+          Map2.prototype.delete = function(key) {
             var index = this._find(
               key,
               /*insert*/
@@ -604,28 +600,28 @@ var Reflect2;
             }
             return false;
           };
-          Map1.prototype.clear = function() {
+          Map2.prototype.clear = function() {
             this._keys.length = 0;
             this._values.length = 0;
             this._cacheKey = cacheSentinel;
             this._cacheIndex = -2;
           };
-          Map1.prototype.keys = function() {
+          Map2.prototype.keys = function() {
             return new MapIterator(this._keys, this._values, getKey);
           };
-          Map1.prototype.values = function() {
+          Map2.prototype.values = function() {
             return new MapIterator(this._keys, this._values, getValue);
           };
-          Map1.prototype.entries = function() {
+          Map2.prototype.entries = function() {
             return new MapIterator(this._keys, this._values, getEntry);
           };
-          Map1.prototype["@@iterator"] = function() {
+          Map2.prototype["@@iterator"] = function() {
             return this.entries();
           };
-          Map1.prototype[iteratorSymbol] = function() {
+          Map2.prototype[iteratorSymbol] = function() {
             return this.entries();
           };
-          Map1.prototype._find = function(key, insert) {
+          Map2.prototype._find = function(key, insert) {
             if (this._cacheKey !== key) {
               this._cacheIndex = this._keys.indexOf(this._cacheKey = key);
             }
@@ -636,73 +632,64 @@ var Reflect2;
             }
             return this._cacheIndex;
           };
-          return Map1;
+          return Map2;
         }()
       );
       function getKey(key, _) {
         return key;
       }
-      __name(getKey, "getKey");
       function getValue(_, value) {
         return value;
       }
-      __name(getValue, "getValue");
       function getEntry(key, value) {
-        return [
-          key,
-          value
-        ];
+        return [key, value];
       }
-      __name(getEntry, "getEntry");
     }
-    __name(CreateMapPolyfill, "CreateMapPolyfill");
     function CreateSetPolyfill() {
       return (
         /** @class */
         function() {
-          function Set1() {
+          function Set2() {
             this._map = new _Map();
           }
-          __name(Set1, "Set1");
-          Object.defineProperty(Set1.prototype, "size", {
-            get: /* @__PURE__ */ __name(function() {
+          Object.defineProperty(Set2.prototype, "size", {
+            get: function() {
               return this._map.size;
-            }, "get"),
+            },
             enumerable: true,
             configurable: true
           });
-          Set1.prototype.has = function(value) {
+          Set2.prototype.has = function(value) {
             return this._map.has(value);
           };
-          Set1.prototype.add = function(value) {
+          Set2.prototype.add = function(value) {
             return this._map.set(value, value), this;
           };
-          Set1.prototype.delete = function(value) {
+          Set2.prototype.delete = function(value) {
             return this._map.delete(value);
           };
-          Set1.prototype.clear = function() {
+          Set2.prototype.clear = function() {
             this._map.clear();
           };
-          Set1.prototype.keys = function() {
+          Set2.prototype.keys = function() {
             return this._map.keys();
           };
-          Set1.prototype.values = function() {
+          Set2.prototype.values = function() {
             return this._map.values();
           };
-          Set1.prototype.entries = function() {
+          Set2.prototype.entries = function() {
             return this._map.entries();
           };
-          Set1.prototype["@@iterator"] = function() {
+          Set2.prototype["@@iterator"] = function() {
             return this.keys();
           };
-          Set1.prototype[iteratorSymbol] = function() {
+          Set2.prototype[iteratorSymbol] = function() {
             return this.keys();
           };
-          return Set1;
+          return Set2;
         }()
       );
     }
-    __name(CreateSetPolyfill, "CreateSetPolyfill");
     function CreateWeakMapPolyfill() {
       var UUID_SIZE = 16;
       var keys = HashMap.create();
@@ -710,11 +697,10 @@ var Reflect2;
       return (
         /** @class */
         function() {
-          function WeakMap1() {
+          function WeakMap2() {
             this._key = CreateUniqueKey();
           }
-          __name(WeakMap1, "WeakMap1");
-          WeakMap1.prototype.has = function(target) {
+          WeakMap2.prototype.has = function(target) {
             var table = GetOrCreateWeakMapTable(
               target,
               /*create*/
@@ -722,7 +708,7 @@ var Reflect2;
             );
             return table !== void 0 ? HashMap.has(table, this._key) : false;
           };
-          WeakMap1.prototype.get = function(target) {
+          WeakMap2.prototype.get = function(target) {
             var table = GetOrCreateWeakMapTable(
               target,
               /*create*/
@@ -730,7 +716,7 @@ var Reflect2;
             );
             return table !== void 0 ? HashMap.get(table, this._key) : void 0;
           };
-          WeakMap1.prototype.set = function(target, value) {
+          WeakMap2.prototype.set = function(target, value) {
             var table = GetOrCreateWeakMapTable(
               target,
               /*create*/
@@ -739,7 +725,7 @@ var Reflect2;
             table[this._key] = value;
             return this;
           };
-          WeakMap1.prototype.delete = function(target) {
+          WeakMap2.prototype.delete = function(target) {
             var table = GetOrCreateWeakMapTable(
               target,
               /*create*/
@@ -747,10 +733,10 @@ var Reflect2;
             );
             return table !== void 0 ? delete table[this._key] : false;
           };
-          WeakMap1.prototype.clear = function() {
+          WeakMap2.prototype.clear = function() {
             this._key = CreateUniqueKey();
           };
-          return WeakMap1;
+          return WeakMap2;
         }()
       );
       function CreateUniqueKey() {
@@ -761,31 +747,29 @@ var Reflect2;
         keys[key] = true;
         return key;
       }
-      __name(CreateUniqueKey, "CreateUniqueKey");
       function GetOrCreateWeakMapTable(target, create) {
         if (!hasOwn.call(target, rootKey)) {
-          if (!create) return void 0;
-          Object.defineProperty(target, rootKey, {
-            value: HashMap.create()
-          });
+          if (!create)
+            return void 0;
+          Object.defineProperty(target, rootKey, { value: HashMap.create() });
         }
         return target[rootKey];
       }
-      __name(GetOrCreateWeakMapTable, "GetOrCreateWeakMapTable");
       function FillRandomBytes(buffer, size) {
-        for (var i = 0; i < size; ++i) buffer[i] = Math.random() * 255 | 0;
+        for (var i = 0; i < size; ++i)
+          buffer[i] = Math.random() * 255 | 0;
         return buffer;
       }
-      __name(FillRandomBytes, "FillRandomBytes");
       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));
+          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);
       }
-      __name(GenRandomBytes, "GenRandomBytes");
       function CreateUUID() {
         var data = GenRandomBytes(UUID_SIZE);
         data[6] = data[6] & 79 | 64;
@@ -793,23 +777,22 @@ var Reflect2;
         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";
+          if (offset === 4 || offset === 6 || offset === 8)
+            result += "-";
+          if (byte < 16)
+            result += "0";
           result += byte.toString(16).toLowerCase();
         }
         return result;
       }
-      __name(CreateUUID, "CreateUUID");
     }
-    __name(CreateWeakMapPolyfill, "CreateWeakMapPolyfill");
     function MakeDictionary(obj) {
       obj.__ = void 0;
       delete obj.__;
       return obj;
     }
-    __name(MakeDictionary, "MakeDictionary");
   });
-})(Reflect2 || (Reflect2 = {}));
+})(Reflect || (Reflect = {}));
 
 // src/typedi.ts
 import { Container } from "typedi";
@@ -817,7 +800,6 @@ import { Service, Inject, Container as Container2 } from "typedi";
 function getInstance(service) {
   return Container.get(service);
 }
-__name(getInstance, "getInstance");
 export {
   Container2 as Container,
   Inject,