react-autolocale 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Williams Joseph
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,180 @@
-# Temporary Holding Version
+# react-autolocale
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Wrap your React + Vite app in one component. `vite build` produces a fully translated static page for every language (`/en/`, `/fr/`, `/es/`, ...) using a free local translation model. No `t()`, no keys, no translation files in your repo, and your source code stays untouched.
+
+## Quick start
+
+**1. Install** (npm, yarn or pnpm)
+
+```bash
+npm install react-autolocale     # or: yarn add react-autolocale   |   pnpm add react-autolocale
+```
+
+**2. Add the plugin to your Vite config**
+
+```bash
+npx react-autolocale init        # or: yarn react-autolocale init   |   pnpm exec react-autolocale init
+```
+
+**3. Wrap your app once**
+
+```tsx
+// main.tsx
+import { AutoScale } from "react-autolocale";
+
+createRoot(document.getElementById("root")!).render(
+  <AutoScale original="en" languages={["fr", "es", "de", "pt"]} exclude={["Acme Cloud"]}>
+    <App />
+  </AutoScale>,
+);
+```
+
+**4. Build**
+
+```bash
+npm run build                    # or: yarn build   |   pnpm build
+npm run preview                  # optional: check the built site locally
+```
+
+The output folder has one page per language and route (`dist/fr/`, `dist/fr/about/`, ...), deployable anywhere that serves static files. The first build takes a few minutes: it installs the free local translation engine (about 440 MB, once, into `~/.cache/react-autolocale/engine`, shared by all your projects) and downloads the models. Later builds reuse the cache. Prefer to manage the engine yourself? `npm install -D @huggingface/transformers` and it will be used instead.
+
+Optional: `npx react-autolocale add switcher` copies an editable language switcher into your project (see below).
+
+Write normal JSX; there is no `t()` to call and no translation file to maintain.
+
+## Multi-page apps (React Router)
+
+Every page is generated, with nothing to configure. The build finds pages two ways: by following the links in each page, and by reading the fixed routes in your router code (`<Route path="/thank-you">`, nested routes, and `createBrowserRouter` objects). Pages written as `/fr/about/index.html` etc. are created for each language.
+
+Dynamic routes (`/users/:id`) can't be known from code, so list the real pages you want with the `routes` option, which can also be a function that fetches them:
+
+```ts
+reactAutolocale({ routes: async () => (await getUsers()).map((u) => `/users/${u.id}`) })
+```
+
+Give your router the language as its basename, and remount it when the language changes:
+
+```tsx
+function Shell() {
+  const { basePath, language } = useLanguage();
+  return (
+    <BrowserRouter basename={basePath} key={language}>
+      <Routes>...</Routes>
+    </BrowserRouter>
+  );
+}
+
+<AutoScale original="en" languages={["fr", "es"]}><Shell /></AutoScale>
+```
+
+Your host must serve `/fr/about/index.html` for `/fr/about`, which static hosts do by default.
+
+## Fixing a translation
+
+Machine translation sometimes gets short UI words wrong (a nav link "Home" may come back as "Sommaire"). Correct any string in the plugin options; overrides always win:
+
+```ts
+reactAutolocale({ overrides: { fr: { Home: "Accueil" }, es: { Home: "Inicio" } } })
+```
+
+## Language switcher
+
+Switching is just navigation to `/fr/` (instant, no reload; a page load when `seo` is on). You choose the UI:
+
+```bash
+npx react-autolocale add switcher   # copies an editable LanguageSwitcher into src/components
+```
+
+or import the ready-made dropdown: `import { LanguageSwitcher } from "react-autolocale"`.
+
+Build your own with the hook:
+
+```tsx
+const { language, languages, setLanguage, basePath } = useLanguage();
+```
+
+## What gets translated
+
+Static JSX text, plus `placeholder`, `title`, `alt`, `aria-label` on HTML elements. `exclude` phrases (brand names) are kept as-is, even inside longer sentences.
+
+## Supported languages
+
+Use these codes in `languages={[...]}`. The source (`original`) language can be any of them.
+
+| Code | Language | Model |
+| --- | --- | --- |
+| `fr` | French | OPUS-MT |
+| `es` | Spanish | OPUS-MT |
+| `de` | German | OPUS-MT |
+| `it` | Italian | OPUS-MT |
+| `nl` | Dutch | OPUS-MT |
+| `ru` | Russian | OPUS-MT |
+| `zh` | Chinese (Simplified) | OPUS-MT |
+| `ar` | Arabic (RTL) | OPUS-MT |
+| `hi` | Hindi | OPUS-MT |
+| `sv` | Swedish | OPUS-MT |
+| `da` | Danish | OPUS-MT |
+| `fi` | Finnish | OPUS-MT |
+| `cs` | Czech | OPUS-MT |
+| `hu` | Hungarian | OPUS-MT |
+| `ro` | Romanian | OPUS-MT |
+| `uk` | Ukrainian | OPUS-MT |
+| `vi` | Vietnamese | OPUS-MT |
+| `id` | Indonesian | OPUS-MT |
+| `pt` | Portuguese | NLLB |
+| `ja` | Japanese | NLLB |
+| `ko` | Korean | NLLB |
+| `tr` | Turkish | NLLB |
+| `pl` | Polish | NLLB |
+| `no` | Norwegian | NLLB |
+| `el` | Greek | NLLB |
+| `he` | Hebrew (RTL) | NLLB |
+| `th` | Thai | NLLB |
+| `bn` | Bengali | NLLB |
+| `fa` | Persian (RTL) | NLLB |
+| `ur` | Urdu (RTL) | NLLB |
+| `bg` | Bulgarian | NLLB |
+| `hr` | Croatian | NLLB |
+| `sk` | Slovak | NLLB |
+| `ca` | Catalan | NLLB |
+| `ms` | Malay | NLLB |
+| `sw` | Swahili | NLLB |
+| `tl` | Tagalog | NLLB |
+| `en` | English (default source) | NLLB when used as a target |
+
+OPUS-MT models are small (about 75 MB each) and are used when the source language is English. NLLB-200 is one larger download (about 600 MB) shared by all the languages marked NLLB, and is also used for any non-English source. Right-to-left languages automatically get `dir="rtl"` on the page.
+
+## Translations and caching
+
+Translations are generated on first build into `node_modules/.cache/react-autolocale/` and reused; only new or changed strings are translated afterwards. Cache that folder in CI. Models download once into `~/.cache/react-autolocale` (about 75 MB per OPUS-MT language, about 600 MB for NLLB: Japanese, Korean, Portuguese and others). The dev server translates text you add while it runs and reloads.
+
+## Automatic language navigation
+
+Whenever a visitor lands on a URL without a language prefix (like `/` or `/about`), they are sent to the page for their saved language, or otherwise their browser language, if you support it: a French browser lands on `/fr/`. A language chosen in the switcher is remembered and wins on later visits; the browser language itself is not saved, it is simply checked each time. Explicit URLs such as `/fr/about/` or `/en/` are never redirected, and unsupported browser languages stay on the original.
+
+## SEO (opt-in)
+
+By default react-autolocale does not touch your SEO: the only changes to `<head>` are one inline script holding that page's translations, plus `lang` and `dir` on `<html>`.
+
+Turn it on with `seo` on the provider:
+
+```tsx
+<AutoScale original="en" languages={["fr", "es"]} seo siteUrl="https://example.com">
+  <App />
+</AutoScale>
+```
+
+With `seo` the build also:
+- translates `<title>` and the description / Open Graph / Twitter meta tags,
+- adds `<link rel="canonical">` and `hreflang` alternates (plus `x-default`) to every page,
+- writes `sitemap.xml` with the alternates (needs `siteUrl`; reference it from your `robots.txt`).
+
+With `seo`, switching language navigates to the real page (so its head tags are correct) instead of swapping in place. Brand names in the title are translated like any text, so add them to `exclude`.
+
+## v1 limits
+
+- Dynamic content (`Hello {name}`, API data) is not translated; planned for v1.5. Text next to `{expressions}` stays in the original language.
+- Dynamic routes (`/users/:id`) only get pages you list in `routes`, or that are linked.
+- `<AutoScale>` props must be literals so the plugin can read them at build time.
+- Use Vite's default `base: "/"`.
+- Machine translation is draft quality.

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/cli.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+//#region src/cli/viteConfig.ts
+const IMPORT_LINE = `import reactAutolocale from "react-autolocale/vite";`;
+/** Adds the react-autolocale plugin to a vite.config source string. Returns null if it can't be done safely. */
+function patchViteConfig(source) {
+	if (source.includes("react-autolocale/vite")) return {
+		code: source,
+		changed: false
+	};
+	let code = source;
+	if (/plugins\s*:\s*\[/.test(code)) code = code.replace(/plugins\s*:\s*\[/, "plugins: [reactAutolocale(), ");
+	else if (/defineConfig\(\s*\{/.test(code)) code = code.replace(/defineConfig\(\s*\{/, "defineConfig({\n  plugins: [reactAutolocale()],");
+	else if (/export\s+default\s*\{/.test(code)) code = code.replace(/export\s+default\s*\{/, "export default {\n  plugins: [reactAutolocale()],");
+	else return null;
+	const imports = [...code.matchAll(/^import[^\n]*$/gm)];
+	const last = imports[imports.length - 1];
+	if (last) {
+		const at = last.index + last[0].length;
+		code = code.slice(0, at) + "\n" + IMPORT_LINE + code.slice(at);
+	} else code = IMPORT_LINE + "\n" + code;
+	return {
+		code,
+		changed: true
+	};
+}
+//#endregion
+//#region src/cli/index.ts
+const HELP = `react-autolocale
+
+Usage:
+  react-autolocale init
+      Adds the plugin to your vite.config for you.
+  react-autolocale add switcher [--dir src/components]
+      Copies an editable <LanguageSwitcher /> into your project.
+`;
+const TSX = `import { useLanguage } from "react-autolocale";
+
+// This file is yours: change the markup, style it, or replace it entirely.
+export function LanguageSwitcher() {
+  const { language, languages, setLanguage } = useLanguage();
+  return (
+    <div role="group" aria-label="Language">
+      {languages.map((l) => (
+        <button
+          key={l.code}
+          lang={l.code}
+          aria-pressed={l.code === language}
+          onClick={() => setLanguage(l.code)}
+        >
+          {l.native}
+        </button>
+      ))}
+    </div>
+  );
+}
+`;
+const JSX = TSX;
+function flag(args, name) {
+	const i = args.indexOf(name);
+	return i >= 0 ? args[i + 1] : void 0;
+}
+const VITE_CONFIGS = [
+	"vite.config.ts",
+	"vite.config.mts",
+	"vite.config.js",
+	"vite.config.mjs"
+];
+const NEXT_STEP = `
+Next, wrap your app once (for example in main.tsx):
+
+  import { AutoScale } from "react-autolocale";
+
+  <AutoScale original="en" languages={["fr", "es"]}>
+    <App />
+  </AutoScale>
+
+Then run your build.`;
+function init(root) {
+	const file = VITE_CONFIGS.map((f) => path.join(root, f)).find((f) => fs.existsSync(f));
+	if (!file) throw new Error("No vite.config found. This package works with Vite projects.");
+	const name = path.basename(file);
+	const patched = patchViteConfig(fs.readFileSync(file, "utf8"));
+	if (!patched) throw new Error(`Could not edit ${name} automatically. Add this yourself:\n  import reactAutolocale from "react-autolocale/vite";\n  plugins: [reactAutolocale(), ...]`);
+	if (patched.changed) fs.writeFileSync(file, patched.code);
+	console.log(patched.changed ? `Added the react-autolocale plugin to ${name}.` : `${name} already uses react-autolocale.`);
+	console.log(NEXT_STEP);
+}
+function addSwitcher(root, args) {
+	const dir = path.resolve(root, flag(args, "--dir") ?? (fs.existsSync(path.join(root, "src")) ? "src/components" : "components"));
+	const ts = fs.existsSync(path.join(root, "tsconfig.json"));
+	const file = path.join(dir, ts ? "LanguageSwitcher.tsx" : "LanguageSwitcher.jsx");
+	if (fs.existsSync(file)) throw new Error(`${path.relative(root, file)} already exists.`);
+	fs.mkdirSync(dir, { recursive: true });
+	fs.writeFileSync(file, ts ? TSX : JSX);
+	console.log(`Created ${path.relative(root, file)}\nImport it anywhere: import { LanguageSwitcher } from "./components/LanguageSwitcher";`);
+}
+try {
+	const [cmd, what, ...rest] = process.argv.slice(2);
+	if (cmd === "init") init(process.cwd());
+	else if (cmd === "add" && what === "switcher") addSwitcher(process.cwd(), rest);
+	else {
+		console.log(HELP);
+		if (cmd) process.exitCode = 1;
+	}
+} catch (err) {
+	console.error(`react-autolocale: ${err.message}`);
+	process.exit(1);
+}
+//#endregion

package/dist/index.d.ts

@@ -0,0 +1,61 @@
+import { CSSProperties, ReactElement, ReactNode } from "react";
+//#region src/runtime/index.d.ts
+type Dict = Record<string, string>;
+declare global {
+  interface Window {
+    /** Written into every generated page so the first render already has its translations. */
+    __AUTOSCALE__?: {
+      lang: string;
+      dict: Dict;
+    };
+  }
+}
+export interface AutoScaleProps {
+  /** Language the app is written in, e.g. "en". Must be a literal so the build can read it. */
+  original: string;
+  /** Languages to generate, e.g. ["fr", "es"]. Must be a literal. */
+  languages: string[];
+  /** Phrases that must never be translated, such as brand names. Must be a literal. */
+  exclude?: string[];
+  /**
+   * Opt in to SEO changes at build time: translated title/meta tags, canonical and hreflang links,
+   * and a sitemap. Off by default: nothing in <head> is touched. Must be a literal.
+   */
+  seo?: boolean | "true";
+  /** Public site URL (e.g. "https://example.com"); used by `seo` for absolute links and the sitemap. */
+  siteUrl?: string;
+  children?: ReactNode;
+}
+/**
+ * Wrap your app once. Language comes from the URL (/fr/...), so every language is a real, static page.
+ * The props are read at build time by the Vite plugin.
+ */
+export declare function AutoScale({ children }: AutoScaleProps): ReactElement;
+/** @internal Inserted by the Vite plugin in place of static JSX text. */
+export declare function __T({ s }: {
+  s: string;
+}): ReactElement;
+/** @internal Inserted by the Vite plugin for translated attributes (placeholder, alt, ...). */
+export declare function __useT(): (s: string) => string;
+export interface LanguageApi {
+  language: string;
+  /** Switches language and updates the URL; resolves once translations are loaded. */
+  setLanguage: (code: string) => Promise<void>;
+  /** All languages, original first. */
+  languages: {
+    code: string;
+    native: string;
+  }[];
+  /** "/fr" - pass to your router's basename if you use client-side routing. */
+  basePath: string;
+}
+export declare function useLanguage(): LanguageApi;
+export interface LanguageSwitcherProps {
+  className?: string;
+  style?: CSSProperties;
+  /** Accessible label for the dropdown. */
+  label?: string;
+}
+/** A dropdown that switches the whole app's language instantly, without a reload. */
+export declare function LanguageSwitcher({ className, style, label }: LanguageSwitcherProps): ReactElement;
+//#endregion

package/dist/index.js

@@ -0,0 +1,136 @@
+import { r as redirectTarget, t as STORAGE_KEY } from "./redirect-CKNY4ru5.js";
+import { Fragment, createContext, createElement, useCallback, useContext, useEffect, useMemo, useState } from "react";
+import { languages, loaders, original, originalNative, seo } from "virtual:react-autolocale";
+//#region src/runtime/index.ts
+const hasDom = typeof window !== "undefined" && typeof document !== "undefined";
+const codes = /* @__PURE__ */ new Set([original, ...languages.map((l) => l.code)]);
+const cache = /* @__PURE__ */ new Map();
+const PREFIX = /^\/([a-z]{2,3})(?=\/|$)/i;
+function prefixOf(pathname) {
+	const code = PREFIX.exec(pathname)?.[1]?.toLowerCase();
+	return code && codes.has(code) ? code : null;
+}
+function pathFor(code) {
+	const { pathname, search, hash } = window.location;
+	return `/${code}${prefixOf(pathname) ? pathname.replace(PREFIX, "") || "/" : pathname}${search}${hash}`;
+}
+function load(code) {
+	const hit = cache.get(code);
+	if (hit) return Promise.resolve(hit);
+	const loader = loaders[code];
+	if (!loader) return Promise.resolve({});
+	return loader().then((m) => m.default).catch(() => ({})).then((dict) => (cache.set(code, dict), dict));
+}
+const Context = createContext({
+	language: original,
+	dict: {},
+	setLanguage: async () => {}
+});
+function initialState() {
+	if (!hasDom) return {
+		language: original,
+		dict: {}
+	};
+	const boot = window.__AUTOSCALE__;
+	const language = boot?.lang ?? prefixOf(window.location.pathname) ?? original;
+	if (boot) cache.set(boot.lang, boot.dict);
+	return {
+		language,
+		dict: language === original ? {} : cache.get(language) ?? {}
+	};
+}
+/**
+* Wrap your app once. Language comes from the URL (/fr/...), so every language is a real, static page.
+* The props are read at build time by the Vite plugin.
+*/
+function AutoScale({ children }) {
+	const [state, setState] = useState(initialState);
+	const apply = useCallback(async (code, push) => {
+		if (!codes.has(code)) return;
+		if (push && hasDom) {
+			try {
+				window.localStorage.setItem(STORAGE_KEY, code);
+			} catch {}
+			if (seo) {
+				window.location.assign(pathFor(code));
+				return;
+			}
+		}
+		const dict = code === original ? {} : await load(code);
+		setState({
+			language: code,
+			dict
+		});
+		if (push && hasDom) window.history.pushState(null, "", pathFor(code));
+	}, []);
+	const setLanguage = useCallback((code) => apply(code, true), [apply]);
+	useEffect(() => {
+		document.documentElement.lang = state.language;
+		document.documentElement.dir = languages.find((l) => l.code === state.language)?.rtl ? "rtl" : "ltr";
+	}, [state.language]);
+	useEffect(() => {
+		let saved = null;
+		try {
+			saved = window.localStorage.getItem(STORAGE_KEY);
+		} catch {}
+		const to = redirectTarget({
+			pathname: window.location.pathname,
+			search: window.location.search,
+			hash: window.location.hash,
+			saved,
+			browser: window.navigator.languages?.length ? window.navigator.languages : [window.navigator.language],
+			codes: [...codes],
+			original
+		});
+		if (to) window.location.replace(to);
+	}, []);
+	useEffect(() => {
+		if (state.language !== original && !cache.has(state.language)) apply(state.language, false);
+		const onPop = () => void apply(prefixOf(window.location.pathname) ?? original, false);
+		window.addEventListener("popstate", onPop);
+		return () => window.removeEventListener("popstate", onPop);
+	}, [apply]);
+	const value = useMemo(() => ({
+		...state,
+		setLanguage
+	}), [state, setLanguage]);
+	return createElement(Context.Provider, { value }, children);
+}
+/** @internal Inserted by the Vite plugin in place of static JSX text. */
+function __T({ s }) {
+	const { dict } = useContext(Context);
+	return createElement(Fragment, null, dict[s] ?? s);
+}
+/** @internal Inserted by the Vite plugin for translated attributes (placeholder, alt, ...). */
+function __useT() {
+	const { dict } = useContext(Context);
+	return useCallback((s) => dict[s] ?? s, [dict]);
+}
+function useLanguage() {
+	const { language, setLanguage } = useContext(Context);
+	return useMemo(() => ({
+		language,
+		setLanguage,
+		languages: [{
+			code: original,
+			native: originalNative
+		}, ...languages],
+		basePath: `/${language}`
+	}), [language, setLanguage]);
+}
+/** A dropdown that switches the whole app's language instantly, without a reload. */
+function LanguageSwitcher({ className, style, label = "Language" }) {
+	const { language, languages: all, setLanguage } = useLanguage();
+	return createElement("select", {
+		className,
+		style,
+		value: language,
+		"aria-label": label,
+		onChange: (e) => void setLanguage(e.target.value)
+	}, all.map((l) => createElement("option", {
+		key: l.code,
+		value: l.code
+	}, l.native)));
+}
+//#endregion
+export { AutoScale, LanguageSwitcher, __T, __useT, useLanguage };

package/dist/redirect-CKNY4ru5.js

@@ -0,0 +1,26 @@
+//#region src/core/redirect.ts
+/**
+* Where should a visitor on an un-prefixed URL (like "/" or "/about") be sent?
+* Saved choice wins, then the browser's language list. Returns null to stay put.
+*/
+function redirectTarget(opts) {
+	const { pathname, codes, original } = opts;
+	const prefix = /^\/([a-z]{2,3})(?=\/|$)/i.exec(pathname)?.[1]?.toLowerCase();
+	if (prefix && codes.includes(prefix)) return null;
+	let target = opts.saved && codes.includes(opts.saved) ? opts.saved : null;
+	for (const tag of opts.browser) {
+		if (target) break;
+		const lower = String(tag).toLowerCase();
+		if (codes.includes(lower)) target = lower;
+		else if (codes.includes(lower.split("-")[0])) target = lower.split("-")[0];
+	}
+	if (!target || target === original) return null;
+	return `/${target}${pathname}${opts.search ?? ""}${opts.hash ?? ""}`;
+}
+const STORAGE_KEY = "react-autolocale:language";
+/** The same logic as a tiny inline script, so the root page redirects before anything paints. */
+function redirectScript(codes, original) {
+	return `(function(){try{var C=${JSON.stringify(codes)},O=${JSON.stringify(original)},p=location.pathname,m=/^\\/([a-z]{2,3})(?=\\/|$)/i.exec(p);if(m&&C.indexOf(m[1].toLowerCase())>-1)return;var t=null,s=localStorage.getItem(${JSON.stringify(STORAGE_KEY)});if(s&&C.indexOf(s)>-1)t=s;var l=navigator.languages||[navigator.language];for(var i=0;i<l.length&&!t;i++){var c=String(l[i]).toLowerCase();if(C.indexOf(c)>-1)t=c;else if(C.indexOf(c.split("-")[0])>-1)t=c.split("-")[0]}if(t&&t!==O)location.replace("/"+t+p+location.search+location.hash)}catch(e){}})()`;
+}
+//#endregion
+export { redirectScript as n, redirectTarget as r, STORAGE_KEY as t };

package/dist/vite.d.ts

@@ -0,0 +1,16 @@
+import { Plugin } from "vite";
+//#region src/vite/index.d.ts
+export interface ReactAutolocaleOptions {
+  /** Folders (relative to the project root) scanned for JSX. Defaults to "src". */
+  include?: string[];
+  /** Fix individual translations by hand, e.g. { fr: { Contact: "Contact" } }. */
+  overrides?: Record<string, Record<string, string>>;
+  /**
+   * Extra pages to build, mainly dynamic ones such as "/users/1" (a function can fetch them). Pages reached
+   * by links and fixed routes written in your router (<Route path="/thank-you">) are found automatically.
+   */
+  routes?: string[] | (() => string[] | Promise<string[]>);
+}
+export default function reactAutolocale(options?: ReactAutolocaleOptions): Plugin;
+//#endregion
+export { reactAutolocale };