nesties 1.1.17 → 1.1.19

package/dist/index.cjs

@@ -1,7 +1,12 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -14,6 +19,14 @@ var __copyProps = (to, from2, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __decorateClass = (decorators, target, key, kind) => {
   var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
@@ -25,6 +38,1091 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
 
+// node_modules/reflect-metadata/Reflect.js
+var require_Reflect = __commonJS({
+  "node_modules/reflect-metadata/Reflect.js"() {
+    var Reflect2;
+    (function(Reflect3) {
+      (function(factory) {
+        var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
+        var exporter = makeExporter(Reflect3);
+        if (typeof root.Reflect !== "undefined") {
+          exporter = makeExporter(root.Reflect, exporter);
+        }
+        factory(exporter, root);
+        if (typeof root.Reflect === "undefined") {
+          root.Reflect = Reflect3;
+        }
+        function makeExporter(target, previous) {
+          return function(key, value) {
+            Object.defineProperty(target, key, { configurable: true, writable: true, value });
+            if (previous)
+              previous(key, value);
+          };
+        }
+        function functionThis() {
+          try {
+            return Function("return this;")();
+          } catch (_) {
+          }
+        }
+        function indirectEvalThis() {
+          try {
+            return (void 0, eval)("(function() { return this; })()");
+          } catch (_) {
+          }
+        }
+        function sloppyModeThis() {
+          return functionThis() || indirectEvalThis();
+        }
+      })(function(exporter, root) {
+        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 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 });
+          } : 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] : void 0;
+          } : function(map, key) {
+            return map[key];
+          }
+        };
+        var functionPrototype = Object.getPrototypeOf(Function);
+        var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
+        var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
+        var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
+        var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : void 0;
+        var metadataRegistry = GetOrCreateMetadataRegistry();
+        var metadataProvider = CreateMetadataProvider(metadataRegistry);
+        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;
+            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);
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey))
+            propertyKey = ToPropertyKey(propertyKey);
+          var provider = GetMetadataProvider(
+            target,
+            propertyKey,
+            /*Create*/
+            false
+          );
+          if (IsUndefined(provider))
+            return false;
+          return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
+        }
+        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 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 provider = GetMetadataProvider(
+            O,
+            P,
+            /*Create*/
+            false
+          );
+          if (IsUndefined(provider))
+            return false;
+          return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
+        }
+        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 void 0;
+        }
+        function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
+          var provider = GetMetadataProvider(
+            O,
+            P,
+            /*Create*/
+            false
+          );
+          if (IsUndefined(provider))
+            return;
+          return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
+        }
+        function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
+          var provider = GetMetadataProvider(
+            O,
+            P,
+            /*Create*/
+            true
+          );
+          provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
+        }
+        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 provider = GetMetadataProvider(
+            O,
+            P,
+            /*create*/
+            false
+          );
+          if (!provider) {
+            return [];
+          }
+          return provider.OrdinaryOwnMetadataKeys(O, P);
+        }
+        function Type3(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 === void 0;
+        }
+        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 (Type3(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 !== void 0) {
+            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
+            /* String */
+          );
+          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 (Type3(argument)) {
+            case 3:
+              return true;
+            case 4:
+              return true;
+            default:
+              return false;
+          }
+        }
+        function SameValueZero(x, y) {
+          return x === y || x !== x && y !== y;
+        }
+        function GetMethod(V, P) {
+          var func = V[P];
+          if (func === void 0 || func === null)
+            return void 0;
+          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 CreateMetadataRegistry() {
+          var fallback;
+          if (!IsUndefined(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") {
+            fallback = CreateFallbackProvider(root.Reflect);
+          }
+          var first;
+          var second;
+          var rest;
+          var targetProviderMap = new _WeakMap();
+          var registry = {
+            registerProvider,
+            getProvider,
+            setProvider
+          };
+          return registry;
+          function registerProvider(provider) {
+            if (!Object.isExtensible(registry)) {
+              throw new Error("Cannot add provider to a frozen registry.");
+            }
+            switch (true) {
+              case fallback === provider:
+                break;
+              case IsUndefined(first):
+                first = provider;
+                break;
+              case first === provider:
+                break;
+              case IsUndefined(second):
+                second = provider;
+                break;
+              case second === provider:
+                break;
+              default:
+                if (rest === void 0)
+                  rest = new _Set();
+                rest.add(provider);
+                break;
+            }
+          }
+          function getProviderNoCache(O, P) {
+            if (!IsUndefined(first)) {
+              if (first.isProviderFor(O, P))
+                return first;
+              if (!IsUndefined(second)) {
+                if (second.isProviderFor(O, P))
+                  return first;
+                if (!IsUndefined(rest)) {
+                  var iterator = GetIterator(rest);
+                  while (true) {
+                    var next = IteratorStep(iterator);
+                    if (!next) {
+                      return void 0;
+                    }
+                    var provider = IteratorValue(next);
+                    if (provider.isProviderFor(O, P)) {
+                      IteratorClose(iterator);
+                      return provider;
+                    }
+                  }
+                }
+              }
+            }
+            if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {
+              return fallback;
+            }
+            return void 0;
+          }
+          function getProvider(O, P) {
+            var providerMap = targetProviderMap.get(O);
+            var provider;
+            if (!IsUndefined(providerMap)) {
+              provider = providerMap.get(P);
+            }
+            if (!IsUndefined(provider)) {
+              return provider;
+            }
+            provider = getProviderNoCache(O, P);
+            if (!IsUndefined(provider)) {
+              if (IsUndefined(providerMap)) {
+                providerMap = new _Map();
+                targetProviderMap.set(O, providerMap);
+              }
+              providerMap.set(P, provider);
+            }
+            return provider;
+          }
+          function hasProvider(provider) {
+            if (IsUndefined(provider))
+              throw new TypeError();
+            return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
+          }
+          function setProvider(O, P, provider) {
+            if (!hasProvider(provider)) {
+              throw new Error("Metadata provider not registered.");
+            }
+            var existingProvider = getProvider(O, P);
+            if (existingProvider !== provider) {
+              if (!IsUndefined(existingProvider)) {
+                return false;
+              }
+              var providerMap = targetProviderMap.get(O);
+              if (IsUndefined(providerMap)) {
+                providerMap = new _Map();
+                targetProviderMap.set(O, providerMap);
+              }
+              providerMap.set(P, provider);
+            }
+            return true;
+          }
+        }
+        function GetOrCreateMetadataRegistry() {
+          var metadataRegistry2;
+          if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+            metadataRegistry2 = root.Reflect[registrySymbol];
+          }
+          if (IsUndefined(metadataRegistry2)) {
+            metadataRegistry2 = CreateMetadataRegistry();
+          }
+          if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+            Object.defineProperty(root.Reflect, registrySymbol, {
+              enumerable: false,
+              configurable: false,
+              writable: false,
+              value: metadataRegistry2
+            });
+          }
+          return metadataRegistry2;
+        }
+        function CreateMetadataProvider(registry) {
+          var metadata2 = new _WeakMap();
+          var provider = {
+            isProviderFor: function(O, P) {
+              var targetMetadata = metadata2.get(O);
+              if (IsUndefined(targetMetadata))
+                return false;
+              return targetMetadata.has(P);
+            },
+            OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata2,
+            OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata2,
+            OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata2,
+            OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys2,
+            OrdinaryDeleteMetadata
+          };
+          metadataRegistry.registerProvider(provider);
+          return provider;
+          function GetOrCreateMetadataMap(O, P, Create) {
+            var targetMetadata = metadata2.get(O);
+            var createdTargetMetadata = false;
+            if (IsUndefined(targetMetadata)) {
+              if (!Create)
+                return void 0;
+              targetMetadata = new _Map();
+              metadata2.set(O, targetMetadata);
+              createdTargetMetadata = true;
+            }
+            var metadataMap = targetMetadata.get(P);
+            if (IsUndefined(metadataMap)) {
+              if (!Create)
+                return void 0;
+              metadataMap = new _Map();
+              targetMetadata.set(P, metadataMap);
+              if (!registry.setProvider(O, P, provider)) {
+                targetMetadata.delete(P);
+                if (createdTargetMetadata) {
+                  metadata2.delete(O);
+                }
+                throw new Error("Wrong provider for target.");
+              }
+            }
+            return metadataMap;
+          }
+          function OrdinaryHasOwnMetadata2(MetadataKey, O, P) {
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(metadataMap))
+              return false;
+            return ToBoolean(metadataMap.has(MetadataKey));
+          }
+          function OrdinaryGetOwnMetadata2(MetadataKey, O, P) {
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(metadataMap))
+              return void 0;
+            return metadataMap.get(MetadataKey);
+          }
+          function OrdinaryDefineOwnMetadata2(MetadataKey, MetadataValue, O, P) {
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              true
+            );
+            metadataMap.set(MetadataKey, MetadataValue);
+          }
+          function OrdinaryOwnMetadataKeys2(O, P) {
+            var keys = [];
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              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 OrdinaryDeleteMetadata(MetadataKey, O, P) {
+            var metadataMap = GetOrCreateMetadataMap(
+              O,
+              P,
+              /*Create*/
+              false
+            );
+            if (IsUndefined(metadataMap))
+              return false;
+            if (!metadataMap.delete(MetadataKey))
+              return false;
+            if (metadataMap.size === 0) {
+              var targetMetadata = metadata2.get(O);
+              if (!IsUndefined(targetMetadata)) {
+                targetMetadata.delete(P);
+                if (targetMetadata.size === 0) {
+                  metadata2.delete(targetMetadata);
+                }
+              }
+            }
+            return true;
+          }
+        }
+        function CreateFallbackProvider(reflect) {
+          var defineMetadata2 = reflect.defineMetadata, hasOwnMetadata2 = reflect.hasOwnMetadata, getOwnMetadata2 = reflect.getOwnMetadata, getOwnMetadataKeys2 = reflect.getOwnMetadataKeys, deleteMetadata2 = reflect.deleteMetadata;
+          var metadataOwner = new _WeakMap();
+          var provider = {
+            isProviderFor: function(O, P) {
+              var metadataPropertySet = metadataOwner.get(O);
+              if (!IsUndefined(metadataPropertySet) && metadataPropertySet.has(P)) {
+                return true;
+              }
+              if (getOwnMetadataKeys2(O, P).length) {
+                if (IsUndefined(metadataPropertySet)) {
+                  metadataPropertySet = new _Set();
+                  metadataOwner.set(O, metadataPropertySet);
+                }
+                metadataPropertySet.add(P);
+                return true;
+              }
+              return false;
+            },
+            OrdinaryDefineOwnMetadata: defineMetadata2,
+            OrdinaryHasOwnMetadata: hasOwnMetadata2,
+            OrdinaryGetOwnMetadata: getOwnMetadata2,
+            OrdinaryOwnMetadataKeys: getOwnMetadataKeys2,
+            OrdinaryDeleteMetadata: deleteMetadata2
+          };
+          return provider;
+        }
+        function GetMetadataProvider(O, P, Create) {
+          var registeredProvider = metadataRegistry.getProvider(O, P);
+          if (!IsUndefined(registeredProvider)) {
+            return registeredProvider;
+          }
+          if (Create) {
+            if (metadataRegistry.setProvider(O, P, metadataProvider)) {
+              return metadataProvider;
+            }
+            throw new Error("Illegal state.");
+          }
+          return void 0;
+        }
+        function CreateMapPolyfill() {
+          var cacheSentinel = {};
+          var arraySentinel = [];
+          var MapIterator = (
+            /** @class */
+            (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: void 0, 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;
+            })()
+          );
+          var Map2 = (
+            /** @class */
+            (function() {
+              function Map3() {
+                this._keys = [];
+                this._values = [];
+                this._cacheKey = cacheSentinel;
+                this._cacheIndex = -2;
+              }
+              Object.defineProperty(Map3.prototype, "size", {
+                get: function() {
+                  return this._keys.length;
+                },
+                enumerable: true,
+                configurable: true
+              });
+              Map3.prototype.has = function(key) {
+                return this._find(
+                  key,
+                  /*insert*/
+                  false
+                ) >= 0;
+              };
+              Map3.prototype.get = function(key) {
+                var index = this._find(
+                  key,
+                  /*insert*/
+                  false
+                );
+                return index >= 0 ? this._values[index] : void 0;
+              };
+              Map3.prototype.set = function(key, value) {
+                var index = this._find(
+                  key,
+                  /*insert*/
+                  true
+                );
+                this._values[index] = value;
+                return this;
+              };
+              Map3.prototype.delete = function(key) {
+                var index = this._find(
+                  key,
+                  /*insert*/
+                  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 (SameValueZero(key, this._cacheKey)) {
+                    this._cacheKey = cacheSentinel;
+                    this._cacheIndex = -2;
+                  }
+                  return true;
+                }
+                return false;
+              };
+              Map3.prototype.clear = function() {
+                this._keys.length = 0;
+                this._values.length = 0;
+                this._cacheKey = cacheSentinel;
+                this._cacheIndex = -2;
+              };
+              Map3.prototype.keys = function() {
+                return new MapIterator(this._keys, this._values, getKey);
+              };
+              Map3.prototype.values = function() {
+                return new MapIterator(this._keys, this._values, getValue);
+              };
+              Map3.prototype.entries = function() {
+                return new MapIterator(this._keys, this._values, getEntry);
+              };
+              Map3.prototype["@@iterator"] = function() {
+                return this.entries();
+              };
+              Map3.prototype[iteratorSymbol] = function() {
+                return this.entries();
+              };
+              Map3.prototype._find = function(key, insert) {
+                if (!SameValueZero(this._cacheKey, key)) {
+                  this._cacheIndex = -1;
+                  for (var i = 0; i < this._keys.length; i++) {
+                    if (SameValueZero(this._keys[i], key)) {
+                      this._cacheIndex = i;
+                      break;
+                    }
+                  }
+                }
+                if (this._cacheIndex < 0 && insert) {
+                  this._cacheIndex = this._keys.length;
+                  this._keys.push(key);
+                  this._values.push(void 0);
+                }
+                return this._cacheIndex;
+              };
+              return Map3;
+            })()
+          );
+          return Map2;
+          function getKey(key, _) {
+            return key;
+          }
+          function getValue(_, value) {
+            return value;
+          }
+          function getEntry(key, value) {
+            return [key, value];
+          }
+        }
+        function CreateSetPolyfill() {
+          var Set2 = (
+            /** @class */
+            (function() {
+              function Set3() {
+                this._map = new _Map();
+              }
+              Object.defineProperty(Set3.prototype, "size", {
+                get: function() {
+                  return this._map.size;
+                },
+                enumerable: true,
+                configurable: true
+              });
+              Set3.prototype.has = function(value) {
+                return this._map.has(value);
+              };
+              Set3.prototype.add = function(value) {
+                return this._map.set(value, value), this;
+              };
+              Set3.prototype.delete = function(value) {
+                return this._map.delete(value);
+              };
+              Set3.prototype.clear = function() {
+                this._map.clear();
+              };
+              Set3.prototype.keys = function() {
+                return this._map.keys();
+              };
+              Set3.prototype.values = function() {
+                return this._map.keys();
+              };
+              Set3.prototype.entries = function() {
+                return this._map.entries();
+              };
+              Set3.prototype["@@iterator"] = function() {
+                return this.keys();
+              };
+              Set3.prototype[iteratorSymbol] = function() {
+                return this.keys();
+              };
+              return Set3;
+            })()
+          );
+          return Set2;
+        }
+        function CreateWeakMapPolyfill() {
+          var UUID_SIZE = 16;
+          var keys = HashMap.create();
+          var rootKey = CreateUniqueKey();
+          return (
+            /** @class */
+            (function() {
+              function WeakMap2() {
+                this._key = CreateUniqueKey();
+              }
+              WeakMap2.prototype.has = function(target) {
+                var table = GetOrCreateWeakMapTable(
+                  target,
+                  /*create*/
+                  false
+                );
+                return table !== void 0 ? HashMap.has(table, this._key) : false;
+              };
+              WeakMap2.prototype.get = function(target) {
+                var table = GetOrCreateWeakMapTable(
+                  target,
+                  /*create*/
+                  false
+                );
+                return table !== void 0 ? HashMap.get(table, this._key) : void 0;
+              };
+              WeakMap2.prototype.set = function(target, value) {
+                var table = GetOrCreateWeakMapTable(
+                  target,
+                  /*create*/
+                  true
+                );
+                table[this._key] = value;
+                return this;
+              };
+              WeakMap2.prototype.delete = function(target) {
+                var table = GetOrCreateWeakMapTable(
+                  target,
+                  /*create*/
+                  false
+                );
+                return table !== void 0 ? 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 void 0;
+              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") {
+              var array = new Uint8Array(size);
+              if (typeof crypto !== "undefined") {
+                crypto.getRandomValues(array);
+              } else if (typeof msCrypto !== "undefined") {
+                msCrypto.getRandomValues(array);
+              } else {
+                FillRandomBytes(array, size);
+              }
+              return array;
+            }
+            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.__ = void 0;
+          delete obj.__;
+          return obj;
+        }
+      });
+    })(Reflect2 || (Reflect2 = {}));
+  }
+});
+
 // index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -72,6 +1170,7 @@ __export(index_exports, {
   createAbortableProvider: () => createAbortableProvider,
   createI18n: () => createI18n,
   createI18nDecorator: () => createI18nDecorator,
+  createMutateInject: () => createMutateInject,
   createProvider: () => createProvider,
   createResolver: () => createResolver,
   fromAbortable: () => fromAbortable,
@@ -112,6 +1211,34 @@ var getApiProperty = (cls, key) => {
   return {};
 };
 
+// src/utility/create-mutate-inject.ts
+var import_reflect_metadata = __toESM(require_Reflect());
+var import_common = require("@nestjs/common");
+var createMutateInject = (tokenResolver) => (token) => (target, propertyKey, parameterIndex) => {
+  const cls = typeof target === "function" ? target : target.constructor;
+  let actualToken = token;
+  if (!actualToken) {
+    if (parameterIndex != null) {
+      const paramTypes = propertyKey == null ? Reflect.getMetadata("design:paramtypes", target) || [] : Reflect.getMetadata("design:paramtypes", target, propertyKey) || [];
+      actualToken = paramTypes[parameterIndex];
+    } else {
+      actualToken = Reflect.getMetadata("design:type", target, propertyKey);
+    }
+    if (!actualToken) {
+      const where = parameterIndex != null ? `${String(propertyKey ?? "constructor")}[${parameterIndex}]` : String(propertyKey);
+      throw new Error(
+        `Cannot infer type from metadata: ${cls?.name ?? "UnknownClass"}.${where}`
+      );
+    }
+  }
+  const pos = parameterIndex != null ? { type: "param", index: parameterIndex } : { type: "property", propertyKey };
+  (0, import_common.Inject)(tokenResolver(actualToken, cls, pos))(
+    target,
+    propertyKey,
+    parameterIndex
+  );
+};
+
 // src/insert-field.ts
 function InsertField(cl, map, newName) {
   const extendedCl = class extends cl {
@@ -170,7 +1297,7 @@ function MergeClassOrMethodDecorators(decs) {
 
 // src/return-message.ts
 var import_swagger2 = require("@nestjs/swagger");
-var import_common = require("@nestjs/common");
+var import_common2 = require("@nestjs/common");
 var BlankReturnMessageDto = class {
   constructor(statusCode, message) {
     this.statusCode = statusCode;
@@ -179,7 +1306,7 @@ var BlankReturnMessageDto = class {
     this.timestamp = /* @__PURE__ */ new Date();
   }
   toException() {
-    return new import_common.HttpException(this, this.statusCode);
+    return new import_common2.HttpException(this, this.statusCode);
   }
 };
 __decorateClass([
@@ -282,33 +1409,42 @@ var ApiErrorTyped = (status, description, type) => ApiTypeResponse(type, {
 });
 
 // src/pipe.ts
-var import_common2 = require("@nestjs/common");
-var DataPipe = () => new import_common2.ValidationPipe({
+var import_common3 = require("@nestjs/common");
+var DataPipe = () => new import_common3.ValidationPipe({
   transform: true,
   transformOptions: { enableImplicitConversion: true }
 });
 var createDataPipeDec = (nestFieldDec) => (...extraPipes) => nestFieldDec(DataPipe(), ...extraPipes);
-var DataQuery = createDataPipeDec(import_common2.Query);
-var DataBody = createDataPipeDec(import_common2.Body);
+var DataQuery = createDataPipeDec(import_common3.Query);
+var DataBody = createDataPipeDec(import_common3.Body);
 
 // src/token.guard.ts
-var import_common4 = require("@nestjs/common");
+var import_common5 = require("@nestjs/common");
 var import_config = require("@nestjs/config");
 var import_swagger5 = require("@nestjs/swagger");
 
 // src/resolver.ts
-var import_common3 = require("@nestjs/common");
+var import_common4 = require("@nestjs/common");
 var import_core = require("@nestjs/core");
 var import_swagger4 = require("@nestjs/swagger");
 
+// src/utility/injection-token-map.ts
+var InjectionTokenMap = /* @__PURE__ */ new Map();
+
 // src/create-provider.ts
 var createProvider = (options, factory) => {
+  if (options.inject) {
+    InjectionTokenMap.set(options.provide, options.inject);
+  }
   return {
     useFactory: factory,
     ...options
   };
 };
 
+// src/utility/resolver-swagger-map.ts
+var ResolverSwaggerMap = /* @__PURE__ */ new Map();
+
 // src/resolver.ts
 var ParamResolverCopiedFieldsFromSwagger = [
   "required",
@@ -369,16 +1505,22 @@ var ParamResolverPipe = class {
   }
 };
 ParamResolverPipe = __decorateClass([
-  (0, import_common3.Injectable)(),
-  __decorateParam(0, (0, import_common3.Inject)(import_core.ModuleRef))
+  (0, import_common4.Injectable)(),
+  __decorateParam(0, (0, import_common4.Inject)(import_core.ModuleRef))
 ], ParamResolverPipe);
 var usedParamResolverTokens = /* @__PURE__ */ new Set();
 var ParamResolverBase = class {
+  toApiPropertyDecorator(extras = {}) {
+    const swaggerInfo = this.toSwaggerInfo();
+    return (extras2 = {}) => MergeClassOrMethodDecorators(
+      swaggerInfo.map((info) => info.swagger({ ...extras, ...extras2 }))
+    );
+  }
   toResolverFunction() {
     return async (req, ref) => this.resolve(req, ref);
   }
   toParamDecorator() {
-    const dec = (0, import_common3.createParamDecorator)((_, ctx) => {
+    const dec = (0, import_common4.createParamDecorator)((_, ctx) => {
       const req = ctx.switchToHttp().getRequest();
       return { req, resolver: this };
     });
@@ -393,24 +1535,26 @@ var ParamResolverBase = class {
     let useToken = token;
     if (usedParamResolverTokens.has(token)) {
       let suffix = 0;
-      const tryToken = `${token}__${suffix}`;
-      while (usedParamResolverTokens.has(tryToken)) {
+      while (usedParamResolverTokens.has(`${token}__${suffix}`)) {
         suffix++;
       }
-      useToken = tryToken;
+      useToken = `${token}__${suffix}`;
     }
+    usedParamResolverTokens.add(useToken);
     const provider = createProvider(
       {
         provide: useToken,
         inject: [import_core.REQUEST, import_core.ModuleRef],
-        scope: import_common3.Scope.REQUEST
+        scope: import_common4.Scope.REQUEST
       },
       this.toResolverFunction()
     );
+    const swaggerInfos = this.toSwaggerInfo();
+    ResolverSwaggerMap.set(useToken, swaggerInfos);
     return {
       token: useToken,
       provider,
-      inject: () => (0, import_common3.Inject)(useToken)
+      inject: () => (0, import_common4.Inject)(useToken)
     };
   }
 };
@@ -447,8 +1591,8 @@ var ParamResolver = class extends ParamResolverBase {
     const suffix = this.info ? `${this.info.paramType.toUpperCase()}_${this.info.paramName}` : `DYNAMIC`;
     return `ParamResolver_${suffix}`;
   }
-  toApiPropertyDecorator(extras = {}) {
-    return (extras2 = {}) => {
+  toSwaggerInfo() {
+    const swagger = (extras2 = {}) => {
       if (this.info) {
         const paramType = this.info.paramType;
         const apiOptions = {
@@ -460,7 +1604,6 @@ var ParamResolver = class extends ParamResolverBase {
             return acc;
           }, {}),
           ...this.info.openapiExtras || {},
-          ...extras,
           ...extras2
         };
         return paramType === "header" ? (0, import_swagger4.ApiHeader)(apiOptions) : paramType === "query" ? (0, import_swagger4.ApiQuery)({ type: "string", ...apiOptions }) : () => {
@@ -469,6 +1612,12 @@ var ParamResolver = class extends ParamResolverBase {
       return () => {
       };
     };
+    return [
+      {
+        swagger,
+        token: this.toString()
+      }
+    ];
   }
 };
 var CombinedParamResolver = class extends ParamResolverBase {
@@ -492,17 +1641,9 @@ var CombinedParamResolver = class extends ParamResolverBase {
     const suffix = Object.entries(this.resolvers).map(([key, resolver]) => `${key.toString()}_${resolver.toString()}`).join("__");
     return `CombinedParamResolver_${suffix}`;
   }
-  toApiPropertyDecorator(extras = {}) {
-    const decs = Object.values(this.resolvers).map(
-      (resolver) => resolver.toApiPropertyDecorator(extras)
-    );
-    return (extras2) => MergeClassOrMethodDecorators(
-      decs.map(
-        (dec) => dec({
-          ...extras,
-          ...extras2
-        })
-      )
+  toSwaggerInfo() {
+    return Object.values(this.resolvers).flatMap(
+      (resolver) => resolver.toSwaggerInfo()
     );
   }
 };
@@ -562,9 +1703,9 @@ var TokenGuard = class {
   }
 };
 TokenGuard = __decorateClass([
-  (0, import_common4.Injectable)(),
-  __decorateParam(0, (0, import_common4.Inject)(import_config.ConfigService)),
-  __decorateParam(1, (0, import_common4.Inject)(import_core2.ModuleRef))
+  (0, import_common5.Injectable)(),
+  __decorateParam(0, (0, import_common5.Inject)(import_config.ConfigService)),
+  __decorateParam(1, (0, import_common5.Inject)(import_core2.ModuleRef))
 ], TokenGuard);
 var RequireToken = (options = {}) => {
   const swaggerDec = options.resolver ? ApiFromResolver(options.resolver, {
@@ -576,7 +1717,7 @@ var RequireToken = (options = {}) => {
     required: false
   });
   return MergeClassOrMethodDecorators([
-    (0, import_common4.UseGuards)(TokenGuard),
+    (0, import_common5.UseGuards)(TokenGuard),
     swaggerDec,
     ApiError(
       options.errorCode || defaultErrorCode,
@@ -588,7 +1729,7 @@ var RequireToken = (options = {}) => {
 
 // src/abort-utils.ts
 var import_rxjs = require("rxjs");
-var import_common5 = require("@nestjs/common");
+var import_common6 = require("@nestjs/common");
 
 // src/utility/abort-http-signal.ts
 function toRawReq(req) {
@@ -654,7 +1795,7 @@ var takeUntilAbort = (signal) => {
     );
   };
 };
-var As = (0, import_common5.createParamDecorator)(
+var As = (0, import_common6.createParamDecorator)(
   (_data, ctx) => {
     const req = ctx.switchToHttp().getRequest();
     return createAbortSignalFromHttp(req);
@@ -662,11 +1803,11 @@ var As = (0, import_common5.createParamDecorator)(
 );
 
 // src/abortable-module/abortable.token.ts
-var import_common7 = require("@nestjs/common");
+var import_common8 = require("@nestjs/common");
 var import_nfkit = require("nfkit");
 
 // src/abortable-module/abort-signal.provider.ts
-var import_common6 = require("@nestjs/common");
+var import_common7 = require("@nestjs/common");
 var import_core3 = require("@nestjs/core");
 var ABORT_SIGNAL = Symbol(
   "ABORT_SIGNAL"
@@ -674,12 +1815,12 @@ var ABORT_SIGNAL = Symbol(
 var AbortSignalProvider = createProvider(
   {
     provide: ABORT_SIGNAL,
-    scope: import_common6.Scope.REQUEST,
+    scope: import_common7.Scope.REQUEST,
     inject: [import_core3.REQUEST]
   },
   createAbortSignalFromHttp
 );
-var InjectAbortSignal = () => (0, import_common6.Inject)(ABORT_SIGNAL);
+var InjectAbortSignal = () => (0, import_common7.Inject)(ABORT_SIGNAL);
 
 // src/abortable-module/abortable.token.ts
 var import_core4 = require("@nestjs/core");
@@ -691,27 +1832,13 @@ var abortableToken = (token) => {
   tokenMemo.set(token, sym);
   return sym;
 };
-function InjectAbortable(token) {
-  return (target, propertyKey, parameterIndex) => {
-    let actualToken = token;
-    if (!actualToken) {
-      const paramTypes = Reflect.getMetadata("design:paramtypes", target, propertyKey) || [];
-      actualToken = paramTypes[parameterIndex];
-      if (!actualToken) {
-        throw new Error(
-          `@InjectAbortable() cannot infer type from metadata: ${target.constructor?.name}[${parameterIndex}]`
-        );
-      }
-    }
-    (0, import_common7.Inject)(abortableToken(actualToken))(target, propertyKey, parameterIndex);
-  };
-}
+var InjectAbortable = createMutateInject(abortableToken);
 function createAbortableProvider(token, opts) {
   const provide = abortableToken(token);
   return createProvider(
     {
       provide,
-      scope: import_common7.Scope.REQUEST,
+      scope: import_common8.Scope.REQUEST,
       inject: [import_core4.ModuleRef, import_core4.REQUEST, ABORT_SIGNAL]
     },
     async (moduleRef, req, signal) => {
@@ -730,7 +1857,7 @@ function createAbortableProvider(token, opts) {
 }
 
 // src/abortable-module/abortable.module.ts
-var import_common8 = require("@nestjs/common");
+var import_common9 = require("@nestjs/common");
 var AbortableModule = class {
   static forRoot() {
     return {
@@ -752,15 +1879,15 @@ var AbortableModule = class {
   }
 };
 AbortableModule = __decorateClass([
-  (0, import_common8.Module)({})
+  (0, import_common9.Module)({})
 ], AbortableModule);
 
 // src/i18n-module/i18n.service.ts
-var import_common10 = require("@nestjs/common");
+var import_common11 = require("@nestjs/common");
 
 // src/i18n-module/i18n-token.ts
-var import_common9 = require("@nestjs/common");
-var { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } = new import_common9.ConfigurableModuleBuilder().build();
+var import_common10 = require("@nestjs/common");
+var { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } = new import_common10.ConfigurableModuleBuilder().build();
 var I18nModuleOptionsToken = MODULE_OPTIONS_TOKEN;
 
 // src/i18n-module/i18n.service.ts
@@ -772,7 +1899,7 @@ var I18nService = class extends import_nfkit2.I18n {
     this.i18nServiceOptions = i18nServiceOptions;
     this.moduleRef = moduleRef;
     this._shadowMiddlewareMap = /* @__PURE__ */ new Map();
-    this.logger = new import_common10.ConsoleLogger("I18nService");
+    this.logger = new import_common11.ConsoleLogger("I18nService");
     this.resolver = createResolver(this.i18nServiceOptions.resolver);
   }
   middleware(mw, prior = false) {
@@ -780,7 +1907,7 @@ var I18nService = class extends import_nfkit2.I18n {
       try {
         return await mw(locale, text, next, ctx);
       } catch (e) {
-        if (e instanceof import_common10.HttpException) {
+        if (e instanceof import_common11.HttpException) {
           throw e;
         }
         this.logger.error(`Error in i18n middleware: ${e.message}`);
@@ -810,16 +1937,16 @@ var I18nService = class extends import_nfkit2.I18n {
   }
 };
 I18nService = __decorateClass([
-  (0, import_common10.Injectable)(),
-  __decorateParam(0, (0, import_common10.Inject)(I18nModuleOptionsToken)),
-  __decorateParam(1, (0, import_common10.Inject)(import_core5.ModuleRef))
+  (0, import_common11.Injectable)(),
+  __decorateParam(0, (0, import_common11.Inject)(I18nModuleOptionsToken)),
+  __decorateParam(1, (0, import_common11.Inject)(import_core5.ModuleRef))
 ], I18nService);
 
 // src/i18n-module/i18n.module.ts
-var import_common12 = require("@nestjs/common");
+var import_common13 = require("@nestjs/common");
 
 // src/i18n-module/locale.pipe.ts
-var import_common11 = require("@nestjs/common");
+var import_common12 = require("@nestjs/common");
 var import_core6 = require("@nestjs/core");
 var LocalePipe = class {
   constructor(i18nService, moduleRef) {
@@ -839,11 +1966,11 @@ var LocalePipe = class {
   }
 };
 LocalePipe = __decorateClass([
-  (0, import_common11.Injectable)(),
-  __decorateParam(0, (0, import_common11.Inject)(I18nService)),
-  __decorateParam(1, (0, import_common11.Inject)(import_core6.ModuleRef))
+  (0, import_common12.Injectable)(),
+  __decorateParam(0, (0, import_common12.Inject)(I18nService)),
+  __decorateParam(1, (0, import_common12.Inject)(import_core6.ModuleRef))
 ], LocalePipe);
-var _dec = (0, import_common11.createParamDecorator)(
+var _dec = (0, import_common12.createParamDecorator)(
   (resolver, ctx) => {
     return { ctx, resolver };
   }
@@ -854,18 +1981,18 @@ var PutLocale = (resolver) => _dec(resolver, LocalePipe);
 var I18nModule = class extends ConfigurableModuleClass {
 };
 I18nModule = __decorateClass([
-  (0, import_common12.Global)(),
-  (0, import_common12.Module)({
+  (0, import_common13.Global)(),
+  (0, import_common13.Module)({
     providers: [I18nService, LocalePipe],
     exports: [I18nService, LocalePipe]
   })
 ], I18nModule);
 
 // src/i18n-module/i18n-decorator.ts
-var import_common14 = require("@nestjs/common");
+var import_common15 = require("@nestjs/common");
 
 // src/i18n-module/i18n.interceptor.ts
-var import_common13 = require("@nestjs/common");
+var import_common14 = require("@nestjs/common");
 var import_rxjs2 = require("rxjs");
 var import_operators = require("rxjs/operators");
 var I18nInterceptor = class {
@@ -878,13 +2005,13 @@ var I18nInterceptor = class {
       (0, import_operators.mergeMap)((data) => this.i18nService.translateRequest(context, data)),
       // 错误路径：若是 HttpException，把其 response 翻译后再抛
       (0, import_operators.catchError)((err) => {
-        if (err instanceof import_common13.HttpException) {
+        if (err instanceof import_common14.HttpException) {
           const status = err.getStatus();
           const resp = err.getResponse();
           return (0, import_rxjs2.from)(this.i18nService.translateRequest(context, resp)).pipe(
             (0, import_operators.mergeMap)(
               (translated) => (0, import_rxjs2.throwError)(
-                () => new import_common13.HttpException(translated, status, { cause: err })
+                () => new import_common14.HttpException(translated, status, { cause: err })
               )
             )
           );
@@ -895,14 +2022,14 @@ var I18nInterceptor = class {
   }
 };
 I18nInterceptor = __decorateClass([
-  (0, import_common13.Injectable)(),
-  __decorateParam(0, (0, import_common13.Inject)(I18nService))
+  (0, import_common14.Injectable)(),
+  __decorateParam(0, (0, import_common14.Inject)(I18nService))
 ], I18nInterceptor);
 
 // src/i18n-module/i18n-decorator.ts
 var createI18nDecorator = (options) => {
   return () => MergeClassOrMethodDecorators([
-    (0, import_common14.UseInterceptors)(I18nInterceptor),
+    (0, import_common15.UseInterceptors)(I18nInterceptor),
     ApiFromResolver(options.resolver, {
       description: "Locale for internationalization",
       required: false,
@@ -975,6 +2102,7 @@ var I18nLookupMiddleware = (0, import_nfkit3.createI18nLookupMiddleware)();
   createAbortableProvider,
   createI18n,
   createI18nDecorator,
+  createMutateInject,
   createProvider,
   createResolver,
   fromAbortable,
@@ -983,4 +2111,22 @@ var I18nLookupMiddleware = (0, import_nfkit3.createI18nLookupMiddleware)();
   getParamResolver,
   takeUntilAbort
 });
+/*! Bundled license information:
+
+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.
+  ***************************************************************************** *)
+*/
 //# sourceMappingURL=index.cjs.map