@hoardodile/i18n 0.0.0

package/src/catalogs.ts

@@ -0,0 +1,31 @@
+/**
+ * The app catalog registry: every shipped language's complete JSON
+ * catalog plus the single resolution point the Electron shell (main
+ * process, wizard, error pages) uses to pick translations.
+ *
+ * Split from `./core.ts` (pure helpers, no catalogs) so the sandboxed
+ * preload and any other bundle that only needs `isSupportedLanguage` /
+ * `resolveSystemLanguage` never loads the catalogs.
+ *
+ * `Record<SupportedLanguage, typeof en>` makes any key drift between
+ * catalogs a **compile error** (the five JSON modules are structurally
+ * typed); `parity.test.ts` enforces the rest (placeholders, plural
+ * pairs, markup tags, ellipsis).
+ */
+
+import de from "./catalogs/de.json"
+import en from "./catalogs/en.json"
+import es from "./catalogs/es.json"
+import ja from "./catalogs/ja.json"
+import zh from "./catalogs/zh.json"
+import type { SupportedLanguage } from "./core.ts"
+
+export const CATALOGS = { en, zh, ja, de, es } as const satisfies Record<
+	SupportedLanguage,
+	typeof en
+>
+
+/** Resolve the app catalog for the active language; pre-SPA (undefined) → English. */
+export function catalogFor(language: SupportedLanguage | undefined): typeof en {
+	return language === undefined ? en : CATALOGS[language]
+}

package/src/core.ts

@@ -0,0 +1,40 @@
+/**
+ * Locale plumbing shared by the web SPA, the Electron shell and the plugin
+ * SDK: the supported-language set and pure helpers. **This module must
+ * stay free of catalog imports** — the sandboxed preload imports
+ * `isSupportedLanguage` from here, and the catalogs (which weigh far
+ * more than this file) live in `./catalogs.ts` (`CATALOGS`,
+ * `catalogFor`), `./catalogs/ui.ts` (`UI_CATALOGS`, `uiCatalogFor`) plus
+ * the per-language JSON modules.
+ *
+ * `catalogs/*.json` (the app `translation` namespace) and `ui/*.json`
+ * (the shared `ui` namespace consumed by `@hoardodile/ui` and the plugin
+ * SDK iframes) must stay in lockstep internally: identical flat key
+ * sets, matching interpolation placeholders, and complete `_one`/`_other`
+ * pairs. `src/parity.test.ts` enforces this — run it after touching any
+ * catalog. `CATALOGS: Record<SupportedLanguage, typeof en>` and
+ * `UI_CATALOGS: Record<SupportedLanguage, typeof uiEn>` additionally
+ * make any key drift a compile error in `tsc`.
+ */
+export const SUPPORTED_LANGUAGES = ["en", "zh", "ja", "de", "es"] as const
+export type SupportedLanguage = (typeof SUPPORTED_LANGUAGES)[number]
+
+export function isSupportedLanguage(value: string): value is SupportedLanguage {
+	return (SUPPORTED_LANGUAGES as readonly string[]).includes(value)
+}
+
+/**
+ * Map a BCP-47 locale string (e.g. `navigator.language`,
+ * `app.getLocale()`, a stored pref) onto the supported set, taking the
+ * base code: `"ja-JP"` → `"ja"`, `"de-DE"` → `"de"`, `"es-MX"` → `"es"`,
+ * `"zh-CN"`/`"zh-TW"` → `"zh"` (any Chinese base maps to the `zh`
+ * catalog, preserving historical behavior). Unknown or missing values
+ * fall back to `"en"`.
+ */
+export function resolveSystemLanguage(
+	raw: string | undefined,
+): SupportedLanguage {
+	const base = raw?.toLowerCase().split("-")[0]
+	if (base !== undefined && isSupportedLanguage(base)) return base
+	return "en"
+}

package/src/create-i18n.ts

@@ -0,0 +1,52 @@
+/**
+ * The i18next instance factory every React root uses: the web SPA, the
+ * desktop wizard/shell pages, the workbench and the plugin SDK iframes
+ * all boot their instance with the same options so catalog behavior
+ * (fallback, plurals, interpolation, type safety) never diverges between
+ * surfaces.
+ *
+ * This module is deliberately free of catalog imports — plugin iframe
+ * bundles import the factory through this subpath and ship only the
+ * small `ui`/`plugin` namespaces (the full app catalog would otherwise
+ * be pulled into every bundle). Host surfaces use `createI18n` from
+ * `@hoardodile/i18n`, which wraps this factory with the shared catalogs.
+ *
+ * React-free on purpose: the Electron main process and the sandboxed
+ * preload keep using `catalogFor` / `uiCatalogFor` directly, and each
+ * React root adds its own `react-i18next` binding (e.g.
+ * `setI18n(instance)`).
+ */
+
+import i18next, { type i18n as I18nInstance, type InitOptions } from "i18next"
+import { SUPPORTED_LANGUAGES } from "./core.ts"
+
+export type CreateI18nOptions = Omit<InitOptions, "lng" | "resources"> & {
+	/** Initial language; undefined lets i18next resolve its default (fallback → "en"). */
+	readonly lng?: string
+	/** Resource map — the shared catalogs (or the smaller ui/plugin set). */
+	readonly resources: InitOptions["resources"]
+}
+
+/**
+ * Create an i18next instance with the canonical option set. Callers
+ * supply the resources explicitly (hosts via the `@hoardodile/i18n`
+ * wrapper, plugins via the SDK).
+ */
+export function createI18n(options: CreateI18nOptions): I18nInstance {
+	const { lng, resources, ...rest } = options
+	const instance = i18next.createInstance()
+	void instance.init({
+		resources,
+		lng,
+		fallbackLng: "en",
+		supportedLngs: [...SUPPORTED_LANGUAGES],
+		nonExplicitSupportedLngs: true,
+		interpolation: { escapeValue: false },
+		returnNull: false,
+		returnEmptyString: false,
+		compatibilityJSON: "v4",
+		pluralSeparator: "_",
+		...rest,
+	} satisfies InitOptions)
+	return instance
+}

package/src/index.ts

@@ -0,0 +1,66 @@
+import type en from "./catalogs/en.json"
+import type uiEn from "./ui/en.json"
+
+/**
+ * Type the `t()` keys of every consumer against the catalogs: a wrong key
+ * (typo or a key added to one catalog but not the others) becomes a
+ * compile error instead of a silently rendered key name. Declared once
+ * here so the web SPA, the desktop surfaces, the workbench and the plugin
+ * SDK all resolve the same resources. The `plugin` namespace is typed
+ * loosely on purpose — its strings are authored per plugin (their
+ * bundles vary), and `@hoardodile/sdk-react`'s `useTranslation` wrapper
+ * returns that loose signature to plugin code.
+ */
+declare module "i18next" {
+	interface CustomTypeOptions {
+		defaultNS: "translation"
+		resources: {
+			translation: typeof en
+			ui: typeof uiEn
+			plugin: Record<string, string>
+		}
+		returnNull: false
+		returnEmptyString: false
+	}
+}
+
+import type { i18n as I18nInstance } from "i18next"
+import { UI_CATALOGS } from "./catalogs/ui.ts"
+import { CATALOGS } from "./catalogs.ts"
+import { SUPPORTED_LANGUAGES } from "./core.ts"
+import {
+	type CreateI18nOptions,
+	createI18n as createI18nCore,
+} from "./create-i18n.ts"
+
+/**
+ * Host-surface factory: an i18next instance preloaded with the shared
+ * catalogs (`translation` + `ui`, all five languages). React roots boot
+ * it with the same options everywhere. Plugin iframes use the `createI18n`
+ * factory from `@hoardodile/i18n/create-i18n` instead with a resource
+ * subset (ui + plugin namespaces) so the full app catalog never enters
+ * their bundles.
+ */
+export function createI18n(
+	options?: Omit<CreateI18nOptions, "resources">,
+): I18nInstance {
+	return createI18nCore({
+		resources: Object.fromEntries(
+			SUPPORTED_LANGUAGES.map((language) => [
+				language,
+				{ translation: CATALOGS[language], ui: UI_CATALOGS[language] },
+			]),
+		),
+		...options,
+	})
+}
+
+export { UI_CATALOGS, uiCatalogFor } from "./catalogs/ui.ts"
+export { CATALOGS, catalogFor } from "./catalogs.ts"
+export {
+	isSupportedLanguage,
+	resolveSystemLanguage,
+	SUPPORTED_LANGUAGES,
+	type SupportedLanguage,
+} from "./core.ts"
+export type { CreateI18nOptions } from "./create-i18n.ts"

package/src/language.test.ts

@@ -0,0 +1,70 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from "vitest"
+import { UI_CATALOGS, uiCatalogFor } from "./catalogs/ui.ts"
+import { CATALOGS, catalogFor } from "./catalogs.ts"
+import {
+	isSupportedLanguage,
+	resolveSystemLanguage,
+	SUPPORTED_LANGUAGES,
+} from "./core.ts"
+
+describe("resolveSystemLanguage", () => {
+	it("maps base codes onto the supported set", () => {
+		expect(resolveSystemLanguage("ja-JP")).toBe("ja")
+		expect(resolveSystemLanguage("de-DE")).toBe("de")
+		expect(resolveSystemLanguage("es-MX")).toBe("es")
+		expect(resolveSystemLanguage("es")).toBe("es")
+		// Any Chinese base maps to the `zh` catalog, preserving history.
+		expect(resolveSystemLanguage("zh-CN")).toBe("zh")
+		expect(resolveSystemLanguage("zh-TW")).toBe("zh")
+		expect(resolveSystemLanguage("ZH-hant")).toBe("zh")
+		expect(resolveSystemLanguage("en-US")).toBe("en")
+	})
+
+	it("falls back to English for unknown or missing values", () => {
+		expect(resolveSystemLanguage("fr")).toBe("en")
+		expect(resolveSystemLanguage("")).toBe("en")
+		expect(resolveSystemLanguage(undefined)).toBe("en")
+	})
+})
+
+describe("catalogFor", () => {
+	it("returns the matching catalog for every supported language", () => {
+		for (const code of SUPPORTED_LANGUAGES) {
+			expect(catalogFor(code), `catalogFor(${code})`).toBe(
+				CATALOGS[code as (typeof SUPPORTED_LANGUAGES)[number]],
+			)
+		}
+	})
+
+	it("falls back to English when no language is pushed yet", () => {
+		expect(catalogFor(undefined)).toBe(CATALOGS.en)
+	})
+})
+
+describe("uiCatalogFor", () => {
+	it("returns the matching ui catalog for every supported language", () => {
+		for (const code of SUPPORTED_LANGUAGES) {
+			expect(uiCatalogFor(code), `uiCatalogFor(${code})`).toBe(
+				UI_CATALOGS[code as (typeof SUPPORTED_LANGUAGES)[number]],
+			)
+		}
+	})
+
+	it("falls back to English when no language is pushed yet", () => {
+		expect(uiCatalogFor(undefined)).toBe(UI_CATALOGS.en)
+	})
+})
+
+describe("isSupportedLanguage", () => {
+	it("accepts exactly the supported base codes", () => {
+		for (const code of SUPPORTED_LANGUAGES) {
+			expect(isSupportedLanguage(code)).toBe(true)
+		}
+		expect(isSupportedLanguage("de-DE")).toBe(false)
+		expect(isSupportedLanguage("fr")).toBe(false)
+		expect(isSupportedLanguage("")).toBe(false)
+	})
+})

package/src/parity.test.ts

@@ -0,0 +1,175 @@
+/**
+ * @vitest-environment node
+ *
+ * Guardrails that keep the i18n catalogs in lockstep — the app
+ * `translation` namespace (`src/catalogs/*.json`), the shared `ui`
+ * namespace (`src/ui/*.json`) and the workbench namespace
+ * (`src/workbench/*.json`). These caught real regressions
+ * historically (dead `_plural` keys under i18next v4, a missing zh
+ * mirror, and the desktop shell's hardcoded ternaries), so they are
+ * intentionally strict: a new key must be registered in every language
+ * before it can ship.
+ *
+ * Structural rules only (key parity, placeholders, plural pairs, markup
+ * tags, ellipsis). Key *naming* is intentionally not enforced — see the
+ * documented conventions in `src/core.ts` and the catalog registries.
+ */
+import { describe, expect, it } from "vitest"
+import { UI_CATALOGS } from "./catalogs/ui.ts"
+import { WORKBENCH_CATALOGS } from "./catalogs/workbench.ts"
+import { CATALOGS } from "./catalogs.ts"
+
+type FlatEntry = { key: string; value: string }
+
+function flatten(
+	obj: Record<string, unknown>,
+	path: string[] = [],
+	out: FlatEntry[] = [],
+): FlatEntry[] {
+	for (const [k, v] of Object.entries(obj)) {
+		if (typeof v === "object" && v !== null) {
+			flatten(v as Record<string, unknown>, [...path, k], out)
+		} else {
+			out.push({ key: [...path, k].join("."), value: String(v) })
+		}
+	}
+	return out
+}
+
+function vars(value: string): string {
+	return (value.match(/\{\{[^}]+\}\}/g) ?? [])
+		.map((m) => m.slice(2, -2))
+		.sort()
+		.join(",")
+}
+
+/** Markup tags (`<name>`, `</name>`, …) — translations must keep them. */
+function tags(value: string): string {
+	return (value.match(/<\/?[a-zA-Z][a-zA-Z0-9-]*>/g) ?? []).sort().join(",")
+}
+
+/** Keys that legitimately keep `{{count}}` without a plural pair. */
+const NO_PLURAL_PAIR_ALLOWLIST = new Set([
+	"search.sectionCount", // "({{count}})" parenthetical
+	"search.viewAll", // "View all ({{count}})"
+	"me.custom.unusedCount", // "{{count}} unused" (adjective)
+	"me.desktop.lan.moreAddresses", // "Other addresses ({{count}})" parenthetical
+	"me.trash.view", // "Review trash ({{count}})"
+	"plugins.countInstalled", // "{{count}} installed" (adjective)
+	"usage.leaderboard.associatedSessionsShort", // "{{count}} associated" (adjective)
+	"categories.panel.dependencyResources", // "{{count}} res" (abbreviation)
+	"categories.panel.dependencyCharacters", // "{{count}} char" (abbreviation)
+	"categories.panel.tagCharacterCount", // "char {{count}}"
+	"categories.panel.tagResourceCount", // "res {{count}}"
+	"deleteEntity.usageMessage", // usage noun is passed in (singular when count=1)
+	"documents.statusBar.charCount", // "{{count}} / {{max}} chars" (range)
+	"sync.banner.overdueDescription", // "{{count}}-day reminder" (compound)
+	"trace.overview.moreThanPrev", // "{{count}} more than the previous period"
+	"trace.overview.lessThanPrev", // "{{count}} less than the previous period"
+	"characters.bulk.toolbarCount", // "{{count}} selected" (adjective)
+	"resources.bulk.toolbarCount", // "{{count}} selected" (adjective)
+	"characters.bulk.toastAllFailed", // "({{count}} failed)" parenthetical
+	"resources.bulk.toastAllFailed", // "({{count}} failed)" parenthetical
+	"characters.selectorDialog.confirmCount", // "Confirm ({{count}})"
+	"messages.viewReplies", // "View replies ({{count}})"
+])
+
+/** Keys that keep ASCII `...` in the value (URL placeholders). */
+const ASCII_ELLIPSIS_ALLOWLIST = new Set([
+	"resources.new.sourceUrlPlaceholder",
+	"resources.editDialog.sourceUrlPlaceholder",
+])
+
+function checkCatalogLockstep(
+	catalogs: Readonly<Record<string, Readonly<Record<string, unknown>>>>,
+): void {
+	const EN = catalogs.en as Record<string, unknown>
+	const enFlat = flatten(EN)
+	const enKeys = new Set(enFlat.map((r) => r.key))
+	const enByKey = new Map(enFlat.map((r) => [r.key, r.value]))
+
+	for (const [name, catalog] of Object.entries(catalogs)) {
+		const flat = flatten(catalog as unknown as Record<string, unknown>)
+		const keys = new Set(flat.map((r) => r.key))
+		const byKey = new Map(flat.map((r) => [r.key, r.value]))
+
+		it(`${name} has identical flat key sets`, () => {
+			expect(
+				[...enKeys].filter((k) => !keys.has(k)),
+				`keys only in en (missing from ${name})`,
+			).toEqual([])
+			expect(
+				[...keys].filter((k) => !enKeys.has(k)),
+				`keys only in ${name}`,
+			).toEqual([])
+		})
+
+		it(`${name} uses the same interpolation placeholders per key`, () => {
+			const mismatched: string[] = []
+			for (const key of enKeys) {
+				const value = byKey.get(key)
+				if (
+					value !== undefined &&
+					vars(enByKey.get(key) ?? "") !== vars(value)
+				) {
+					mismatched.push(key)
+				}
+			}
+			expect(mismatched, "placeholder mismatch").toEqual([])
+		})
+
+		it(`${name} keeps <name> markup tags identical per key`, () => {
+			const mismatched: string[] = []
+			for (const key of enKeys) {
+				const value = byKey.get(key)
+				if (
+					value !== undefined &&
+					tags(enByKey.get(key) ?? "") !== tags(value)
+				) {
+					mismatched.push(key)
+				}
+			}
+			expect(mismatched, "markup tag mismatch").toEqual([])
+		})
+
+		it(`${name} has complete plural pairs and no legacy suffixes`, () => {
+			const bad: string[] = []
+			for (const key of keys) {
+				if (/_(plural|singular)$/.test(key)) bad.push(`${key} (legacy suffix)`)
+			}
+			for (const key of keys) {
+				const base = key.replace(/_(one|other|few|many|zero)$/, "")
+				if (base === key) continue
+				if (!keys.has(`${base}_one`) || !keys.has(`${base}_other`)) {
+					bad.push(`${key} (incomplete pair)`)
+				}
+			}
+			expect(bad, "plural violations").toEqual([])
+		})
+
+		it(`${name} uses U+2026 ellipsis everywhere except URL placeholders`, () => {
+			const violating = flat
+				.filter((r) => r.value.includes("..."))
+				.map((r) => r.key)
+				.filter((k) => !ASCII_ELLIPSIS_ALLOWLIST.has(k))
+			expect(violating, "ASCII ellipsis outside allowlist").toEqual([])
+		})
+	}
+
+	it("never leaves a count key without a plural pair unless allowlisted", () => {
+		const violating: string[] = []
+		for (const [key, value] of enByKey) {
+			if (!value.includes("{{count}}")) continue
+			if (/_(one|other|few|many|zero)$/.test(key)) continue
+			if (NO_PLURAL_PAIR_ALLOWLIST.has(key)) continue
+			violating.push(key)
+		}
+		expect(violating, "count key without plural pair").toEqual([])
+	})
+}
+
+describe("i18n catalog parity", () => {
+	checkCatalogLockstep(CATALOGS)
+	checkCatalogLockstep(UI_CATALOGS)
+	checkCatalogLockstep(WORKBENCH_CATALOGS)
+})

package/src/react.ts

@@ -0,0 +1,25 @@
+import { I18nextProvider, setI18n } from "react-i18next"
+
+/**
+ * React binding shared by every host surface. Import the provider and
+ * `setI18n` from HERE (not from `react-i18next`) so the provider and
+ * `@hoardodile/ui` components resolve the SAME react-i18next context
+ * instance: the workspace pins two typescript toolchains and pnpm
+ * therefore keeps two physical copies of react-i18next (keyed by peer
+ * context), so react-i18next's module-global default instance must NOT
+ * be relied on across package boundaries — hosts pass the instance
+ * explicitly.
+ *
+ * The `@hoardodile/ui` components call `useTranslation("ui")` against
+ * this context; host roots wrap their tree with the provider:
+ *
+ * ```tsx
+ * <I18nProvider i18n={i18n}>
+ *   <App />
+ * </I18nProvider>
+ * ```
+ *
+ * Test setups that cannot wrap a provider bind the same instance here so
+ * ui components still resolve it.
+ */
+export { I18nextProvider as I18nProvider, setI18n }

package/src/ui/de.json

@@ -0,0 +1,86 @@
+{
+	"caption": {
+		"back": "Zurück",
+		"forward": "Vorwärts",
+		"reload": "Neu laden",
+		"minimize": "Minimieren",
+		"maximize": "Maximieren",
+		"restore": "Wiederherstellen",
+		"close": "Schließen",
+		"devtools": "Entwicklertools"
+	},
+	"closeConfirm": {
+		"title": "hoardodile schließen?",
+		"description": "Die App läuft im Infobereich weiter, außer du beendest sie.",
+		"tray": "Im Infobereich ausblenden",
+		"quit": "App beenden",
+		"cancel": "Abbrechen",
+		"remember": "Meine Auswahl merken"
+	},
+	"pluginDownload": {
+		"eyebrow": "Plugin-Download",
+		"title": "Diese Datei herunterladen?",
+		"description": "{{pluginName}} möchte eine Datei in seinen eigenen Speicherordner herunterladen. Die Datei wird von der unten stehenden URL geladen und nur innerhalb des Plugin-Ordners gespeichert.",
+		"urlLabel": "URL",
+		"destLabel": "Ziel",
+		"sizeLabel": "Größe",
+		"unknownSize": "unbekannt",
+		"deny": "Ablehnen",
+		"allow": "Erlauben",
+		"remember": "Für diese Sitzung merken (keine weiteren Rückfragen dieses Plugins)"
+	},
+	"pagination": {
+		"region": "Seitennavigation",
+		"prev": "Zurück",
+		"next": "Weiter",
+		"previous": "Vorherige",
+		"goTo": "Gehe zu",
+		"jumpToPage": "Seite",
+		"morePages": "Weitere Seiten"
+	},
+	"aria": {
+		"loading": "Wird geladen",
+		"closeToast": "Benachrichtigung schließen",
+		"close": "Schließen",
+		"more": "Mehr",
+		"toggleSidebar": "Seitenleiste umschalten",
+		"mobileSidebarDescription": "Zeigt die mobile Seitenleiste.",
+		"sidebar": "Seitenleiste",
+		"breadcrumb": "Breadcrumb"
+	},
+	"dialog": {
+		"cancel": "Abbrechen"
+	},
+	"confirmByTyping": {
+		"prompt": "Tippe „<name>{{name}}</name>“ ein, um zu bestätigen"
+	},
+	"colorPicker": {
+		"clear": "Farbe entfernen",
+		"addPreset": "Zu meinen Presets hinzufügen",
+		"removePresetAria": "Preset {{color}} entfernen",
+		"customSwatch": "Benutzerdefinierte Farbe wählen"
+	},
+	"fontPicker": {
+		"inherit": "Globale Schriftart übernehmen",
+		"inheritedHint": "Übernimmt derzeit die globale Schriftarteinstellung",
+		"addCustom": "Schriftart per Name hinzufügen, Eingabetaste drücken…",
+		"selected": "Fallback-Reihenfolge — zum Sortieren ziehen",
+		"description": "Oberfläche und Listen — Dokumente behalten ihre Lesestimme."
+	},
+	"imageCrop": {
+		"saving": "Speichern…",
+		"remove": "Entfernen",
+		"save": "Speichern",
+		"pickHint": "Klicken oder ablegen",
+		"reselect": "Erneut hochladen",
+		"previewLabel": "Vorschau",
+		"previewAlt": "Zugeschnittene Vorschau",
+		"showPreview": "Vorschau anzeigen",
+		"saveFailed": "Speichern fehlgeschlagen"
+	},
+	"panelToolbar": {
+		"add": "Hinzufügen",
+		"unused": "Ungenutzt",
+		"reorder": "Neu ordnen"
+	}
+}

package/src/ui/en.json

@@ -0,0 +1,86 @@
+{
+	"caption": {
+		"back": "Back",
+		"forward": "Forward",
+		"reload": "Reload",
+		"minimize": "Minimize",
+		"maximize": "Maximize",
+		"restore": "Restore",
+		"close": "Close",
+		"devtools": "Developer tools"
+	},
+	"closeConfirm": {
+		"title": "Close hoardodile?",
+		"description": "The app keeps running in the tray unless you quit it.",
+		"tray": "Hide to tray",
+		"quit": "Quit the app",
+		"cancel": "Cancel",
+		"remember": "Remember my choice"
+	},
+	"pluginDownload": {
+		"eyebrow": "Plugin download",
+		"title": "Download this file?",
+		"description": "{{pluginName}} wants to download a file into its own storage folder. The file is fetched from the URL below and stored only inside the plugin's folder.",
+		"urlLabel": "URL",
+		"destLabel": "Destination",
+		"sizeLabel": "Size",
+		"unknownSize": "unknown",
+		"deny": "Deny",
+		"allow": "Allow",
+		"remember": "Remember for this session (no more prompts from this plugin)"
+	},
+	"pagination": {
+		"region": "pagination",
+		"prev": "Prev",
+		"next": "Next",
+		"previous": "Previous",
+		"goTo": "Go to",
+		"jumpToPage": "Page",
+		"morePages": "More pages"
+	},
+	"aria": {
+		"loading": "Loading",
+		"closeToast": "Close toast",
+		"close": "Close",
+		"more": "More",
+		"toggleSidebar": "Toggle Sidebar",
+		"mobileSidebarDescription": "Displays the mobile sidebar.",
+		"sidebar": "Sidebar",
+		"breadcrumb": "breadcrumb"
+	},
+	"dialog": {
+		"cancel": "Cancel"
+	},
+	"confirmByTyping": {
+		"prompt": "Type \"<name>{{name}}</name>\" to confirm"
+	},
+	"colorPicker": {
+		"clear": "Clear color",
+		"addPreset": "Add to my presets",
+		"removePresetAria": "Remove preset {{color}}",
+		"customSwatch": "Pick a custom color"
+	},
+	"fontPicker": {
+		"inherit": "Inherit global font",
+		"inheritedHint": "Currently inheriting the global font setting",
+		"addCustom": "Add a font by name, press Enter…",
+		"selected": "Fallback order — drag to rearrange",
+		"description": "Chrome and lists — documents keep their reading voice."
+	},
+	"imageCrop": {
+		"saving": "Saving…",
+		"remove": "Remove",
+		"save": "Save",
+		"pickHint": "Click or drop",
+		"reselect": "Re-upload",
+		"previewLabel": "Preview",
+		"previewAlt": "Cropped preview",
+		"showPreview": "Show preview",
+		"saveFailed": "Save failed"
+	},
+	"panelToolbar": {
+		"add": "Add",
+		"unused": "Unused",
+		"reorder": "Reorder"
+	}
+}