intor 2.4.6 → 2.4.7

package/dist/core/src/routing/pathname/localize-pathname.js

@@ -11,7 +11,7 @@ import { standardizePathname } from './standardize-pathname.js';
  * // config.supportedLocales: ["en-US"]
  * // config.routing.basePath: "/app"
  * // config.routing.prefix: "all"
- * localizePathname(config, "/app/en-US/about", "en-US");
+ * localizePathname("/app/en-US/about", config, "en-US");
  * // => {
  * //   pathname: '/app/en-US/about'
  * //   unprefixedPathname: '/about',

package/dist/core/src/server/intor/intor.js

@@ -18,7 +18,7 @@ async function intor(config, locale, options) {
     // Initialize a locale-bound translator snapshot with messages loaded
     const translator = await initTranslator(config, locale, {
         readers: options?.readers,
-        allowCacheWrite: options?.allowCacheWrite,
+        allowCacheWrite: options?.allowCacheWrite ?? true,
         fetch: options?.fetch || globalThis.fetch,
     });
     logger.info("Intor initialized.");

package/dist/express/src/routing/pathname/localize-pathname.js

@@ -11,7 +11,7 @@ import { standardizePathname } from './standardize-pathname.js';
  * // config.supportedLocales: ["en-US"]
  * // config.routing.basePath: "/app"
  * // config.routing.prefix: "all"
- * localizePathname(config, "/app/en-US/about", "en-US");
+ * localizePathname("/app/en-US/about", config, "en-US");
  * // => {
  * //   pathname: '/app/en-US/about'
  * //   unprefixedPathname: '/about',

package/dist/fastify/src/routing/pathname/localize-pathname.js

@@ -11,7 +11,7 @@ import { standardizePathname } from './standardize-pathname.js';
  * // config.supportedLocales: ["en-US"]
  * // config.routing.basePath: "/app"
  * // config.routing.prefix: "all"
- * localizePathname(config, "/app/en-US/about", "en-US");
+ * localizePathname("/app/en-US/about", config, "en-US");
  * // => {
  * //   pathname: '/app/en-US/about'
  * //   unprefixedPathname: '/about',

package/dist/hono/src/routing/pathname/localize-pathname.js

@@ -11,7 +11,7 @@ import { standardizePathname } from './standardize-pathname.js';
  * // config.supportedLocales: ["en-US"]
  * // config.routing.basePath: "/app"
  * // config.routing.prefix: "all"
- * localizePathname(config, "/app/en-US/about", "en-US");
+ * localizePathname("/app/en-US/about", config, "en-US");
  * // => {
  * //   pathname: '/app/en-US/about'
  * //   unprefixedPathname: '/about',

package/dist/next/src/routing/pathname/localize-pathname.js

@@ -11,7 +11,7 @@ import { standardizePathname } from './standardize-pathname.js';
  * // config.supportedLocales: ["en-US"]
  * // config.routing.basePath: "/app"
  * // config.routing.prefix: "all"
- * localizePathname(config, "/app/en-US/about", "en-US");
+ * localizePathname("/app/en-US/about", config, "en-US");
  * // => {
  * //   pathname: '/app/en-US/about'
  * //   unprefixedPathname: '/about',

package/dist/next/src/server/intor/intor.js

@@ -18,7 +18,7 @@ async function intor(config, locale, options) {
     // Initialize a locale-bound translator snapshot with messages loaded
     const translator = await initTranslator(config, locale, {
         readers: options?.readers,
-        allowCacheWrite: options?.allowCacheWrite,
+        allowCacheWrite: options?.allowCacheWrite ?? true,
         fetch: options?.fetch || globalThis.fetch,
     });
     logger.info("Intor initialized.");

package/dist/svelte-kit/export/svelte-kit/index.js

@@ -1 +1,2 @@
+export { createIntorHandler } from '../../src/adapters/svelte-kit/create-intor-handler.js';
 export { useNavigation } from '../../src/adapters/svelte-kit/use-navigation.js';

package/dist/svelte-kit/src/adapters/svelte-kit/{server/create-intor-handler.js → create-intor-handler.js}

@@ -1,12 +1,12 @@
 import { redirect } from '@sveltejs/kit';
 import { isSvelteKitSSG } from './utils/is-svelte-kit-ssg.js';
-import '../../../core/error/intor-error.js';
-import { normalizeQuery } from '../../../core/utils/normalizers/normalize-query.js';
+import '../../core/error/intor-error.js';
+import { normalizeQuery } from '../../core/utils/normalizers/normalize-query.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
-import { resolveInbound } from '../../../routing/inbound/resolve-inbound.js';
-import { getLocaleFromAcceptLanguage } from '../../../routing/locale/get-locale-from-accept-language.js';
+import { resolveInbound } from '../../routing/inbound/resolve-inbound.js';
+import { getLocaleFromAcceptLanguage } from '../../routing/locale/get-locale-from-accept-language.js';
 
 /**
  * Resolves locale-aware routing for the current execution context.

package/dist/svelte-kit/src/core/utils/resolve-loader-options.js

@@ -21,7 +21,7 @@ const resolveLoaderOptions = (config, runtime) => {
     // ------------------------------------------------
     // runtime: client
     // ------------------------------------------------
-    if (runtime === "client") {
+    {
         const client = config.client?.loader;
         if (client) {
             // Client loader is always remote by design
@@ -29,10 +29,6 @@ const resolveLoaderOptions = (config, runtime) => {
         }
         return config.server?.loader ?? config.loader;
     }
-    // ------------------------------------------------
-    // runtime: server
-    // ------------------------------------------------
-    return config.server?.loader ?? config.loader;
 };
 
 export { resolveLoaderOptions };

package/dist/svelte-kit/src/policies/shoud-full-reload.js

@@ -8,7 +8,7 @@ import 'intor-translator';
  * Determine whether client-side navigation must be forced to reload.
  */
 function shouldFullReload(config) {
-    const loader = resolveLoaderOptions(config, "client");
+    const loader = resolveLoaderOptions(config);
     return (loader?.mode === "local" || config.routing.outbound.forceFullReload === true);
 }
 

package/dist/svelte-kit/src/routing/pathname/localize-pathname.js

@@ -11,7 +11,7 @@ import { standardizePathname } from './standardize-pathname.js';
  * // config.supportedLocales: ["en-US"]
  * // config.routing.basePath: "/app"
  * // config.routing.prefix: "all"
- * localizePathname(config, "/app/en-US/about", "en-US");
+ * localizePathname("/app/en-US/about", config, "en-US");
  * // => {
  * //   pathname: '/app/en-US/about'
  * //   unprefixedPathname: '/about',

package/dist/types/export/svelte-kit/index.d.ts

@@ -1 +1 @@
-export { useNavigation } from "../../src/adapters/svelte-kit";
+export { createIntorHandler, useNavigation } from "../../src/adapters/svelte-kit";

package/dist/types/src/adapters/next/server/get-translator.d.ts

@@ -10,7 +10,7 @@ type GetTranslatorNextParams<CK extends GenConfigKeys = "__default__"> = Omit<Ge
  *
  * @platform Next.js
  */
-export declare function getTranslator<CK extends GenConfigKeys = "__default__", ReplacementSchema = GenReplacements<CK>, RichSchema = GenRich<CK>, PK extends LocalizedPreKey<GenMessages<CK>> | undefined = undefined>(config: IntorResolvedConfig, params: GetTranslatorNextParams<CK> & {
+export declare function getTranslator<CK extends GenConfigKeys = "__default__", ReplacementSchema = GenReplacements<CK>, RichSchema = GenRich<CK>, PK extends LocalizedPreKey<GenMessages<CK>> | undefined = undefined>(config: IntorResolvedConfig, params?: GetTranslatorNextParams<CK> & {
     preKey?: PK;
 }): Promise<TranslatorInstance<GenMessages<CK>, ReplacementSchema, RichSchema, PK>>;
 export {};

package/dist/types/src/adapters/svelte-kit/{server/create-intor-handler.d.ts → create-intor-handler.d.ts}

@@ -1,4 +1,4 @@
-import type { IntorResolvedConfig } from "../../../config";
+import type { IntorResolvedConfig } from "../../config";
 import type { Handle } from "@sveltejs/kit";
 /**
  * Resolves locale-aware routing for the current execution context.

package/dist/types/src/adapters/svelte-kit/index.d.ts

@@ -1 +1,2 @@
+export { createIntorHandler } from "./create-intor-handler";
 export { useNavigation } from "./use-navigation";

package/dist/types/src/routing/index.d.ts

@@ -1,4 +1,4 @@
 export { resolveInbound, type InboundResult, type InboundContext, resolveInboundFromRequest, } from "./inbound";
+export { resolveOutbound, type OutboundResult } from "./outbound";
 export { localizePathname, type LocalizedPathname } from "./pathname";
 export { getLocaleFromAcceptLanguage, getLocaleFromPathname, getLocaleFromHost, getLocaleFromQuery, } from "./locale";
-export { resolveOutbound, type OutboundResult } from "./outbound";

package/dist/types/src/routing/pathname/localize-pathname.d.ts

@@ -37,7 +37,7 @@ export interface LocalizedPathname {
  * // config.supportedLocales: ["en-US"]
  * // config.routing.basePath: "/app"
  * // config.routing.prefix: "all"
- * localizePathname(config, "/app/en-US/about", "en-US");
+ * localizePathname("/app/en-US/about", config, "en-US");
  * // => {
  * //   pathname: '/app/en-US/about'
  * //   unprefixedPathname: '/about',

package/dist/types/src/server/intor/intor.d.ts

@@ -1,14 +1,13 @@
 import type { IntorValue } from "./types";
 import type { IntorResolvedConfig } from "../../config";
-import type { Locale } from "intor-translator";
-import { type GenConfigKeys, type MessagesReaders, type RuntimeFetch } from "../../core";
+import { type GenConfigKeys, type GenLocale, type MessagesReaders, type RuntimeFetch } from "../../core";
 /**
  * Initializes Intor for the current execution context.
  *
  * Produces a server-side snapshot for SSR and
  * full-stack rendering environments.
  */
-export declare function intor<CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, locale: Locale, options?: {
+export declare function intor<CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, locale: GenLocale<CK> | (string & {}), options?: {
     readers?: MessagesReaders;
     allowCacheWrite?: boolean;
     fetch?: RuntimeFetch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intor",
-  "version": "2.4.6",
+  "version": "2.4.7",
   "description": "The i18n library for modern JavaScript",
   "author": "Yiming Liao",
   "homepage": "https://github.com/yiming-liao/intor#readme",
@@ -73,10 +73,6 @@
       "import": "./dist/svelte-kit/export/svelte-kit/index.js",
       "types": "./dist/types/export/svelte-kit/index.d.ts"
     },
-    "./svelte-kit/server": {
-      "import": "./dist/svelte-kit/export/svelte-kit/server/index.js",
-      "types": "./dist/types/export/svelte-kit/server/index.d.ts"
-    },
     "./express": {
       "import": "./dist/express/export/express/index.js",
       "types": "./dist/types/export/express/index.d.ts",

package/dist/svelte-kit/export/svelte-kit/server/index.js

@@ -1,2 +0,0 @@
-export { createIntorHandler } from '../../../src/adapters/svelte-kit/server/create-intor-handler.js';
-export { intor } from '../../../src/adapters/svelte-kit/server/intor.js';

package/dist/svelte-kit/src/adapters/svelte-kit/server/intor.js

@@ -1,24 +0,0 @@
-import { intor as intor$1 } from '../../../server/intor/intor.js';
-import '../../../core/error/intor-error.js';
-import 'logry';
-import 'p-limit';
-import 'intor-translator';
-import 'node:path';
-import 'node:fs/promises';
-
-/**
- * Initializes Intor for the current execution context.
- *
- * - Uses the locale resolved by the SvelteKit request lifecycle.
- * - Permits cache writes during server execution.
- * @platform SvelteKit
- */
-async function intor(config, locale, fetch, options) {
-    return await intor$1(config, locale, {
-        readers: options?.readers,
-        allowCacheWrite: options?.allowCacheWrite ?? true,
-        fetch,
-    });
-}
-
-export { intor };

package/dist/svelte-kit/src/core/logger/get-logger.js

@@ -1,39 +0,0 @@
-import { logry } from 'logry';
-import { getGlobalLoggerPool } from './global-logger-pool.js';
-
-const DEFAULT_FORMAT_CONFIG = {
-    timestamp: { withDate: false },
-};
-const DEFAULT_RENDER_CONFIG = {
-    timestamp: {},
-    id: { visible: true, prefix: "<", suffix: ">" },
-    meta: { lineBreaksAfter: 1 },
-};
-/**
- * Get a shared logger instance by id.
- * - Safe across hot reloads
- * - Prevents unbounded memory usage via soft LRU
- */
-function getLogger({ id = "default", formatConfig, renderConfig, preset, ...options }) {
-    const pool = getGlobalLoggerPool();
-    let logger = pool.get(id);
-    if (!logger) {
-        logger = logry({
-            id,
-            formatConfig: !formatConfig && !preset ? DEFAULT_FORMAT_CONFIG : formatConfig,
-            renderConfig: !renderConfig && !preset ? DEFAULT_RENDER_CONFIG : renderConfig,
-            preset,
-            ...options,
-        });
-        pool.set(id, logger);
-        // Soft LRU: keep pool size under control
-        if (pool.size > 1000) {
-            const keys = [...pool.keys()];
-            for (const key of keys.slice(0, 200))
-                pool.delete(key);
-        }
-    }
-    return logger;
-}
-
-export { getLogger };

package/dist/svelte-kit/src/core/logger/global-logger-pool.js

@@ -1,8 +0,0 @@
-function getGlobalLoggerPool() {
-    if (!globalThis.__INTOR_LOGGER_POOL__) {
-        globalThis.__INTOR_LOGGER_POOL__ = new Map();
-    }
-    return globalThis.__INTOR_LOGGER_POOL__;
-}
-
-export { getGlobalLoggerPool };

package/dist/svelte-kit/src/core/messages/load-remote-messages/collect-remote-resources.js

@@ -1,25 +0,0 @@
-/**
- * Collect remote message resources for a given locale.
- *
- * - Always includes the root `index.json`
- * - Optionally includes namespace-specific resources
- * - Produces semantic paths for later message nesting
- *
- * This function performs no I/O and does not validate resource existence.
- */
-function collectRemoteResources({ locale, baseUrl, namespaces, }) {
-    const basePath = `${baseUrl}/${locale}`;
-    // Root translation resource (always loaded)
-    const indexResource = { url: `${basePath}/index.json`, path: [] };
-    // When no namespaces are provided, the locale domain consists of index only
-    if (!namespaces || namespaces.length === 0)
-        return [indexResource];
-    // Namespace-specific resources are nested under their namespace key
-    const nsResources = namespaces.map((ns) => ({
-        url: `${basePath}/${ns}.json`,
-        path: [ns],
-    }));
-    return [indexResource, ...nsResources];
-}
-
-export { collectRemoteResources };

package/dist/svelte-kit/src/core/messages/load-remote-messages/fetch-remote-resource.js

@@ -1,47 +0,0 @@
-import { getLogger } from '../../logger/get-logger.js';
-import { isValidMessages } from '../utils/is-valid-messages.js';
-
-/**
- * Fetch a single remote messages resource.
- *
- * This function performs a single HTTP request to retrieve
- * a remote translation messages payload.
- *
- * It is responsible for:
- * - Issuing the network request
- * - Validating the returned message structure
- * - Handling abort and network errors
- */
-async function fetchRemoteResource({ fetch, url, headers, signal, loggerOptions, }) {
-    const baseLogger = getLogger(loggerOptions);
-    const logger = baseLogger.child({ scope: "fetch-locale-messages" });
-    try {
-        // Fetch
-        const response = await fetch(url, {
-            method: "GET",
-            headers: { "Content-Type": "application/json", ...headers },
-            cache: "no-store",
-            signal,
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status} ${response.statusText}`);
-        }
-        // Parse JSON body
-        const data = await response.json();
-        // Validate messages structure
-        if (!isValidMessages(data)) {
-            throw new Error("Invalid messages structure");
-        }
-        return data;
-    }
-    catch (error) {
-        if (error instanceof Error && error.name === "AbortError") {
-            logger.debug("Remote fetch aborted.", { url });
-            return;
-        }
-        logger.warn("Failed to fetch remote messages.", { url, error });
-        return;
-    }
-}
-
-export { fetchRemoteResource };

package/dist/svelte-kit/src/core/messages/load-remote-messages/load-remote-messages.js

@@ -1,93 +0,0 @@
-import pLimit from 'p-limit';
-import { getLogger } from '../../logger/get-logger.js';
-import { collectRemoteResources } from './collect-remote-resources.js';
-import { fetchRemoteResource } from './fetch-remote-resource.js';
-import { resolveRemoteResources } from './resolve-remote-resources.js';
-
-/**
- * Load locale messages from a remote source.
- *
- * This function serves as the orchestration layer for remote message loading.
- * It coordinates:
- *
- * - Locale resolution with fallbacks
- * - Concurrency control for network requests
- * - Remote resource fetching and message merging
- *
- * Remote messages are fetched on demand and are not memoized at the process level.
- *
- * Network requests and response validation are delegated to lower-level utilities.
- */
-const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurrency, fetch, url: baseUrl, headers, signal, loggerOptions, }) => {
-    const baseLogger = getLogger(loggerOptions);
-    const logger = baseLogger.child({ scope: "load-remote-messages" });
-    // Abort early if the request has already been cancelled
-    if (signal?.aborted) {
-        logger.debug("Remote message loading aborted before fetch.");
-        return;
-    }
-    const start = performance.now();
-    logger.debug("Loading remote messages.", { baseUrl });
-    // ----------------------------------------------------------------
-    // Resolve locale messages with ordered fallback strategy
-    // ----------------------------------------------------------------
-    const limit = concurrency ? pLimit(concurrency) : undefined;
-    const candidateLocales = [locale, ...(fallbackLocales || [])];
-    let messages;
-    for (let i = 0; i < candidateLocales.length; i++) {
-        const candidateLocale = candidateLocales[i];
-        const isLast = i === candidateLocales.length - 1;
-        try {
-            // -----------------------------------------------------------------
-            // Collect remote message resources for the locale
-            // -----------------------------------------------------------------
-            const resources = collectRemoteResources({
-                locale: candidateLocale,
-                baseUrl,
-                namespaces,
-            });
-            // -----------------------------------------------------------------
-            // Fetch all message chunks in parallel
-            // -----------------------------------------------------------------
-            const fetchUrl = (url) => fetchRemoteResource({ url, headers, signal, loggerOptions, fetch });
-            const results = await Promise.all(resources.map(({ url }) => limit ? limit(() => fetchUrl(url)) : fetchUrl(url)));
-            // Guard: no valid remote resources
-            if (!results.some(Boolean))
-                continue;
-            // -----------------------------------------------------------------
-            // Resolve and merge remote message resources
-            // -----------------------------------------------------------------
-            const resolved = resolveRemoteResources(resources.map((res, i) => ({ path: res.path, data: results[i] })));
-            // -----------------------------------------------------------------
-            // Wrap resolved messages into locale-scoped LocaleMessages
-            // -----------------------------------------------------------------
-            messages = { [candidateLocale]: resolved };
-            break;
-        }
-        catch {
-            if (signal?.aborted) {
-                logger.debug("Remote message loading aborted.");
-                return;
-            }
-            if (isLast) {
-                logger.warn("Failed to load messages for all candidate locales.", {
-                    locale,
-                    fallbackLocales,
-                });
-            }
-            else {
-                logger.warn(`Failed to load locale messages for "${candidateLocale}", trying next fallback.`);
-            }
-        }
-    }
-    // Final success log with resolved locale and timing
-    if (messages) {
-        logger.trace("Finished loading remote messages.", {
-            loadedLocale: Object.keys(messages)[0],
-            duration: `${Math.round(performance.now() - start)} ms`,
-        });
-    }
-    return messages;
-};
-
-export { loadRemoteMessages };

package/dist/svelte-kit/src/core/messages/load-remote-messages/resolve-remote-resources.js

@@ -1,24 +0,0 @@
-import { deepMerge } from '../../utils/deep-merge.js';
-import { nestObjectFromPath } from '../utils/nest-object-from-path.js';
-
-/**
- * Resolve remote message resources into a single MessageObject.
- *
- * - Applies semantic nesting based on resource path
- * - Merges all resolved message chunks
- *
- * Always returns a MessageObject.
- * An empty object represents an empty translation domain.
- */
-function resolveRemoteResources(resources) {
-    let result = {};
-    for (const { path, data } of resources) {
-        if (!data)
-            continue;
-        const resolved = path.length > 0 ? nestObjectFromPath(path, data) : data;
-        result = deepMerge(result, resolved);
-    }
-    return result;
-}
-
-export { resolveRemoteResources };

package/dist/svelte-kit/src/core/messages/merge-messages.js

@@ -1,33 +0,0 @@
-import { getLogger } from '../logger/get-logger.js';
-import { deepMerge } from '../utils/deep-merge.js';
-
-/**
- * Merge locale-specific messages with runtime overrides.
- *
- * - Only merges messages under the given locale
- * - Emits debug logs for add / override events
- */
-function mergeMessages(a, b, { config, locale, onEvent }) {
-    const baseLogger = getLogger({ ...config.logger, id: config.id });
-    const logger = baseLogger.child({ scope: "merge-messages" });
-    // Merge messages for the active locale only
-    const merged = deepMerge(a?.[locale] ?? {}, b?.[locale] ?? {}, {
-        onOverride: (event) => {
-            if (onEvent) {
-                onEvent(event);
-                return;
-            }
-            const { kind, path, next, prev } = event;
-            if (kind === "add")
-                return;
-            logger.debug(`Override | ${locale}: "${path}"`, { prev, next });
-        },
-    });
-    // Preserve other locales, update only the target one
-    return {
-        ...a,
-        [locale]: merged,
-    };
-}
-
-export { mergeMessages };

package/dist/svelte-kit/src/core/messages/utils/is-valid-messages.js

@@ -1,44 +0,0 @@
-/** Check if a value is a plain object (not null, not array) */
-function isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
- * Check if a value is a valid MessageObject.
- *
- * - Supports all MessageValue variants (primitive, array, object).
- * - Uses an iterative approach to avoid stack overflow.
- */
-function isValidMessages(value) {
-    if (!isPlainObject(value))
-        return false;
-    const stack = [value];
-    while (stack.length > 0) {
-        const current = stack.pop();
-        // primitives are always valid
-        if (current === null ||
-            typeof current === "string" ||
-            typeof current === "number" ||
-            typeof current === "boolean") {
-            continue;
-        }
-        // array → validate each item
-        if (Array.isArray(current)) {
-            for (const item of current) {
-                stack.push(item);
-            }
-            continue;
-        }
-        // object → validate each value
-        if (isPlainObject(current)) {
-            for (const v of Object.values(current)) {
-                stack.push(v);
-            }
-            continue;
-        }
-        // everything else is invalid
-        return false;
-    }
-    return true;
-}
-
-export { isPlainObject, isValidMessages };

package/dist/svelte-kit/src/core/messages/utils/nest-object-from-path.js

@@ -1,21 +0,0 @@
-/**
- * Wraps a value inside nested objects according to a given path.
- *
- * @example
- * ```ts
- * const value = { a: "A" };
- *
- * nestObjectFromPath(["auth", "verify"], value); // → { auth: { verify: { a: "A" } } }
- *
- * nestObjectFromPath([], value); // →  { a: "A" }
- * ```
- */
-function nestObjectFromPath(path, value) {
-    let obj = value;
-    for (let i = path.length - 1; i >= 0; i--) {
-        obj = { [path[i]]: obj };
-    }
-    return obj;
-}
-
-export { nestObjectFromPath };

package/dist/svelte-kit/src/core/translator/create-translator.js

@@ -1,30 +0,0 @@
-import { Translator } from 'intor-translator';
-import { mergeMessages } from '../messages/merge-messages.js';
-
-/**
- * Create a server-side Translator instance for a fixed locale.
- *
- * - Merges static config messages with runtime-loaded messages
- * - Initializes a Translator bound to a specific locale
- * - Injects fallback rules, handlers, and plugins from config
- */
-function createTranslator(params) {
-    const { config, locale, messages, handlers, plugins } = params;
-    // Merge static config messages with runtime-loaded messages
-    const finalMessages = mergeMessages(config.messages, messages, {
-        config,
-        locale,
-    });
-    const translator = new Translator({
-        locale,
-        messages: finalMessages,
-        fallbackLocales: config.fallbackLocales,
-        loadingMessage: config.translator?.loadingMessage,
-        missingMessage: config.translator?.missingMessage,
-        handlers,
-        plugins,
-    });
-    return translator;
-}
-
-export { createTranslator };