intor 2.4.17 → 2.5.0

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

@@ -34,9 +34,8 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurr
     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;
+    for (const candidateLocale of candidateLocales) {
+        const isLast = candidateLocale === candidateLocales[candidateLocales.length - 1];
         try {
             // -----------------------------------------------------------------
             // Collect remote message resources for the locale
@@ -44,12 +43,18 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurr
             const resources = collectRemoteResources({
                 locale: candidateLocale,
                 baseUrl,
-                namespaces,
+                ...(namespaces !== undefined ? { namespaces } : {}),
             });
             // -----------------------------------------------------------------
             // Fetch all message chunks in parallel
             // -----------------------------------------------------------------
-            const fetchUrl = (url) => fetchRemoteResource({ url, headers, signal, loggerOptions, fetch });
+            const fetchUrl = (url) => fetchRemoteResource({
+                url,
+                ...(headers !== undefined ? { headers } : {}),
+                ...(signal !== undefined ? { 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))
@@ -57,7 +62,10 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurr
             // -----------------------------------------------------------------
             // Resolve and merge remote message resources
             // -----------------------------------------------------------------
-            const resolved = resolveRemoteResources(resources.map((res, i) => ({ path: res.path, data: results[i] })));
+            const resolved = resolveRemoteResources(resources.map((res, i) => {
+                const data = results[i];
+                return { path: res.path, ...(data !== undefined ? { data } : {}) };
+            }));
             // -----------------------------------------------------------------
             // Wrap resolved messages into locale-scoped LocaleMessages
             // -----------------------------------------------------------------

package/dist/react/src/core/messages/merge-messages.js

@@ -6,6 +6,8 @@ import { deepMerge } from '../utils/deep-merge.js';
  *
  * - Only merges messages under the given locale
  * - Emits debug logs for add / override events
+ *
+ * @public
  */
 function mergeMessages(a, b, { config, locale, onEvent }) {
     const baseLogger = getLogger({ ...config.logger, id: config.id });

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

@@ -1,10 +1,14 @@
 export { createIntorStore } from '../../src/client/svelte/provider/create-intor-store.js';
 import IntorProviderComponent from '../../src/client/svelte/provider/intor-provider.svelte';
-export { useIntorContext } from '../../src/client/svelte/provider/use-intor-context.js';
+import 'svelte';
 export { useTranslator } from '../../src/client/svelte/translator/use-translator.js';
-export { getClientLocale } from '../../src/client/shared/helpers/get-client-locale.js';
 
 // intor / svelte
+/**
+ * Svelte provider component for Intor.
+ *
+ * @public
+ */
 const IntorProvider = IntorProviderComponent;
 
 export { IntorProvider };

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

@@ -0,0 +1,7 @@
+import 'intor-translator';
+import 'svelte';
+import 'svelte/store';
+import 'logry';
+import 'p-limit';
+import '../../../src/client/svelte/provider/intor-provider.svelte';
+export { getIntorContext } from '../../../src/client/svelte/provider/get-intor-context.js';

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

@@ -1,4 +1,3 @@
-import '../../../core/error/intor-error.js';
 import { resolveLoaderOptions } from '../../../core/utils/resolve-loader-options.js';
 import 'logry';
 import { loadRemoteMessages } from '../../../core/messages/load-remote-messages/load-remote-messages.js';
@@ -20,6 +19,7 @@ const createRefetchMessages = ({ config, onLoadingStart, onLoadingEnd, onMessage
         const loader = resolveLoaderOptions(config);
         if (!loader || loader.mode !== "remote")
             return;
+        const { namespaces, concurrency, url, headers } = loader;
         // Abort previous request
         controller?.abort();
         const currentController = new AbortController();
@@ -29,11 +29,11 @@ const createRefetchMessages = ({ config, onLoadingStart, onLoadingEnd, onMessage
             const loadedMessages = await loadRemoteMessages({
                 locale: newLocale,
                 fallbackLocales: config.fallbackLocales[newLocale] || [],
-                namespaces: loader.namespaces,
-                concurrency: loader.concurrency,
+                ...(namespaces !== undefined ? { namespaces } : {}),
+                ...(concurrency !== undefined ? { concurrency } : {}),
                 fetch: globalThis.fetch,
-                url: loader.url,
-                headers: loader.headers,
+                url,
+                ...(headers !== undefined ? { headers } : {}),
                 signal: currentController.signal,
                 loggerOptions: config.logger,
             });

package/dist/svelte/src/client/shared/provider/effective-state.js

@@ -0,0 +1,12 @@
+// runtime > external > config
+// Always resolves to a non-null message object.
+function resolveEffectiveMessages(runtime, external, configMessages) {
+    return runtime ?? external ?? configMessages ?? {};
+}
+// external > internal
+// Loading is active if either source is truthy
+function resolveEffectiveIsLoading(external, internal) {
+    return !!external || internal;
+}
+
+export { resolveEffectiveIsLoading, resolveEffectiveMessages };

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

@@ -6,7 +6,7 @@ const buildCookieString = (cookieOptions, value) => {
     // Cookie name and encoded value
     const parts = [`${name}=${encodeURIComponent(value)}`];
     // Add expiration and max-age if provided
-    if (maxAge) {
+    if (maxAge !== undefined) {
         const expires = new Date(Date.now() + maxAge * 1000).toUTCString();
         parts.push(`expires=${expires}`, `max-age=${maxAge}`);
     }
@@ -18,7 +18,8 @@ const buildCookieString = (cookieOptions, value) => {
     }
     // Add SameSite policy (e.g., Lax, Strict)
     if (sameSite) {
-        parts.push(`SameSite=${sameSite[0].toUpperCase()}${sameSite.slice(1).toLowerCase()}`);
+        const normalized = sameSite.charAt(0).toUpperCase() + sameSite.slice(1).toLowerCase();
+        parts.push(`SameSite=${normalized}`);
     }
     // Add Secure flag if not explicitly disabled
     if (secure !== false) {

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

@@ -1,11 +1,12 @@
 import { Translator } from 'intor-translator';
 import { setContext } from 'svelte';
 import { writable, readable, derived, get } from 'svelte/store';
-import { attachLocaleEffects } from './effects/locale-effects.js';
-import { attachMessagesEffects } from './effects/messages-effects.js';
+import { resolveEffectiveIsLoading, resolveEffectiveMessages } from '../../shared/provider/effective-state.js';
+import { attachLocaleEffects } from './effects/attach-locale-effects.js';
+import { attachMessagesEffects } from './effects/attach-messages-effects.js';
 
-const INTOR_CONTEXT_KEY = Symbol("intor:svelte");
-function createIntorStore({ config, locale: initialLocale, messages, handlers, plugins, onLocaleChange, isLoading: externalIsLoading, }) {
+const INTOR_CONTEXT_KEY = Symbol("IntorContext");
+function buildIntorStores({ config, locale: initialLocale, messages, handlers, hooks, onLocaleChange, isLoading: externalIsLoading, }) {
     // ---------------------------------------------------------------------------
     // Internal state
     // ---------------------------------------------------------------------------
@@ -16,12 +17,12 @@ function createIntorStore({ config, locale: initialLocale, messages, handlers, p
     // Locale transition
     // -----------------------------------------------------------------------------
     /** Request a locale change. */
-    async function setLocale(next) {
+    function setLocale(next) {
         const current = get(locale);
         if (next === current)
             return;
         locale.set(next);
-        onLocaleChange?.(next); // Notify external listener (fire-and-forget)
+        void onLocaleChange?.(next); // Notify external listener (fire-and-forget)
     }
     // ---------------------------------------------------------------------------
     // Effective state
@@ -29,30 +30,46 @@ function createIntorStore({ config, locale: initialLocale, messages, handlers, p
     const externalIsLoadingStore = typeof externalIsLoading === "object" && "subscribe" in externalIsLoading
         ? externalIsLoading
         : readable(!!externalIsLoading);
-    // external > internal
-    const effectiveIsLoading = derived([externalIsLoadingStore, internalIsLoading], ([$external, $internal]) => $external || $internal);
-    // runtime (client refetch) > initial > config (static)
-    const initialMessagesStore = readable(messages || config.messages || {});
-    const effectiveMessages = derived([runtimeMessages, initialMessagesStore], ([$runtime, $initial]) => $runtime || $initial);
+    const effectiveIsLoading = derived([externalIsLoadingStore, internalIsLoading], ([$external, $internal]) => resolveEffectiveIsLoading($external, $internal));
+    const effectiveMessages = derived(runtimeMessages, ($runtime) => resolveEffectiveMessages($runtime, messages, config.messages));
     // ---------------------------------------------------------------------------
     // Translator
     // ---------------------------------------------------------------------------
+    const { loadingMessage, missingMessage } = config.translator ?? {};
     const translator = derived([effectiveMessages, locale, effectiveIsLoading], ([$messages, $locale, $isLoading]) => new Translator({
         messages: $messages,
         locale: $locale,
         isLoading: $isLoading,
         fallbackLocales: config.fallbackLocales,
-        loadingMessage: config.translator?.loadingMessage,
-        missingMessage: config.translator?.missingMessage,
-        handlers,
-        plugins,
+        ...(loadingMessage !== undefined ? { loadingMessage } : {}),
+        ...(missingMessage !== undefined ? { missingMessage } : {}),
+        ...(handlers !== undefined ? { handlers } : {}),
+        ...(hooks !== undefined ? { hooks } : {}),
     }));
-    // ---------------------------------------------------------------------------
-    // Side effects
-    // ---------------------------------------------------------------------------
-    attachLocaleEffects(locale, config);
-    attachMessagesEffects({ config, locale, runtimeMessages, internalIsLoading });
-    setContext(INTOR_CONTEXT_KEY, { config, locale, setLocale, translator });
+    return {
+        config,
+        locale,
+        setLocale,
+        translator,
+        runtimeMessages,
+        internalIsLoading,
+    };
+}
+/**
+ * Svelte initializer for Intor.
+ *
+ * @public
+ */
+function createIntorStore(value) {
+    const stores = buildIntorStores(value);
+    attachLocaleEffects(stores.locale, value.config);
+    attachMessagesEffects({
+        config: value.config,
+        locale: stores.locale,
+        runtimeMessages: stores.runtimeMessages,
+        internalIsLoading: stores.internalIsLoading,
+    });
+    setContext(INTOR_CONTEXT_KEY, stores);
 }
 
-export { INTOR_CONTEXT_KEY, createIntorStore };
+export { INTOR_CONTEXT_KEY, buildIntorStores, createIntorStore };

package/dist/svelte/src/client/svelte/provider/effects/{locale-effects.js → attach-locale-effects.js}

@@ -1,5 +1,4 @@
 import { shouldPersistOnFirstVisit } from '../../../../policies/should-persist-on-first-visit.js';
-import '../../../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';

package/dist/svelte/src/client/svelte/provider/effects/{messages-effects.js → attach-messages-effects.js}

@@ -15,7 +15,7 @@ function attachMessagesEffects({ locale, config, runtimeMessages, internalIsLoad
             isInitial = false;
             return;
         }
-        refetchMessages(value);
+        void refetchMessages(value);
     });
     return unsubscribe;
 }

package/dist/svelte/src/client/svelte/provider/{use-intor-context.js → get-intor-context.js}

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

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

@@ -1,20 +1,19 @@
 import { derived } from 'svelte/store';
-import '../../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 import { createTRich } from '../../../core/translator/create-t-rich.js';
 import 'svelte';
 import '../provider/intor-provider.svelte';
-import { useIntorContext } from '../provider/use-intor-context.js';
+import { getIntorContext } from '../provider/get-intor-context.js';
 
 /**
  * Svelte utility for accessing the active, scope-aware translator instance.
  *
- * @platform Svelte
+ * @public
  */
 function useTranslator(preKey) {
-    const { translator, locale, setLocale } = useIntorContext();
+    const { translator, locale, setLocale } = getIntorContext();
     const scoped = derived(translator, ($t) => $t.scoped(preKey));
     return {
         messages: derived(translator, ($t) => $t.messages),

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

@@ -5,7 +5,6 @@ const DEFAULT_FORMAT_CONFIG = {
     timestamp: { withDate: false },
 };
 const DEFAULT_RENDER_CONFIG = {
-    timestamp: {},
     id: { visible: true, prefix: "<", suffix: ">" },
     meta: { lineBreaksAfter: 1 },
 };
@@ -14,23 +13,27 @@ const DEFAULT_RENDER_CONFIG = {
  * - Safe across hot reloads
  * - Prevents unbounded memory usage via soft LRU
  */
-function getLogger({ id = "default", formatConfig, renderConfig, preset, ...options }) {
+function getLogger({ id = "default", 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);
+    const existing = pool.get(id);
+    if (existing)
+        return existing;
+    const baseConfig = preset === undefined
+        ? {
+            formatConfig: DEFAULT_FORMAT_CONFIG,
+            renderConfig: DEFAULT_RENDER_CONFIG,
+        }
+        : { preset };
+    const logger = logry({
+        id,
+        ...baseConfig,
+        ...options,
+    });
+    pool.set(id, logger);
+    // Soft LRU: keep pool size under control
+    if (pool.size > 1000) {
+        for (const key of [...pool.keys()].slice(0, 200)) {
+            pool.delete(key);
         }
     }
     return logger;

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

@@ -21,13 +21,13 @@ async function fetchRemoteResource({ fetch, url, headers, signal, loggerOptions,
             method: "GET",
             headers: { "Content-Type": "application/json", ...headers },
             cache: "no-store",
-            signal,
+            ...(signal !== undefined ? { signal } : {}),
         });
         if (!response.ok) {
             throw new Error(`HTTP ${response.status} ${response.statusText}`);
         }
         // Parse JSON body
-        const data = await response.json();
+        const data = (await response.json());
         // Validate messages structure
         if (!isValidMessages(data)) {
             throw new Error("Invalid messages structure");

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

@@ -34,9 +34,8 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurr
     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;
+    for (const candidateLocale of candidateLocales) {
+        const isLast = candidateLocale === candidateLocales[candidateLocales.length - 1];
         try {
             // -----------------------------------------------------------------
             // Collect remote message resources for the locale
@@ -44,12 +43,18 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurr
             const resources = collectRemoteResources({
                 locale: candidateLocale,
                 baseUrl,
-                namespaces,
+                ...(namespaces !== undefined ? { namespaces } : {}),
             });
             // -----------------------------------------------------------------
             // Fetch all message chunks in parallel
             // -----------------------------------------------------------------
-            const fetchUrl = (url) => fetchRemoteResource({ url, headers, signal, loggerOptions, fetch });
+            const fetchUrl = (url) => fetchRemoteResource({
+                url,
+                ...(headers !== undefined ? { headers } : {}),
+                ...(signal !== undefined ? { 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))
@@ -57,7 +62,10 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurr
             // -----------------------------------------------------------------
             // Resolve and merge remote message resources
             // -----------------------------------------------------------------
-            const resolved = resolveRemoteResources(resources.map((res, i) => ({ path: res.path, data: results[i] })));
+            const resolved = resolveRemoteResources(resources.map((res, i) => {
+                const data = results[i];
+                return { path: res.path, ...(data !== undefined ? { data } : {}) };
+            }));
             // -----------------------------------------------------------------
             // Wrap resolved messages into locale-scoped LocaleMessages
             // -----------------------------------------------------------------

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

@@ -6,6 +6,8 @@ import { deepMerge } from '../utils/deep-merge.js';
  *
  * - Only merges messages under the given locale
  * - Emits debug logs for add / override events
+ *
+ * @public
  */
 function mergeMessages(a, b, { config, locale, onEvent }) {
     const baseLogger = getLogger({ ...config.logger, id: config.id });

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

@@ -1,19 +1,18 @@
 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 'intor-translator';
 import { resolveInbound } from '../../routing/inbound/resolve-inbound.js';
 import { getLocaleFromAcceptLanguage } from '../../routing/locale/get-locale-from-accept-language.js';
+import { isSvelteKitSSG } from './utils/is-svelte-kit-ssg.js';
 
 /**
  * Resolves locale-aware routing for the current execution context.
  *
  * - Acts as the canonical routing authority within the SvelteKit request lifecycle.
  *
- * @platform SvelteKit
+ * @public
  */
 function createIntorHandler(config) {
     return async function intorHandler({ event, resolve }) {
@@ -25,20 +24,26 @@ function createIntorHandler(config) {
         // ----------------------------------------------------------
         let inboundResult;
         if (isSvelteKitSSG(event)) {
+            const locale = event.params?.["locale"];
+            if (!locale)
+                throw new Error("Locale param is missing in SSG mode.");
             inboundResult = {
-                locale: event.params?.locale,
+                locale,
                 localeSource: "path",
                 pathname: event.url.pathname,
                 shouldRedirect: false,
             };
         }
         else {
+            const cookie = event.cookies.get(config.cookie.name);
             const { host, searchParams, pathname: rawPathname } = event.url;
-            inboundResult = await resolveInbound(config, rawPathname, {
+            inboundResult = resolveInbound(config, rawPathname, {
                 host,
                 query: normalizeQuery(Object.fromEntries(searchParams.entries())),
-                cookie: event.cookies.get(config.cookie.name),
-                detected: localeFromAcceptLanguage || config.defaultLocale,
+                ...(cookie !== undefined ? { cookie } : {}),
+                ...(localeFromAcceptLanguage !== undefined
+                    ? { detected: localeFromAcceptLanguage }
+                    : {}),
             });
         }
         const { locale, localeSource, pathname, shouldRedirect } = inboundResult;

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

@@ -1,10 +1,9 @@
 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 'intor-translator';
+import { executeNavigation } from '../../client/shared/navigation/execute-navigation.js';
+import { getIntorContext } from 'intor/svelte/internal';
 import { resolveOutbound } from '../../routing/outbound/resolve-outbound.js';
 import { goto } from '$app/navigation';
 import { page } from '$app/state';
@@ -15,13 +14,13 @@ import { page } from '$app/state';
  * Provides imperative navigation helpers that integrate
  * Intor's locale-aware routing and side effects.
  *
- * @platform SvelteKit
+ * @public
  */
 function useNavigation() {
-    const { config, locale: currentLocale, setLocale } = useIntorContext();
+    const { config, locale: currentLocale, setLocale } = getIntorContext();
     async function goto$1(url, opts) {
         const { locale, ...rest } = opts || {};
-        const outboundResult = resolveOutbound(config, get(currentLocale), page.url.pathname, { destination: url, locale });
+        const outboundResult = resolveOutbound(config, get(currentLocale), page.url.pathname, { destination: url, ...(locale !== undefined ? { locale } : {}) });
         executeNavigation(outboundResult, {
             config,
             currentLocale: get(currentLocale),

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

@@ -1,4 +1,3 @@
-import '../../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';

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

@@ -6,7 +6,7 @@ const buildCookieString = (cookieOptions, value) => {
     // Cookie name and encoded value
     const parts = [`${name}=${encodeURIComponent(value)}`];
     // Add expiration and max-age if provided
-    if (maxAge) {
+    if (maxAge !== undefined) {
         const expires = new Date(Date.now() + maxAge * 1000).toUTCString();
         parts.push(`expires=${expires}`, `max-age=${maxAge}`);
     }
@@ -18,7 +18,8 @@ const buildCookieString = (cookieOptions, value) => {
     }
     // Add SameSite policy (e.g., Lax, Strict)
     if (sameSite) {
-        parts.push(`SameSite=${sameSite[0].toUpperCase()}${sameSite.slice(1).toLowerCase()}`);
+        const normalized = sameSite.charAt(0).toUpperCase() + sameSite.slice(1).toLowerCase();
+        parts.push(`SameSite=${normalized}`);
     }
     // Add Secure flag if not explicitly disabled
     if (secure !== false) {

package/dist/svelte-kit/src/core/locale/match-locale.js

@@ -9,12 +9,16 @@ import { parseLocale } from './parse-locale.js';
  * 2. Same language + same script
  * 3. Same language only (only if candidate has no script)
  *
+ * Returns one of the original `supportedLocales` values if matched.
  * Returns `undefined` if no match is found.
  *
  * Notes:
  * - Matching is deterministic and order-sensitive.
- * - Does not perform automatic fallback to default locale.
- * - Does not cross script boundaries.
+ * - Does not perform automatic fallback to a default locale.
+ *   Consumers are responsible for applying fallback logic.
+ * - If the candidate includes a script subtag, language-only fallback is skipped.
+ *
+ * @public
  */
 function matchLocale(locale, supportedLocales = []) {
     if (!locale || supportedLocales.length === 0)

package/dist/svelte-kit/src/core/locale/parse-locale.js

@@ -12,8 +12,8 @@ function parseLocale(tag) {
             const locale = new Intl.Locale(tag);
             return {
                 language: locale.language,
-                script: locale.script,
-                region: locale.region,
+                ...(locale.script !== undefined ? { script: locale.script } : {}),
+                ...(locale.region !== undefined ? { region: locale.region } : {}),
             };
         }
     }

package/dist/svelte-kit/src/core/utils/normalizers/normalize-pathname.js

@@ -1,21 +1,24 @@
 /**
- * Normalize a raw pathname string to ensure consistent formatting.
+ * Normalizes a raw pathname string into a consistent structural form.
  *
- * - Trims leading and trailing whitespace (code points ≤ 32).
- * - Collapses consecutive slashes into a single slash.
- * - Ensures a single leading slash and removes redundant trailing slashes.
- * - Optionally removes the leading slash.
- * - Avoids intermediate array allocations for performance.
+ * Canonical guarantees:
+ * - Leading and trailing whitespace (code points ≤ 32) are trimmed
+ * - Consecutive slashes are collapsed into a single slash
+ * - The result always starts with a single "/"
+ * - Redundant trailing slashes are removed
+ * - The root path is represented as "/"
+ *
+ * This function is deterministic and allocation-minimized.
  */
-const normalizePathname = (rawPathname, options = {}) => {
+const normalizePathname = (rawPathname) => {
     const length = rawPathname.length;
     let start = 0;
     let end = length - 1;
     // Trim leading whitespace
-    while (start <= end && (rawPathname.codePointAt(start) ?? 0) <= 32)
+    while (start <= end && rawPathname.codePointAt(start) <= 32)
         start++;
     // Trim trailing whitespace
-    while (end >= start && (rawPathname.codePointAt(end) ?? 0) <= 32)
+    while (end >= start && rawPathname.codePointAt(end) <= 32)
         end--;
     if (start > end)
         return "/"; // Only whitespace
@@ -33,10 +36,6 @@ const normalizePathname = (rawPathname, options = {}) => {
             hasSlash = false;
         }
     }
-    // If the result has a leading slash and we want to remove it, do so
-    if (options.removeLeadingSlash && result.startsWith("/")) {
-        result = result.slice(1);
-    }
     return result || "/";
 };
 

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

@@ -1,4 +1,3 @@
-import '../core/error/intor-error.js';
 import { resolveLoaderOptions } from '../core/utils/resolve-loader-options.js';
 import 'logry';
 import 'p-limit';