nesties 1.1.5 → 1.1.7

package/dist/index.cjs

@@ -6,11 +6,11 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
+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: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
   }
   return to;
 };
@@ -34,6 +34,7 @@ __export(index_exports, {
   ApiBlankResponse: () => ApiBlankResponse,
   ApiError: () => ApiError,
   ApiErrorTyped: () => ApiErrorTyped,
+  ApiFromResolver: () => ApiFromResolver,
   ApiTypeResponse: () => ApiTypeResponse,
   As: () => As,
   BlankPaginatedReturnMessageDto: () => BlankPaginatedReturnMessageDto,
@@ -43,22 +44,31 @@ __export(index_exports, {
   DataQuery: () => DataQuery,
   GenericPaginatedReturnMessageDto: () => GenericPaginatedReturnMessageDto,
   GenericReturnMessageDto: () => GenericReturnMessageDto,
+  I18nInterceptor: () => I18nInterceptor,
+  I18nLookupMiddleware: () => I18nLookupMiddleware,
+  I18nModule: () => I18nModule,
+  I18nService: () => I18nService,
   InjectAbortSignal: () => InjectAbortSignal,
   InjectAbortable: () => InjectAbortable,
   InsertField: () => InsertField,
+  LocalePipe: () => LocalePipe,
   MergeClassDecorators: () => MergeClassDecorators,
   MergeClassOrMethodDecorators: () => MergeClassOrMethodDecorators,
   MergeMethodDecorators: () => MergeMethodDecorators,
   MergeParameterDecorators: () => MergeParameterDecorators,
   MergePropertyDecorators: () => MergePropertyDecorators,
   PaginatedReturnMessageDto: () => PaginatedReturnMessageDto,
+  PutLocale: () => PutLocale,
   RequireToken: () => RequireToken,
   ReturnMessageDto: () => ReturnMessageDto,
   StringReturnMessageDto: () => StringReturnMessageDto,
   TokenGuard: () => TokenGuard,
   abortableToken: () => abortableToken,
   createAbortableProvider: () => createAbortableProvider,
+  createI18n: () => createI18n,
+  createI18nDecorator: () => createI18nDecorator,
   createProvider: () => createProvider,
+  createResolver: () => createResolver,
   fromAbortable: () => fromAbortable,
   getClassFromClassOrArray: () => getClassFromClassOrArray,
   takeUntilAbort: () => takeUntilAbort
@@ -254,40 +264,161 @@ var DataBody = createDataPipeDec(import_common2.Body);
 // src/token.guard.ts
 var import_common3 = require("@nestjs/common");
 var import_config = require("@nestjs/config");
+var import_swagger5 = require("@nestjs/swagger");
+
+// src/resolver.ts
 var import_swagger4 = require("@nestjs/swagger");
+var coerceToString = (v) => {
+  if (v == null) return void 0;
+  if (v === false) return void 0;
+  if (Array.isArray(v)) return v.length ? coerceToString(v[0]) : void 0;
+  if (typeof v === "string") return v;
+  if (typeof v === "number") return String(v);
+  return void 0;
+};
+var getHeader = (req, name) => {
+  const viaMethod = typeof req.getHeader === "function" && req.getHeader(name) || typeof req.header === "function" && req.header(name) || typeof req.get === "function" && req.get(name);
+  if (viaMethod) {
+    return coerceToString(viaMethod);
+  }
+  const n = name.toLowerCase();
+  const headers = req.headers ?? {};
+  if (n in headers) return coerceToString(headers[n]);
+  const hit = Object.entries(headers).find(([k]) => k.toLowerCase() === n)?.[1];
+  return coerceToString(hit);
+};
+var pickPrimaryFromAcceptLanguage = (v) => {
+  if (!v) return void 0;
+  const first = v.split(",")[0]?.trim();
+  return first?.split(";")[0]?.trim() || first;
+};
+function getQueryValue(req, key) {
+  const q = req.query;
+  if (q && typeof q === "object" && !("raw" in q)) {
+    const v = q[key];
+    if (v != null) return coerceToString(v);
+  }
+  const rawUrl = req.originalUrl ?? req.url;
+  if (typeof rawUrl === "string" && rawUrl.includes("?")) {
+    try {
+      const search = rawUrl.startsWith("http") ? new URL(rawUrl).search : new URL(rawUrl, "http://localhost").search;
+      if (search) {
+        const params = new URLSearchParams(search);
+        const val = params.get(key);
+        if (val != null) return val;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+var createResolver = (_options) => {
+  if (typeof _options === "function") {
+    return _options;
+  }
+  const options = _options;
+  const field = options.paramType;
+  let name = options.paramName;
+  if (field === "header") name = name.toLowerCase();
+  return (ctx) => {
+    const req = ctx.switchToHttp().getRequest();
+    if (field === "header") {
+      let raw = getHeader(req, name);
+      if (name === "accept-language") raw = pickPrimaryFromAcceptLanguage(raw);
+      return raw;
+    }
+    if (field === "query") {
+      return getQueryValue(req, name);
+    }
+    throw new Error(`Unsupported paramType: ${field}`);
+  };
+};
+var ApiFromResolver = (_options, extras = {}) => {
+  if (typeof _options === "function") {
+    return () => {
+    };
+  }
+  const options = _options;
+  const paramType = options?.paramType;
+  const apiOptions = {
+    name: options.paramName,
+    ...extras
+  };
+  return paramType === "header" ? (0, import_swagger4.ApiHeader)(apiOptions) : paramType === "query" ? (0, import_swagger4.ApiQuery)({ type: "string", ...apiOptions }) : () => {
+  };
+};
+
+// src/token.guard.ts
+var import_typed_reflector = require("typed-reflector");
+var import_core = require("@nestjs/core");
+var reflector = new import_typed_reflector.Reflector();
+var Metadata = new import_typed_reflector.MetadataSetter();
+var defaultHeaderName = "x-server-token";
+var defaultConfigName = "SERVER_TOKEN";
+var defaultErrorCode = 401;
 var TokenGuard = class {
-  constructor(config) {
+  constructor(config, moduleRef) {
     this.config = config;
-    this.token = this.config.get("SERVER_TOKEN");
+    this.moduleRef = moduleRef;
   }
   async canActivate(context) {
-    const request = context.switchToHttp().getRequest();
-    const token = request.headers["x-server-token"];
-    if (this.token && token !== this.token) {
-      throw new BlankReturnMessageDto(401, "Unauthorized").toException();
+    const controller = context.getClass();
+    const handlerName = context.getHandler()?.name;
+    let config = {};
+    if (controller) {
+      if (handlerName) {
+        config = reflector.get("requireTokenOptions", controller, handlerName) || {};
+      } else {
+        config = reflector.get("requireTokenOptions", controller) || {};
+      }
+    }
+    const resolver = createResolver(
+      config.resolver || { paramType: "header", paramName: defaultHeaderName }
+    );
+    const tokenSource = config.tokenSource || defaultConfigName;
+    const [tokenFromClient, tokenFromConfig] = await Promise.all([
+      resolver(context, this.moduleRef),
+      typeof tokenSource === "function" ? tokenSource(context, this.moduleRef) : this.config.get(tokenSource)
+    ]);
+    if (tokenFromConfig && tokenFromConfig !== tokenFromClient) {
+      throw new BlankReturnMessageDto(
+        config.errorCode || defaultErrorCode,
+        "Unauthorized"
+      ).toException();
     }
     return true;
   }
 };
 TokenGuard = __decorateClass([
   (0, import_common3.Injectable)(),
-  __decorateParam(0, (0, import_common3.Inject)(import_config.ConfigService))
+  __decorateParam(0, (0, import_common3.Inject)(import_config.ConfigService)),
+  __decorateParam(1, (0, import_common3.Inject)(import_core.ModuleRef))
 ], TokenGuard);
-var RequireToken = () => MergeClassOrMethodDecorators([
-  (0, import_common3.UseGuards)(TokenGuard),
-  (0, import_swagger4.ApiHeader)({
-    name: "x-server-token",
+var RequireToken = (options = {}) => {
+  const swaggerDec = options.resolver ? ApiFromResolver(options.resolver, {
     description: "Server token",
     required: false
-  }),
-  ApiError(401, "Incorrect server token provided")
-]);
+  }) : (0, import_swagger5.ApiHeader)({
+    name: defaultHeaderName,
+    description: "Server token",
+    required: false
+  });
+  return MergeClassOrMethodDecorators([
+    (0, import_common3.UseGuards)(TokenGuard),
+    swaggerDec,
+    ApiError(
+      options.errorCode || defaultErrorCode,
+      "Incorrect server token provided"
+    ),
+    ...options ? [Metadata.set("requireTokenOptions", options)] : []
+  ]);
+};
 
 // src/abort-utils.ts
 var import_rxjs = require("rxjs");
 var import_common4 = require("@nestjs/common");
 
-// src/abort-http-signal.ts
+// src/utility/abort-http-signal.ts
 function toRawReq(req) {
   if (req?.raw?.socket) return req.raw;
   return req;
@@ -364,7 +495,7 @@ var import_nfkit = require("nfkit");
 
 // src/abortable-module/abort-signal.provider.ts
 var import_common5 = require("@nestjs/common");
-var import_core = require("@nestjs/core");
+var import_core2 = require("@nestjs/core");
 
 // src/create-provider.ts
 var createProvider = (options, factory) => {
@@ -382,14 +513,14 @@ var AbortSignalProvider = createProvider(
   {
     provide: ABORT_SIGNAL,
     scope: import_common5.Scope.REQUEST,
-    inject: [import_core.REQUEST]
+    inject: [import_core2.REQUEST]
   },
   createAbortSignalFromHttp
 );
 var InjectAbortSignal = () => (0, import_common5.Inject)(ABORT_SIGNAL);
 
 // src/abortable-module/abortable.token.ts
-var import_core2 = require("@nestjs/core");
+var import_core3 = require("@nestjs/core");
 var tokenMemo = /* @__PURE__ */ new Map();
 var abortableToken = (token) => {
   if (tokenMemo.has(token)) return tokenMemo.get(token);
@@ -419,10 +550,10 @@ function createAbortableProvider(token, opts) {
     {
       provide,
       scope: import_common6.Scope.REQUEST,
-      inject: [import_core2.ModuleRef, import_core2.REQUEST, ABORT_SIGNAL]
+      inject: [import_core3.ModuleRef, import_core3.REQUEST, ABORT_SIGNAL]
     },
     async (moduleRef, req, signal) => {
-      const ctxId = import_core2.ContextIdFactory.getByRequest(req);
+      const ctxId = import_core3.ContextIdFactory.getByRequest(req);
       const svc = await moduleRef.resolve(token, ctxId, { strict: false });
       if (svc == null) {
         throw new Error(
@@ -461,6 +592,418 @@ var AbortableModule = class {
 AbortableModule = __decorateClass([
   (0, import_common7.Module)({})
 ], AbortableModule);
+
+// src/i18n-module/i18n.service.ts
+var import_common9 = require("@nestjs/common");
+
+// src/i18n-module/i18n-token.ts
+var import_common8 = require("@nestjs/common");
+var I18nResolverToken = Symbol("I18nResolverToken");
+var { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } = new import_common8.ConfigurableModuleBuilder().build();
+var I18nModuleOptionsToken = MODULE_OPTIONS_TOKEN;
+
+// src/utility/parse-i18n.ts
+var parseI18n = (text) => {
+  const pieces = [];
+  if (!text) return pieces;
+  let i = 0;
+  const n = text.length;
+  while (i < n) {
+    const start = text.indexOf("#{", i);
+    if (start === -1) {
+      if (i < n) pieces.push({ type: "raw", value: text.slice(i) });
+      break;
+    }
+    let j = start + 2;
+    let depth = 1;
+    while (j < n && depth > 0) {
+      const ch = text.charCodeAt(j);
+      if (ch === 123) depth++;
+      else if (ch === 125) depth--;
+      j++;
+    }
+    if (depth !== 0) {
+      pieces.push({ type: "raw", value: text.slice(i) });
+      break;
+    }
+    if (start > i) {
+      pieces.push({ type: "raw", value: text.slice(i, start) });
+    }
+    const rawInner = text.slice(start + 2, j - 1);
+    const key = rawInner.trim();
+    pieces.push({ type: "ph", rawInner, key });
+    i = j;
+  }
+  return pieces;
+};
+
+// src/i18n-module/i18n.service.ts
+var import_core4 = require("@nestjs/core");
+var I18nService = class {
+  constructor(options, moduleRef) {
+    this.options = options;
+    this.moduleRef = moduleRef;
+    this.resolver = createResolver(this.options.resolver);
+    this.locales = new Set(this.options.locales);
+    this.defaultLocale = this.options.defaultLocale ?? this.options.locales[0];
+    this.middlewares = [];
+    this.logger = new import_common9.ConsoleLogger("I18nService");
+  }
+  middleware(mw, prior = false) {
+    if (prior) {
+      this.middlewares.unshift(mw);
+    } else {
+      this.middlewares.push(mw);
+    }
+  }
+  buildFallbackChain(locale) {
+    const best = this.getExactLocale(locale);
+    const parts = [];
+    const segs = best.split("-");
+    for (let i = segs.length; i > 1; i--)
+      parts.push(segs.slice(0, i).join("-"));
+    parts.push(segs[0]);
+    if (!parts.includes(this.defaultLocale)) parts.push(this.defaultLocale);
+    return Array.from(new Set(parts)).filter((p) => this.locales.has(p));
+  }
+  async applyMiddlewares(locale, text, ctx) {
+    const mws = this.middlewares;
+    const tryLocale = async (loc) => {
+      const dispatch = async (i) => {
+        if (i >= mws.length) return void 0;
+        const mw = mws[i];
+        let nextCalled = false;
+        const next = async () => {
+          nextCalled = true;
+          return dispatch(i + 1);
+        };
+        try {
+          const res = await mw(loc, text, next, ctx);
+          if (res == null && !nextCalled) {
+            return dispatch(i + 1);
+          }
+          return res;
+        } catch (e) {
+          if (e instanceof import_common9.HttpException) {
+            throw e;
+          }
+          this.logger.warn(`Middleware at index ${i} threw an error: ${e}`);
+          return dispatch(i + 1);
+        }
+      };
+      return dispatch(0);
+    };
+    for (const loc of this.buildFallbackChain(locale)) {
+      const result = await tryLocale(loc);
+      if (result != null) {
+        return result;
+      }
+    }
+    return void 0;
+  }
+  getExactLocale(locale) {
+    const input = (locale ?? "").trim();
+    if (!input) return this.defaultLocale;
+    if (this.locales.has(input)) return input;
+    const entries = Array.from(this.locales).map((l) => ({
+      orig: l,
+      lower: l.toLowerCase()
+    }));
+    const lower = input.toLowerCase();
+    const exact = entries.find((e) => e.lower === lower);
+    if (exact) return exact.orig;
+    const parts = lower.split("-");
+    while (parts.length > 1) {
+      parts.pop();
+      const candidate = parts.join("-");
+      const hit = entries.find((e) => e.lower === candidate);
+      if (hit) return hit.orig;
+    }
+    return this.defaultLocale;
+  }
+  async getExactLocaleFromRequest(ctx) {
+    const locale = await this.resolver(ctx, this.moduleRef);
+    return this.getExactLocale(locale);
+  }
+  async translateString(locale, text, ctx) {
+    if (!text) return text;
+    locale = this.getExactLocale(locale);
+    const pieces = parseI18n(text);
+    if (!pieces.some((p) => p.type === "ph")) {
+      return pieces.map((p) => p.type === "raw" ? p.value : `#{${p.rawInner}}`).join("");
+    }
+    const promises = [];
+    for (const p of pieces) {
+      if (p.type === "ph") {
+        promises.push(this.applyMiddlewares(locale, p.key, ctx));
+      }
+    }
+    const results = await Promise.all(promises);
+    let out = "";
+    let k = 0;
+    for (const p of pieces) {
+      if (p.type === "raw") {
+        out += p.value;
+      } else {
+        const r = results[k++];
+        out += r == null ? `#{${p.rawInner}}` : r;
+      }
+    }
+    return out;
+  }
+  async translate(locale, obj, ctx) {
+    const visited = /* @__PURE__ */ new WeakSet();
+    const isBuiltInObject = (v) => {
+      if (v == null || typeof v !== "object") return false;
+      if (v instanceof Date || v instanceof RegExp || v instanceof Map || v instanceof Set || v instanceof WeakMap || v instanceof WeakSet || v instanceof ArrayBuffer || v instanceof DataView || ArrayBuffer.isView(v))
+        return true;
+      const tag = Object.prototype.toString.call(v);
+      switch (tag) {
+        case "[object URL]":
+        case "[object URLSearchParams]":
+        case "[object Error]":
+        case "[object Blob]":
+        case "[object File]":
+        case "[object FormData]":
+          return true;
+        default:
+          return false;
+      }
+    };
+    const translateObjectPreservingProto = async (value) => {
+      const proto = Object.getPrototypeOf(value);
+      const out = Object.create(proto);
+      const keys = Reflect.ownKeys(value);
+      await Promise.all(
+        keys.map(async (key) => {
+          const desc = Object.getOwnPropertyDescriptor(value, key);
+          if (!desc) return;
+          if ("value" in desc) {
+            const newVal = await visit(desc.value);
+            Object.defineProperty(out, key, { ...desc, value: newVal });
+            return;
+          }
+          Object.defineProperty(out, key, desc);
+          let current = void 0;
+          if (typeof desc.get === "function") {
+            try {
+              current = desc.get.call(value);
+            } catch {
+            }
+          }
+          if (current === void 0) return;
+          try {
+            const newVal = await visit(current);
+            if (typeof desc.set === "function") {
+              try {
+                desc.set.call(out, newVal);
+              } catch {
+              }
+            }
+          } catch {
+          }
+        })
+      );
+      return out;
+    };
+    const isTranslatable = (v) => {
+      if (!v) return { ok: false };
+      const t = typeof v;
+      if (t === "number" || t === "bigint" || t === "symbol" || t === "function") {
+        return { ok: false };
+      }
+      if (t === "string") return { ok: true, kind: "string" };
+      if (t === "object") {
+        return { ok: true, kind: "object" };
+      }
+      return { ok: false };
+    };
+    const visit = async (value) => {
+      const check = isTranslatable(value);
+      if (!check.ok) {
+        return value;
+      }
+      if (check.kind === "string") {
+        return this.translateString(locale, value, ctx);
+      }
+      if (value instanceof Promise) {
+        return value.then((resolved) => visit(resolved));
+      }
+      if (typeof value === "object") {
+        if (!Array.isArray(value) && isBuiltInObject(value)) return value;
+        if (visited.has(value)) return value;
+        visited.add(value);
+        if (Array.isArray(value)) {
+          const out = await Promise.all(value.map((v) => visit(v)));
+          return out;
+        }
+        return translateObjectPreservingProto(value);
+      }
+      return value;
+    };
+    return visit(obj);
+  }
+  async translateRequest(ctx, obj) {
+    const locale = await this.resolver(ctx, this.moduleRef);
+    return this.translate(locale, obj, ctx);
+  }
+};
+I18nService = __decorateClass([
+  (0, import_common9.Injectable)(),
+  __decorateParam(0, (0, import_common9.Inject)(I18nModuleOptionsToken)),
+  __decorateParam(1, (0, import_common9.Inject)(import_core4.ModuleRef))
+], I18nService);
+
+// src/i18n-module/i18n.module.ts
+var import_common11 = require("@nestjs/common");
+
+// src/i18n-module/locale.pipe.ts
+var import_common10 = require("@nestjs/common");
+var LocalePipe = class {
+  constructor(i18nService) {
+    this.i18nService = i18nService;
+  }
+  async transform(ctx, metadata) {
+    const resolver = ctx.resolver;
+    if (resolver) {
+      const _resolver = createResolver(resolver);
+      const locale = await _resolver(ctx.ctx, void 0);
+      return this.i18nService.getExactLocale(locale);
+    } else {
+      return this.i18nService.getExactLocaleFromRequest(ctx.ctx);
+    }
+  }
+};
+LocalePipe = __decorateClass([
+  (0, import_common10.Injectable)(),
+  __decorateParam(0, (0, import_common10.Inject)(I18nService))
+], LocalePipe);
+var _dec = (0, import_common10.createParamDecorator)((resolver, ctx) => {
+  return { ctx, resolver };
+});
+var PutLocale = (resolver) => _dec(resolver, LocalePipe);
+
+// src/i18n-module/i18n.module.ts
+var I18nModule = class extends ConfigurableModuleClass {
+};
+I18nModule = __decorateClass([
+  (0, import_common11.Global)(),
+  (0, import_common11.Module)({
+    providers: [I18nService, LocalePipe],
+    exports: [I18nService, LocalePipe]
+  })
+], I18nModule);
+
+// src/i18n-module/i18n-decorator.ts
+var import_common13 = require("@nestjs/common");
+
+// src/i18n-module/i18n.interceptor.ts
+var import_common12 = require("@nestjs/common");
+var import_rxjs2 = require("rxjs");
+var import_operators = require("rxjs/operators");
+var I18nInterceptor = class {
+  constructor(i18nService) {
+    this.i18nService = i18nService;
+  }
+  intercept(context, next) {
+    return next.handle().pipe(
+      // 成功路径：把响应体交给 i18n 做异步翻译
+      (0, import_operators.mergeMap)((data) => this.i18nService.translateRequest(context, data)),
+      // 错误路径：若是 HttpException，把其 response 翻译后再抛
+      (0, import_operators.catchError)((err) => {
+        if (err instanceof import_common12.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_common12.HttpException(translated, status, { cause: err })
+              )
+            )
+          );
+        }
+        return (0, import_rxjs2.throwError)(() => err);
+      })
+    );
+  }
+};
+I18nInterceptor = __decorateClass([
+  (0, import_common12.Injectable)(),
+  __decorateParam(0, (0, import_common12.Inject)(I18nService))
+], I18nInterceptor);
+
+// src/i18n-module/i18n-decorator.ts
+var createI18nDecorator = (options) => {
+  return () => MergeClassOrMethodDecorators([
+    (0, import_common13.UseInterceptors)(I18nInterceptor),
+    ApiFromResolver(options.resolver, {
+      description: "Locale for internationalization",
+      required: false,
+      default: options.defaultLocale ?? options.locales[0],
+      enum: options.locales
+    })
+  ]);
+};
+
+// src/i18n-module/i18n-factory.ts
+var createI18n = (options) => {
+  if (!options.resolver) {
+    options.resolver = {
+      paramType: "header",
+      paramName: "x-client-language"
+    };
+  }
+  return {
+    UseI18n: createI18nDecorator(options),
+    I18nModule: I18nModule.register(options)
+  };
+};
+
+// src/i18n-module/middlewares/lookup.ts
+var I18nLookupMiddleware = (dict, options) => {
+  const matchType = options?.matchType ?? "exact";
+  const dictFactory = typeof dict === "function" ? dict : () => dict;
+  const pickBestByHierarchy = (input, locales) => {
+    if (!input) return void 0;
+    const entries = locales.map((l) => ({ orig: l, lower: l.toLowerCase() }));
+    const lower = input.toLowerCase();
+    const exact = entries.find((e) => e.lower === lower);
+    if (exact) return exact.orig;
+    const parts = lower.split("-");
+    while (parts.length > 1) {
+      parts.pop();
+      const candidate = parts.join("-");
+      const hit = entries.find((e) => e.lower === candidate);
+      if (hit) return hit.orig;
+    }
+    return void 0;
+  };
+  return async (locale, key, next, ctx) => {
+    const dictResolved = await dictFactory(locale, key, ctx);
+    let dictionary = dictResolved[locale];
+    if (!dictionary) {
+      if (matchType === "hierarchy") {
+        const best = pickBestByHierarchy(locale, Object.keys(dictResolved));
+        if (best) dictionary = dictResolved[best];
+      } else if (matchType === "startsWith") {
+        const keys = Object.keys(dictResolved).filter(
+          (k) => locale.startsWith(k)
+        );
+        if (keys.length) {
+          const best = keys.reduce((a, b) => b.length > a.length ? b : a);
+          dictionary = dictResolved[best];
+        }
+      }
+    }
+    if (dictionary && Object.prototype.hasOwnProperty.call(dictionary, key)) {
+      const val = dictionary[key];
+      if (val != null) {
+        return val;
+      }
+    }
+    return next();
+  };
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ABORT_SIGNAL,
@@ -469,6 +1012,7 @@ AbortableModule = __decorateClass([
   ApiBlankResponse,
   ApiError,
   ApiErrorTyped,
+  ApiFromResolver,
   ApiTypeResponse,
   As,
   BlankPaginatedReturnMessageDto,
@@ -478,22 +1022,31 @@ AbortableModule = __decorateClass([
   DataQuery,
   GenericPaginatedReturnMessageDto,
   GenericReturnMessageDto,
+  I18nInterceptor,
+  I18nLookupMiddleware,
+  I18nModule,
+  I18nService,
   InjectAbortSignal,
   InjectAbortable,
   InsertField,
+  LocalePipe,
   MergeClassDecorators,
   MergeClassOrMethodDecorators,
   MergeMethodDecorators,
   MergeParameterDecorators,
   MergePropertyDecorators,
   PaginatedReturnMessageDto,
+  PutLocale,
   RequireToken,
   ReturnMessageDto,
   StringReturnMessageDto,
   TokenGuard,
   abortableToken,
   createAbortableProvider,
+  createI18n,
+  createI18nDecorator,
   createProvider,
+  createResolver,
   fromAbortable,
   getClassFromClassOrArray,
   takeUntilAbort