nesties 1.1.22 → 1.1.24

package/dist/index.mjs

@@ -1,28 +1,5 @@
-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 __copyProps = (to, from2, except, desc) => {
-  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
-    for (let key of __getOwnPropNames(from2))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
-  }
-  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 __decorateClass = (decorators, target, key, kind) => {
   var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
@@ -33,1091 +10,6 @@ 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 = {}));
-  }
-});
-
 // src/insert-field.ts
 import { ApiProperty } from "@nestjs/swagger";
 
@@ -1149,7 +41,6 @@ var getApiProperty = (cls, key) => {
 };
 
 // src/utility/create-mutate-inject.ts
-var import_reflect_metadata = __toESM(require_Reflect());
 import { Inject } from "@nestjs/common";
 var createMutateInject = (tokenResolver) => (token) => (target, propertyKey, parameterIndex) => {
   const cls = typeof target === "function" ? target : target.constructor;
@@ -1176,6 +67,18 @@ var createMutateInject = (tokenResolver) => (token) => (target, propertyKey, par
   );
 };
 
+// src/utility/parse-bool.ts
+var parseBool = (value) => {
+  const trueValues = ["true", "1", "yes", "on", true, 1];
+  const falseValues = ["false", "0", "no", "off", false, 0];
+  if (trueValues.indexOf(value) !== -1) return true;
+  if (falseValues.indexOf(value) !== -1) return false;
+  if (!!value) {
+    return true;
+  }
+  return void 0;
+};
+
 // src/insert-field.ts
 function InsertField(cl, map, newName) {
   const extendedCl = class extends cl {
@@ -1368,7 +271,7 @@ import {
 import { ConfigService } from "@nestjs/config";
 import { ApiHeader as ApiHeader2 } from "@nestjs/swagger";
 
-// src/resolver.ts
+// src/resolver/resolver.ts
 import {
   createParamDecorator,
   Inject as Inject2,
@@ -1412,7 +315,7 @@ var uniqBy = (arr, fn) => {
   return result;
 };
 
-// src/resolver.ts
+// src/resolver/resolver.ts
 var ParamResolverCopiedFieldsFromSwagger = [
   "required",
   "description",
@@ -1675,6 +578,145 @@ var ApiFromResolver = (_options, extras = {}) => {
   return getParamResolver(_options).toApiPropertyDecorator(extras)();
 };
 
+// src/resolver/lambda.ts
+var createLambdaParamResolver = (cb) => (resolver) => new TransformParamResolver(resolver, cb);
+var ParseIntParamResolver = createLambdaParamResolver((s) => {
+  if (s == null) {
+    return s;
+  }
+  const res = parseInt(s, 10);
+  if (isNaN(res)) {
+    throw new BlankReturnMessageDto(
+      400,
+      "Invalid integer parameter"
+    ).toException();
+  }
+  return res;
+});
+var ParseFloatParamResolver = createLambdaParamResolver(
+  (s) => {
+    if (s == null) {
+      return s;
+    }
+    const res = parseFloat(s);
+    if (isNaN(res)) {
+      throw new BlankReturnMessageDto(
+        400,
+        "Invalid float parameter"
+      ).toException();
+    }
+    return res;
+  }
+);
+var ParseBoolParamResolver = createLambdaParamResolver(parseBool);
+var ParseDateParamResolver = createLambdaParamResolver(
+  (s) => {
+    if (s == null) {
+      return s;
+    }
+    const res = new Date(s);
+    if (isNaN(res.getTime())) {
+      throw new BlankReturnMessageDto(
+        400,
+        "Invalid date parameter"
+      ).toException();
+    }
+    return res;
+  }
+);
+var ParseBase64ParamResolver = createLambdaParamResolver(
+  (s) => {
+    if (s == null) {
+      return s;
+    }
+    const normalized = s.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized + "=".repeat((4 - normalized.length % 4) % 4);
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(padded)) {
+      throw new BlankReturnMessageDto(
+        400,
+        "Invalid base64 parameter"
+      ).toException();
+    }
+    const buf = Buffer.from(padded, "base64");
+    const re = buf.toString("base64").replace(/=+$/g, "");
+    const in0 = padded.replace(/=+$/g, "");
+    if (re !== in0) {
+      throw new BlankReturnMessageDto(
+        400,
+        "Invalid base64 parameter"
+      ).toException();
+    }
+    return buf;
+  }
+);
+var DefaultValueParamResolver = (r, defaultValue) => createLambdaParamResolver(
+  (value) => value === void 0 || value === null ? defaultValue : value
+)(r);
+
+// src/utility/collect-info-from-injection-token.ts
+import {
+  PARAMTYPES_METADATA,
+  SELF_DECLARED_DEPS_METADATA
+} from "@nestjs/common/constants";
+function asArray(v) {
+  if (v == null) return [];
+  return Array.isArray(v) ? v : [v];
+}
+function getCtorDepsFromClass(cls) {
+  const paramTypes = Reflect.getMetadata(PARAMTYPES_METADATA, cls) ?? [];
+  const selfDeclared = Reflect.getMetadata(SELF_DECLARED_DEPS_METADATA, cls) ?? [];
+  const overrides = new Map(
+    selfDeclared.map((d) => [d.index, d.param])
+  );
+  return paramTypes.map((t, i) => overrides.get(i) ?? t).filter((t) => t != null && t !== Object);
+}
+var collectInfoFromInjectionToken = (map, token) => {
+  const visited = /* @__PURE__ */ new Set();
+  const out = /* @__PURE__ */ new Set();
+  const dfs = (t) => {
+    if (t == null) return;
+    if (visited.has(t)) return;
+    visited.add(t);
+    for (const v of asArray(map.get(t))) {
+      out.add(v);
+    }
+    const deps = InjectionTokenMap.get(t);
+    if (deps?.length) {
+      for (const d of deps) dfs(d);
+    }
+    if (typeof t === "function") {
+      const ctorDeps = getCtorDepsFromClass(t);
+      for (const d of ctorDeps) dfs(d);
+    }
+  };
+  dfs(token);
+  return Array.from(out);
+};
+var createCollectorFromInjectionToken = (map) => (token) => collectInfoFromInjectionToken(map, token);
+
+// src/utility/swagger-injection-collector.ts
+var swaggerInjectionCollector = createCollectorFromInjectionToken(ResolverSwaggerMap);
+
+// src/resolver/api-inject.ts
+var clsUsedMap = /* @__PURE__ */ new WeakMap();
+var ApiInject = createMutateInject((token, cls) => {
+  const swaggers = swaggerInjectionCollector(token);
+  if (!swaggers.length) return token;
+  let usedSet = clsUsedMap.get(cls);
+  if (!usedSet) {
+    usedSet = /* @__PURE__ */ new Set();
+    clsUsedMap.set(cls, usedSet);
+  }
+  for (const swagger of swaggers) {
+    if (usedSet.has(swagger.token)) {
+      continue;
+    }
+    usedSet.add(swagger.token);
+    swagger.swagger()(cls);
+  }
+  return token;
+});
+
 // src/token.guard.ts
 import { MetadataSetter, Reflector } from "typed-reflector";
 import { ModuleRef as ModuleRef2 } from "@nestjs/core";
@@ -1913,14 +955,20 @@ var I18nModuleOptionsToken = MODULE_OPTIONS_TOKEN;
 // src/i18n-module/i18n.service.ts
 import { ModuleRef as ModuleRef4 } from "@nestjs/core";
 import { I18n } from "nfkit";
+
+// src/i18n-module/i18n-param-resolver.token.ts
+var I18nParamResolverToken = "I18N_PARAM_RESOLVER";
+var I18nParamResolverProviderToken = "I18N_PARAM_RESOLVER_PROVIDER";
+
+// src/i18n-module/i18n.service.ts
 var I18nService = class extends I18n {
-  constructor(i18nServiceOptions, moduleRef) {
+  constructor(i18nServiceOptions, moduleRef, resolver) {
     super(i18nServiceOptions);
     this.i18nServiceOptions = i18nServiceOptions;
     this.moduleRef = moduleRef;
+    this.resolver = resolver;
     this._shadowMiddlewareMap = /* @__PURE__ */ new Map();
     this.logger = new ConsoleLogger("I18nService");
-    this.resolver = createResolver(this.i18nServiceOptions.resolver);
   }
   middleware(mw, prior = false) {
     const wrappedMw = async (locale, text, next, ctx) => {
@@ -1947,19 +995,20 @@ var I18nService = class extends I18n {
   }
   async getExactLocaleFromRequest(ctx) {
     const req = ctx.switchToHttp().getRequest();
-    const locale = await this.resolver(req, this.moduleRef);
+    const locale = await this.resolver.resolve(req, this.moduleRef);
     return this.getExactLocale(locale);
   }
   async translateRequest(ctx, obj) {
     const req = ctx.switchToHttp().getRequest();
-    const locale = await this.resolver(req, this.moduleRef);
+    const locale = await this.resolver.resolve(req, this.moduleRef);
     return this.translate(locale, obj, ctx);
   }
 };
 I18nService = __decorateClass([
   Injectable3(),
   __decorateParam(0, Inject6(I18nModuleOptionsToken)),
-  __decorateParam(1, Inject6(ModuleRef4))
+  __decorateParam(1, Inject6(ModuleRef4)),
+  __decorateParam(2, Inject6(I18nParamResolverToken))
 ], I18nService);
 
 // src/i18n-module/i18n.module.ts
@@ -2002,12 +1051,26 @@ var _dec = createParamDecorator3(
 var PutLocale = (resolver) => _dec(resolver, LocalePipe);
 
 // src/i18n-module/i18n.module.ts
+var providerFromOptions = createProvider(
+  {
+    provide: I18nParamResolverToken,
+    inject: [I18nModuleOptionsToken]
+  },
+  (options) => getParamResolver(
+    options.resolver || {
+      paramType: "header",
+      paramName: "x-client-language"
+    }
+  )
+);
 var I18nModule = class extends ConfigurableModuleClass {
+  static forRoot(options) {
+  }
 };
 I18nModule = __decorateClass([
   Global(),
   Module2({
-    providers: [I18nService, LocalePipe],
+    providers: [I18nService, LocalePipe, providerFromOptions],
     exports: [I18nService, LocalePipe]
   })
 ], I18nModule);
@@ -2067,6 +1130,24 @@ var createI18nDecorator = (options) => {
   ]);
 };
 
+// src/i18n-module/locale.context.ts
+import { Inject as Inject9, Injectable as Injectable6, Scope as Scope4 } from "@nestjs/common";
+var LocaleContext = class {
+  constructor(localeInput, i18nService) {
+    this.localeInput = localeInput;
+    this.i18nService = i18nService;
+    this.locale = this.i18nService.getExactLocale(this.localeInput);
+  }
+  translate(v) {
+    return this.i18nService.translate(this.locale, v);
+  }
+};
+LocaleContext = __decorateClass([
+  Injectable6({ scope: Scope4.REQUEST }),
+  __decorateParam(0, Inject9(I18nParamResolverProviderToken)),
+  __decorateParam(1, Inject9(I18nService))
+], LocaleContext);
+
 // src/i18n-module/i18n-factory.ts
 var createI18n = (options) => {
   if (!options.resolver) {
@@ -2075,9 +1156,29 @@ var createI18n = (options) => {
       paramName: "x-client-language"
     };
   }
+  const resolver = getParamResolver(options.resolver);
+  const paramProvider = resolver.toRequestScopedProvider();
+  const module = I18nModule.register(options);
+  module.providers ??= [];
+  module.exports ??= [];
+  module.providers.push(
+    paramProvider.provider,
+    LocaleContext,
+    // re-exports the resolved param value for LocaleContext injection
+    createProvider(
+      {
+        provide: I18nParamResolverProviderToken,
+        inject: [paramProvider.token]
+      },
+      (s) => s
+    )
+  );
+  module.exports.push(paramProvider.provider, LocaleContext);
   return {
     UseI18n: createI18nDecorator(options),
-    I18nModule: I18nModule.register(options)
+    I18nModule: module,
+    I18nParamResolver: resolver,
+    I18nParamResolverProvider: paramProvider
   };
 };
 
@@ -2092,6 +1193,7 @@ export {
   ApiError,
   ApiErrorTyped,
   ApiFromResolver,
+  ApiInject,
   ApiTypeResponse,
   As,
   BlankPaginatedReturnMessageDto,
@@ -2100,6 +1202,7 @@ export {
   DataBody,
   DataPipe,
   DataQuery,
+  DefaultValueParamResolver,
   GenericPaginatedReturnMessageDto,
   GenericReturnMessageDto,
   I18nInterceptor,
@@ -2119,6 +1222,11 @@ export {
   ParamResolver,
   ParamResolverBase,
   ParamResolverPipe,
+  ParseBase64ParamResolver,
+  ParseBoolParamResolver,
+  ParseDateParamResolver,
+  ParseFloatParamResolver,
+  ParseIntParamResolver,
   PutLocale,
   RenameClass,
   RequireToken,
@@ -2130,6 +1238,7 @@ export {
   createAbortableProvider,
   createI18n,
   createI18nDecorator,
+  createLambdaParamResolver,
   createMutateInject,
   createProvider,
   createResolver,
@@ -2137,24 +1246,7 @@ export {
   getApiProperty,
   getClassFromClassOrArray,
   getParamResolver,
+  parseBool,
   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.mjs.map