intor 2.4.14 → 2.4.15

package/dist/next/src/routing/inbound/resolve-locale/resolve-locale.js

@@ -1,5 +1,5 @@
 import '../../../core/error/intor-error.js';
-import { normalizeLocale } from '../../../core/utils/normalizers/normalize-locale.js';
+import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -15,7 +15,7 @@ function resolveLocale(config, context) {
     const { localeSources } = config.routing.inbound;
     for (const source of localeSources) {
         const locale = context[source]?.locale;
-        const normalized = normalizeLocale(locale, config.supportedLocales);
+        const normalized = matchLocale(locale, config.supportedLocales);
         if (!normalized)
             continue;
         return {
@@ -24,7 +24,7 @@ function resolveLocale(config, context) {
         };
     }
     // Fallback: detected is always available
-    const fallback = normalizeLocale(context.detected.locale, config.supportedLocales) ||
+    const fallback = matchLocale(context.detected.locale, config.supportedLocales) ||
         config.defaultLocale;
     return {
         locale: fallback,

package/dist/react/src/client/shared/helpers/get-client-locale.js

@@ -1,5 +1,5 @@
 import '../../../core/error/intor-error.js';
-import { normalizeLocale } from '../../../core/utils/normalizers/normalize-locale.js';
+import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -16,7 +16,7 @@ function getClientLocale(config) {
     // Locale from browser preference
     const browserLocale = detectBrowserLocale();
     const localeCandidate = cookieLocale || browserLocale;
-    return normalizeLocale(localeCandidate, supportedLocales) || defaultLocale;
+    return matchLocale(localeCandidate, supportedLocales) || defaultLocale;
 }
 
 export { getClientLocale };

package/dist/react/src/core/locale/canonicalize-locale.js

@@ -0,0 +1,23 @@
+/**
+ * Canonicalizes a BCP 47 locale string.
+ *
+ * - Uses `Intl.getCanonicalLocales` when available.
+ * - Returns the original input if `Intl` is unavailable.
+ * - Returns `undefined` for invalid locale input.
+ *
+ * This function performs normalization only.
+ * It does not perform matching or fallback.
+ */
+function canonicalizeLocale(input) {
+    try {
+        if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
+            return input;
+        }
+        return Intl.getCanonicalLocales(input)[0];
+    }
+    catch {
+        return;
+    }
+}
+
+export { canonicalizeLocale };

package/dist/react/src/core/locale/match-locale.js

@@ -0,0 +1,57 @@
+import { canonicalizeLocale } from './canonicalize-locale.js';
+import { parseLocale } from './parse-locale.js';
+
+/**
+ * Matches a locale candidate against a list of supported locales.
+ *
+ * Resolution order:
+ * 1. Exact canonical match
+ * 2. Same language + same script
+ * 3. Same language only (only if candidate has no script)
+ *
+ * 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.
+ */
+function matchLocale(locale, supportedLocales = []) {
+    if (!locale || supportedLocales.length === 0)
+        return;
+    const canonicalCandidate = canonicalizeLocale(locale);
+    if (!canonicalCandidate)
+        return;
+    const candidateParts = parseLocale(canonicalCandidate);
+    const supportedCanonical = supportedLocales.flatMap((original) => {
+        const canonical = canonicalizeLocale(original);
+        if (!canonical)
+            return [];
+        return [{ original, canonical, parts: parseLocale(canonical) }];
+    });
+    // 1. Exact match
+    for (const s of supportedCanonical) {
+        if (s.canonical === canonicalCandidate) {
+            return s.original;
+        }
+    }
+    // 2. Same language + same script
+    if (candidateParts.script) {
+        for (const s of supportedCanonical) {
+            if (s.parts.language === candidateParts.language &&
+                s.parts.script === candidateParts.script) {
+                return s.original;
+            }
+        }
+        return;
+    }
+    // 3. Same language only
+    for (const s of supportedCanonical) {
+        if (s.parts.language === candidateParts.language) {
+            return s.original;
+        }
+    }
+    return;
+}
+
+export { matchLocale };

package/dist/react/src/core/locale/parse-locale.js

@@ -0,0 +1,27 @@
+/**
+ * Parses a canonical locale tag into structural components.
+ *
+ * - Uses `Intl.Locale` when available.
+ * - Falls back to minimal parsing (language only) if unavailable.
+ *
+ * This function does not validate or match locales.
+ */
+function parseLocale(tag) {
+    try {
+        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+            const locale = new Intl.Locale(tag);
+            return {
+                language: locale.language,
+                script: locale.script,
+                region: locale.region,
+            };
+        }
+    }
+    catch {
+        // fallback below
+    }
+    const parts = tag.split("-");
+    return { language: parts[0].toLowerCase() };
+}
+
+export { parseLocale };

package/dist/svelte/src/client/shared/helpers/get-client-locale.js

@@ -1,5 +1,5 @@
 import '../../../core/error/intor-error.js';
-import { normalizeLocale } from '../../../core/utils/normalizers/normalize-locale.js';
+import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -16,7 +16,7 @@ function getClientLocale(config) {
     // Locale from browser preference
     const browserLocale = detectBrowserLocale();
     const localeCandidate = cookieLocale || browserLocale;
-    return normalizeLocale(localeCandidate, supportedLocales) || defaultLocale;
+    return matchLocale(localeCandidate, supportedLocales) || defaultLocale;
 }
 
 export { getClientLocale };

package/dist/svelte/src/core/locale/canonicalize-locale.js

@@ -0,0 +1,23 @@
+/**
+ * Canonicalizes a BCP 47 locale string.
+ *
+ * - Uses `Intl.getCanonicalLocales` when available.
+ * - Returns the original input if `Intl` is unavailable.
+ * - Returns `undefined` for invalid locale input.
+ *
+ * This function performs normalization only.
+ * It does not perform matching or fallback.
+ */
+function canonicalizeLocale(input) {
+    try {
+        if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
+            return input;
+        }
+        return Intl.getCanonicalLocales(input)[0];
+    }
+    catch {
+        return;
+    }
+}
+
+export { canonicalizeLocale };

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

@@ -0,0 +1,57 @@
+import { canonicalizeLocale } from './canonicalize-locale.js';
+import { parseLocale } from './parse-locale.js';
+
+/**
+ * Matches a locale candidate against a list of supported locales.
+ *
+ * Resolution order:
+ * 1. Exact canonical match
+ * 2. Same language + same script
+ * 3. Same language only (only if candidate has no script)
+ *
+ * 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.
+ */
+function matchLocale(locale, supportedLocales = []) {
+    if (!locale || supportedLocales.length === 0)
+        return;
+    const canonicalCandidate = canonicalizeLocale(locale);
+    if (!canonicalCandidate)
+        return;
+    const candidateParts = parseLocale(canonicalCandidate);
+    const supportedCanonical = supportedLocales.flatMap((original) => {
+        const canonical = canonicalizeLocale(original);
+        if (!canonical)
+            return [];
+        return [{ original, canonical, parts: parseLocale(canonical) }];
+    });
+    // 1. Exact match
+    for (const s of supportedCanonical) {
+        if (s.canonical === canonicalCandidate) {
+            return s.original;
+        }
+    }
+    // 2. Same language + same script
+    if (candidateParts.script) {
+        for (const s of supportedCanonical) {
+            if (s.parts.language === candidateParts.language &&
+                s.parts.script === candidateParts.script) {
+                return s.original;
+            }
+        }
+        return;
+    }
+    // 3. Same language only
+    for (const s of supportedCanonical) {
+        if (s.parts.language === candidateParts.language) {
+            return s.original;
+        }
+    }
+    return;
+}
+
+export { matchLocale };

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

@@ -0,0 +1,27 @@
+/**
+ * Parses a canonical locale tag into structural components.
+ *
+ * - Uses `Intl.Locale` when available.
+ * - Falls back to minimal parsing (language only) if unavailable.
+ *
+ * This function does not validate or match locales.
+ */
+function parseLocale(tag) {
+    try {
+        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+            const locale = new Intl.Locale(tag);
+            return {
+                language: locale.language,
+                script: locale.script,
+                region: locale.region,
+            };
+        }
+    }
+    catch {
+        // fallback below
+    }
+    const parts = tag.split("-");
+    return { language: parts[0].toLowerCase() };
+}
+
+export { parseLocale };

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

@@ -0,0 +1,23 @@
+/**
+ * Canonicalizes a BCP 47 locale string.
+ *
+ * - Uses `Intl.getCanonicalLocales` when available.
+ * - Returns the original input if `Intl` is unavailable.
+ * - Returns `undefined` for invalid locale input.
+ *
+ * This function performs normalization only.
+ * It does not perform matching or fallback.
+ */
+function canonicalizeLocale(input) {
+    try {
+        if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
+            return input;
+        }
+        return Intl.getCanonicalLocales(input)[0];
+    }
+    catch {
+        return;
+    }
+}
+
+export { canonicalizeLocale };

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

@@ -0,0 +1,57 @@
+import { canonicalizeLocale } from './canonicalize-locale.js';
+import { parseLocale } from './parse-locale.js';
+
+/**
+ * Matches a locale candidate against a list of supported locales.
+ *
+ * Resolution order:
+ * 1. Exact canonical match
+ * 2. Same language + same script
+ * 3. Same language only (only if candidate has no script)
+ *
+ * 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.
+ */
+function matchLocale(locale, supportedLocales = []) {
+    if (!locale || supportedLocales.length === 0)
+        return;
+    const canonicalCandidate = canonicalizeLocale(locale);
+    if (!canonicalCandidate)
+        return;
+    const candidateParts = parseLocale(canonicalCandidate);
+    const supportedCanonical = supportedLocales.flatMap((original) => {
+        const canonical = canonicalizeLocale(original);
+        if (!canonical)
+            return [];
+        return [{ original, canonical, parts: parseLocale(canonical) }];
+    });
+    // 1. Exact match
+    for (const s of supportedCanonical) {
+        if (s.canonical === canonicalCandidate) {
+            return s.original;
+        }
+    }
+    // 2. Same language + same script
+    if (candidateParts.script) {
+        for (const s of supportedCanonical) {
+            if (s.parts.language === candidateParts.language &&
+                s.parts.script === candidateParts.script) {
+                return s.original;
+            }
+        }
+        return;
+    }
+    // 3. Same language only
+    for (const s of supportedCanonical) {
+        if (s.parts.language === candidateParts.language) {
+            return s.original;
+        }
+    }
+    return;
+}
+
+export { matchLocale };

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

@@ -0,0 +1,27 @@
+/**
+ * Parses a canonical locale tag into structural components.
+ *
+ * - Uses `Intl.Locale` when available.
+ * - Falls back to minimal parsing (language only) if unavailable.
+ *
+ * This function does not validate or match locales.
+ */
+function parseLocale(tag) {
+    try {
+        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+            const locale = new Intl.Locale(tag);
+            return {
+                language: locale.language,
+                script: locale.script,
+                region: locale.region,
+            };
+        }
+    }
+    catch {
+        // fallback below
+    }
+    const parts = tag.split("-");
+    return { language: parts[0].toLowerCase() };
+}
+
+export { parseLocale };

package/dist/svelte-kit/src/routing/inbound/resolve-locale/resolve-locale.js

@@ -1,5 +1,5 @@
 import '../../../core/error/intor-error.js';
-import { normalizeLocale } from '../../../core/utils/normalizers/normalize-locale.js';
+import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -15,7 +15,7 @@ function resolveLocale(config, context) {
     const { localeSources } = config.routing.inbound;
     for (const source of localeSources) {
         const locale = context[source]?.locale;
-        const normalized = normalizeLocale(locale, config.supportedLocales);
+        const normalized = matchLocale(locale, config.supportedLocales);
         if (!normalized)
             continue;
         return {
@@ -24,7 +24,7 @@ function resolveLocale(config, context) {
         };
     }
     // Fallback: detected is always available
-    const fallback = normalizeLocale(context.detected.locale, config.supportedLocales) ||
+    const fallback = matchLocale(context.detected.locale, config.supportedLocales) ||
         config.defaultLocale;
     return {
         locale: fallback,

package/dist/types/export/index.d.ts

@@ -1,3 +1,3 @@
-export { LOCALE_PLACEHOLDER, IntorError, IntorErrorCode, clearLoggerPool, mergeMessages, type MessagesReader, type MessagesReaders, type GenLocale as Locale, } from "../src/core";
+export { LOCALE_PLACEHOLDER, IntorError, IntorErrorCode, matchLocale, clearLoggerPool, mergeMessages, type MessagesReader, type MessagesReaders, type GenLocale as Locale, } from "../src/core";
 export { defineIntorConfig, type IntorRawConfig, type IntorResolvedConfig, } from "../src/config";
 export { localizePathname, type InboundContext } from "../src/routing";

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

@@ -1,6 +1,7 @@
 export { LOCALE_PLACEHOLDER, INTOR_HEADERS } from "./constants";
 export { IntorError, IntorErrorCode } from "./error";
-export { deepMerge, type PlainObject, type DeepMergeOverrideEvent, resolveLoaderOptions, parseCookieHeader, normalizePathname, normalizeCacheKey, normalizeLocale, normalizeQuery, type NormalizedQuery, } from "./utils";
+export { deepMerge, type PlainObject, type DeepMergeOverrideEvent, resolveLoaderOptions, parseCookieHeader, normalizePathname, normalizeCacheKey, normalizeQuery, type NormalizedQuery, } from "./utils";
+export { matchLocale } from "./locale";
 export { getLogger, clearLoggerPool } from "./logger";
 export { loadRemoteMessages, mergeMessages, isValidMessages, nestObjectFromPath, type MessagesReader, type MessagesReaders, INTOR_PREFIX, INTOR_MESSAGES_KIND_KEY, INTOR_MESSAGES_KIND, getMessagesKind, type IntorMessagesKind, } from "./messages";
 export { createHtmlRenderer, type TagRenderers, type HtmlTagRenderers, } from "./render";

package/dist/types/src/core/locale/canonicalize-locale.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Canonicalizes a BCP 47 locale string.
+ *
+ * - Uses `Intl.getCanonicalLocales` when available.
+ * - Returns the original input if `Intl` is unavailable.
+ * - Returns `undefined` for invalid locale input.
+ *
+ * This function performs normalization only.
+ * It does not perform matching or fallback.
+ */
+export declare function canonicalizeLocale(input: string): string | undefined;

package/dist/types/src/core/locale/index.d.ts

@@ -0,0 +1 @@
+export { matchLocale } from "./match-locale";

package/dist/types/src/core/locale/match-locale.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Matches a locale candidate against a list of supported locales.
+ *
+ * Resolution order:
+ * 1. Exact canonical match
+ * 2. Same language + same script
+ * 3. Same language only (only if candidate has no script)
+ *
+ * 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.
+ */
+export declare function matchLocale(locale: string | undefined, supportedLocales?: readonly string[]): string | undefined;

package/dist/types/src/core/locale/parse-locale.d.ts

@@ -0,0 +1,14 @@
+export type LocaleParts = {
+    language: string;
+    script?: string;
+    region?: string;
+};
+/**
+ * Parses a canonical locale tag into structural components.
+ *
+ * - Uses `Intl.Locale` when available.
+ * - Falls back to minimal parsing (language only) if unavailable.
+ *
+ * This function does not validate or match locales.
+ */
+export declare function parseLocale(tag: string): LocaleParts;

package/dist/types/src/core/utils/index.d.ts

@@ -1,4 +1,4 @@
 export { deepMerge, type PlainObject, type DeepMergeOverrideEvent, } from "./deep-merge";
 export { resolveLoaderOptions } from "./resolve-loader-options";
 export { parseCookieHeader } from "./parse-cookie-header";
-export { normalizeCacheKey, normalizeLocale, normalizePathname, normalizeQuery, type NormalizedQuery, } from "./normalizers";
+export { normalizeCacheKey, normalizePathname, normalizeQuery, type NormalizedQuery, } from "./normalizers";

package/dist/types/src/core/utils/normalizers/index.d.ts

@@ -1,4 +1,3 @@
 export { normalizeCacheKey } from "./normalize-cache-key";
 export { normalizePathname } from "./normalize-pathname";
-export { normalizeLocale } from "./normalize-locale";
 export { normalizeQuery, type NormalizedQuery } from "./normalize-query";

package/dist/vue/src/client/shared/helpers/get-client-locale.js

@@ -1,5 +1,5 @@
 import '../../../core/error/intor-error.js';
-import { normalizeLocale } from '../../../core/utils/normalizers/normalize-locale.js';
+import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -16,7 +16,7 @@ function getClientLocale(config) {
     // Locale from browser preference
     const browserLocale = detectBrowserLocale();
     const localeCandidate = cookieLocale || browserLocale;
-    return normalizeLocale(localeCandidate, supportedLocales) || defaultLocale;
+    return matchLocale(localeCandidate, supportedLocales) || defaultLocale;
 }
 
 export { getClientLocale };

package/dist/vue/src/core/locale/canonicalize-locale.js

@@ -0,0 +1,23 @@
+/**
+ * Canonicalizes a BCP 47 locale string.
+ *
+ * - Uses `Intl.getCanonicalLocales` when available.
+ * - Returns the original input if `Intl` is unavailable.
+ * - Returns `undefined` for invalid locale input.
+ *
+ * This function performs normalization only.
+ * It does not perform matching or fallback.
+ */
+function canonicalizeLocale(input) {
+    try {
+        if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
+            return input;
+        }
+        return Intl.getCanonicalLocales(input)[0];
+    }
+    catch {
+        return;
+    }
+}
+
+export { canonicalizeLocale };

package/dist/vue/src/core/locale/match-locale.js

@@ -0,0 +1,57 @@
+import { canonicalizeLocale } from './canonicalize-locale.js';
+import { parseLocale } from './parse-locale.js';
+
+/**
+ * Matches a locale candidate against a list of supported locales.
+ *
+ * Resolution order:
+ * 1. Exact canonical match
+ * 2. Same language + same script
+ * 3. Same language only (only if candidate has no script)
+ *
+ * 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.
+ */
+function matchLocale(locale, supportedLocales = []) {
+    if (!locale || supportedLocales.length === 0)
+        return;
+    const canonicalCandidate = canonicalizeLocale(locale);
+    if (!canonicalCandidate)
+        return;
+    const candidateParts = parseLocale(canonicalCandidate);
+    const supportedCanonical = supportedLocales.flatMap((original) => {
+        const canonical = canonicalizeLocale(original);
+        if (!canonical)
+            return [];
+        return [{ original, canonical, parts: parseLocale(canonical) }];
+    });
+    // 1. Exact match
+    for (const s of supportedCanonical) {
+        if (s.canonical === canonicalCandidate) {
+            return s.original;
+        }
+    }
+    // 2. Same language + same script
+    if (candidateParts.script) {
+        for (const s of supportedCanonical) {
+            if (s.parts.language === candidateParts.language &&
+                s.parts.script === candidateParts.script) {
+                return s.original;
+            }
+        }
+        return;
+    }
+    // 3. Same language only
+    for (const s of supportedCanonical) {
+        if (s.parts.language === candidateParts.language) {
+            return s.original;
+        }
+    }
+    return;
+}
+
+export { matchLocale };

package/dist/vue/src/core/locale/parse-locale.js

@@ -0,0 +1,27 @@
+/**
+ * Parses a canonical locale tag into structural components.
+ *
+ * - Uses `Intl.Locale` when available.
+ * - Falls back to minimal parsing (language only) if unavailable.
+ *
+ * This function does not validate or match locales.
+ */
+function parseLocale(tag) {
+    try {
+        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+            const locale = new Intl.Locale(tag);
+            return {
+                language: locale.language,
+                script: locale.script,
+                region: locale.region,
+            };
+        }
+    }
+    catch {
+        // fallback below
+    }
+    const parts = tag.split("-");
+    return { language: parts[0].toLowerCase() };
+}
+
+export { parseLocale };