reroute-js 0.45.11 → 0.46.0

package/react/index.js

@@ -1,20 +1,24 @@
 /**
- * reroute-js v0.45.11
+ * reroute-js v0.46.0
  *
  * @license MIT
  * @copyright 2026 stewones <hi@stewan.io>
- * @see https://github.com/stewones/reroute
+ * @see https://github.com/Intenseloop/reroute
  *
  * Built with Bun <3
  */
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -393,32 +397,310 @@ import {
   isValidElement,
   useEffect as useEffect8,
   useLayoutEffect,
-  useMemo as useMemo9,
+  useMemo as useMemo11,
   useRef,
   useState as useState8
 } from "react";
 import { flushSync as flushSync2 } from "react-dom";
 
 // packages/react/src/hooks/useContent.ts
-import { useCallback as useCallback3, useEffect as useEffect3, useMemo as useMemo3, useState as useState4 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect3, useMemo as useMemo4, useState as useState4 } from "react";
 
-// packages/react/src/providers/ContentProvider.tsx
+// packages/react/src/i18n/helpers.ts
+import { IntlMessageFormat } from "intl-messageformat";
+function getMessage(catalog, key) {
+  if (!(catalog && key))
+    return;
+  const parts = key.split(".");
+  let current = catalog;
+  for (const part of parts) {
+    if (current == null || typeof current === "string")
+      return;
+    current = current[part];
+  }
+  return typeof current === "string" ? current : undefined;
+}
+function lookupMessage(catalogs, locale, defaultLocale, key) {
+  return getMessage(catalogs[locale], key) ?? (locale !== defaultLocale ? getMessage(catalogs[defaultLocale], key) : undefined);
+}
+var formatterCache = new Map;
+function formatMessage(message, locale, values) {
+  if ((!values || Object.keys(values).length === 0) && !/\{[^}]+\}/.test(message)) {
+    return message;
+  }
+  const cacheKey = `${locale}\x00${message}`;
+  let formatter = formatterCache.get(cacheKey);
+  if (!formatter) {
+    formatter = new IntlMessageFormat(message, locale);
+    formatterCache.set(cacheKey, formatter);
+  }
+  try {
+    const result = formatter.format(values);
+    return typeof result === "string" ? result : String(result);
+  } catch {
+    return message;
+  }
+}
+function createTranslator(catalogs, locale, defaultLocale) {
+  return (key, values) => {
+    const message = lookupMessage(catalogs, locale, defaultLocale, key);
+    if (message == null)
+      return key;
+    return formatMessage(message, locale, values);
+  };
+}
+function looksLikeLocale(segment) {
+  return /^[a-z]{2}(?:-[A-Za-z0-9]{2,8})*$/i.test(segment);
+}
+function parseContentPath(pathname, availableLocales = [], collections) {
+  const pathOnly = pathname.split("?")[0].split("#")[0];
+  const parts = pathOnly.split("/").filter(Boolean);
+  if (parts.length < 2)
+    return;
+  const [collection, second, third] = parts;
+  if (collections && !collections.includes(collection)) {
+    return;
+  }
+  const localeSet = new Set(availableLocales.map((l) => l.toLowerCase()));
+  if (parts.length >= 3 && third) {
+    const secondIsLocale = localeSet.size > 0 ? localeSet.has(second.toLowerCase()) : looksLikeLocale(second);
+    if (secondIsLocale) {
+      const locale = availableLocales.find((l) => l.toLowerCase() === second.toLowerCase()) || second;
+      return {
+        collection,
+        name: third,
+        locale,
+        routingPathname: `/${collection}/${third}`
+      };
+    }
+  }
+  return {
+    collection,
+    name: second,
+    routingPathname: `/${collection}/${second}`
+  };
+}
+function localizeContentHref(collection, name, locale, defaultLocale) {
+  if (!locale || locale === defaultLocale) {
+    return `/${collection}/${name}`;
+  }
+  return `/${collection}/${locale}/${name}`;
+}
+function localizeHref(to, locale, defaultLocale, availableLocales = [], collections) {
+  try {
+    const url = new URL(to, "http://local");
+    const parsed = parseContentPath(url.pathname, availableLocales, collections);
+    if (!parsed)
+      return to;
+    url.pathname = localizeContentHref(parsed.collection, parsed.name, locale, defaultLocale);
+    return `${url.pathname}${url.search}${url.hash}`;
+  } catch {
+    return to;
+  }
+}
+
+// packages/react/src/i18n/LocaleProvider.tsx
 import {
   createContext,
   useCallback,
   useContext,
   useMemo,
+  useSyncExternalStore
+} from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var LocaleContext = createContext(null);
+var DISABLED_STATE = {
+  enabled: false,
+  locale: "en-US",
+  defaultLocale: "en-US",
+  locales: [],
+  cookie: "reroute-locale",
+  catalogs: {}
+};
+function readHydration() {
+  try {
+    const g = globalThis;
+    const raw = g.__REROUTE_I18N__;
+    if (raw && typeof raw === "object") {
+      return {
+        enabled: !!raw.enabled,
+        locale: raw.locale || "en-US",
+        defaultLocale: raw.defaultLocale || "en-US",
+        locales: Array.isArray(raw.locales) ? raw.locales : [],
+        cookie: raw.cookie || "reroute-locale",
+        catalogs: raw.catalogs || {},
+        collections: raw.collections
+      };
+    }
+  } catch {}
+  return DISABLED_STATE;
+}
+function sameHydration(a, b) {
+  return a.enabled === b.enabled && a.locale === b.locale && a.defaultLocale === b.defaultLocale && a.cookie === b.cookie && a.catalogs === b.catalogs && a.locales === b.locales && a.collections === b.collections;
+}
+var store = {
+  state: readHydration(),
+  listeners: new Set
+};
+function subscribe(listener) {
+  store.listeners.add(listener);
+  return () => {
+    store.listeners.delete(listener);
+  };
+}
+function getSnapshot() {
+  const fromGlobal = readHydration();
+  if (fromGlobal.enabled && !sameHydration(store.state, fromGlobal)) {
+    store.state = fromGlobal;
+  }
+  return store.state;
+}
+function getServerSnapshot() {
+  return store.state;
+}
+function setStoreState(partial) {
+  const next = { ...store.state, ...partial };
+  if (sameHydration(store.state, next))
+    return;
+  store.state = next;
+  try {
+    globalThis.__REROUTE_I18N__ = store.state;
+  } catch {}
+  for (const listener of store.listeners)
+    listener();
+}
+function seedStore(value) {
+  const next = {
+    ...readHydration(),
+    ...value,
+    enabled: true,
+    locale: value.locale || store.state.locale,
+    defaultLocale: value.defaultLocale || store.state.defaultLocale,
+    locales: value.locales || store.state.locales,
+    cookie: value.cookie || store.state.cookie,
+    catalogs: value.catalogs || store.state.catalogs,
+    collections: value.collections || store.state.collections
+  };
+  if (sameHydration(store.state, next))
+    return;
+  store.state = next;
+  try {
+    globalThis.__REROUTE_I18N__ = store.state;
+  } catch {}
+}
+function writeLocaleCookie(name, locale) {
+  if (typeof document === "undefined")
+    return;
+  const maxAge = 60 * 60 * 24 * 365;
+  document.cookie = `${name}=${encodeURIComponent(locale)}; Path=/; Max-Age=${maxAge}; SameSite=Lax`;
+}
+function LocaleProvider({
+  children,
+  value
+}) {
+  if (value?.enabled) {
+    seedStore(value);
+  }
+  const state = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+  const translator = useMemo(() => {
+    if (!state.enabled) {
+      return (key) => key;
+    }
+    return createTranslator(state.catalogs, state.locale, state.defaultLocale);
+  }, [state.enabled, state.catalogs, state.locale, state.defaultLocale]);
+  const setLocale = useCallback((next) => {
+    if (!state.enabled)
+      return;
+    if (!state.locales.includes(next))
+      return;
+    writeLocaleCookie(state.cookie, next);
+    setStoreState({ locale: next });
+    if (typeof window === "undefined")
+      return;
+    const parsed = parseContentPath(window.location.pathname, state.locales, state.collections);
+    if (parsed) {
+      const target = localizeContentHref(parsed.collection, parsed.name, next, state.defaultLocale);
+      const url = `${target}${window.location.search}${window.location.hash}`;
+      window.location.assign(url);
+      return;
+    }
+    window.location.reload();
+  }, [state]);
+  const localizePath = useCallback((to) => {
+    if (!state.enabled)
+      return to;
+    return localizeHref(to, state.locale, state.defaultLocale, state.locales, state.collections);
+  }, [state]);
+  const localizeContentPath = useCallback((collection, name) => {
+    if (!state.enabled)
+      return `/${collection}/${name}`;
+    return localizeContentHref(collection, name, state.locale, state.defaultLocale);
+  }, [state]);
+  const ctx = useMemo(() => ({
+    enabled: state.enabled,
+    locale: state.locale,
+    defaultLocale: state.defaultLocale,
+    locales: state.locales,
+    t: translator,
+    setLocale,
+    localizePath,
+    localizeContentPath
+  }), [state, translator, setLocale, localizePath, localizeContentPath]);
+  return /* @__PURE__ */ jsx2(LocaleContext.Provider, {
+    value: ctx,
+    children
+  });
+}
+function useLocaleContext() {
+  const ctx = useContext(LocaleContext);
+  if (ctx)
+    return ctx;
+  return {
+    enabled: false,
+    locale: "en-US",
+    defaultLocale: "en-US",
+    locales: [],
+    t: (key) => key,
+    setLocale: () => {},
+    localizePath: (to) => to,
+    localizeContentPath: (collection, name) => `/${collection}/${name}`
+  };
+}
+function useLocale() {
+  const { locale, locales, defaultLocale, enabled, setLocale } = useLocaleContext();
+  return { locale, locales, defaultLocale, enabled, setLocale };
+}
+function t(key, values) {
+  const state = getSnapshot();
+  if (!state.enabled)
+    return key;
+  return createTranslator(state.catalogs, state.locale, state.defaultLocale)(key, values);
+}
+
+// packages/react/src/providers/ContentProvider.tsx
+import {
+  createContext as createContext2,
+  useCallback as useCallback2,
+  useContext as useContext2,
+  useMemo as useMemo2,
   useState as useState2
 } from "react";
 
 // packages/react/src/lib/content.ts
+function looksLikeLocale2(segment) {
+  return /^[a-z]{2}(?:-[A-Za-z0-9]{2,8})*$/i.test(segment);
+}
 function parseContentHref(href) {
   try {
     const url = new URL(href, "http://local");
-    const [collection, name] = url.pathname.split("/").filter(Boolean);
-    if (!(collection && name))
+    const parts = url.pathname.split("/").filter(Boolean);
+    if (parts.length < 2)
       return;
-    return { collection, name };
+    const [collection, second, third] = parts;
+    if (parts.length >= 3 && third && looksLikeLocale2(second)) {
+      return { collection, name: third, locale: second };
+    }
+    return { collection, name: second };
   } catch {
     return;
   }
@@ -429,7 +711,7 @@ function createResolverFromGetEntry(getEntry) {
     if (!parsed)
       return;
     try {
-      const entry = getEntry(parsed.collection, parsed.name);
+      const entry = getEntry(parsed.collection, parsed.name, parsed.locale);
       if (!entry)
         return parsed;
       const moduleUrl = entry?.module;
@@ -441,12 +723,33 @@ function createResolverFromGetEntry(getEntry) {
 }
 
 // packages/react/src/providers/ContentProvider.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
-var ContentRegistryContext = createContext(null);
-var ContentIndexContext = createContext(null);
-var ContentGetEntryContext = createContext(null);
-var ContentLoadCollectionContext = createContext(null);
-var MarkdownComponentsContext = createContext(null);
+import { jsx as jsx3 } from "react/jsx-runtime";
+function findIndexEntry(list, name, locale) {
+  if (locale) {
+    return list.find((e) => e?.name === name && e?.locale === locale) || list.find((e) => e?.name === name);
+  }
+  return list.find((e) => e?.name === name);
+}
+function resolveFromIndex(href, idx) {
+  const parsed = parseContentHref(href);
+  if (!parsed)
+    return;
+  try {
+    const list = idx[parsed.collection];
+    if (Array.isArray(list)) {
+      const found = findIndexEntry(list, parsed.name, parsed.locale);
+      if (found && typeof found.module === "string") {
+        return { ...parsed, module: found.module };
+      }
+    }
+  } catch {}
+  return parsed;
+}
+var ContentRegistryContext = createContext2(null);
+var ContentIndexContext = createContext2(null);
+var ContentGetEntryContext = createContext2(null);
+var ContentLoadCollectionContext = createContext2(null);
+var MarkdownComponentsContext = createContext2(null);
 function ContentProvider({
   children,
   resolveByHref,
@@ -482,28 +785,14 @@ function ContentProvider({
     return result;
   });
   const entryFn = getEntry || null;
-  const resolver = useMemo(() => {
+  const resolver = useMemo2(() => {
     if (typeof resolveByHref === "function")
       return resolveByHref;
     if (typeof getEntry === "function")
       return createResolverFromGetEntry(getEntry);
-    return (href) => {
-      const parsed = parseContentHref(href);
-      if (!parsed)
-        return;
-      try {
-        const list = idx?.[parsed.collection];
-        if (Array.isArray(list)) {
-          const found = list.find((e) => e?.name === parsed.name);
-          if (found && typeof found.module === "string") {
-            return { ...parsed, module: found.module };
-          }
-        }
-      } catch {}
-      return parsed;
-    };
+    return (href) => resolveFromIndex(href, idx);
   }, [resolveByHref, getEntry, idx]);
-  const ensureCollection = useCallback(async (collection) => {
+  const ensureCollection = useCallback2(async (collection) => {
     try {
       const existing = idx[collection];
       const w = typeof window !== "undefined" ? window : undefined;
@@ -527,15 +816,15 @@ function ContentProvider({
       return;
     }
   }, [idx, loadCollection]);
-  return /* @__PURE__ */ jsx2(ContentRegistryContext.Provider, {
+  return /* @__PURE__ */ jsx3(ContentRegistryContext.Provider, {
     value: resolver,
-    children: /* @__PURE__ */ jsx2(ContentIndexContext.Provider, {
+    children: /* @__PURE__ */ jsx3(ContentIndexContext.Provider, {
       value: idx,
-      children: /* @__PURE__ */ jsx2(ContentGetEntryContext.Provider, {
+      children: /* @__PURE__ */ jsx3(ContentGetEntryContext.Provider, {
         value: entryFn,
-        children: /* @__PURE__ */ jsx2(ContentLoadCollectionContext.Provider, {
+        children: /* @__PURE__ */ jsx3(ContentLoadCollectionContext.Provider, {
           value: ensureCollection,
-          children: /* @__PURE__ */ jsx2(MarkdownComponentsContext.Provider, {
+          children: /* @__PURE__ */ jsx3(MarkdownComponentsContext.Provider, {
             value: markdownComponents || null,
             children
           })
@@ -545,23 +834,23 @@ function ContentProvider({
   });
 }
 function useContentResolver() {
-  return useContext(ContentRegistryContext);
+  return useContext2(ContentRegistryContext);
 }
 function useContentIndex() {
-  return useContext(ContentIndexContext);
+  return useContext2(ContentIndexContext);
 }
 function useContentGetEntry() {
-  return useContext(ContentGetEntryContext);
+  return useContext2(ContentGetEntryContext);
 }
 function useContentLoadCollection() {
-  return useContext(ContentLoadCollectionContext);
+  return useContext2(ContentLoadCollectionContext);
 }
 function useMarkdownComponents() {
-  return useContext(MarkdownComponentsContext);
+  return useContext2(MarkdownComponentsContext);
 }
 
 // packages/react/src/hooks/useSearch.ts
-import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useState as useState3 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect2, useMemo as useMemo3, useState as useState3 } from "react";
 function useSearch(params) {
   const {
     query,
@@ -571,7 +860,7 @@ function useSearch(params) {
     enabled = true,
     debounce = 300
   } = params;
-  const stableCollections = useMemo2(() => collections, [collections]);
+  const stableCollections = useMemo3(() => collections, [collections]);
   const [results, setResults] = useState3([]);
   const [total, setTotal] = useState3(0);
   const [page, setPage] = useState3(paramPage);
@@ -579,7 +868,7 @@ function useSearch(params) {
   const [totalPages, setTotalPages] = useState3(0);
   const [isLoading, setIsLoading] = useState3(false);
   const [error, setError] = useState3(null);
-  const performSearch = useCallback2(async (searchQuery, searchPage) => {
+  const performSearch = useCallback3(async (searchQuery, searchPage) => {
     if (!searchQuery.trim()) {
       setResults([]);
       setTotal(0);
@@ -603,6 +892,12 @@ function useSearch(params) {
       if (paramPageSize) {
         params2.set("pageSize", String(paramPageSize));
       }
+      try {
+        const g = globalThis;
+        if (g.__REROUTE_I18N__?.enabled && g.__REROUTE_I18N__.locale) {
+          params2.set("lang", g.__REROUTE_I18N__.locale);
+        }
+      } catch {}
       const response = await fetch(`/__reroute_search?${params2.toString()}`);
       if (!response.ok) {
         const errorData = await response.json().catch(() => ({}));
@@ -647,7 +942,7 @@ function useSearch(params) {
     }, debounce);
     return () => clearTimeout(timeoutId);
   }, [query, paramPage, enabled, debounce, performSearch]);
-  const search = useCallback2(async (newQuery, newPage) => {
+  const search = useCallback3(async (newQuery, newPage) => {
     await performSearch(newQuery, newPage);
   }, [performSearch]);
   return {
@@ -663,6 +958,24 @@ function useSearch(params) {
 }
 
 // packages/react/src/hooks/useContent.ts
+function pickLocaleEntries(list, locale, defaultLocale) {
+  const byName = new Map;
+  for (const item of list) {
+    const name = item.name;
+    if (!name)
+      continue;
+    const arr = byName.get(name) || [];
+    arr.push(item);
+    byName.set(name, arr);
+  }
+  const result = [];
+  for (const variants of byName.values()) {
+    const preferred = variants.find((v) => v.locale === locale) || variants.find((v) => v.locale === defaultLocale) || variants.find((v) => !v.locale) || variants[0];
+    if (preferred)
+      result.push(preferred);
+  }
+  return result;
+}
 function sortByDate(order) {
   return (a, b) => {
     const da = a?.meta && a.meta?.date ? Date.parse(String(a.meta.date)) : 0;
@@ -825,11 +1138,11 @@ function prefetchContent(entry) {
     const w = window;
     if (!w.__REROUTE_MODULES__)
       w.__REROUTE_MODULES__ = {};
-    const store = w.__REROUTE_MODULES__;
-    if (store[key])
+    const store2 = w.__REROUTE_MODULES__;
+    if (store2[key])
       return;
     import(modUrl).then((m) => {
-      store[key] = m;
+      store2[key] = m;
     }).catch(() => {});
   } catch {}
 }
@@ -870,6 +1183,7 @@ function useContent(params) {
   }
   const index = useContentIndex();
   const loadCollection = useContentLoadCollection();
+  const { locale, defaultLocale, enabled: i18nEnabled } = useLocale();
   const [_ready, setReady] = useState4(() => {
     const have = index?.[collection];
     return Array.isArray(have) && have.length > 0;
@@ -931,12 +1245,19 @@ function useContent(params) {
       cancelled = true;
     };
   }, [collection, index, loadCollection, limit, filter, fields]);
-  const items = useMemo3(() => {
+  const items = useMemo4(() => {
     const source = index || {};
     const list = source?.[collection];
     if (!Array.isArray(list) || list.length === 0)
       return [];
     let cloned = [...list];
+    if (i18nEnabled) {
+      cloned = pickLocaleEntries(cloned, locale, defaultLocale);
+      cloned = cloned.map((item) => ({
+        ...item,
+        href: localizeContentHref(item.collection || collection, item.name, locale, defaultLocale)
+      }));
+    }
     cloned = applyFilter(cloned, filter);
     if (typeof sort === "function") {
       cloned = cloned.sort(sort);
@@ -970,14 +1291,23 @@ function useContent(params) {
       } catch {}
     }
     return cloned;
-  }, [index, collection, sort, limit, filter]);
+  }, [
+    index,
+    collection,
+    sort,
+    limit,
+    filter,
+    i18nEnabled,
+    locale,
+    defaultLocale
+  ]);
   useEffect3(() => {
     if (typeof window === "undefined")
       return;
     const handler = (e) => {
       const detail = e.detail;
       if (detail?.collection === collection) {
-        setContentLoadTick((t) => t + 1);
+        setContentLoadTick((t2) => t2 + 1);
       }
     };
     window.addEventListener("__reroute_content_loading__", handler);
@@ -987,8 +1317,8 @@ function useContent(params) {
       window.removeEventListener("__reroute_content_loaded__", handler);
     };
   }, [collection]);
-  const prefetch = useCallback3((entry) => prefetchContent(entry), []);
-  const hasLoadingModules = useMemo3(() => {
+  const prefetch = useCallback4((entry) => prefetchContent(entry), []);
+  const hasLoadingModules = useMemo4(() => {
     if (typeof window === "undefined") {
       return false;
     }
@@ -1005,17 +1335,20 @@ function useContent(params) {
   return { items, isLoading, prefetch };
 }
 // packages/react/src/hooks/useData.ts
-import { useEffect as useEffect5, useMemo as useMemo5, useState as useState5 } from "react";
+import { useEffect as useEffect5, useMemo as useMemo7, useState as useState5 } from "react";
 
 // packages/react/src/hooks/useRouter.tsx
-import { useContext as useContext2 } from "react";
+import { useContext as useContext3 } from "react";
+// packages/react/src/providers/RerouteProvider.tsx
+import { useCallback as useCallback6, useMemo as useMemo6 } from "react";
+
 // packages/react/src/providers/RouterProvider.tsx
 import React, {
-  createContext as createContext2,
-  useCallback as useCallback4,
+  createContext as createContext3,
+  useCallback as useCallback5,
   useEffect as useEffect4,
-  useMemo as useMemo4,
-  useSyncExternalStore
+  useMemo as useMemo5,
+  useSyncExternalStore as useSyncExternalStore2
 } from "react";
 import { flushSync } from "react-dom";
 
@@ -1163,10 +1496,10 @@ function applyRouteHead(head) {
 }
 
 // packages/react/src/providers/RouterProvider.tsx
-import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+import { jsx as jsx4, jsxs } from "react/jsx-runtime";
 var isBrowser2 = typeof window !== "undefined" && typeof window.document !== "undefined";
-var OutletContext = createContext2(null);
-var RouterContext = createContext2(null);
+var OutletContext = createContext3(null);
+var RouterContext = createContext3(null);
 var listeners = [];
 var currentLocation = isBrowser2 ? {
   pathname: window.location.pathname,
@@ -1208,7 +1541,7 @@ function applyHeadIfStillOnPage(pathnameToUse, payload, matchRoute) {
           console.error("[RouterProvider] Error applying head after lazy fetch:", e);
         }
       }
-    } else {}
+    }
   });
 }
 function processLazyFetchResponse(json, pathnameToUse, matchRoute) {
@@ -1289,7 +1622,7 @@ function applyRouteHeadAndLang(currentPathname, pathname, target, matchRoute) {
       applyLang(ssr.lang);
   } catch {}
 }
-function subscribe(listener) {
+function subscribe2(listener) {
   if (!isBrowser2)
     return () => {};
   listeners.push(listener);
@@ -1297,7 +1630,7 @@ function subscribe(listener) {
     listeners = listeners.filter((l) => l !== listener);
   };
 }
-function getSnapshot() {
+function getSnapshot2() {
   return currentLocation;
 }
 function emitChange() {
@@ -1457,8 +1790,8 @@ function RouterProvider({
       serverSnapshotRef.current = { pathname: pathOnly, search, hash };
     }
   }
-  const getServerSnapshot = useCallback4(() => serverSnapshotRef.current, []);
-  const location = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) || currentLocation;
+  const getServerSnapshot2 = useCallback5(() => serverSnapshotRef.current, []);
+  const location = useSyncExternalStore2(subscribe2, getSnapshot2, getServerSnapshot2) || currentLocation;
   useEffect4(() => {
     if (!isBrowser2)
       return;
@@ -1472,10 +1805,10 @@ function RouterProvider({
       emitChange();
     }
   }, []);
-  const target = useMemo4(() => matchRoute(location.pathname), [location.pathname, matchRoute]);
+  const target = useMemo5(() => matchRoute(location.pathname), [location.pathname, matchRoute]);
   const params = target?.params || {};
-  const searchParams = useMemo4(() => new URLSearchParams(location.search), [location.search]);
-  const navigate = useCallback4((to, options = {}) => {
+  const searchParams = useMemo5(() => new URLSearchParams(location.search), [location.search]);
+  const navigate = useCallback5((to, options = {}) => {
     navigateInternal(to, options);
   }, []);
   useEffect4(() => {
@@ -1652,7 +1985,7 @@ function RouterProvider({
       }
     };
   }, [target, pathname, matchRoute]);
-  const notFoundResolver = useCallback4((pathname2) => {
+  const notFoundResolver = useCallback5((pathname2) => {
     try {
       const list = Array.isArray(notFoundRoutes) ? notFoundRoutes : [];
       let chosen;
@@ -1672,7 +2005,7 @@ function RouterProvider({
       return;
     }
   }, [notFoundRoutes]);
-  const contextValue = useMemo4(() => ({
+  const contextValue = useMemo5(() => ({
     pathname: location.pathname,
     params,
     searchParams,
@@ -1689,7 +2022,7 @@ function RouterProvider({
     matchRoute,
     notFoundResolver
   ]);
-  const matchingLayouts = useMemo4(() => {
+  const matchingLayouts = useMemo5(() => {
     return layouts.filter((layout) => {
       if (layout.pattern === "/")
         return true;
@@ -1701,25 +2034,25 @@ function RouterProvider({
   let content;
   if (target) {
     const Component = target.route.component;
-    let outletContent = /* @__PURE__ */ jsx3(Component, {});
+    let outletContent = /* @__PURE__ */ jsx4(Component, {});
     for (let i = matchingLayouts.length - 1;i >= 0; i--) {
       const Layout = matchingLayouts[i].component;
       const currentOutlet = outletContent;
-      outletContent = /* @__PURE__ */ jsx3(OutletContext.Provider, {
+      outletContent = /* @__PURE__ */ jsx4(OutletContext.Provider, {
         value: currentOutlet,
-        children: /* @__PURE__ */ jsx3(Layout, {})
+        children: /* @__PURE__ */ jsx4(Layout, {})
       });
     }
     content = outletContent;
   } else {
     const Fallback = notFoundResolver(location.pathname) || NotFound;
     if (Fallback) {
-      content = /* @__PURE__ */ jsx3(Fallback, {});
+      content = /* @__PURE__ */ jsx4(Fallback, {});
     } else {
       content = /* @__PURE__ */ jsxs("div", {
         style: { padding: "2rem", textAlign: "center" },
         children: [
-          /* @__PURE__ */ jsx3("h1", {
+          /* @__PURE__ */ jsx4("h1", {
             children: "404 - Page Not Found"
           }),
           /* @__PURE__ */ jsxs("p", {
@@ -1729,7 +2062,7 @@ function RouterProvider({
               " could not be found."
             ]
           }),
-          /* @__PURE__ */ jsx3("a", {
+          /* @__PURE__ */ jsx4("a", {
             href: "/",
             children: "Go Home"
           })
@@ -1737,14 +2070,22 @@ function RouterProvider({
       });
     }
   }
-  return /* @__PURE__ */ jsx3(RouterContext.Provider, {
+  return /* @__PURE__ */ jsx4(RouterContext.Provider, {
     value: contextValue,
     children: children || content
   });
 }
 
 // packages/react/src/providers/RerouteProvider.tsx
-import { jsx as jsx4 } from "react/jsx-runtime";
+import { jsx as jsx5 } from "react/jsx-runtime";
+function readI18nHydration() {
+  try {
+    const raw = globalThis.__REROUTE_I18N__;
+    if (raw?.enabled)
+      return raw;
+  } catch {}
+  return;
+}
 function RerouteProvider({
   byCollection,
   getContentEntry,
@@ -1759,30 +2100,51 @@ function RerouteProvider({
   viewTransitions,
   scrollRestoration,
   markdownComponents,
+  i18n: i18nProp,
   children
 }) {
   const loader = loadContent || (contentBaseUrl ? (c) => import(`${contentBaseUrl}/${c}.js`) : undefined);
-  return /* @__PURE__ */ jsx4(ContentProvider, {
-    getEntry: getContentEntry,
-    byCollection: byCollection || null,
-    loadCollection: loader,
-    markdownComponents,
-    children: /* @__PURE__ */ jsx4(RouterProvider, {
-      layouts,
-      matchRoute,
-      notFoundRoutes,
-      notFound,
-      pathname,
-      searchParams,
-      viewTransitions,
-      scrollRestoration,
-      children
+  const i18n = i18nProp?.enabled ? i18nProp : readI18nHydration();
+  const locales = i18n?.locales || [];
+  const collections = useMemo6(() => {
+    if (i18n?.collections?.length)
+      return i18n.collections;
+    if (byCollection)
+      return Object.keys(byCollection);
+    return;
+  }, [i18n?.collections, byCollection]);
+  const matchRouteWithLocale = useCallback6((path) => {
+    if (!(i18n?.enabled && locales.length)) {
+      return matchRoute(path);
+    }
+    const parsed = parseContentPath(path, locales, collections);
+    const routingPath = parsed?.routingPathname || path;
+    return matchRoute(routingPath);
+  }, [i18n?.enabled, locales, collections, matchRoute]);
+  return /* @__PURE__ */ jsx5(LocaleProvider, {
+    value: i18n,
+    children: /* @__PURE__ */ jsx5(ContentProvider, {
+      getEntry: getContentEntry,
+      byCollection: byCollection || null,
+      loadCollection: loader,
+      markdownComponents,
+      children: /* @__PURE__ */ jsx5(RouterProvider, {
+        layouts,
+        matchRoute: matchRouteWithLocale,
+        notFoundRoutes,
+        notFound,
+        pathname,
+        searchParams,
+        viewTransitions,
+        scrollRestoration,
+        children
+      })
     })
   });
 }
 // packages/react/src/hooks/useRouter.tsx
 function useRouter() {
-  const context = useContext2(RouterContext);
+  const context = useContext3(RouterContext);
   if (!context) {
     throw new Error("useRouter must be used within a RouterProvider");
   }
@@ -2003,7 +2365,7 @@ function useData(key) {
       pending[pathToFetch] = fetchPromise;
     } catch {}
   }, [k, pathname]);
-  return useMemo5(() => {
+  return useMemo7(() => {
     try {
       const source = typeof window === "undefined" ? globalThis.__REROUTE_DATA__ : window.__REROUTE_DATA__;
       let value = source?.[k];
@@ -2168,10 +2530,10 @@ function useData(key) {
   }, [k, _tick, pathname]);
 }
 // packages/react/src/hooks/useFeed.ts
-import { useMemo as useMemo6 } from "react";
+import { useMemo as useMemo8 } from "react";
 function useFeed() {
   const { pathname } = useRouter();
-  return useMemo6(() => {
+  return useMemo8(() => {
     const availableFeeds = typeof globalThis !== "undefined" ? globalThis.__REROUTE_AVAILABLE_FEEDS__ || globalThis.__REROUTE_FEEDS__ || [] : [];
     const parts = pathname.split("/").filter(Boolean);
     const mainFeedUrl = "/feed.xml";
@@ -2199,7 +2561,7 @@ function useFeed() {
   }, [pathname]);
 }
 // packages/react/src/hooks/useLayoutData.ts
-import { useEffect as useEffect6, useMemo as useMemo7, useState as useState6 } from "react";
+import { useEffect as useEffect6, useMemo as useMemo9, useState as useState6 } from "react";
 var isThenable2 = (value) => {
   return typeof value === "object" && value !== null && typeof value.then === "function";
 };
@@ -2214,7 +2576,7 @@ var isInitialHydration2 = () => {
 function useLayoutData() {
   const { pathname } = useRouter();
   const [_tick, setTick] = useState6(0);
-  const layoutKey = useMemo7(() => {
+  const layoutKey = useMemo9(() => {
     const parts = pathname.split("/").filter(Boolean);
     if (parts.length === 0)
       return "__layout:/";
@@ -2303,7 +2665,7 @@ function useLayoutData() {
       });
     } catch {}
   }, [layoutKey, pathname]);
-  return useMemo7(() => {
+  return useMemo9(() => {
     try {
       const source = typeof window === "undefined" ? globalThis.__REROUTE_DATA__ : window.__REROUTE_DATA__;
       let value = source?.[layoutKey];
@@ -2361,10 +2723,10 @@ function useLayoutData() {
   }, [layoutKey, _tick]);
 }
 // packages/react/src/hooks/useLlms.ts
-import { useMemo as useMemo8 } from "react";
+import { useMemo as useMemo10 } from "react";
 function useLlms() {
   const { pathname } = useRouter();
-  return useMemo8(() => {
+  return useMemo10(() => {
     const availableLlms = typeof globalThis !== "undefined" ? globalThis.__REROUTE_AVAILABLE_LLMS__ || globalThis.__REROUTE_LLMS__ || [] : [];
     const parts = pathname.split("/").filter(Boolean);
     const mainLlmsUrl = "/llms.txt";
@@ -2488,7 +2850,16 @@ function useToc() {
   return { toc, isLoading: false };
 }
 // packages/react/src/components/ContentRoute.tsx
-import { jsx as jsx5 } from "react/jsx-runtime";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function looksLikeLocale3(segment) {
+  return /^[a-z]{2}(?:-[A-Za-z0-9]{2,8})*$/i.test(segment);
+}
+function contentModuleKey(collection, name, locale, defaultLocale) {
+  if (locale && locale !== defaultLocale) {
+    return `${collection}:${name}:${locale}`;
+  }
+  return `${collection}:${name}`;
+}
 function getCapturedHtml(key) {
   try {
     const g = globalThis;
@@ -2512,26 +2883,33 @@ function ContentRoute({
   const params = useParams();
   const router = useRouter();
   const { pathname, notFoundResolver } = router;
-  const inferredName = name || params.slug || params.name || (() => {
+  const { locale, defaultLocale, enabled: i18nEnabled } = useLocale();
+  const pathInfo = (() => {
     try {
       const parts = String(pathname || "").split("/").filter(Boolean);
-      return parts.length >= 2 ? parts[1] : undefined;
-    } catch {
-      return;
-    }
+      if (parts.length >= 3 && looksLikeLocale3(parts[1])) {
+        return { name: parts[2], locale: parts[1] };
+      }
+      if (parts.length >= 2) {
+        return { name: parts[1], locale: undefined };
+      }
+    } catch {}
+    return { name: undefined, locale: undefined };
   })();
-  const key = inferredName ? `${collection}:${inferredName}` : `${collection}:`;
+  const inferredName = name || params.slug || params.name || pathInfo.name;
+  const activeLocale = pathInfo.locale || (i18nEnabled ? locale : defaultLocale) || defaultLocale;
+  const key = inferredName ? contentModuleKey(collection, inferredName, activeLocale, defaultLocale) : `${collection}:`;
   const ctxGetEntry = useContentGetEntry();
   const idx = useContentIndex();
   const ensureCollection = useContentLoadCollection();
   const markdownComponents = useMarkdownComponents();
   const resolved404 = notFoundResolver ? notFoundResolver(pathname) : undefined;
-  const resolveEntry = getEntry || ctxGetEntry || ((c, n) => {
+  const resolveEntry = getEntry || ctxGetEntry || ((c, n, loc) => {
     try {
       const list = idx?.[c];
       if (!Array.isArray(list))
         return;
-      const found = list.find((e) => e?.name === n);
+      const found = (loc ? list.find((e) => e?.name === n && e?.locale === loc) : undefined) || list.find((e) => e?.name === n && e?.locale === defaultLocale) || list.find((e) => e?.name === n);
       if (!found)
         return;
       return {
@@ -2543,8 +2921,8 @@ function ContentRoute({
       return;
     }
   });
-  const entry = inferredName && resolveEntry ? resolveEntry(collection, inferredName) : undefined;
-  const initialComp = useMemo9(() => {
+  const entry = inferredName && resolveEntry ? resolveEntry(collection, inferredName, activeLocale) : undefined;
+  const initialComp = useMemo11(() => {
     try {
       const g = globalThis;
       const mod = g.__REROUTE_SSR_MODULES__?.[key];
@@ -2554,8 +2932,8 @@ function ContentRoute({
       }
     } catch {}
     if (typeof window !== "undefined") {
-      const store = window.__REROUTE_MODULES__ || {};
-      const cached = store[key];
+      const store2 = window.__REROUTE_MODULES__ || {};
+      const cached = store2[key];
       if (cached) {
         const C = cached.default || cached;
         return toComponent(C);
@@ -2578,8 +2956,8 @@ function ContentRoute({
     if (g.__REROUTE_SSR_MODULES__?.[key]) {
       hasInitialContent = true;
     } else if (typeof window !== "undefined") {
-      const store = window.__REROUTE_MODULES__ || {};
-      if (store[key]) {
+      const store2 = window.__REROUTE_MODULES__ || {};
+      if (store2[key]) {
         hasInitialContent = true;
       }
     } else if (entry?.component) {
@@ -2710,11 +3088,11 @@ function ContentRoute({
   const compProps = markdownComponents ? { components: markdownComponents } : {};
   const isServer = typeof window === "undefined";
   if (isServer) {
-    return /* @__PURE__ */ jsx5("div", {
+    return /* @__PURE__ */ jsx6("div", {
       "data-reroute": "content",
       "data-reroute-key": key,
       ref: containerRef,
-      children: /* @__PURE__ */ jsx5(Comp, {
+      children: /* @__PURE__ */ jsx6(Comp, {
         ...compProps
       })
     });
@@ -2722,18 +3100,18 @@ function ContentRoute({
   const capturedHtml = getCapturedHtml(key);
   const hasLoadedModule = !!globalThis.__REROUTE_SSR_MODULES__?.[key] || !!globalThis.__REROUTE_MODULES__?.[key];
   if (capturedHtml && !hasLoadedModule) {
-    return /* @__PURE__ */ jsx5("div", {
+    return /* @__PURE__ */ jsx6("div", {
       "data-reroute": "content",
       "data-reroute-key": key,
       ref: containerRef,
       dangerouslySetInnerHTML: { __html: capturedHtml }
     });
   }
-  return /* @__PURE__ */ jsx5("div", {
+  return /* @__PURE__ */ jsx6("div", {
     "data-reroute": "content",
     "data-reroute-key": key,
     ref: containerRef,
-    children: /* @__PURE__ */ jsx5(Comp, {
+    children: /* @__PURE__ */ jsx6(Comp, {
       ...compProps
     })
   });
@@ -2744,7 +3122,7 @@ import {
   useRef as useRef2,
   useState as useState9
 } from "react";
-import { jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
+import { jsx as jsx7, jsxs as jsxs2 } from "react/jsx-runtime";
 var DEFAULT_DEVICE_SIZES = [640, 750, 828, 1080, 1200, 1920, 2048, 3840];
 function generateSrcSet(src, width, quality, format, loader) {
   const sizes = width ? DEFAULT_DEVICE_SIZES.filter((size) => size <= width * 2) : DEFAULT_DEVICE_SIZES;
@@ -2901,7 +3279,7 @@ function Image({
           height: "100%"
         },
         children: [
-          showSpinner && !isLoaded && !hasError && /* @__PURE__ */ jsx6("span", {
+          showSpinner && !isLoaded && !hasError && /* @__PURE__ */ jsx7("span", {
             style: {
               position: "absolute",
               inset: 0,
@@ -2912,7 +3290,7 @@ function Image({
               zIndex: 1,
               pointerEvents: "none"
             },
-            children: spinner || /* @__PURE__ */ jsx6("span", {
+            children: spinner || /* @__PURE__ */ jsx7("span", {
               style: {
                 display: "block",
                 width: `${spinnerSize}px`,
@@ -2924,7 +3302,7 @@ function Image({
               }
             })
           }),
-          placeholder === "blur" && placeholderSrc && !isLoaded && !hasError && /* @__PURE__ */ jsx6("img", {
+          placeholder === "blur" && placeholderSrc && !isLoaded && !hasError && /* @__PURE__ */ jsx7("img", {
             src: placeholderSrc,
             draggable,
             alt: "",
@@ -2940,7 +3318,7 @@ function Image({
               zIndex: -1
             }
           }),
-          /* @__PURE__ */ jsx6("img", {
+          /* @__PURE__ */ jsx7("img", {
             ref: imgRef,
             draggable,
             src: priority || supportsNativeLazyLoading() ? imageUrl : undefined,
@@ -2959,7 +3337,7 @@ function Image({
             className,
             ...props
           }),
-          showSpinner && !isLoaded && /* @__PURE__ */ jsx6("style", {
+          showSpinner && !isLoaded && /* @__PURE__ */ jsx7("style", {
             children: `
 						@keyframes reroute-spin {
 							0% { transform: rotate(0deg); }
@@ -2969,7 +3347,7 @@ function Image({
           })
         ]
       }),
-      showCaption && /* @__PURE__ */ jsx6("em", {
+      showCaption && /* @__PURE__ */ jsx7("em", {
         style: {
           display: "block",
           fontSize: "75%",
@@ -2985,8 +3363,8 @@ function Image({
   });
 }
 // packages/react/src/components/Link.tsx
-import { useCallback as useCallback5, useContext as useContext3, useMemo as useMemo10 } from "react";
-import { jsx as jsx7 } from "react/jsx-runtime";
+import { useCallback as useCallback7, useContext as useContext4, useMemo as useMemo12 } from "react";
+import { jsx as jsx8 } from "react/jsx-runtime";
 function parseLocalUrl(to) {
   if (typeof window === "undefined")
     return null;
@@ -3026,35 +3404,35 @@ function dispatchDataEvent(detail) {
 function storeAndDispatchData(path, payload, silent = false) {
   if (!payload || typeof payload !== "object")
     return;
-  const store = getRerouteDataStore();
+  const store2 = getRerouteDataStore();
   if (payload.__reroute_multiple__ === true) {
     const keys = Object.keys(payload).filter((k) => k !== "__reroute_multiple__");
     for (const key of keys) {
-      store[key] = payload[key];
+      store2[key] = payload[key];
     }
     if (!silent)
       dispatchDataEvent({ keys });
   } else if (payload.__flatten__ === true || payload.__reroute_flattened__ === true) {
     const keys = Object.keys(payload).filter((k) => k !== "__flatten__" && k !== "__reroute_flattened__");
     for (const key of keys) {
-      store[key] = payload[key];
+      store2[key] = payload[key];
     }
-    store[path] = payload;
+    store2[path] = payload;
     if (!silent)
       dispatchDataEvent({ keys: [...keys, path] });
   } else {
-    store[path] = payload;
+    store2[path] = payload;
     if (!silent)
       dispatchDataEvent({ key: path });
   }
 }
 function needsDataPrefetch(path, inferred, matchRoute) {
   const isDynamic = !!matchRoute?.(path)?.route?.isDynamic;
-  const store = getRerouteDataStore();
+  const store2 = getRerouteDataStore();
   const hasRealContent = inferred?.module !== undefined;
   if (hasRealContent)
     return false;
-  if (store[path] !== undefined)
+  if (store2[path] !== undefined)
     return false;
   const route = matchRoute?.(path)?.route;
   const hasSSRData = !!(route?.ssr && typeof route.ssr === "object" && typeof route.ssr.data === "function");
@@ -3131,18 +3509,20 @@ function Link({
   draggable = false,
   ...props
 }) {
-  const routerContext = useContext3(RouterContext);
+  const routerContext = useContext4(RouterContext);
   const router = useRouter();
   const resolver = useContentResolver();
   const contentIndex = useContentIndex();
   const ensureCollection = useContentLoadCollection();
+  const { localizePath, enabled: i18nEnabled } = useLocaleContext();
   const hasRouter = !!routerContext;
   const { navigate, matchRoute } = router || {
     navigate: () => {},
     matchRoute: () => null
   };
-  const inferred = useMemo10(() => resolver ? resolver(String(to)) : undefined, [resolver, to]);
-  const handleSameRouteNavigation = useCallback5((localUrl) => {
+  const resolvedTo = useMemo12(() => i18nEnabled ? localizePath(String(to)) : String(to), [i18nEnabled, localizePath, to]);
+  const inferred = useMemo12(() => resolver ? resolver(resolvedTo) : undefined, [resolver, resolvedTo]);
+  const handleSameRouteNavigation = useCallback7((localUrl) => {
     const currentPath = window.location.pathname + window.location.search;
     if (localUrl.fullPath !== currentPath)
       return false;
@@ -3153,14 +3533,17 @@ function Link({
       if (element) {
         element.scrollIntoView({ behavior: "smooth" });
       } else {
-        navigate(fragment ? `${to}#${fragment}` : to, { replace, state });
+        navigate(fragment ? `${resolvedTo}#${fragment}` : resolvedTo, {
+          replace,
+          state
+        });
       }
     } else {
       window.scrollTo({ top: 0, behavior: "smooth" });
     }
     return true;
-  }, [fragment, navigate, replace, state, to]);
-  const triggerPrefetch = useCallback5((localUrl, options) => {
+  }, [fragment, navigate, replace, state, resolvedTo]);
+  const triggerPrefetch = useCallback7((localUrl, options) => {
     if (needsDataPrefetch(localUrl.path, inferred, matchRoute)) {
       if (options?.withTimeout) {
         prefetchRouteDataWithTimeout(localUrl.path);
@@ -3173,27 +3556,30 @@ function Link({
       prefetchContentModule(inferred, contentIndex, ensureCollection);
     }
   }, [inferred, ensureCollection, contentIndex, matchRoute]);
-  const handleClick = useCallback5(async (e) => {
+  const handleClick = useCallback7(async (e) => {
     onClick?.(e);
     if (!hasRouter)
       return;
     if (isModifiedClick(e, props.target))
       return;
-    if (shouldSkipInterception(String(to)))
+    if (shouldSkipInterception(resolvedTo))
       return;
     e.preventDefault();
-    const localUrl = parseLocalUrl(String(to));
+    const localUrl = parseLocalUrl(resolvedTo);
     if (localUrl && handleSameRouteNavigation(localUrl))
       return;
     if (prefetch && localUrl) {
       await triggerPrefetch(localUrl, { withTimeout: true });
     }
-    navigate(fragment ? `${to}#${fragment}` : to, { replace, state });
+    navigate(fragment ? `${resolvedTo}#${fragment}` : resolvedTo, {
+      replace,
+      state
+    });
   }, [
     onClick,
     hasRouter,
     props.target,
-    to,
+    resolvedTo,
     handleSameRouteNavigation,
     prefetch,
     triggerPrefetch,
@@ -3202,24 +3588,24 @@ function Link({
     replace,
     state
   ]);
-  const handleMouseEnter = useCallback5((e) => {
+  const handleMouseEnter = useCallback7((e) => {
     if (prefetch) {
-      const localUrl = parseLocalUrl(String(to));
+      const localUrl = parseLocalUrl(resolvedTo);
       if (localUrl)
         triggerPrefetch(localUrl, { silent: true });
     }
     onMouseEnter?.(e);
-  }, [prefetch, to, triggerPrefetch, onMouseEnter]);
-  const handleFocus = useCallback5((e) => {
+  }, [prefetch, resolvedTo, triggerPrefetch, onMouseEnter]);
+  const handleFocus = useCallback7((e) => {
     if (prefetch) {
-      const localUrl = parseLocalUrl(String(to));
+      const localUrl = parseLocalUrl(resolvedTo);
       if (localUrl)
         triggerPrefetch(localUrl, { silent: true });
     }
     onFocus?.(e);
-  }, [prefetch, to, triggerPrefetch, onFocus]);
-  const href = fragment ? `${to}#${fragment}` : to;
-  return /* @__PURE__ */ jsx7("a", {
+  }, [prefetch, resolvedTo, triggerPrefetch, onFocus]);
+  const href = fragment ? `${resolvedTo}#${fragment}` : resolvedTo;
+  return /* @__PURE__ */ jsx8("a", {
     href,
     onClick: handleClick,
     onMouseEnter: handleMouseEnter,
@@ -3230,7 +3616,7 @@ function Link({
 }
 // packages/react/src/components/Markdown.tsx
 import { Streamdown } from "streamdown";
-import { jsx as jsx8 } from "react/jsx-runtime";
+import { jsx as jsx9 } from "react/jsx-runtime";
 function Markdown({
   children,
   className,
@@ -3240,9 +3626,9 @@ function Markdown({
 }) {
   const finalRemarkPlugins = [...remarkPlugins];
   const finalRehypePlugins = [...rehypePlugins];
-  return /* @__PURE__ */ jsx8("div", {
+  return /* @__PURE__ */ jsx9("div", {
     className,
-    children: /* @__PURE__ */ jsx8(Streamdown, {
+    children: /* @__PURE__ */ jsx9(Streamdown, {
       remarkPlugins: finalRemarkPlugins,
       rehypePlugins: finalRehypePlugins,
       components,
@@ -3251,11 +3637,11 @@ function Markdown({
   });
 }
 // packages/react/src/components/Outlet.tsx
-import { useContext as useContext4 } from "react";
-import { jsx as jsx9, Fragment as Fragment2 } from "react/jsx-runtime";
+import { useContext as useContext5 } from "react";
+import { jsx as jsx10, Fragment as Fragment2 } from "react/jsx-runtime";
 function Outlet() {
-  const outletContent = useContext4(OutletContext);
-  return /* @__PURE__ */ jsx9(Fragment2, {
+  const outletContent = useContext5(OutletContext);
+  return /* @__PURE__ */ jsx10(Fragment2, {
     children: outletContent
   });
 }
@@ -3274,7 +3660,7 @@ async function collectionSearch(options) {
       return null;
     const indexData = JSON.parse(await file.text());
     const entries = indexData.entries || [];
-    const terms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 1);
+    const terms = query.toLowerCase().split(/\s+/).filter((t2) => t2.length > 1);
     if (terms.length === 0)
       return null;
     const collectionsFilter = searchParams?.get("collections")?.split(",").filter(Boolean);
@@ -3362,6 +3748,8 @@ export {
   useParams,
   useNavigate,
   useMarkdownComponents,
+  useLocaleContext,
+  useLocale,
   useLlms,
   useLayoutData,
   useFeed,
@@ -3371,6 +3759,7 @@ export {
   useContentIndex,
   useContentGetEntry,
   useContent,
+  t,
   storeAndDispatchData,
   shouldSkipInterception,
   preloadRoute,
@@ -3379,12 +3768,16 @@ export {
   prefetchContentModule,
   prefetchContent,
   parseLocalUrl,
+  parseContentPath,
   parseContentHref,
   needsDataPrefetch,
+  localizeHref,
+  localizeContentHref,
   isModifiedClick,
   getRerouteDataStore,
   fetchRouteData,
   dispatchDataEvent,
+  createTranslator,
   createResolverFromGetEntry,
   createLazyRoute,
   collectionSearch,
@@ -3398,6 +3791,7 @@ export {
   OutletContext,
   Outlet,
   Markdown,
+  LocaleProvider,
   Link,
   Image,
   ContentRoute,
@@ -3405,4 +3799,4 @@ export {
   ClientOnly
 };
 
-//# debugId=9B63CBF08200528F64756E2164756E21
+//# debugId=C69A90B48CACDDC864756E2164756E21