intor 2.0.3 → 2.2.0

package/dist/config/index.cjs

@@ -86,8 +86,8 @@ var normalizePathname = (rawPathname, options = {}) => {
   const length = rawPathname.length;
   let start = 0;
   let end = length - 1;
-  while (start <= end && rawPathname.charCodeAt(start) <= 32) start++;
-  while (end >= start && rawPathname.charCodeAt(end) <= 32) end--;
+  while (start <= end && (rawPathname.codePointAt(start) ?? 0) <= 32) start++;
+  while (end >= start && (rawPathname.codePointAt(end) ?? 0) <= 32) end--;
   if (start > end) return "/";
   let result = "";
   let hasSlash = false;
@@ -98,11 +98,7 @@ var normalizePathname = (rawPathname, options = {}) => {
         hasSlash = true;
       }
     } else {
-      if (hasSlash || result === "") {
-        result += "/" + char;
-      } else {
-        result += char;
-      }
+      result += hasSlash || result === "" ? "/" + char : char;
       hasSlash = false;
     }
   }
@@ -119,7 +115,7 @@ var resolveRoutingOptions = (routing = {}) => {
     ...routing,
     firstVisit: {
       ...DEFAULT_ROUTING_OPTIONS.firstVisit,
-      ...routing.firstVisit || {}
+      ...routing.firstVisit
     },
     basePath: normalizePathname(routing?.basePath || "")
   };

package/dist/config/index.d.cts

@@ -1,5 +1,5 @@
 import { Level, NormalizerConfig, FormatterConfig, LoggerPreset } from 'logry/edge';
-import { Locale, LocaleNamespaceMessages, FallbackLocalesMap } from 'intor-translator';
+import { Locale, LocaleMessages, FallbackLocalesMap } from 'intor-translator';
 
 type CookieRawOptions = {
     /** Completely disable cookie usage (no read, no write, no lookup by name) - default: false */
@@ -109,7 +109,7 @@ type WithLoader = {
 };
 type IntorRawConfig = (WithLoader | WithoutLoader) & {
     readonly id?: string;
-    readonly messages?: LocaleNamespaceMessages;
+    readonly messages?: LocaleMessages;
     readonly defaultLocale: Locale;
     readonly fallbackLocales?: FallbackLocalesMap;
     readonly translator?: TranslatorOptions;
@@ -120,7 +120,7 @@ type IntorRawConfig = (WithLoader | WithoutLoader) & {
 };
 type IntorResolvedConfig = (WithLoader | WithoutLoader) & {
     readonly id: string;
-    readonly messages?: LocaleNamespaceMessages;
+    readonly messages?: LocaleMessages;
     readonly defaultLocale: Locale;
     readonly fallbackLocales: FallbackLocalesMap;
     readonly translator?: TranslatorOptions;

package/dist/config/index.d.ts

@@ -1,5 +1,5 @@
 import { Level, NormalizerConfig, FormatterConfig, LoggerPreset } from 'logry/edge';
-import { Locale, LocaleNamespaceMessages, FallbackLocalesMap } from 'intor-translator';
+import { Locale, LocaleMessages, FallbackLocalesMap } from 'intor-translator';
 
 type CookieRawOptions = {
     /** Completely disable cookie usage (no read, no write, no lookup by name) - default: false */
@@ -109,7 +109,7 @@ type WithLoader = {
 };
 type IntorRawConfig = (WithLoader | WithoutLoader) & {
     readonly id?: string;
-    readonly messages?: LocaleNamespaceMessages;
+    readonly messages?: LocaleMessages;
     readonly defaultLocale: Locale;
     readonly fallbackLocales?: FallbackLocalesMap;
     readonly translator?: TranslatorOptions;
@@ -120,7 +120,7 @@ type IntorRawConfig = (WithLoader | WithoutLoader) & {
 };
 type IntorResolvedConfig = (WithLoader | WithoutLoader) & {
     readonly id: string;
-    readonly messages?: LocaleNamespaceMessages;
+    readonly messages?: LocaleMessages;
     readonly defaultLocale: Locale;
     readonly fallbackLocales: FallbackLocalesMap;
     readonly translator?: TranslatorOptions;

package/dist/config/index.js

@@ -84,8 +84,8 @@ var normalizePathname = (rawPathname, options = {}) => {
   const length = rawPathname.length;
   let start = 0;
   let end = length - 1;
-  while (start <= end && rawPathname.charCodeAt(start) <= 32) start++;
-  while (end >= start && rawPathname.charCodeAt(end) <= 32) end--;
+  while (start <= end && (rawPathname.codePointAt(start) ?? 0) <= 32) start++;
+  while (end >= start && (rawPathname.codePointAt(end) ?? 0) <= 32) end--;
   if (start > end) return "/";
   let result = "";
   let hasSlash = false;
@@ -96,11 +96,7 @@ var normalizePathname = (rawPathname, options = {}) => {
         hasSlash = true;
       }
     } else {
-      if (hasSlash || result === "") {
-        result += "/" + char;
-      } else {
-        result += char;
-      }
+      result += hasSlash || result === "" ? "/" + char : char;
       hasSlash = false;
     }
   }
@@ -117,7 +113,7 @@ var resolveRoutingOptions = (routing = {}) => {
     ...routing,
     firstVisit: {
       ...DEFAULT_ROUTING_OPTIONS.firstVisit,
-      ...routing.firstVisit || {}
+      ...routing.firstVisit
     },
     basePath: normalizePathname(routing?.basePath || "")
   };

package/dist/index.cjs

@@ -31,33 +31,6 @@ var DEFAULT_CACHE_OPTIONS = {
   // 1 hour
 };
 
-// src/shared/error/intor-error.ts
-var IntorError = class extends Error {
-  constructor({ message, code, id }) {
-    const fullMessage = id ? `[${id}] ${message}` : message;
-    super(fullMessage);
-    this.name = "IntorError";
-    this.id = id;
-    this.code = code;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-
-// src/modules/messages/load-local-messages/utils/read-message-record-file.ts
-var readMessageRecordFile = async (filePath, loggerOptions) => {
-  const fileName = path__default.default.basename(filePath, ".json");
-  const content = await fs__default.default.readFile(filePath, "utf-8");
-  const parsed = JSON.parse(content);
-  if (typeof parsed !== "object" || parsed === null) {
-    throw new IntorError({
-      id: loggerOptions.id,
-      code: "INTOR_INVALID_MESSAGE_FORMAT" /* INVALID_MESSAGE_FORMAT */,
-      message: "Invalid message format"
-    });
-  }
-  return { fileName, content: parsed };
-};
-
 // src/shared/logger/global-logger-pool.ts
 function getGlobalLoggerPool() {
   if (!globalThis.__INTOR_LOGGER_POOL__) {
@@ -76,22 +49,40 @@ var DEFAULT_FORMATTER_CONFIG = {
 };
 function getLogger({
   id,
-  formatterConfig = DEFAULT_FORMATTER_CONFIG,
+  formatterConfig,
+  preset,
   ...options
 }) {
   const pool = getGlobalLoggerPool();
   let logger = pool.get(id);
   if (!logger) {
-    logger = logry.logry({ id, formatterConfig, ...options });
+    logger = logry.logry({
+      id,
+      formatterConfig: !formatterConfig && !preset ? DEFAULT_FORMATTER_CONFIG : formatterConfig,
+      preset,
+      ...options
+    });
     pool.set(id, logger);
     if (pool.size > 1e3) {
-      const keys = Array.from(pool.keys());
+      const keys = [...pool.keys()];
       for (const key of keys.slice(0, 200)) pool.delete(key);
     }
   }
   return logger;
 }
 
+// src/shared/error/intor-error.ts
+var IntorError = class extends Error {
+  constructor({ message, code, id }) {
+    const fullMessage = id ? `[${id}] ${message}` : message;
+    super(fullMessage);
+    this.name = "IntorError";
+    this.id = id;
+    this.code = code;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
 // src/modules/messages/load-local-messages/load-namespace-group/parse-message-file.ts
 var MAX_PATH_LENGTH = 260;
 var parseMessageFile = async (filePath, loggerOptions) => {
@@ -112,9 +103,17 @@ var parseMessageFile = async (filePath, loggerOptions) => {
     return null;
   }
   try {
-    const { content } = await readMessageRecordFile(trimmedPath, loggerOptions);
-    logger.trace(`Message file loaded.`, { filePath: trimmedPath });
-    return content;
+    const content = await fs__default.default.readFile(trimmedPath, "utf8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new IntorError({
+        id: loggerOptions.id,
+        code: "INTOR_INVALID_MESSAGE_FORMAT" /* INVALID_MESSAGE_FORMAT */,
+        message: "Invalid message format"
+      });
+    }
+    logger.trace("Message file loaded.", { filePath: trimmedPath });
+    return parsed;
   } catch (error) {
     logger.warn("Failed to parse message file.", {
       filePath: trimmedPath,
@@ -208,7 +207,7 @@ var addToNamespaceGroup = ({
   const filePathsSet = new Set(group.filePaths);
   if (!filePathsSet.has(filePath)) {
     filePathsSet.add(filePath);
-    group.filePaths = Array.from(filePathsSet);
+    group.filePaths = [...filePathsSet];
     namespaceGroups.set(nsKey, group);
   }
 };
@@ -218,14 +217,15 @@ var traverseDirectory = async ({
   options,
   currentDirPath,
   namespaceGroups,
-  namespacePathSegments
+  namespacePathSegments,
+  readdir = fs__default.default.readdir
 }) => {
   const { limit } = options;
   const loggerOptions = options.logger || { id: "default" };
   const baseLogger = getLogger({ ...loggerOptions });
   const logger = baseLogger.child({ scope: "traverse-directory" });
   try {
-    const dirents = await fs__default.default.readdir(currentDirPath, { withFileTypes: true });
+    const dirents = await readdir(currentDirPath, { withFileTypes: true });
     const dirPromises = dirents.map(
       (dirent) => limit(async () => {
         const filePath = path__default.default.join(currentDirPath, dirent.name);
@@ -241,7 +241,8 @@ var traverseDirectory = async ({
             namespaceGroups,
             currentDirPath: filePath,
             namespacePathSegments: [...namespacePathSegments, dirent.name],
-            options
+            options,
+            readdir
           });
         }
       }).catch((error) => {
@@ -316,7 +317,7 @@ var loadSingleLocale = async ({
     namespaceGroups: [...namespaceGroups.entries()].map(([ns, val]) => ({
       namespace: ns,
       isAtRoot: val.isAtRoot,
-      fileCounts: val.filePaths.length
+      fileCount: val.filePaths.length
     }))
   });
   const namespaceGroupTasks = [...namespaceGroups.entries()].filter(
@@ -347,8 +348,8 @@ var loadLocaleWithFallback = async ({
 }) => {
   const baseLogger = getLogger({ ...loggerOptions });
   const logger = baseLogger.child({ scope: "load-locale-with-fallback" });
-  const localesToTry = [targetLocale, ...fallbackLocales];
-  for (const locale of localesToTry) {
+  const candidateLocales = [targetLocale, ...fallbackLocales];
+  for (const locale of candidateLocales) {
     try {
       const validNamespaces = await loadSingleLocale({
         basePath,
@@ -367,7 +368,7 @@ var loadLocaleWithFallback = async ({
     }
   }
   logger.warn("All fallback locales failed.", {
-    attemptedLocales: localesToTry
+    attemptedLocales: candidateLocales
   });
   return;
 };
@@ -384,7 +385,7 @@ function clearMessagesPool() {
 
 // src/shared/utils/merge-messages.ts
 var mergeMessages = (staticMessages = {}, loadedMessages = {}) => {
-  const result = Object.keys(staticMessages).length ? { ...staticMessages } : {};
+  const result = Object.keys(staticMessages).length > 0 ? { ...staticMessages } : {};
   for (const locale in loadedMessages) {
     const loaded = loadedMessages[locale];
     if (!result[locale]) {
@@ -403,7 +404,7 @@ var mergeMessages = (staticMessages = {}, loadedMessages = {}) => {
 var CACHE_KEY_DELIMITER = "|";
 var sanitize = (k) => k.replaceAll(/[\u200B-\u200D\uFEFF]/g, "").replaceAll(/[\r\n]/g, "").trim();
 var normalizeCacheKey = (key, delimiter = CACHE_KEY_DELIMITER) => {
-  if (!key) return null;
+  if (key === null || key === void 0) return null;
   if (Array.isArray(key)) {
     if (key.length === 0) return null;
     const normalized = key.map((k) => {
@@ -427,56 +428,44 @@ var resolveNamespaces = ({
   pathname
 }) => {
   const { loader } = config;
-  const {
-    routeNamespaces = {},
-    namespaces: fallbackNamespaces
-  } = loader;
-  const { unprefixedPathname } = extractPathname({ config, pathname });
-  const standardizedPathname = standardizePathname({
-    config,
-    pathname: unprefixedPathname
-  });
+  const { routeNamespaces = {}, namespaces } = loader || {};
+  const standardizedPathname = standardizePathname({ config, pathname });
   const placeholderRemovedPathname = standardizedPathname.replace(
     `/${PREFIX_PLACEHOLDER}`,
     ""
   );
-  const defaultNamespaces = routeNamespaces.default ?? [];
-  const exactMatchNamespaces = routeNamespaces[standardizedPathname] ?? routeNamespaces[placeholderRemovedPathname];
-  if (exactMatchNamespaces) {
-    return [...defaultNamespaces, ...exactMatchNamespaces];
-  }
-  let bestMatch = "";
-  let bestNamespaces;
+  const collected = [
+    ...routeNamespaces.default || [],
+    // default
+    ...namespaces || [],
+    // default
+    ...routeNamespaces[standardizedPathname] || [],
+    // exact match
+    ...routeNamespaces[placeholderRemovedPathname] || []
+    // exact match
+  ];
   const prefixPatterns = Object.keys(routeNamespaces).filter(
     (pattern) => pattern.endsWith("/*")
   );
   for (const pattern of prefixPatterns) {
     const basePath = pattern.replace(/\/\*$/, "");
-    if (standardizedPathname.startsWith(basePath)) {
-      if (basePath.length > bestMatch.length) {
-        bestMatch = basePath;
-        bestNamespaces = routeNamespaces[pattern];
-      }
+    if (standardizedPathname.startsWith(basePath) || placeholderRemovedPathname.startsWith(basePath)) {
+      collected.push(...routeNamespaces[pattern] || []);
     }
   }
-  const matchedNamespaces = bestNamespaces ?? routeNamespaces["/*"] ?? fallbackNamespaces ?? [];
-  if (matchedNamespaces.length > 0) {
-    return [...defaultNamespaces, ...matchedNamespaces];
-  } else {
-    return [...defaultNamespaces];
-  }
+  return [...new Set(collected)];
 };
 
 // src/shared/utils/locale/normalize-locale.ts
+var toCanonical = (input) => {
+  try {
+    return Intl.getCanonicalLocales(input)[0]?.toLowerCase();
+  } catch {
+    return;
+  }
+};
 var normalizeLocale = (locale = "", supportedLocales = []) => {
   if (!locale || supportedLocales.length === 0) return;
-  const toCanonical = (input) => {
-    try {
-      return Intl.getCanonicalLocales(input)[0]?.toLowerCase();
-    } catch {
-      return;
-    }
-  };
   const canonicalLocale = toCanonical(locale);
   if (!canonicalLocale) return;
   const supportedCanonicalMap = /* @__PURE__ */ new Map();
@@ -507,12 +496,12 @@ var resolvePreferredLocale = (acceptLanguageHeader, supportedLocales) => {
   const supportedLocalesSet = new Set(supportedLocales);
   const preferred = acceptLanguageHeader.split(",").map((part) => {
     const [lang, qValue] = part.split(";");
-    const q = qValue ? parseFloat(qValue.split("=")[1]) : 1;
-    if (isNaN(q)) {
+    const q = qValue ? Number.parseFloat(qValue.split("=")[1]) : 1;
+    if (Number.isNaN(q)) {
       return { lang: lang.trim(), q: 0 };
     }
     return { lang: lang.trim(), q };
-  }).sort((a, b) => b.q - a.q).find(({ lang }) => supportedLocalesSet.has(lang))?.lang;
+  }).toSorted((a, b) => b.q - a.q).find(({ lang }) => supportedLocalesSet.has(lang))?.lang;
   return preferred;
 };
 
@@ -521,8 +510,8 @@ var normalizePathname = (rawPathname, options = {}) => {
   const length = rawPathname.length;
   let start = 0;
   let end = length - 1;
-  while (start <= end && rawPathname.charCodeAt(start) <= 32) start++;
-  while (end >= start && rawPathname.charCodeAt(end) <= 32) end--;
+  while (start <= end && (rawPathname.codePointAt(start) ?? 0) <= 32) start++;
+  while (end >= start && (rawPathname.codePointAt(end) ?? 0) <= 32) end--;
   if (start > end) return "/";
   let result = "";
   let hasSlash = false;
@@ -533,11 +522,7 @@ var normalizePathname = (rawPathname, options = {}) => {
         hasSlash = true;
       }
     } else {
-      if (hasSlash || result === "") {
-        result += "/" + char;
-      } else {
-        result += char;
-      }
+      result += hasSlash || result === "" ? "/" + char : char;
       hasSlash = false;
     }
   }
@@ -561,8 +546,8 @@ var extractPathname = ({
   } else if (basePath && normalizedPathname === basePath) {
     prefixedPathname = "/";
   }
-  const pathParts = prefixedPathname.split("/").filter(Boolean);
-  const maybeLocale = pathParts[0] || "";
+  const pathPart = prefixedPathname.split("/").find(Boolean);
+  const maybeLocale = pathPart || "";
   const isLocalePrefixed = config.supportedLocales?.includes(maybeLocale);
   let unprefixedPathname = prefixedPathname;
   if (prefix === "all") {
@@ -595,7 +580,7 @@ var standardizePathname = ({
     PREFIX_PLACEHOLDER,
     normalizePathname(pathname)
   ];
-  const standardizedPathname = parts.join("/").replace(/\/{2,}/g, "/");
+  const standardizedPathname = parts.join("/").replaceAll(/\/{2,}/g, "/");
   return normalizePathname(standardizedPathname);
 };
 
@@ -626,16 +611,19 @@ var loadLocalMessages = async ({
     namespaces: namespaces && namespaces.length > 0 ? { count: namespaces?.length, list: [...namespaces] } : "All Namespaces",
     concurrency
   });
-  const pool = getGlobalMessagesPool();
+  let pool;
+  if (cache.enabled) {
+    pool = getGlobalMessagesPool();
+  }
   const key = normalizeCacheKey([
     loggerOptions.id,
     resolvedBasePath,
     locale,
-    [...fallbackLocales ?? []].sort().join(","),
-    [...namespaces ?? []].sort().join(",")
+    (fallbackLocales ?? []).toSorted().join(","),
+    (namespaces ?? []).toSorted().join(",")
   ]);
   if (cache.enabled && key) {
-    const cached = await pool.get(key);
+    const cached = await pool?.get(key);
     if (cached) {
       logger.debug("Messages cache hit.", { key });
       return cached;
@@ -652,7 +640,7 @@ var loadLocalMessages = async ({
     logger: loggerOptions
   });
   if (cache.enabled && key) {
-    await pool.set(key, messages, cache.ttl);
+    await pool?.set(key, messages, cache.ttl);
   }
   const end = perf_hooks.performance.now();
   const duration = Math.round(end - start);
@@ -769,16 +757,19 @@ var loadApiMessages = async ({
     logger.warn("No apiUrl provided. Skipping fetch.");
     return;
   }
-  const pool = getGlobalMessagesPool();
+  let pool;
+  if (cache.enabled) {
+    pool = getGlobalMessagesPool();
+  }
   const key = normalizeCacheKey([
     loggerOptions.id,
     basePath,
     locale,
-    [...fallbackLocales ?? []].sort().join(","),
-    [...namespaces ?? []].sort().join(",")
+    (fallbackLocales ?? []).toSorted().join(","),
+    (namespaces ?? []).toSorted().join(",")
   ]);
   if (cache.enabled && key) {
-    const cached = await pool.get(key);
+    const cached = await pool?.get(key);
     if (cached) {
       logger.debug("Messages cache hit.", { key });
       return cached;
@@ -794,7 +785,7 @@ var loadApiMessages = async ({
   });
   if (messages) {
     if (cache.enabled && key) {
-      await pool.set(key, messages, cache.ttl);
+      await pool?.set(key, messages, cache.ttl);
     }
     return messages;
   }
@@ -812,7 +803,7 @@ var loadApiMessages = async ({
       searchParams: decodeURIComponent(searchParams.toString())
     });
     if (cache.enabled && key) {
-      await pool.set(key, fallbackResult.messages, cache.ttl);
+      await pool?.set(key, fallbackResult.messages, cache.ttl);
     }
     return fallbackResult.messages;
   }
@@ -823,39 +814,45 @@ var loadApiMessages = async ({
   return;
 };
 
-// src/modules/messages/get-messages.ts
-var getMessages = async ({
+// src/modules/messages/load-messages.ts
+var loadMessages = async ({
   config,
   locale,
   pathname
 }) => {
-  const baseLogger = getLogger({ id: config.id });
+  const baseLogger = getLogger({ id: config.id, ...config.logger });
   const logger = baseLogger.child({ scope: "messages-loader" });
-  const loaderOptions = config.loader;
+  if (!config.loader) {
+    logger.warn(
+      "No loader options have been configured in the current config."
+    );
+    return;
+  }
+  const { id, loader, cache } = config;
   const fallbackLocales = config.fallbackLocales[locale] || [];
   const namespaces = resolveNamespaces({ config, pathname });
   logger.debug("Namespaces ready for loading.", {
     namespaces: namespaces.length > 0 ? { count: namespaces.length, list: [...namespaces] } : "All Namespaces"
   });
-  logger.debug("Loader type selected.", { loaderType: loaderOptions.type });
+  logger.debug("Loader type selected.", { loaderType: loader.type });
   let loadedMessages;
-  if (loaderOptions.type === "import") {
-    const loadLocalMessages2 = createLoadLocalMessages(loaderOptions.basePath);
+  if (loader.type === "import") {
+    const loadLocalMessages2 = createLoadLocalMessages(loader.basePath);
     loadedMessages = await loadLocalMessages2({
-      ...loaderOptions,
+      ...loader,
       locale,
       fallbackLocales,
       namespaces,
-      cache: config.cache,
-      logger: { id: config.id }
+      cache,
+      logger: { id }
     });
-  } else if (loaderOptions.type === "api") {
+  } else if (loader.type === "api") {
     loadedMessages = await loadApiMessages({
-      ...loaderOptions,
+      ...loader,
       locale,
       fallbackLocales,
       namespaces,
-      logger: { id: config.id }
+      logger: { id }
     });
   }
   if (!loadedMessages || Object.keys(loadedMessages).length === 0) {
@@ -865,29 +862,22 @@ var getMessages = async ({
 };
 
 // src/modules/intor/intor.ts
-var intor = async ({
-  config,
-  adapter,
-  adapterRuntime
-}) => {
+var intor = async (config, i18nContext) => {
   const baseLogger = getLogger({ id: config.id, ...config.logger });
   const logger = baseLogger.child({ scope: "intor" });
   logger.info("Start Intor initialization.");
   const { messages, loader } = config;
-  let runtime;
-  if (adapter) {
-    runtime = await adapter(config);
-  } else {
-    runtime = {
-      locale: adapterRuntime?.locale || config.defaultLocale,
-      pathname: adapterRuntime?.pathname || ""
-    };
-  }
-  const { locale, pathname } = runtime;
-  logger.debug("Runtime resolved via adapter/fallback", runtime);
+  const isI18nContextFunction = typeof i18nContext === "function";
+  const context = isI18nContextFunction ? await i18nContext(config) : {
+    locale: i18nContext?.locale || config.defaultLocale,
+    pathname: i18nContext?.pathname || ""
+  };
+  const { locale, pathname } = context;
+  const source = isI18nContextFunction ? "[function]" : "[static object]";
+  logger.debug(`Context resolved via ${source}.`, context);
   let loadedMessages;
   if (shouldLoadMessages(loader)) {
-    loadedMessages = await getMessages({ config, locale, pathname });
+    loadedMessages = await loadMessages({ config, locale, pathname });
   }
   const mergedMessages = mergeMessages(messages, loadedMessages);
   logger.info("Messages initialized.", {
@@ -905,6 +895,25 @@ var intor = async ({
     messages: mergedMessages
   };
 };
+async function getTranslator(opts) {
+  const { config, locale, pathname = "", preKey, handlers } = opts;
+  const messages = await loadMessages({ config, locale, pathname });
+  const translator = new intorTranslator.Translator({
+    locale,
+    messages,
+    fallbackLocales: config.fallbackLocales,
+    loadingMessage: config.translator?.loadingMessage,
+    placeholder: config.translator?.placeholder,
+    handlers
+  });
+  const props = { messages, locale };
+  const scoped = translator.scoped(preKey);
+  return {
+    ...props,
+    hasKey: preKey ? scoped.hasKey : translator.hasKey,
+    t: preKey ? scoped.t : translator.t
+  };
+}
 
 Object.defineProperty(exports, "Translator", {
   enumerable: true,
@@ -914,10 +923,11 @@ exports.PREFIX_PLACEHOLDER = PREFIX_PLACEHOLDER;
 exports.clearLoggerPool = clearLoggerPool;
 exports.clearMessagesPool = clearMessagesPool;
 exports.extractPathname = extractPathname;
-exports.getMessages = getMessages;
+exports.getTranslator = getTranslator;
 exports.intor = intor;
 exports.loadApiMessages = loadApiMessages;
 exports.loadLocalMessages = loadLocalMessages;
+exports.loadMessages = loadMessages;
 exports.mergeMessages = mergeMessages;
 exports.normalizeCacheKey = normalizeCacheKey;
 exports.normalizeLocale = normalizeLocale;