astro 3.4.4 → 3.5.0

package/dist/core/render/index.d.ts

@@ -1,8 +1,7 @@
 import type { AstroMiddlewareInstance, ComponentInstance, RouteData } from '../../@types/astro.js';
 import type { Environment } from './environment.js';
-export { createRenderContext } from './context.js';
+export { computePreferredLocale, createRenderContext } from './context.js';
 export type { RenderContext } from './context.js';
-export { tryRenderRoute } from './core.js';
 export { createEnvironment } from './environment.js';
 export { getParamsAndProps } from './params-and-props.js';
 export { loadRenderer } from './renderer.js';
@@ -18,7 +17,7 @@ export interface SSROptions {
     preload: ComponentInstance;
     /** Request */
     request: Request;
-    /** optional, in case we need to render something outside of a dev server */
+    /** optional, in case we need to render something outside a dev server */
     route: RouteData;
     /**
      * Optional middlewares

package/dist/core/render/index.js

@@ -1,12 +1,11 @@
-import { createRenderContext } from "./context.js";
-import { tryRenderRoute } from "./core.js";
+import { computePreferredLocale, createRenderContext } from "./context.js";
 import { createEnvironment } from "./environment.js";
 import { getParamsAndProps } from "./params-and-props.js";
 import { loadRenderer } from "./renderer.js";
 export {
+  computePreferredLocale,
   createEnvironment,
   createRenderContext,
   getParamsAndProps,
-  loadRenderer,
-  tryRenderRoute
+  loadRenderer
 };

package/dist/core/render/params-and-props.d.ts

@@ -2,7 +2,7 @@ import type { ComponentInstance, Params, Props, RouteData } from '../../@types/a
 import type { Logger } from '../logger/core.js';
 import { RouteCache } from './route-cache.js';
 interface GetParamsAndPropsOptions {
-    mod: ComponentInstance;
+    mod: ComponentInstance | undefined;
     route?: RouteData | undefined;
     routeCache: RouteCache;
     pathname: string;

package/dist/core/render/params-and-props.js

@@ -1,4 +1,5 @@
 import { AstroError, AstroErrorData } from "../errors/index.js";
+import { routeIsFallback } from "../redirects/helpers.js";
 import { routeIsRedirect } from "../redirects/index.js";
 import { getParams } from "../routing/params.js";
 import { RouteCache, callGetStaticPaths, findPathItemByKey } from "./route-cache.js";
@@ -8,10 +9,12 @@ async function getParamsAndProps(opts) {
     return [{}, {}];
   }
   const params = getRouteParams(route, pathname) ?? {};
-  if (routeIsRedirect(route)) {
+  if (routeIsRedirect(route) || routeIsFallback(route)) {
     return [params, {}];
   }
-  validatePrerenderEndpointCollision(route, mod, params);
+  if (mod) {
+    validatePrerenderEndpointCollision(route, mod, params);
+  }
   const staticPaths = await callGetStaticPaths({
     mod,
     route,

package/dist/core/render/result.d.ts

@@ -30,5 +30,6 @@ export interface CreateResultArgs {
     status: number;
     locals: App.Locals;
     cookies?: AstroCookies;
+    locales: string[] | undefined;
 }
 export declare function createResult(args: CreateResultArgs): SSRResult;

package/dist/core/render/result.js

@@ -3,6 +3,7 @@ import { renderJSX } from "../../runtime/server/jsx.js";
 import { chunkToString } from "../../runtime/server/render/index.js";
 import { AstroCookies } from "../cookies/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
+import { computePreferredLocale, computePreferredLocaleList } from "./context.js";
 const clientAddressSymbol = Symbol.for("astro.clientAddress");
 const responseSentSymbol = Symbol.for("astro.responseSent");
 function getFunctionExpression(slot) {
@@ -88,6 +89,8 @@ function createResult(args) {
     writable: false
   });
   let cookies = args.cookies;
+  let preferredLocale = void 0;
+  let preferredLocaleList = void 0;
   const result = {
     styles: args.styles ?? /* @__PURE__ */ new Set(),
     scripts: args.scripts ?? /* @__PURE__ */ new Set(),
@@ -126,6 +129,26 @@ function createResult(args) {
           result.cookies = cookies;
           return cookies;
         },
+        get preferredLocale() {
+          if (preferredLocale) {
+            return preferredLocale;
+          }
+          if (args.locales) {
+            preferredLocale = computePreferredLocale(request, args.locales);
+            return preferredLocale;
+          }
+          return void 0;
+        },
+        get preferredLocaleList() {
+          if (preferredLocaleList) {
+            return preferredLocaleList;
+          }
+          if (args.locales) {
+            preferredLocaleList = computePreferredLocaleList(request, args.locales);
+            return preferredLocaleList;
+          }
+          return void 0;
+        },
         params,
         props,
         locals,

package/dist/core/render/route-cache.d.ts

@@ -1,7 +1,7 @@
 import type { ComponentInstance, GetStaticPathsItem, GetStaticPathsResultKeyed, Params, RouteData, RuntimeMode } from '../../@types/astro.js';
 import type { Logger } from '../logger/core.js';
 interface CallGetStaticPathsOptions {
-    mod: ComponentInstance;
+    mod: ComponentInstance | undefined;
     route: RouteData;
     routeCache: RouteCache;
     logger: Logger;

package/dist/core/render/route-cache.js

@@ -12,24 +12,30 @@ async function callGetStaticPaths({
   const cached = routeCache.get(route);
   if (cached?.staticPaths)
     return cached.staticPaths;
-  validateDynamicRouteModule(mod, { ssr, route });
+  if (mod) {
+    validateDynamicRouteModule(mod, { ssr, route });
+  }
   if (ssr && !route.prerender) {
     const entry = Object.assign([], { keyed: /* @__PURE__ */ new Map() });
     routeCache.set(route, { ...cached, staticPaths: entry });
     return entry;
   }
-  if (!mod.getStaticPaths) {
-    throw new Error("Unexpected Error.");
-  }
   let staticPaths = [];
-  staticPaths = await mod.getStaticPaths({
-    // Q: Why the cast?
-    // A: So users downstream can have nicer typings, we have to make some sacrifice in our internal typings, which necessitate a cast here
-    paginate: generatePaginateFunction(route),
-    rss() {
-      throw new AstroError(AstroErrorData.GetStaticPathsRemovedRSSHelper);
+  if (mod) {
+    if (!mod.getStaticPaths) {
+      throw new Error("Unexpected Error.");
     }
-  });
+    if (mod) {
+      staticPaths = await mod.getStaticPaths({
+        // Q: Why the cast?
+        // A: So users downstream can have nicer typings, we have to make some sacrifice in our internal typings, which necessitate a cast here
+        paginate: generatePaginateFunction(route),
+        rss() {
+          throw new AstroError(AstroErrorData.GetStaticPathsRemovedRSSHelper);
+        }
+      });
+    }
+  }
   validateGetStaticPathsResult(staticPaths, logger, route);
   const keyedStaticPaths = staticPaths;
   keyedStaticPaths.keyed = /* @__PURE__ */ new Map();

package/dist/core/routing/manifest/create.js

@@ -34,7 +34,9 @@ function getParts(part, file) {
   });
   return result;
 }
-function getPattern(segments, base, addTrailingSlash) {
+function getPattern(segments, config) {
+  const base = config.base;
+  const addTrailingSlash = config.trailingSlash;
   const pathname = segments.map((segment) => {
     if (segment.length === 1 && segment[0].spread) {
       return "(?:\\/(.*?))?";
@@ -222,7 +224,7 @@ function createRouteManifest({ settings, cwd, fsMod }, logger) {
         components.push(item.file);
         const component = item.file;
         const trailingSlash = item.isPage ? settings.config.trailingSlash : "never";
-        const pattern = getPattern(segments, settings.config.base, trailingSlash);
+        const pattern = getPattern(segments, settings.config);
         const generate = getRouteGenerator(segments, trailingSlash);
         const pathname = segments.every((segment) => segment.length === 1 && !segment[0].dynamic) ? `/${segments.map((segment) => segment[0].content).join("/")}` : null;
         const route = `/${segments.map(([{ dynamic, content }]) => dynamic ? `[${content}]` : content).join("/")}`.toLowerCase();
@@ -268,7 +270,7 @@ function createRouteManifest({ settings, cwd, fsMod }, logger) {
     const type = resolved.endsWith(".astro") ? "page" : "endpoint";
     const isPage = type === "page";
     const trailingSlash = isPage ? config.trailingSlash : "never";
-    const pattern = getPattern(segments, settings.config.base, trailingSlash);
+    const pattern = getPattern(segments, settings.config);
     const generate = getRouteGenerator(segments, trailingSlash);
     const pathname = segments.every((segment) => segment.length === 1 && !segment[0].dynamic) ? `/${segments.map((segment) => segment[0].content).join("/")}` : null;
     const params = segments.flat().filter((p) => p.dynamic).map((p) => p.content);
@@ -298,7 +300,7 @@ This route collides with: "${collision.component}".`
       validateSegment(s);
       return getParts(s, from);
     });
-    const pattern = getPattern(segments, settings.config.base, trailingSlash);
+    const pattern = getPattern(segments, settings.config);
     const generate = getRouteGenerator(segments, trailingSlash);
     const pathname = segments.every((segment) => segment.length === 1 && !segment[0].dynamic) ? `/${segments.map((segment) => segment[0].content).join("/")}` : null;
     const params = segments.flat().filter((p) => p.dynamic).map((p) => p.content);
@@ -334,6 +336,118 @@ This route collides with: "${collision.component}".`
     }
     routes.push(routeData);
   });
+  const i18n = settings.config.experimental.i18n;
+  if (i18n) {
+    const routesByLocale = /* @__PURE__ */ new Map();
+    const setRoutes = new Set(routes);
+    for (const locale of i18n.locales.filter((loc) => loc !== i18n.defaultLocale)) {
+      for (const route of setRoutes) {
+        if (!route.route.includes(`/${locale}`)) {
+          continue;
+        }
+        const currentRoutes = routesByLocale.get(locale);
+        if (currentRoutes) {
+          currentRoutes.push(route);
+          routesByLocale.set(locale, currentRoutes);
+        } else {
+          routesByLocale.set(locale, [route]);
+        }
+        setRoutes.delete(route);
+      }
+    }
+    for (const route of setRoutes) {
+      const currentRoutes = routesByLocale.get(i18n.defaultLocale);
+      if (currentRoutes) {
+        currentRoutes.push(route);
+        routesByLocale.set(i18n.defaultLocale, currentRoutes);
+      } else {
+        routesByLocale.set(i18n.defaultLocale, [route]);
+      }
+      setRoutes.delete(route);
+    }
+    if (i18n.routingStrategy === "prefix-always") {
+      const defaultLocaleRoutes = routesByLocale.get(i18n.defaultLocale);
+      if (defaultLocaleRoutes) {
+        const indexDefaultRoute = defaultLocaleRoutes.find((routeData) => {
+          return routeData.component.includes("index");
+        });
+        if (indexDefaultRoute) {
+          const pathname = "/";
+          const route = "/";
+          const segments = removeLeadingForwardSlash(route).split(path.posix.sep).filter(Boolean).map((s) => {
+            validateSegment(s);
+            return getParts(s, route);
+          });
+          routes.push({
+            ...indexDefaultRoute,
+            pathname,
+            route,
+            segments,
+            pattern: getPattern(segments, config),
+            type: "fallback"
+          });
+        }
+      }
+    }
+    if (i18n.fallback) {
+      let fallback = Object.entries(i18n.fallback);
+      if (fallback.length > 0) {
+        for (const [fallbackFromLocale, fallbackToLocale] of fallback) {
+          let fallbackToRoutes;
+          if (fallbackToLocale === i18n.defaultLocale) {
+            fallbackToRoutes = routesByLocale.get(i18n.defaultLocale);
+          } else {
+            fallbackToRoutes = routesByLocale.get(fallbackToLocale);
+          }
+          const fallbackFromRoutes = routesByLocale.get(fallbackFromLocale);
+          if (!fallbackToRoutes) {
+            continue;
+          }
+          for (const fallbackToRoute of fallbackToRoutes) {
+            const hasRoute = fallbackFromRoutes && // we check if the fallback from locale (the origin) has already this route
+            fallbackFromRoutes.some((route) => {
+              if (fallbackToLocale === i18n.defaultLocale) {
+                return route.route.replace(`/${fallbackFromLocale}`, "") === fallbackToRoute.route;
+              } else {
+                return route.route.replace(`/${fallbackToLocale}`, `/${fallbackFromLocale}`) === fallbackToRoute.route;
+              }
+            });
+            if (!hasRoute) {
+              let pathname;
+              let route;
+              if (fallbackToLocale === i18n.defaultLocale) {
+                if (fallbackToRoute.pathname) {
+                  pathname = `/${fallbackFromLocale}${fallbackToRoute.pathname}`;
+                }
+                route = `/${fallbackFromLocale}${fallbackToRoute.route}`;
+              } else {
+                pathname = fallbackToRoute.pathname?.replace(
+                  `/${fallbackToLocale}`,
+                  `/${fallbackFromLocale}`
+                );
+                route = fallbackToRoute.route.replace(
+                  `/${fallbackToLocale}`,
+                  `/${fallbackFromLocale}`
+                );
+              }
+              const segments = removeLeadingForwardSlash(route).split(path.posix.sep).filter(Boolean).map((s) => {
+                validateSegment(s);
+                return getParts(s, route);
+              });
+              routes.push({
+                ...fallbackToRoute,
+                pathname,
+                route,
+                segments,
+                pattern: getPattern(segments, config),
+                type: "fallback"
+              });
+            }
+          }
+        }
+      }
+    }
+  }
   return {
     routes
   };

package/dist/core/sync/index.d.ts

@@ -1,14 +1,7 @@
-/// <reference types="node" resolution-mode="require"/>
-import fsMod from 'node:fs';
-import type { AstroInlineConfig, AstroSettings } from '../../@types/astro.js';
+import type { AstroInlineConfig } from '../../@types/astro.js';
 import type { Logger } from '../logger/core.js';
 export type ProcessExit = 0 | 1;
-export type SyncOptions = {
-    /**
-     * @internal only used for testing
-     */
-    fs?: typeof fsMod;
-};
+export type SyncOptions = {};
 export type SyncInternalOptions = SyncOptions & {
     logger: Logger;
 };
@@ -19,18 +12,3 @@ export type SyncInternalOptions = SyncOptions & {
  * @experimental The JavaScript API is experimental
  */
 export default function sync(inlineConfig: AstroInlineConfig, options?: SyncOptions): Promise<ProcessExit>;
-/**
- * Generate content collection types, and then returns the process exit signal.
- *
- * A non-zero process signal is emitted in case there's an error while generating content collection types.
- *
- * This should only be used when the callee already has an `AstroSetting`, otherwise use `sync()` instead.
- * @internal
- *
- * @param {SyncOptions} options
- * @param {AstroSettings} settings Astro settings
- * @param {typeof fsMod} options.fs The file system
- * @param {LogOptions} options.logging Logging options
- * @return {Promise<ProcessExit>}
- */
-export declare function syncInternal(settings: AstroSettings, { logger, fs }: SyncInternalOptions): Promise<ProcessExit>;

package/dist/i18n/index.d.ts

@@ -0,0 +1,54 @@
+import type { AstroConfig } from '../@types/astro.js';
+type GetLocaleRelativeUrl = GetLocaleOptions & {
+    locale: string;
+    base: string;
+    locales: string[];
+    trailingSlash: AstroConfig['trailingSlash'];
+    format: AstroConfig['build']['format'];
+    routingStrategy?: 'prefix-always' | 'prefix-other-locales';
+    defaultLocale: string;
+};
+export type GetLocaleOptions = {
+    /**
+     * Makes the locale URL-friendly by replacing underscores with dashes, and converting the locale to lower case.
+     * @default true
+     */
+    normalizeLocale?: boolean;
+    /**
+     * An optional path to add after the `locale`.
+     */
+    path?: string;
+    /**
+     *  An optional path to prepend to `locale`.
+     */
+    prependWith?: string;
+};
+type GetLocaleAbsoluteUrl = GetLocaleRelativeUrl & {
+    site: AstroConfig['site'];
+};
+/**
+ * The base URL
+ */
+export declare function getLocaleRelativeUrl({ locale, base, locales, trailingSlash, format, path, prependWith, normalizeLocale, routingStrategy, defaultLocale, }: GetLocaleRelativeUrl): string;
+/**
+ * The absolute URL
+ */
+export declare function getLocaleAbsoluteUrl({ site, ...rest }: GetLocaleAbsoluteUrl): string;
+type GetLocalesBaseUrl = GetLocaleOptions & {
+    base: string;
+    locales: string[];
+    trailingSlash: AstroConfig['trailingSlash'];
+    format: AstroConfig['build']['format'];
+    routingStrategy?: 'prefix-always' | 'prefix-other-locales';
+    defaultLocale: string;
+};
+export declare function getLocaleRelativeUrlList({ base, locales, trailingSlash, format, path, prependWith, normalizeLocale, routingStrategy, defaultLocale, }: GetLocalesBaseUrl): string[];
+export declare function getLocaleAbsoluteUrlList({ site, ...rest }: GetLocaleAbsoluteUrl): string[];
+/**
+ *
+ * Given a locale, this function:
+ * - replaces the `_` with a `-`;
+ * - transforms all letters to be lower case;
+ */
+export declare function normalizeTheLocale(locale: string): string;
+export {};

package/dist/i18n/index.js

@@ -0,0 +1,91 @@
+import { appendForwardSlash, joinPaths } from "@astrojs/internal-helpers/path";
+import { shouldAppendForwardSlash } from "../core/build/util.js";
+import { MissingLocale } from "../core/errors/errors-data.js";
+import { AstroError } from "../core/errors/index.js";
+function getLocaleRelativeUrl({
+  locale,
+  base,
+  locales,
+  trailingSlash,
+  format,
+  path,
+  prependWith,
+  normalizeLocale = true,
+  routingStrategy = "prefix-other-locales",
+  defaultLocale
+}) {
+  if (!locales.includes(locale)) {
+    throw new AstroError({
+      ...MissingLocale,
+      message: MissingLocale.message(locale, locales)
+    });
+  }
+  const pathsToJoin = [base, prependWith];
+  const normalizedLocale = normalizeLocale ? normalizeTheLocale(locale) : locale;
+  if (routingStrategy === "prefix-always") {
+    pathsToJoin.push(normalizedLocale);
+  } else if (locale !== defaultLocale) {
+    pathsToJoin.push(normalizedLocale);
+  }
+  pathsToJoin.push(path);
+  if (shouldAppendForwardSlash(trailingSlash, format)) {
+    return appendForwardSlash(joinPaths(...pathsToJoin));
+  } else {
+    return joinPaths(...pathsToJoin);
+  }
+}
+function getLocaleAbsoluteUrl({ site, ...rest }) {
+  const locale = getLocaleRelativeUrl(rest);
+  if (site) {
+    return joinPaths(site, locale);
+  } else {
+    return locale;
+  }
+}
+function getLocaleRelativeUrlList({
+  base,
+  locales,
+  trailingSlash,
+  format,
+  path,
+  prependWith,
+  normalizeLocale = false,
+  routingStrategy = "prefix-other-locales",
+  defaultLocale
+}) {
+  return locales.map((locale) => {
+    const pathsToJoin = [base, prependWith];
+    const normalizedLocale = normalizeLocale ? normalizeTheLocale(locale) : locale;
+    if (routingStrategy === "prefix-always") {
+      pathsToJoin.push(normalizedLocale);
+    } else if (locale !== defaultLocale) {
+      pathsToJoin.push(normalizedLocale);
+    }
+    pathsToJoin.push(path);
+    if (shouldAppendForwardSlash(trailingSlash, format)) {
+      return appendForwardSlash(joinPaths(...pathsToJoin));
+    } else {
+      return joinPaths(...pathsToJoin);
+    }
+  });
+}
+function getLocaleAbsoluteUrlList({ site, ...rest }) {
+  const locales = getLocaleRelativeUrlList(rest);
+  return locales.map((locale) => {
+    if (site) {
+      return joinPaths(site, locale);
+    } else {
+      return locale;
+    }
+  });
+}
+function normalizeTheLocale(locale) {
+  return locale.replaceAll("_", "-").toLowerCase();
+}
+export {
+  getLocaleAbsoluteUrl,
+  getLocaleAbsoluteUrlList,
+  getLocaleRelativeUrl,
+  getLocaleRelativeUrlList,
+  normalizeTheLocale
+};

package/dist/i18n/middleware.d.ts

@@ -0,0 +1,2 @@
+import type { MiddlewareEndpointHandler, SSRManifest } from '../@types/astro.js';
+export declare function createI18nMiddleware(i18n: SSRManifest['i18n'], base: SSRManifest['base']): MiddlewareEndpointHandler | undefined;

package/dist/i18n/middleware.js

@@ -0,0 +1,62 @@
+import { joinPaths } from "@astrojs/internal-helpers/path";
+function checkIsLocaleFree(pathname, locales) {
+  for (const locale of locales) {
+    if (pathname.includes(`/${locale}`)) {
+      return false;
+    }
+  }
+  return true;
+}
+function createI18nMiddleware(i18n, base) {
+  if (!i18n) {
+    return void 0;
+  }
+  return async (context, next) => {
+    if (!i18n) {
+      return await next();
+    }
+    const { locales, defaultLocale, fallback } = i18n;
+    const url = context.url;
+    const response = await next();
+    if (response instanceof Response) {
+      const separators = url.pathname.split("/");
+      const pathnameContainsDefaultLocale = url.pathname.includes(`/${defaultLocale}`);
+      const isLocaleFree = checkIsLocaleFree(url.pathname, i18n.locales);
+      if (i18n.routingStrategy === "prefix-other-locales" && pathnameContainsDefaultLocale) {
+        const newLocation = url.pathname.replace(`/${defaultLocale}`, "");
+        response.headers.set("Location", newLocation);
+        return new Response(null, {
+          status: 404,
+          headers: response.headers
+        });
+      } else if (i18n.routingStrategy === "prefix-always") {
+        if (url.pathname === base || url.pathname === base + "/") {
+          return context.redirect(`${joinPaths(base, i18n.defaultLocale)}`);
+        } else if (isLocaleFree) {
+          return new Response(null, {
+            status: 404,
+            headers: response.headers
+          });
+        }
+      }
+      if (response.status >= 300 && fallback) {
+        const fallbackKeys = i18n.fallback ? Object.keys(i18n.fallback) : [];
+        const urlLocale = separators.find((s) => locales.includes(s));
+        if (urlLocale && fallbackKeys.includes(urlLocale)) {
+          const fallbackLocale = fallback[urlLocale];
+          let newPathname;
+          if (fallbackLocale === defaultLocale) {
+            newPathname = url.pathname.replace(`/${urlLocale}`, ``);
+          } else {
+            newPathname = url.pathname.replace(`/${urlLocale}`, `/${fallbackLocale}`);
+          }
+          return context.redirect(newPathname);
+        }
+      }
+    }
+    return response;
+  };
+}
+export {
+  createI18nMiddleware
+};

package/dist/i18n/vite-plugin-i18n.d.ts

@@ -0,0 +1,7 @@
+import * as vite from 'vite';
+import type { AstroSettings } from '../@types/astro.js';
+type AstroInternationalization = {
+    settings: AstroSettings;
+};
+export default function astroInternationalization({ settings, }: AstroInternationalization): vite.Plugin;
+export {};

package/dist/i18n/vite-plugin-i18n.js

@@ -0,0 +1,62 @@
+import * as vite from "vite";
+const virtualModuleId = "astro:i18n";
+const resolvedVirtualModuleId = "\0" + virtualModuleId;
+function astroInternationalization({
+  settings
+}) {
+  return {
+    name: "astro:i18n",
+    enforce: "pre",
+    async resolveId(id) {
+      if (id === virtualModuleId) {
+        return resolvedVirtualModuleId;
+      }
+    },
+    load(id) {
+      if (id === resolvedVirtualModuleId) {
+        return `
+					import { 
+						getLocaleRelativeUrl as _getLocaleRelativeUrl, 
+						getLocaleRelativeUrlList as _getLocaleRelativeUrlList,
+						getLocaleAbsoluteUrl as _getLocaleAbsoluteUrl, 
+						getLocaleAbsoluteUrlList as _getLocaleAbsoluteUrlList,
+						 
+					} from "astro/i18n";
+					
+					const base =  ${JSON.stringify(settings.config.base)};
+					const trailingSlash =  ${JSON.stringify(settings.config.trailingSlash)};
+					const format =  ${JSON.stringify(settings.config.build.format)};
+					const site = ${JSON.stringify(settings.config.site)};
+					const i18n = ${JSON.stringify(settings.config.experimental.i18n)};
+					
+					export const getRelativeLocaleUrl = (locale, path = "", opts) => _getLocaleRelativeUrl({ 
+						locale,
+						path, 
+						base, 
+						trailingSlash, 
+						format,
+						...i18n,
+						...opts 
+					});
+					export const getAbsoluteLocaleUrl = (locale, path = "", opts) => _getLocaleAbsoluteUrl({ 
+						locale, 
+						path, 
+						base, 
+						trailingSlash, 
+						format, 
+						site, 
+						...i18n,
+						...opts 
+					});
+					
+					export const getRelativeLocaleUrlList = (path = "", opts) => _getLocaleRelativeUrlList({ 
+						base, path, trailingSlash, format, ...i18n, ...opts });
+					export const getAbsoluteLocaleUrlList = (path = "", opts) => _getLocaleAbsoluteUrlList({ base, path, trailingSlash, format, site, ...i18n, ...opts });
+				`;
+      }
+    }
+  };
+}
+export {
+  astroInternationalization as default
+};

package/dist/integrations/astroFeaturesValidation.js

@@ -11,7 +11,10 @@ const ALL_UNSUPPORTED = {
   serverOutput: UNSUPPORTED,
   staticOutput: UNSUPPORTED,
   hybridOutput: UNSUPPORTED,
-  assets: UNSUPPORTED_ASSETS_FEATURE
+  assets: UNSUPPORTED_ASSETS_FEATURE,
+  i18n: {
+    detectBrowserLanguage: UNSUPPORTED
+  }
 };
 function validateSupportedFeatures(adapterName, featureMap = ALL_UNSUPPORTED, config, logger) {
   const {