@lupinum/ginko-i18n 0.4.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @lupinum/ginko-i18n
 
+## 0.6.0
+
+No changes in this release.
+
+## 0.5.0
+
+### Patch Changes
+
+- [#21](https://github.com/lupinum-dev/ginko/pull/21) [`80f93a4`](https://github.com/lupinum-dev/ginko/commit/80f93a4f6bd171e1146b929913254039becdd991) Thanks [@Mat4m0](https://github.com/Mat4m0)! - Add the `dateLanguage` option to `createFormatters` and `createTranslator`: dates in another tag (`en-GB`) while numbers and words stay in `language`.
+
+- [#21](https://github.com/lupinum-dev/ginko/pull/21) [`80f93a4`](https://github.com/lupinum-dev/ginko/commit/80f93a4f6bd171e1146b929913254039becdd991) Thanks [@Mat4m0](https://github.com/Mat4m0)! - Fix `//blog` on Nuxt 4: a doubled leading slash now answers with a 301 to `/blog` there too, instead of showing the home page.
+
+- [#21](https://github.com/lupinum-dev/ginko/pull/21) [`80f93a4`](https://github.com/lupinum-dev/ginko/commit/80f93a4f6bd171e1146b929913254039becdd991) Thanks [@Mat4m0](https://github.com/Mat4m0)! - Fix error pages: they get no canonical or hreflang and are noindex.
+
+- [#21](https://github.com/lupinum-dev/ginko/pull/21) [`80f93a4`](https://github.com/lupinum-dev/ginko/commit/80f93a4f6bd171e1146b929913254039becdd991) Thanks [@Mat4m0](https://github.com/Mat4m0)! - Fix page addresses in another case: `/Blog` now answers with a 301 to `/blog`, and the canonical link uses that spelling.
+
+- [#21](https://github.com/lupinum-dev/ginko/pull/21) [`80f93a4`](https://github.com/lupinum-dev/ginko/commit/80f93a4f6bd171e1146b929913254039becdd991) Thanks [@Mat4m0](https://github.com/Mat4m0)! - Fix doubled and trailing slashes: `//blog` and `/blog/` now answer with a 301 to `/blog`, so every page has one URL.
+
+- [#21](https://github.com/lupinum-dev/ginko/pull/21) [`80f93a4`](https://github.com/lupinum-dev/ginko/commit/80f93a4f6bd171e1146b929913254039becdd991) Thanks [@Mat4m0](https://github.com/Mat4m0)! - Change dates in user-locale zones to follow the region of the browser's first language when it is the same language and the locale names no region (`en` reads 25/10/2026 in an en-GB browser); numbers and words stay in the locale's language.
+
 ## 0.4.0
 
 ### Minor Changes

package/README.md

@@ -210,7 +210,15 @@ export default defineNuxtPlugin(() => {
 Every page gets `<html lang dir>`, a canonical link, hreflang links (with `x-default` for the default
 locale) and `og:locale`. Pages that are not translated into a locale get no hreflang for it. Set
 `baseUrl` so the links are absolute; without it the module uses `runtimeConfig.public.siteUrl`, and
-without both the links are relative (the build warns). Turn the tags off with `seo: false`.
+without both the links are relative (the build warns). Turn the tags off with `seo: false`. Error
+pages (404, 503) are not pages of the site: they get `lang`, `dir` and `robots: noindex`, but no
+canonical, hreflang or `og:url`.
+
+Every page has one URL. The server answers other spellings of it with a 301 to that URL: repeated
+slashes (`//blog`), a trailing slash (`/blog/`) and a locale code in another case (`/EN/about`). A
+page path in another case (`/Blog`) redirects to the spelling of the page file or route; a slug keeps
+the case the visitor typed, and the page decides whether it exists. URLs therefore never end in `/`, except the
+root. The canonical link and `og:url` use that one URL.
 
 With `@nuxtjs/sitemap` installed, the module turns its `autoI18n` off and gives it explicit alternates,
 because `@nuxtjs/sitemap` pairs locales by stripping the prefix, which is wrong for translated slugs.
@@ -286,6 +294,10 @@ hydration mismatch. Set the cookie from the user's account setting when they sig
 (`ginko_locale=en; Path=/; Max-Age=31536000; SameSite=Lax`), so the first render already has the
 right language.
 
+Dates in a zone follow the region of the browser's first language when it is the same language and the
+locale names no region: `en` reads 25/10/2026 in an `en-GB` browser and 10/25/2026 in an `en-US` one.
+Numbers and words stay in the locale's language, and a locale with a region (`de-AT`) keeps it.
+
 `switchLocale(code)` changes the language:
 
 ```vue
@@ -461,18 +473,20 @@ Framework-free and parser-free. See [Outside Nuxt](#outside-nuxt).
 
 | Export | Meaning |
 | --- | --- |
-| `createTranslator({ messages, fallback?, language, timeZone?, params?, onMissing? })` | A `Translator` (`t`, `parts`, `has`) for one locale. Lookup: `messages`, then `fallback`, then the key itself. |
+| `createTranslator({ messages, fallback?, language, timeZone?, dateLanguage?, params?, onMissing? })` | A `Translator` (`t`, `parts`, `has`) for one locale. Lookup: `messages`, then `fallback`, then the key itself. `dateLanguage` writes the dates in messages in another tag (`en-GB`). |
 | `defineCatalog<K>(trees, { defaultLocale, params? })` | A `Catalog`: `t(locale, key, params?, options?)`, `translator(locale)`, `locales`, `defaultLocale`, `isLocale(value)`. An unknown locale gets the default; a full tag (`en-US`) finds its language. |
 | `KeysOf<typeof catalog>` | The dotted keys of a source catalog type: `'mail.invite.subject' \| …`. |
-| `createFormatters(language, { timeZone? })` | The `format` object of `useI18n()`. |
+| `createFormatters(language, { timeZone?, dateLanguage? })` | The `format` object of `useI18n()`. `dateLanguage` writes `date` and `range` in another tag (`en-GB`); numbers and words stay in `language`. |
 | `resolveConfig({ locales, defaultLocale?, strategy?, exclude?, userLocale? })` | The resolved locale config for the functions below. |
 | `localizePath(path, code, config)` | Adds the prefix: `/about` → `/en/about`. |
 | `stripLocale(path, config)` | Removes it: `/en/about` → `/about`. |
 | `localeFromPath(path, config)` | The code a path belongs to, or `undefined` (`/de/x` under `prefix_except_default`). |
 | `negotiateLocale(header, config)` | The best code for an `Accept-Language` header, or `undefined`. |
+| `regionalLanguage(language, browser)` | The tag that formats dates in a user-locale zone: the browser's regional variant of `language` (`en` + `en-GB` → `en-GB`), else `language`. |
 | `isExcluded(path, config)` | Whether the path never gets a prefix (`exclude`, `/api/**`, Nuxt internals). |
 | `inUserZone(path, config)` | Whether the path is in a user-locale zone (`userLocale`). |
 | `canonicalCase(path, config)` | The path with its prefix in the code's own case (`/EN/about` → `/en/about`), or `undefined` when it is already right. |
+| `cleanPath(path, config)` | The one form of a path: no repeated or trailing slashes, the prefix in the code's own case (`//EN/about/` → `/en/about`), or `undefined` when it is already right. The server redirects other forms here with a 301. |
 | `alternatesOf(paths, config)` | The hreflang links of a page from its path per code: `{ hreflang, path }[]`, with `x-default` for the default locale. The head tags and the sitemap use it. |
 | `ogLocale(language)` | The `og:locale` form of a tag: `de-AT` → `de_AT`. |
 | `partsToString(parts)` | The plain text of a `parts()` result. |

package/dist/cli/index.mjs

@@ -6,7 +6,7 @@ import { createHash } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import { parse, TYPE } from '@formatjs/icu-messageformat-parser';
 import { k as keyProblem } from '../shared/ginko-i18n.BPkxIZl5.mjs';
-import { L as LOCALE_CODE } from '../shared/ginko-i18n.C1vsnUyB.mjs';
+import { L as LOCALE_CODE } from '../shared/ginko-i18n.0DBFKY5Y.mjs';
 import { M as MANIFEST_VERSION } from '../shared/ginko-i18n.BloO2EKS.mjs';
 
 const ORIGINS = ["library", "layer", "app"];

package/dist/core/index.d.mts

@@ -1,34 +1,16 @@
-import { P as Params, T as TranslateOptions, a as Translator, M as MessageTree } from '../shared/ginko-i18n.Fn02YzGM.mjs';
-export { b as Part, c as createTranslator, p as partsToString } from '../shared/ginko-i18n.Fn02YzGM.mjs';
-export { a as LocaleConfig, b as LocaleInfo, L as LocaleInput, S as Strategy, c as alternatesOf, d as canonicalCase, i as inUserZone, e as isExcluded, l as localeFromPath, f as localizePath, n as negotiateLocale, o as ogLocale, r as resolveConfig, s as stripLocale } from '../shared/ginko-i18n.C3yTBMSg.mjs';
-
-/** Dotted keys of a raw catalog type: `KeysOf<typeof de>` → `'errors.noAccess' | 'mail.invite.subject'`. */
-type KeysOf<T, P extends string = ''> = {
-    [K in keyof T & string]: T[K] extends string ? `${P}${K}` : KeysOf<T[K], `${P}${K}.`>;
-}[keyof T & string];
-interface Catalog<K extends string = string> {
-    /** Locale codes that have a tree, in the order given. */
-    locales: string[];
-    defaultLocale: string;
-    isLocale: (value: unknown) => value is string;
-    /** The text in `locale`; an unknown or missing locale gets the default locale. */
-    t: (locale: string | undefined, key: K, params?: Params, options?: TranslateOptions) => string;
-    /** The full translator of one locale (`parts`, `has`), with the same fallback. */
-    translator: (locale: string | undefined) => Translator;
-}
-/**
- * Pass the key type explicitly, so the trees can come precompiled (no parser at runtime):
- * `defineCatalog<KeysOf<typeof de>>(compiled, { defaultLocale: 'de' })`.
- */
-declare function defineCatalog<K extends string = string>(trees: Record<string, MessageTree>, options: {
-    defaultLocale: string;
-    params?: Params;
-}): Catalog<K>;
+import { P as Params, T as TranslateOptions, a as Translator, M as MessageTree } from '../shared/ginko-i18n.BW09FRJO.mjs';
+export { b as Part, c as createTranslator, p as partsToString } from '../shared/ginko-i18n.BW09FRJO.mjs';
+export { a as LocaleConfig, b as LocaleInfo, L as LocaleInput, S as Strategy, c as alternatesOf, d as canonicalCase, e as cleanPath, i as inUserZone, f as isExcluded, l as localeFromPath, g as localizePath, n as negotiateLocale, o as ogLocale, r as regionalLanguage, h as resolveConfig, s as stripLocale } from '../shared/ginko-i18n.DAtdFZNJ.mjs';
 
 type DateStyle = 'short' | 'medium' | 'long' | 'full';
 interface FormatterOptions {
     /** IANA time zone (`Europe/Vienna`) for timestamps. Calendar dates always use UTC. Default `UTC`. */
     timeZone?: string;
+    /**
+     * The tag for dates (`date`, `range`) when it differs from `language`: a regional variant (`en-GB` orders
+     * 25/10/2026) while numbers and words stay in `language`. Default `language`.
+     */
+    dateLanguage?: string;
 }
 type DateInput = Date | number | string;
 declare function createFormatters(language: string, options?: FormatterOptions): {
@@ -50,5 +32,28 @@ declare function createFormatters(language: string, options?: FormatterOptions):
 };
 type Formatters = ReturnType<typeof createFormatters>;
 
+/** Dotted keys of a raw catalog type: `KeysOf<typeof de>` → `'errors.noAccess' | 'mail.invite.subject'`. */
+type KeysOf<T, P extends string = ''> = {
+    [K in keyof T & string]: T[K] extends string ? `${P}${K}` : KeysOf<T[K], `${P}${K}.`>;
+}[keyof T & string];
+interface Catalog<K extends string = string> {
+    /** Locale codes that have a tree, in the order given. */
+    locales: string[];
+    defaultLocale: string;
+    isLocale: (value: unknown) => value is string;
+    /** The text in `locale`; an unknown or missing locale gets the default locale. */
+    t: (locale: string | undefined, key: K, params?: Params, options?: TranslateOptions) => string;
+    /** The full translator of one locale (`parts`, `has`), with the same fallback. */
+    translator: (locale: string | undefined) => Translator;
+}
+/**
+ * Pass the key type explicitly, so the trees can come precompiled (no parser at runtime):
+ * `defineCatalog<KeysOf<typeof de>>(compiled, { defaultLocale: 'de' })`.
+ */
+declare function defineCatalog<K extends string = string>(trees: Record<string, MessageTree>, options: {
+    defaultLocale: string;
+    params?: Params;
+}): Catalog<K>;
+
 export { MessageTree, Params, TranslateOptions, Translator, createFormatters, defineCatalog };
 export type { Catalog, DateStyle, FormatterOptions, Formatters, KeysOf };

package/dist/core/index.mjs

@@ -1,4 +1,4 @@
-export { b as alternatesOf, c as canonicalCase, i as inUserZone, a as isExcluded, d as localeFromPath, l as localizePath, n as negotiateLocale, o as ogLocale, r as resolveConfig, s as stripLocale } from '../shared/ginko-i18n.C1vsnUyB.mjs';
+export { b as alternatesOf, c as canonicalCase, d as cleanPath, i as inUserZone, a as isExcluded, e as localeFromPath, l as localizePath, n as negotiateLocale, o as ogLocale, f as regionalLanguage, r as resolveConfig, s as stripLocale } from '../shared/ginko-i18n.0DBFKY5Y.mjs';
 
 const cache = /* @__PURE__ */ new Map();
 function cached(key, make) {
@@ -32,17 +32,18 @@ const RELATIVE_UNITS = [
 ];
 function createFormatters(language, options = {}) {
   const zone = options.timeZone ?? "UTC";
+  const dates = options.dateLanguage ?? language;
   const zoneFor = (value) => isCalendarDate(value) ? "UTC" : zone;
   return {
     /** `8. Oktober 2026`. A style or Intl options; a calendar date (`2026-10-08`) never shifts a day. */
-    date: (value, options2 = "long") => spaces(dateFormat(language, zoneFor(value), options2).format(toDate(value))),
+    date: (value, options2 = "long") => spaces(dateFormat(dates, zoneFor(value), options2).format(toDate(value))),
     /**
      * `20.–21. Juni 2026` / `20–21 June 2026`; one day stays one date. Same options as `date`.
      * If either end is a calendar date, the whole range uses UTC so that date keeps its day.
      */
     range: (from, to, options2 = "long") => {
       const [start, end] = [toDate(from), toDate(to)];
-      const format = dateFormat(language, isCalendarDate(from) || isCalendarDate(to) ? "UTC" : zone, options2);
+      const format = dateFormat(dates, isCalendarDate(from) || isCalendarDate(to) ? "UTC" : zone, options2);
       if (start.getTime() === end.getTime()) return spaces(format.format(start));
       return spaces(format.formatRange(start, end)).replace(/(\d\.?)\s?[–-]\s?(\d)/, "$1\u2013$2");
     },
@@ -83,9 +84,9 @@ function formatDate(format, value, options) {
 function show(value) {
   return value == null ? "" : String(value);
 }
-function formatParts(message, params, language, timeZone = "UTC") {
+function formatParts(message, params, language, options = {}) {
   if (typeof message === "string") return [message];
-  const format = createFormatters(language, { timeZone });
+  const format = createFormatters(language, options);
   const out = [];
   const walk = (nodes, pound, into) => {
     for (const node of nodes) {
@@ -157,7 +158,7 @@ function createTranslator(options) {
       options.onMissing?.(key);
       return [key];
     }
-    return formatParts(message, { ...options.params, ...params }, options.language, call?.timeZone ?? options.timeZone);
+    return formatParts(message, { ...options.params, ...params }, options.language, { timeZone: call?.timeZone ?? options.timeZone, dateLanguage: options.dateLanguage });
   };
   return {
     parts,

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": "^4.6.0 || ^5.0.0-0"
   },
-  "version": "0.4.0",
+  "version": "0.6.0",
   "builder": {
     "@nuxt/module-builder": "1.0.3",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -3,7 +3,7 @@ import { join } from 'node:path';
 import { defineNuxtModule, hasNuxtModule, createResolver, addTemplate, addTypeTemplate, addNitroPlugin, addPlugin, addImports, addComponent, addServerHandler, addServerImports, updateTemplates } from '@nuxt/kit';
 import { M as MANIFEST_VERSION } from './shared/ginko-i18n.BloO2EKS.mjs';
 import { m as mergeTrees, a as compileTree, s as sourceProblem } from './shared/ginko-i18n.BPkxIZl5.mjs';
-import { r as resolveConfig, i as inUserZone, l as localizePath, a as isExcluded } from './shared/ginko-i18n.C1vsnUyB.mjs';
+import { r as resolveConfig, i as inUserZone, l as localizePath, a as isExcluded } from './shared/ginko-i18n.0DBFKY5Y.mjs';
 import '@formatjs/icu-messageformat-parser';
 
 const caches = (rule) => !!(rule.isr || rule.swr || rule.cache);

package/dist/runtime/composables.js

@@ -1,7 +1,7 @@
 import { computed, onMounted, ref } from "vue";
 import { navigateTo, useNuxtApp, useRoute, useRouter } from "#imports";
 import { config } from "#ginko-i18n/config.mjs";
-import { createFormatters, createTranslator, inUserZone, localeFromPath, localizePath, negotiateLocale, stripLocale } from "@lupinum/ginko-i18n/core";
+import { createFormatters, createTranslator, inUserZone, localeFromPath, localizePath, negotiateLocale, regionalLanguage, stripLocale } from "@lupinum/ginko-i18n/core";
 import { typedTranslator } from "./types.js";
 const c = config;
 export function currentLocale(path, cfg = c, userLocale) {
@@ -40,9 +40,11 @@ export function useI18n(namespace) {
   const zone = computed(() => inUserZone(route.path, c));
   const locale = computed(() => state.fixedLocale ?? currentLocale(route.path, c, state.userLocale.value));
   const current = computed(() => c.locales.find((l) => l.code === locale.value));
+  const dateLanguage = computed(() => zone.value ? regionalLanguage(current.value.language, state.browserLanguage.value) : current.value.language);
   const translator = computed(() => createTranslator({
     messages: state.messages[locale.value],
     language: current.value.language,
+    dateLanguage: dateLanguage.value,
     params: c.params,
     timeZone: c.timeZone,
     onMissing: import.meta.dev ? (key) => console.warn(`[ginko-i18n] Missing message "${key}" (${locale.value})`) : void 0
@@ -72,7 +74,7 @@ export function useI18n(namespace) {
     }
     await navigateTo(alternates.value.find((a) => a.code === code).path);
   }
-  const formatters = () => createFormatters(current.value.language, { timeZone: c.timeZone });
+  const formatters = () => createFormatters(current.value.language, { timeZone: c.timeZone, dateLanguage: dateLanguage.value });
   const format = {
     date: (...args) => formatters().date(...args),
     range: (...args) => formatters().range(...args),

package/dist/runtime/plugin.js

@@ -1,8 +1,8 @@
 import { shallowReactive } from "vue";
-import { defineNuxtPlugin, isPrerendered, loadPayload, useHead, useRequestEvent, useRoute, useRouter, useState } from "#imports";
+import { addRouteMiddleware, defineNuxtPlugin, isPrerendered, loadPayload, navigateTo, useError, useHead, useRequestEvent, useRequestHeader, useRoute, useRouter, useState } from "#imports";
 import { config } from "#ginko-i18n/config.mjs";
 import { loaders } from "#ginko-i18n/loaders.mjs";
-import { alternatesOf, inUserZone, localeFromPath, ogLocale } from "@lupinum/ginko-i18n/core";
+import { alternatesOf, cleanPath, inUserZone, localeFromPath, ogLocale } from "@lupinum/ginko-i18n/core";
 import { alternatesKey, createLocalePath, currentLocale, useI18n, writeLocaleCookie } from "./composables.js";
 export default defineNuxtPlugin({
   name: "ginko-i18n",
@@ -24,9 +24,31 @@ export default defineNuxtPlugin({
       const fromEvent = import.meta.server ? useRequestEvent()?.context.locale : void 0;
       return typeof fromEvent === "string" && c.locales.some((l) => l.code === fromEvent) ? fromEvent : c.defaultLocale;
     });
+    const browserLanguage = useState("ginko-i18n:browser-language", () => {
+      if (import.meta.client) return navigator.language;
+      return useRequestHeader("accept-language")?.split(",")[0]?.split(";")[0]?.trim() || void 0;
+    });
     let inlined = false;
     const resolvers = [];
     const router = useRouter();
+    const decoded = (path) => {
+      try {
+        return decodeURI(path);
+      } catch {
+        return path;
+      }
+    };
+    const canonicalPath = (to) => {
+      const own = to.name && to.matched.length ? router.resolve({ name: to.name, params: to.params }).path : to.path;
+      const path = decoded(own) === decoded(to.path) ? to.path : own;
+      return cleanPath(path, c) ?? path;
+    };
+    const same = (path) => decoded(path).replace(/(.)\/$/, "$1").toLowerCase();
+    addRouteMiddleware("ginko-i18n:canonical", (to) => {
+      const canonical = canonicalPath(to);
+      if (canonical !== to.path && same(canonical) === same(to.path))
+        return navigateTo({ path: canonical, query: to.query, hash: to.hash }, { redirectCode: 301, replace: true });
+    }, { global: true });
     router.beforeResolve(async (to) => {
       const zone = inUserZone(to.path, c);
       const code = zone ? userLocale.value : localeFromPath(to.path, c) ?? c.defaultLocale;
@@ -78,26 +100,28 @@ export default defineNuxtPlugin({
       fixedLocale = fromProp ?? currentLocale(new URL(url, "http://x").pathname, c, userLocale.value);
     }
     if (fixedLocale) await load(fixedLocale);
-    nuxtApp.provide("ginkoI18n", { messages, load, fixedLocale, resolvers, userLocale });
+    nuxtApp.provide("ginkoI18n", { messages, load, fixedLocale, resolvers, userLocale, browserLanguage });
     if (c.seo) {
       nuxtApp.hook("app:created", () => {
         const route = useRoute();
         const i18n = useI18n();
+        const error = useError();
         useHead(() => {
           const code = currentLocale(route.path, c, userLocale.value);
           const locale = c.locales.find((l) => l.code === code);
+          if (error.value) return { htmlAttrs: { lang: locale.language, dir: locale.dir }, meta: [{ name: "robots", content: "noindex" }] };
           if (inUserZone(route.path, c)) return { htmlAttrs: { lang: locale.language, dir: locale.dir } };
           const translated = i18n.alternates.value.filter((a) => a.translated);
           const url = (path) => `${c.baseUrl}${c.base}${path}`;
           return {
             htmlAttrs: { lang: locale.language, dir: locale.dir },
             link: [
-              { rel: "canonical", href: url(route.path) },
+              { rel: "canonical", href: url(canonicalPath(route)) },
               ...alternatesOf(Object.fromEntries(translated.map((a) => [a.code, a.path])), c).map((a) => ({ rel: "alternate", hreflang: a.hreflang, href: url(a.path) }))
             ],
             meta: [
               // Share links point at the canonical address, like search engines.
-              { property: "og:url", content: url(route.path) },
+              { property: "og:url", content: url(canonicalPath(route)) },
               { property: "og:locale", content: ogLocale(locale.language) },
               ...translated.filter((a) => !a.current).map((a) => ({ property: "og:locale:alternate", content: ogLocale(a.language) }))
             ]

package/dist/runtime/server/middleware.js

@@ -1,19 +1,22 @@
 import { defineEventHandler, getRequestHeader, getRequestURL, sendRedirect } from "nuxt/server";
 import { config } from "#ginko-i18n/config.mjs";
-import { canonicalCase, inUserZone, localizePath } from "@lupinum/ginko-i18n/core";
+import { cleanPath, inUserZone, isExcluded, localizePath } from "@lupinum/ginko-i18n/core";
 import { preferredLocale, requestLocale } from "./locale.js";
 const c = config;
 export default defineEventHandler((event) => {
   const url = getRequestURL(event);
   if (c.base && url.pathname !== c.base && !url.pathname.startsWith(`${c.base}/`)) return;
   const path = url.pathname.slice(c.base.length) || "/";
+  const requested = ("path" in event && typeof event.path === "string" ? event.path : url.pathname).split("?")[0] ?? "";
+  if (!isExcluded(path, c)) {
+    const clean = cleanPath(/^[/\\]{2}/.test(requested) && !c.base ? requested : path, c);
+    if (clean) return sendRedirect(event, `${c.base}${clean}${url.search}`, 301);
+  }
   if (inUserZone(path, c)) {
     event.res.headers.append("vary", "accept-language, cookie");
     event.context.locale = requestLocale(event, path);
     return;
   }
-  const canonical = canonicalCase(path, c);
-  if (canonical) return sendRedirect(event, `${c.base}${canonical}${url.search}`, 301);
   if (path === "/" && c.strategy === "prefix" && !getRequestHeader(event, "x-nitro-prerender")) {
     event.res.headers.append("vary", "accept-language, cookie");
     return sendRedirect(event, c.base + localizePath("/", preferredLocale(event) ?? c.defaultLocale, c) + url.search, 302);

package/dist/runtime/types.d.ts

@@ -84,6 +84,11 @@ export interface I18nState {
      * cookie or Accept-Language, read from the payload on the client, changed only by `switchLocale`.
      */
     userLocale: Ref<string>;
+    /**
+     * The person's first browser language (`useState('ginko-i18n:browser-language')`): Accept-Language on the server,
+     * from the payload on the client. User-locale zones format dates in its region (`regionalLanguage`).
+     */
+    browserLanguage: Ref<string | undefined>;
     /** Set while rendering an island: its page's locale, since islands have no route of their own. */
     fixedLocale?: string;
     /**

package/dist/shared/{ginko-i18n.C1vsnUyB.mjs → ginko-i18n.0DBFKY5Y.mjs}

@@ -18,6 +18,17 @@ function nativeName(language) {
     return language;
   }
 }
+function regionalLanguage(language, browser) {
+  if (!browser) return language;
+  try {
+    const own = new Intl.Locale(language);
+    const theirs = new Intl.Locale(browser);
+    const same = theirs.language === own.language && (!own.script || own.script === theirs.script);
+    return !own.region && theirs.region && same ? theirs.baseName : language;
+  } catch {
+    return language;
+  }
+}
 function ogLocale(language) {
   const tag = new Intl.Locale(language);
   return tag.region ? `${tag.language}_${tag.region}` : tag.language;
@@ -84,6 +95,12 @@ function canonicalCase(path, config) {
   if (!locale || locale.code === segment) return void 0;
   return `/${locale.code}${path.slice(segment.length + 1)}`;
 }
+function cleanPath(path, config) {
+  let clean = path.replace(/[\\/]{2,}/g, "/");
+  if (clean.length > 1 && clean.endsWith("/")) clean = clean.slice(0, -1);
+  clean = canonicalCase(clean, config) ?? clean;
+  return clean === path ? void 0 : clean;
+}
 function localeFromPath(path, config) {
   if (isExcluded(path, config) || inUserZone(path, config)) return void 0;
   const segment = firstSegment(path);
@@ -127,4 +144,4 @@ function negotiateLocale(header, config) {
   return void 0;
 }
 
-export { LOCALE_CODE as L, isExcluded as a, alternatesOf as b, canonicalCase as c, localeFromPath as d, inUserZone as i, localizePath as l, negotiateLocale as n, ogLocale as o, resolveConfig as r, stripLocale as s };
+export { LOCALE_CODE as L, isExcluded as a, alternatesOf as b, canonicalCase as c, cleanPath as d, localeFromPath as e, regionalLanguage as f, inUserZone as i, localizePath as l, negotiateLocale as n, ogLocale as o, resolveConfig as r, stripLocale as s };

package/dist/shared/{ginko-i18n.Fn02YzGM.d.mts → ginko-i18n.BW09FRJO.d.mts}

@@ -31,6 +31,8 @@ declare function createTranslator(options: {
     language: string;
     /** Zone for dates that are not calendar dates (`YYYY-MM-DD` is always UTC). Default `UTC`. */
     timeZone?: string;
+    /** The tag for dates in messages when it differs from `language` (see `FormatterOptions.dateLanguage`). */
+    dateLanguage?: string;
     params?: Params;
     onMissing?: (key: string) => void;
 }): Translator;

package/dist/shared/{ginko-i18n.C3yTBMSg.d.mts → ginko-i18n.DAtdFZNJ.d.mts}

@@ -22,6 +22,12 @@ interface LocaleConfig {
     /** Path patterns whose locale comes from the user (cookie, then Accept-Language), not from the URL. */
     userLocale: string[];
 }
+/**
+ * The tag that formats dates for `language` in a user-locale zone, where `browser` is the person's first
+ * browser language (Accept-Language, `navigator.language`): its regional variant when it is the same language and
+ * `language` names no region itself (`en` read in an `en-GB` browser formats as `en-GB`: 25/10/2026), else `language`.
+ */
+declare function regionalLanguage(language: string, browser: string | undefined): string;
 /** `og:locale` wants `language_TERRITORY`: `de-AT` → `de_AT`, `zh-Hant-TW` → `zh_TW`, `zh-Hant` → `zh`. */
 declare function ogLocale(language: string): string;
 declare function resolveConfig(input: {
@@ -53,6 +59,13 @@ declare function inUserZone(path: string, config: LocaleConfig): boolean;
  * The router matches case-insensitively, so a wrong-case URL would otherwise render in the default locale.
  */
 declare function canonicalCase(path: string, config: LocaleConfig): string | undefined;
+/**
+ * The one form of a path: no repeated slashes, no trailing slash (except `/`), the locale code in its
+ * own case. `undefined` when the path already has it. Browsers read `\` as `/` in http(s) URLs, so a
+ * run of mixed `/` and `\` collapses to one `/`: `//evil.com` and `/\evil.com/` become `/evil.com`,
+ * and a redirect to the result never leaves the site.
+ */
+declare function cleanPath(path: string, config: LocaleConfig): string | undefined;
 /** The locale a path belongs to, or `undefined` when the path has no locale (`prefix` root, excluded paths, user-locale zones). */
 declare function localeFromPath(path: string, config: LocaleConfig): string | undefined;
 declare function stripLocale(path: string, config: LocaleConfig): string;
@@ -64,5 +77,5 @@ declare function localizePath(path: string, locale: string, config: LocaleConfig
  */
 declare function negotiateLocale(header: string | null | undefined, config: LocaleConfig): string | undefined;
 
-export { alternatesOf as c, canonicalCase as d, isExcluded as e, localizePath as f, inUserZone as i, localeFromPath as l, negotiateLocale as n, ogLocale as o, resolveConfig as r, stripLocale as s };
+export { alternatesOf as c, canonicalCase as d, cleanPath as e, isExcluded as f, localizePath as g, resolveConfig as h, inUserZone as i, localeFromPath as l, negotiateLocale as n, ogLocale as o, regionalLanguage as r, stripLocale as s };
 export type { LocaleInput as L, Strategy as S, LocaleConfig as a, LocaleInfo as b };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lupinum/ginko-i18n",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "type": "module",
   "description": "Nuxt i18n with the URL as the only locale source.",
   "license": "MIT",