intor 2.3.29 → 2.3.31

package/dist/next/src/server/helpers/get-translator.js

@@ -2,12 +2,12 @@ import { initTranslator } from '../translator/init-translator.js';
 
 // Implementation
 async function getTranslator(config, params) {
-    const { readers, allowCacheWrite, preKey, handlers, plugins } = params;
-    const locale = params.locale;
+    const { locale, readers, allowCacheWrite, fetch, preKey, handlers, plugins } = params;
     // Initialize a locale-bound translator snapshot with messages loaded
     const translator = await initTranslator(config, locale, {
         readers,
         allowCacheWrite,
+        fetch: fetch || globalThis.fetch,
         preKey,
         plugins,
         handlers,

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

@@ -9,21 +9,16 @@ import { initTranslator } from '../translator/init-translator.js';
  * Produces a server-side snapshot for SSR and
  * full-stack rendering environments.
  */
-async function intor(config, localeOrResolver, options) {
+async function intor(config, locale, options) {
     const baseLogger = getLogger(config.logger);
     const logger = baseLogger.child({ scope: "intor" });
     logger.info("Start Intor initialization.");
-    // Resolve locale
-    const isLocaleFunction = typeof localeOrResolver === "function";
-    const locale = isLocaleFunction
-        ? await localeOrResolver(config)
-        : localeOrResolver || config.defaultLocale;
-    const source = typeof localeOrResolver === "function" ? "resolver" : "static";
-    logger.debug(`Initial locale resolved as "${locale}" via "${source}".`);
+    logger.debug(`Initializing Intor with locale "${locale}".`);
     // Initialize a locale-bound translator snapshot with messages loaded
     const translator = await initTranslator(config, locale, {
         readers: options?.readers,
         allowCacheWrite: options?.allowCacheWrite,
+        fetch: options?.fetch || globalThis.fetch,
     });
     logger.info("Intor initialized.");
     return {

package/dist/next/src/server/messages/load-messages.js

@@ -17,7 +17,7 @@ import { loadLocalMessages } from './load-local-messages/load-local-messages.js'
  * Message traversal, parsing, fallback resolution, and caching logic
  * are delegated to the selected loader.
  */
-const loadMessages = async ({ config, locale, readers, allowCacheWrite = false, }) => {
+const loadMessages = async ({ config, locale, readers, allowCacheWrite = false, fetch, }) => {
     const baseLogger = getLogger(config.logger);
     const logger = baseLogger.child({ scope: "load-messages" });
     // ---------------------------------------------------------------------------
@@ -61,6 +61,7 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
             fallbackLocales,
             namespaces,
             concurrency,
+            fetch,
             url: loader.url,
             headers: loader.headers,
             loggerOptions: config.logger,

package/dist/next/src/server/translator/init-translator.js

@@ -14,13 +14,19 @@ import { createTranslator } from './create-translator.js';
  * - Returns an immutable translator snapshot.
  */
 async function initTranslator(config, locale, options) {
-    const { readers, allowCacheWrite = false, preKey, handlers, plugins, } = options || {};
+    const { readers, allowCacheWrite = false, fetch, preKey, handlers, plugins, } = options;
     const loader = resolveLoaderOptions(config, "server");
     // Load messages
     let messages = {};
     if (loader) {
-        messages =
-            (await loadMessages({ config, locale, readers, allowCacheWrite })) || {};
+        const loaded = await loadMessages({
+            config,
+            locale,
+            readers,
+            allowCacheWrite,
+            fetch,
+        });
+        messages = loaded || {};
     }
     // Create immutable translator snapshot
     return createTranslator({

package/dist/react/export/react/index.js

@@ -2,7 +2,5 @@ export { IntorProvider } from '../../src/client/react/provider/intor-provider.js
 export { useIntorContext } from '../../src/client/react/provider/use-intor-context.js';
 export { useTranslator } from '../../src/client/react/translator/use-translator.js';
 export { Trans } from '../../src/client/react/translator/trans.js';
-export { useResolveNavigation } from '../../src/client/react/navigation/use-resolve-navigation.js';
-export { useExecuteNavigation } from '../../src/client/react/navigation/use-execute-navigation.js';
 export { useIntor } from '../../src/client/react/helpers/use-intor.js';
 export { getClientLocale } from '../../src/client/shared/helpers/get-client-locale.js';

package/dist/react/src/client/shared/messages/create-refetch-messages.js

@@ -30,6 +30,7 @@ const createRefetchMessages = ({ config, onLoadingStart, onLoadingEnd, onMessage
                 fallbackLocales: config.fallbackLocales[newLocale] || [],
                 namespaces: loader.namespaces,
                 concurrency: loader.concurrency,
+                fetch: globalThis.fetch,
                 url: loader.url,
                 headers: loader.headers,
                 signal: currentController.signal,

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

@@ -12,7 +12,7 @@ import { isValidMessages } from '../utils/is-valid-messages.js';
  * - Validating the returned message structure
  * - Handling abort and network errors
  */
-async function fetchRemoteResource({ url, headers, signal, loggerOptions, }) {
+async function fetchRemoteResource({ fetch, url, headers, signal, loggerOptions, }) {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "fetch-locale-messages" });
     try {

package/dist/react/src/core/messages/load-remote-messages/load-remote-messages.js

@@ -18,7 +18,7 @@ import { resolveRemoteResources } from './resolve-remote-resources.js';
  *
  * Network requests and response validation are delegated to lower-level utilities.
  */
-const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurrency, url: baseUrl, headers, signal, loggerOptions, }) => {
+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
@@ -49,7 +49,7 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurr
             // -----------------------------------------------------------------
             // Fetch all message chunks in parallel
             // -----------------------------------------------------------------
-            const fetchUrl = (url) => fetchRemoteResource({ url, headers, signal, loggerOptions });
+            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))

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

@@ -1,3 +1,5 @@
-export { createIntorStore } from '../../src/client/svelte/store/create-intor-store.js';
-export { createIntor } from '../../src/client/svelte/helpers/create-intor.js';
+export { createIntorStore } from '../../src/client/svelte/provider/create-intor-store.js';
+export { default as IntorProvider } from '../../src/client/svelte/provider/intor-provider.svelte';
+export { useIntorContext } from '../../src/client/svelte/provider/use-intor-context.js';
+export { useTranslator } from '../../src/client/svelte/translator/use-translator.js';
 export { getClientLocale } from '../../src/client/shared/helpers/get-client-locale.js';

package/dist/svelte/src/client/shared/messages/create-refetch-messages.js

@@ -30,6 +30,7 @@ const createRefetchMessages = ({ config, onLoadingStart, onLoadingEnd, onMessage
                 fallbackLocales: config.fallbackLocales[newLocale] || [],
                 namespaces: loader.namespaces,
                 concurrency: loader.concurrency,
+                fetch: globalThis.fetch,
                 url: loader.url,
                 headers: loader.headers,
                 signal: currentController.signal,

package/dist/svelte/src/client/svelte/{store → provider}/create-intor-store.js

@@ -1,9 +1,10 @@
 import { Translator } from 'intor-translator';
+import { setContext } from 'svelte';
 import { writable, readable, derived, get } from 'svelte/store';
-import { createTranslatorBindings } from './create-translator-bindings.js';
 import { attachLocaleEffects } from './effects/locale-effects.js';
 import { attachMessagesEffects } from './effects/messages-effects.js';
 
+const INTOR_CONTEXT_KEY = Symbol("intor:svelte");
 function createIntorStore({ config, locale: initialLocale, messages, handlers, plugins, onLocaleChange, isLoading: externalIsLoading, }) {
     // ---------------------------------------------------------------------------
     // Internal state
@@ -25,11 +26,12 @@ function createIntorStore({ config, locale: initialLocale, messages, handlers, p
     // ---------------------------------------------------------------------------
     // Effective state
     // ---------------------------------------------------------------------------
-    const externalIsLoadingStore = externalIsLoading ?? readable(false);
+    const externalIsLoadingStore = readable(!!externalIsLoading);
     // external > internal
     const effectiveIsLoading = derived([externalIsLoadingStore, internalIsLoading], ([$external, $internal]) => $external || $internal);
     // runtime (client refetch) > initial > config (static)
-    const effectiveMessages = derived([runtimeMessages, messages ?? readable(undefined)], ([$runtime, $initial]) => $runtime || $initial || config.messages || {});
+    const initialMessagesStore = readable(messages || config.messages || {});
+    const effectiveMessages = derived([runtimeMessages, initialMessagesStore], ([$runtime, $initial]) => $runtime || $initial);
     // ---------------------------------------------------------------------------
     // Translator
     // ---------------------------------------------------------------------------
@@ -48,16 +50,7 @@ function createIntorStore({ config, locale: initialLocale, messages, handlers, p
     // ---------------------------------------------------------------------------
     attachLocaleEffects(locale, config);
     attachMessagesEffects({ config, locale, runtimeMessages, internalIsLoading });
-    const { scoped, t, tRich } = createTranslatorBindings(translator);
-    return {
-        messages: effectiveMessages,
-        locale,
-        isLoading: effectiveIsLoading,
-        setLocale,
-        scoped,
-        t,
-        tRich,
-    };
+    setContext(INTOR_CONTEXT_KEY, { config, locale, setLocale, translator });
 }
 
-export { createIntorStore };
+export { INTOR_CONTEXT_KEY, createIntorStore };

package/dist/svelte/src/client/svelte/provider/intor-provider.svelte

@@ -0,0 +1,7 @@
+<script lang="ts">
+  import { createIntorStore } from "./create-intor-store";
+  export let value;
+  createIntorStore(value);
+</script>
+
+<slot />

package/dist/svelte/src/client/svelte/provider/use-intor-context.js

@@ -0,0 +1,11 @@
+import { getContext } from 'svelte';
+import { INTOR_CONTEXT_KEY } from './create-intor-store.js';
+
+function useIntorContext() {
+    const context = getContext(INTOR_CONTEXT_KEY);
+    if (!context)
+        throw new Error("useIntorContext must be used within IntorProvider");
+    return context;
+}
+
+export { useIntorContext };

package/dist/svelte/src/client/svelte/render/create-svelte-renderer.js

@@ -18,12 +18,11 @@ const createSvelteRenderer = (options) => {
         },
         /** Render semantic tag nodes */
         tag(name, attributes, children) {
-            const renderer = tagRenderers?.[name];
-            // Custom tag renderer
-            if (renderer) {
-                return typeof renderer === "function"
-                    ? renderer(children, attributes)
-                    : renderer;
+            const tagRenderer = tagRenderers?.[name];
+            if (tagRenderer) {
+                return typeof tagRenderer === "function"
+                    ? tagRenderer(children)
+                    : tagRenderer;
             }
             // Default behavior: render as native HTML tag
             return `<${name}${renderAttributes(attributes)}>${children.join("")}</${name}>`;

package/dist/svelte/src/client/svelte/translator/create-t-rich.js

@@ -0,0 +1,23 @@
+import { renderRichMessageSvelte } from '../render/render-rich-message-svelte.js';
+
+/**
+ * Create a Svelte-specific rich translation function.
+ *
+ * This adapter bridges the core Translator with the Svelte rich
+ * message rendering flow.
+ *
+ * - Resolves translated messages via `translator.t`
+ * - Renders semantic tags using Svelte renderers
+ * - Supports optional scoped keys via `preKey`
+ *
+ * Intended for Svelte client usage only.
+ */
+const createTRich = (translator, preKey) => {
+    const t = preKey ? translator.scoped(preKey).t : translator.t;
+    return (key, tagRenderers, replacements) => {
+        const message = t(key, replacements);
+        return renderRichMessageSvelte(message, tagRenderers);
+    };
+};
+
+export { createTRich };

package/dist/svelte/src/client/svelte/translator/use-translator.js

@@ -0,0 +1,32 @@
+import { derived } from 'svelte/store';
+import 'intor-translator';
+import 'svelte';
+import '../../../core/error/intor-error.js';
+import 'logry';
+import 'p-limit';
+import '../provider/intor-provider.svelte';
+import { useIntorContext } from '../provider/use-intor-context.js';
+import { createTRich } from './create-t-rich.js';
+
+// Implementation
+function useTranslator(preKey) {
+    const { translator, locale, setLocale } = useIntorContext();
+    const scoped = preKey
+        ? derived(translator, ($t) => $t.scoped(preKey))
+        : translator;
+    return {
+        messages: derived(translator, ($t) => $t.messages),
+        locale,
+        isLoading: derived(translator, ($t) => $t.isLoading),
+        setLocale,
+        hasKey: derived(scoped, ($t) => $t.hasKey),
+        t: derived(scoped, ($t) => $t.t),
+        tRich: derived(translator, ($t) => createTRich($t, preKey)),
+        // NOTE:
+        // The runtime implementation is intentionally erased.
+        // Type safety is guaranteed by public type contracts.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    };
+}
+
+export { useTranslator };

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

@@ -12,7 +12,7 @@ import { isValidMessages } from '../utils/is-valid-messages.js';
  * - Validating the returned message structure
  * - Handling abort and network errors
  */
-async function fetchRemoteResource({ url, headers, signal, loggerOptions, }) {
+async function fetchRemoteResource({ fetch, url, headers, signal, loggerOptions, }) {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "fetch-locale-messages" });
     try {

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

@@ -18,7 +18,7 @@ import { resolveRemoteResources } from './resolve-remote-resources.js';
  *
  * Network requests and response validation are delegated to lower-level utilities.
  */
-const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurrency, url: baseUrl, headers, signal, loggerOptions, }) => {
+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
@@ -49,7 +49,7 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurr
             // -----------------------------------------------------------------
             // Fetch all message chunks in parallel
             // -----------------------------------------------------------------
-            const fetchUrl = (url) => fetchRemoteResource({ url, headers, signal, loggerOptions });
+            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))

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

@@ -0,0 +1 @@
+export { useNavigation } from '../../src/adapters/svelte-kit/navigation/use-navigation.js';

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

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

package/dist/svelte-kit/src/adapters/svelte-kit/navigation/use-navigation.js

@@ -0,0 +1,36 @@
+import { get } from 'svelte/store';
+import { executeNavigation } from '../../../client/shared/navigation/execute-navigation.js';
+import { useIntorContext } from 'intor/svelte';
+import '../../../core/error/intor-error.js';
+import 'logry';
+import 'p-limit';
+import { resolveNavigation } from '../../../routing/navigation/resolve-navigation.js';
+import { goto } from '$app/navigation';
+import { page } from '$app/state';
+
+/**
+ * Locale-aware navigation utilities for SvelteKit.
+ *
+ * Provides imperative navigation helpers that integrate
+ * Intor's locale-aware routing and side effects.
+ *
+ * @platform SvelteKit
+ */
+function useNavigation() {
+    const { config, locale: currentLocale, setLocale } = useIntorContext();
+    async function goto$1(url, opts) {
+        const { locale, ...rest } = opts || {};
+        const navigationResult = resolveNavigation(config, get(currentLocale), page.url.pathname, { destination: url, locale });
+        executeNavigation(navigationResult, {
+            config,
+            currentLocale: get(currentLocale),
+            setLocale,
+        });
+        return goto(navigationResult.destination, rest);
+    }
+    return {
+        goto: goto$1,
+    };
+}
+
+export { useNavigation };

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

@@ -0,0 +1,66 @@
+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 'logry';
+import 'p-limit';
+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.
+ *
+ * The resolved routing state is exposed via response headers.
+ *
+ * - Acts as the canonical routing authority within the SvelteKit request lifecycle.
+ *
+ * @platform SvelteKit
+ */
+function createIntorHandle(config) {
+    return async ({ event, resolve }) => {
+        // Locale from Accept-Language header
+        const acceptLanguage = event.request.headers.get("accept-language");
+        const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(acceptLanguage, config.supportedLocales);
+        // ----------------------------------------------------------
+        // Resolve inbound routing decision (pure computation)
+        // ----------------------------------------------------------
+        let inbound;
+        if (isSvelteKitSSG(event)) {
+            inbound = {
+                locale: event.params?.locale,
+                localeSource: "path",
+                pathname: event.url.pathname,
+                shouldRedirect: false,
+            };
+        }
+        else {
+            inbound = await resolveInbound(config, event.url.pathname, false, {
+                host: event.url.host,
+                query: normalizeQuery(Object.fromEntries(event.url.searchParams.entries())),
+                cookie: event.cookies.get(config.cookie.name),
+                detected: localeFromAcceptLanguage || config.defaultLocale,
+            });
+        }
+        const { locale, localeSource, pathname, shouldRedirect } = inbound;
+        // ----------------------------------------------------------
+        // Redirect if needed
+        // ----------------------------------------------------------
+        if (shouldRedirect)
+            redirect(307, pathname);
+        // ----------------------------------------------------------
+        // Bind inbound routing context
+        // ----------------------------------------------------------
+        // @ts-expect-error - App.Locals must be extended by user
+        event.locals.intor = {
+            locale,
+            localeSource,
+            pathname,
+        };
+        const response = await resolve(event, {
+            transformPageChunk: ({ html }) => html.replace("%lang%", locale),
+        });
+        return response;
+    };
+}
+
+export { createIntorHandle };

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

@@ -0,0 +1,24 @@
+import '../../../core/error/intor-error.js';
+import 'logry';
+import 'p-limit';
+import { intor as intor$1 } from '../../../server/intor/intor.js';
+import 'node:path';
+import 'node:fs/promises';
+import 'intor-translator';
+
+/**
+ * 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/adapters/svelte-kit/server/utils/is-svelte-kit-ssg.js

@@ -0,0 +1,15 @@
+/**
+ * Heuristic to detect static (prerender) execution in SvelteKit.
+ *
+ * This is NOT a guaranteed signal.
+ * It intentionally prefers false positives over false negatives.
+ */
+function isSvelteKitSSG(event) {
+    // No user-agent is a strong signal of static rendering
+    if (event.request.headers.get("user-agent") === null) {
+        return true;
+    }
+    return false;
+}
+
+export { isSvelteKitSSG };

package/dist/svelte-kit/src/client/shared/navigation/execute-navigation.js

@@ -0,0 +1,49 @@
+import '../../../core/error/intor-error.js';
+import 'logry';
+import 'p-limit';
+import { shouldSyncLocale } from '../../../policies/should-sync-locale.js';
+import { setLocaleCookie } from '../utils/locale/set-locale-cookie.js';
+
+/**
+ * Executes a resolved navigation result.
+ *
+ * Applies all imperative side effects required to complete navigation,
+ * including locale synchronization, cookie persistence, and full reloads.
+ *
+ * This function must be called after `resolveNavigation`.
+ */
+function executeNavigation(navigationResult, context, e) {
+    const { config, currentLocale, setLocale } = context;
+    const { cookie } = config;
+    const { destination, kind, locale } = navigationResult;
+    // ------------------------------------------------------
+    // External navigation: let browser handle it
+    // ------------------------------------------------------
+    if (kind === "external") {
+        return;
+    }
+    // ------------------------------------------------------
+    // Full reload: commit locale side effects, then perform document reload
+    // ------------------------------------------------------
+    if (kind === "reload") {
+        if (shouldSyncLocale(locale, currentLocale)) {
+            if (cookie.persist) {
+                setLocaleCookie(cookie, locale);
+            }
+        }
+        globalThis.location.href = destination;
+        return;
+    }
+    // ------------------------------------------------------
+    // Client-side navigation only
+    // ------------------------------------------------------
+    if (shouldSyncLocale(locale, currentLocale)) {
+        // Eagerly persist locale to avoid stale cookie during client-side navigation.
+        if (cookie.persist) {
+            setLocaleCookie(cookie, locale);
+        }
+        setLocale(locale);
+    }
+}
+
+export { executeNavigation };

package/dist/svelte-kit/src/client/shared/utils/build-cookie-string.js

@@ -0,0 +1,30 @@
+/**
+ * Build a serialized cookie string.
+ */
+const buildCookieString = (cookieOptions, value) => {
+    const { name, maxAge, path, domain, sameSite, secure } = cookieOptions;
+    // Cookie name and encoded value
+    const parts = [`${name}=${encodeURIComponent(value)}`];
+    // Add expiration and max-age if provided
+    if (maxAge) {
+        const expires = new Date(Date.now() + maxAge * 1000).toUTCString();
+        parts.push(`expires=${expires}`, `max-age=${maxAge}`);
+    }
+    // Set path (default to "/")
+    parts.push(`path=${path ?? "/"}`);
+    // Add domain if specified
+    if (domain) {
+        parts.push(`domain=${domain}`);
+    }
+    // Add SameSite policy (e.g., Lax, Strict)
+    if (sameSite) {
+        parts.push(`SameSite=${sameSite[0].toUpperCase()}${sameSite.slice(1).toLowerCase()}`);
+    }
+    // Add Secure flag if not explicitly disabled
+    if (secure !== false) {
+        parts.push(`Secure`);
+    }
+    return parts.join("; ");
+};
+
+export { buildCookieString };

package/dist/svelte-kit/src/client/shared/utils/locale/set-locale-cookie.js

@@ -0,0 +1,15 @@
+import { buildCookieString } from '../build-cookie-string.js';
+
+/**
+ * Persist locale to a cookie.
+ *
+ * This function relies on `document.cookie`.
+ */
+const setLocaleCookie = (cookieOptions, locale) => {
+    if (typeof document === "undefined")
+        return;
+    // Build and apply the cookie string
+    document.cookie = buildCookieString(cookieOptions, locale);
+};
+
+export { setLocaleCookie };

package/dist/svelte-kit/src/core/error/intor-error.js

@@ -0,0 +1,9 @@
+var IntorErrorCode;
+(function (IntorErrorCode) {
+    // config
+    IntorErrorCode["INVALID_CONFIG_ID"] = "INTOR_INVALID_CONFIG_ID";
+    IntorErrorCode["MISSING_SUPPORTED_LOCALES"] = "INTOR_MISSING_SUPPORTED_LOCALES";
+    IntorErrorCode["UNSUPPORTED_DEFAULT_LOCALE"] = "INTOR_UNSUPPORTED_DEFAULT_LOCALE";
+})(IntorErrorCode || (IntorErrorCode = {}));
+
+export { IntorErrorCode };

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

@@ -0,0 +1,39 @@
+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

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