intor 2.5.0 → 2.5.1

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

@@ -1,31 +1,22 @@
-/**
- * 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 !== undefined) {
-        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) {
-        const normalized = sameSite.charAt(0).toUpperCase() + sameSite.slice(1).toLowerCase();
-        parts.push(`SameSite=${normalized}`);
-    }
-    // Add Secure flag if not explicitly disabled
-    if (secure !== false) {
-        parts.push(`Secure`);
-    }
-    return parts.join("; ");
+  const { name, maxAge, path, domain, sameSite, secure } = cookieOptions;
+  const parts = [`${name}=${encodeURIComponent(value)}`];
+  if (maxAge !== void 0) {
+    const expires = new Date(Date.now() + maxAge * 1e3).toUTCString();
+    parts.push(`expires=${expires}`, `max-age=${maxAge}`);
+  }
+  parts.push(`path=${path ?? "/"}`);
+  if (domain) {
+    parts.push(`domain=${domain}`);
+  }
+  if (sameSite) {
+    const normalized = sameSite.charAt(0).toUpperCase() + sameSite.slice(1).toLowerCase();
+    parts.push(`SameSite=${normalized}`);
+  }
+  if (secure !== false) {
+    parts.push(`Secure`);
+  }
+  return parts.join("; ");
 };
 
 export { buildCookieString };

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

@@ -1,15 +1,8 @@
 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);
+  if (typeof document === "undefined") return;
+  document.cookie = buildCookieString(cookieOptions, locale);
 };
 
 export { setLocaleCookie };

package/dist/svelte-kit/src/core/constants/locale-placeholder.js

@@ -1,4 +1,3 @@
-// Default locale placeholder
 const LOCALE_PLACEHOLDER = "{locale}";
 
 export { LOCALE_PLACEHOLDER };

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

@@ -1,23 +1,12 @@
-/**
- * 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;
+  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

@@ -1,61 +1,35 @@
 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 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 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)
-        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;
+  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) }];
+  });
+  for (const s of supportedCanonical) {
+    if (s.canonical === canonicalCandidate) {
+      return s.original;
     }
-    // 3. Same language only
+  }
+  if (candidateParts.script) {
     for (const s of supportedCanonical) {
-        if (s.parts.language === candidateParts.language) {
-            return s.original;
-        }
+      if (s.parts.language === candidateParts.language && s.parts.script === candidateParts.script) {
+        return s.original;
+      }
     }
     return;
+  }
+  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

@@ -1,27 +1,17 @@
-/**
- * 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,
-                ...(locale.script !== undefined ? { script: locale.script } : {}),
-                ...(locale.region !== undefined ? { region: locale.region } : {}),
-            };
-        }
+  try {
+    if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+      const locale = new Intl.Locale(tag);
+      return {
+        language: locale.language,
+        ...locale.script !== void 0 ? { script: locale.script } : {},
+        ...locale.region !== void 0 ? { region: locale.region } : {}
+      };
     }
-    catch {
-        // fallback below
-    }
-    const parts = tag.split("-");
-    return { language: parts[0].toLowerCase() };
+  } catch {
+  }
+  const parts = tag.split("-");
+  return { language: parts[0].toLowerCase() };
 }
 
 export { parseLocale };

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

@@ -1,42 +1,24 @@
-/**
- * Normalizes a raw pathname string into a consistent structural form.
- *
- * 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) => {
-    const length = rawPathname.length;
-    let start = 0;
-    let end = length - 1;
-    // Trim leading whitespace
-    while (start <= end && rawPathname.codePointAt(start) <= 32)
-        start++;
-    // Trim trailing whitespace
-    while (end >= start && rawPathname.codePointAt(end) <= 32)
-        end--;
-    if (start > end)
-        return "/"; // Only whitespace
-    let result = "";
-    let hasSlash = false;
-    for (let i = start; i <= end; i++) {
-        const char = rawPathname[i];
-        if (char === "/") {
-            if (!hasSlash) {
-                hasSlash = true;
-            }
-        }
-        else {
-            result += hasSlash || result === "" ? "/" + char : char;
-            hasSlash = false;
-        }
+  const length = rawPathname.length;
+  let start = 0;
+  let end = length - 1;
+  while (start <= end && rawPathname.codePointAt(start) <= 32) start++;
+  while (end >= start && rawPathname.codePointAt(end) <= 32) end--;
+  if (start > end) return "/";
+  let result = "";
+  let hasSlash = false;
+  for (let i = start; i <= end; i++) {
+    const char = rawPathname[i];
+    if (char === "/") {
+      if (!hasSlash) {
+        hasSlash = true;
+      }
+    } else {
+      result += hasSlash || result === "" ? "/" + char : char;
+      hasSlash = false;
     }
-    return result || "/";
+  }
+  return result || "/";
 };
 
 export { normalizePathname };

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

@@ -1,25 +1,11 @@
-/**
- * Normalize a raw query object into a string-only map.
- *
- * This utility is used to sanitize framework-specific query inputs
- * into a stable shape that the routing core
- * can safely consume.
- *
- * Behavior:
- * - Keeps only entries whose values are strings
- * - Ignores arrays, objects, and other non-string values
- * - Does not throw or attempt to coerce values
- *
- * This function is intentionally conservative by design.
- */
 function normalizeQuery(query) {
-    const normalized = {};
-    for (const [key, value] of Object.entries(query)) {
-        if (typeof value === "string") {
-            normalized[key] = value;
-        }
+  const normalized = {};
+  for (const [key, value] of Object.entries(query)) {
+    if (typeof value === "string") {
+      normalized[key] = value;
     }
-    return normalized;
+  }
+  return normalized;
 }
 
 export { normalizeQuery };

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

@@ -1,34 +1,11 @@
-/**
- * Resolve the effective message loader for a given runtime.
- *
- * Loader resolution follows an inheritance-based priority model:
- *
- * - client runtime:
- *   client.loader → server.loader → root loader
- *
- * - server runtime:
- *   server.loader → root loader
- *
- * This allows the client runtime to inherit server behavior
- * when no explicit client loader is provided.
- *
- * Notes:
- * - Static `messages` are intentionally NOT handled here.
- * - Returning `undefined` indicates that no loader is enabled
- *   for the given runtime.
- */
 const resolveLoaderOptions = (config, runtime) => {
-    // ------------------------------------------------
-    // runtime: client
-    // ------------------------------------------------
-    {
-        const client = config.client?.loader;
-        if (client) {
-            // Client loader is always remote by design
-            return { mode: "remote", ...client };
-        }
-        return config.server?.loader ?? config.loader;
+  {
+    const client = config.client?.loader;
+    if (client) {
+      return { mode: "remote", ...client };
     }
+    return config.server?.loader ?? config.loader;
+  }
 };
 
 export { resolveLoaderOptions };

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

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

package/dist/svelte-kit/src/policies/should-sync-locale.js

@@ -1,8 +1,5 @@
-/**
- * Determine whether locale synchronization is required.
- */
 function shouldSyncLocale(currentLocale, targetLocale) {
-    return currentLocale !== targetLocale;
+  return currentLocale !== targetLocale;
 }
 
 export { shouldSyncLocale };

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

@@ -4,44 +4,29 @@ import { getLocaleFromQuery } from '../locale/get-locale-from-query.js';
 import { resolveLocale } from './resolve-locale/resolve-locale.js';
 import { resolvePathname } from './resolve-pathname/resolve-pathname.js';
 
-/**
- * Resolves inbound routing state.
- *
- * - Resolves the effective locale from inbound inputs
- * - Localizes the pathname based on the resolved locale
- * - Indicates whether a redirect is required
- *
- * No side effects. No navigation.
- */
 function resolveInbound(config, rawPathname, localeInputs, options) {
-    const { queryKey } = config.routing.inbound;
-    const { host, query, cookie, detected } = localeInputs;
-    // ------------------------------------------------------
-    // Resolve locale from inbound inputs
-    // ------------------------------------------------------
-    const pathLocale = getLocaleFromPathname(rawPathname, config);
-    const hostLocale = getLocaleFromHost(host);
-    const queryLocale = getLocaleFromQuery(query, queryKey);
-    const { locale, localeSource } = resolveLocale(config, {
-        ...(pathLocale !== undefined && { path: { locale: pathLocale } }),
-        ...(hostLocale !== undefined && { host: { locale: hostLocale } }),
-        ...(queryLocale !== undefined && { query: { locale: queryLocale } }),
-        ...(cookie !== undefined && { cookie: { locale: cookie } }),
-        ...(detected !== undefined && { detected: { locale: detected } }),
-    });
-    // ------------------------------------------------------
-    // Resolve localized pathname and redirect requirement
-    // ------------------------------------------------------
-    const { pathname, shouldRedirect } = resolvePathname(config, rawPathname, {
-        locale,
-        hasPathLocale: !!pathLocale,
-        hasPersisted: !!cookie});
-    return {
-        locale,
-        localeSource,
-        pathname,
-        shouldRedirect,
-    };
+  const { queryKey } = config.routing.inbound;
+  const { host, query, cookie, detected } = localeInputs;
+  const pathLocale = getLocaleFromPathname(rawPathname, config);
+  const hostLocale = getLocaleFromHost(host);
+  const queryLocale = getLocaleFromQuery(query, queryKey);
+  const { locale, localeSource } = resolveLocale(config, {
+    ...pathLocale !== void 0 && { path: { locale: pathLocale } },
+    ...hostLocale !== void 0 && { host: { locale: hostLocale } },
+    ...queryLocale !== void 0 && { query: { locale: queryLocale } },
+    ...cookie !== void 0 && { cookie: { locale: cookie } },
+    ...detected !== void 0 && { detected: { locale: detected } }
+  });
+  const { pathname, shouldRedirect } = resolvePathname(config, rawPathname, {
+    locale,
+    hasPathLocale: !!pathLocale,
+    hasPersisted: !!cookie});
+  return {
+    locale,
+    localeSource,
+    pathname,
+    shouldRedirect
+  };
 }
 
 export { resolveInbound };

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

@@ -3,48 +3,31 @@ import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Resolves the active locale from inbound routing configuration.
- *
- * Resolution order:
- * 1. Configured locale signals (path / query / host / cookie)
- * 2. Runtime detection signal ("detected")
- * 3. Invariant fallback ("default")
- *
- * Always returns a supported locale.
- */
 function resolveLocale(config, context) {
-    const { localeSources } = config.routing.inbound;
-    // ------------------------------------------------------
-    // 1. Configured resolution signals (policy-ordered)
-    // ------------------------------------------------------
-    for (const source of localeSources) {
-        const locale = context[source]?.locale;
-        const normalized = matchLocale(locale, config.supportedLocales);
-        if (!normalized)
-            continue;
-        return {
-            locale: normalized,
-            localeSource: source,
-        };
-    }
-    // ------------------------------------------------------
-    // 2. Detection fallback (runtime signal)
-    // ------------------------------------------------------
-    const detected = matchLocale(context.detected?.locale, config.supportedLocales);
-    if (detected) {
-        return {
-            locale: detected,
-            localeSource: "detected",
-        };
-    }
-    // ------------------------------------------------------
-    // 3. Final invariant fallback (guaranteed)
-    // ------------------------------------------------------
+  const { localeSources } = config.routing.inbound;
+  for (const source of localeSources) {
+    const locale = context[source]?.locale;
+    const normalized = matchLocale(locale, config.supportedLocales);
+    if (!normalized) continue;
     return {
-        locale: config.defaultLocale,
-        localeSource: "default",
+      locale: normalized,
+      localeSource: source
     };
+  }
+  const detected = matchLocale(
+    context.detected?.locale,
+    config.supportedLocales
+  );
+  if (detected) {
+    return {
+      locale: detected,
+      localeSource: "detected"
+    };
+  }
+  return {
+    locale: config.defaultLocale,
+    localeSource: "default"
+  };
 }
 
 export { resolveLocale };

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

@@ -4,39 +4,33 @@ import { exceptDefault } from './strategies/except-default.js';
 import { none } from './strategies/none.js';
 
 const assertNever = (x) => {
-    throw new Error(`Unhandled prefix strategy: ${String(x)}`);
+  throw new Error(`Unhandled prefix strategy: ${String(x)}`);
 };
-/**
- * Resolves the canonical pathname based on locale prefix behavior.
- *
- * The resolved pathname represents the final, normalized form
- * used for routing and navigation.
- */
 const resolvePathname = (config, rawPathname, context) => {
-    const { localePrefix } = config.routing;
-    let directive;
-    switch (localePrefix) {
-        case "all": {
-            directive = all(config, context);
-            break;
-        }
-        case "except-default": {
-            directive = exceptDefault(config, context);
-            break;
-        }
-        case "none": {
-            directive = none();
-            break;
-        }
-        default: {
-            return assertNever(localePrefix);
-        }
+  const { localePrefix } = config.routing;
+  let directive;
+  switch (localePrefix) {
+    case "all": {
+      directive = all(config, context);
+      break;
     }
-    const { pathname } = localizePathname(rawPathname, config, context.locale);
-    return {
-        pathname,
-        shouldRedirect: directive.type === "redirect",
-    };
+    case "except-default": {
+      directive = exceptDefault(config, context);
+      break;
+    }
+    case "none": {
+      directive = none();
+      break;
+    }
+    default: {
+      return assertNever(localePrefix);
+    }
+  }
+  const { pathname } = localizePathname(rawPathname, config, context.locale);
+  return {
+    pathname,
+    shouldRedirect: directive.type === "redirect"
+  };
 };
 
 export { resolvePathname };

package/dist/svelte-kit/src/routing/inbound/resolve-pathname/strategies/all.js

@@ -1,28 +1,15 @@
-/**
- * Resolve pathname decision for routing prefix strategy: "all".
- */
 function all(config, context) {
-    const { hasPathLocale, hasPersisted} = context;
-    const { redirect } = config.routing.inbound.firstVisit;
-    const isFirstVisit = !hasPersisted;
-    // ----------------------------------------------------------
-    // URL already canonical
-    // ----------------------------------------------------------
-    if (hasPathLocale) {
-        return { type: "pass" };
-    }
-    // ----------------------------------------------------------
-    // Apply first-visit redirect policy
-    // ----------------------------------------------------------
-    if (isFirstVisit) {
-        if (!redirect)
-            return { type: "pass" };
-        return { type: "redirect" };
-    }
-    // ----------------------------------------------------------
-    // Redirect to the locale-prefixed URL
-    // ----------------------------------------------------------
+  const { hasPathLocale, hasPersisted} = context;
+  const { redirect } = config.routing.inbound.firstVisit;
+  const isFirstVisit = !hasPersisted;
+  if (hasPathLocale) {
+    return { type: "pass" };
+  }
+  if (isFirstVisit) {
+    if (!redirect) return { type: "pass" };
     return { type: "redirect" };
+  }
+  return { type: "redirect" };
 }
 
 export { all };