@chipmobilesdk/rn-i18n 0.1.3 → 0.3.0

package/src/i18n.ts

@@ -1,3 +1,5 @@
+import { createReporter } from './config/diagnostics';
+import type { ResolvedInvalidFormatPolicy } from './format/invalid';
 import type {
 	ActiveLocalePreference,
 	I18nConfig,
@@ -12,7 +14,13 @@ import type {
 import { validateConfig } from './config/validateConfig';
 import { createActiveLocaleStore } from './locale/activeLocale';
 import { defaultDeviceLocaleProvider, matchSupportedLocale } from './locale/deviceLocale';
-import { readPersistedLocale, writePersistedLocale } from './locale/persistence';
+import {
+	clearPersistedLocale,
+	readPersistedLocale,
+	readPersistedLocaleSync,
+	writePersistedLocale,
+} from './locale/persistence';
+import { hasPluralRule } from './translation/plurals';
 import { translate } from './translation/resolver';
 import type { ResolverContext } from './translation/resolver';
 import { createRuntimeRegistry, registerRuntimeEntries } from './translation/runtimeKeys';
@@ -25,13 +33,34 @@ import type { UnitFormatOptions } from './format/units';
 export interface I18n<TKey extends string = string> {
 	/** Resolves the initial locale: persisted → device → primary fallback. */
 	init(): Promise<void>;
+	/**
+	 * `init()` without waiting, before the first render (PERF-08). Resolves the locale
+	 * and returns true when it can do so synchronously: persistence is off, or the
+	 * storage adapter has `getItemSync`. Returns false, changing nothing, when the
+	 * adapter can only read asynchronously; call `init()` then.
+	 */
+	initSync(): boolean;
 	t(key: TKey, vars?: TranslateVars, options?: TranslateOptions): string;
 	getLocale(): ActiveLocalePreference;
 	/** Switches at runtime without restart and persists best-effort. */
 	setLocale(code: string): Promise<void>;
+	/**
+	 * Forgets the stored choice and follows the device again — the "System
+	 * language" option a settings screen offers (I18N-17). Resolves to the
+	 * locale now active.
+	 */
+	useDeviceLocale(): Promise<ActiveLocalePreference>;
 	getSupportedLocales(): readonly LocaleConfig[];
 	formatNumber(value: number, options?: Intl.NumberFormatOptions): string;
-	formatDate(value: Date | number, options?: Intl.DateTimeFormatOptions): string;
+	/**
+	 * Options are merged over the locale's default (`{ month: 'long' }` keeps the
+	 * year and day). `replaceDefaults` uses only what is passed.
+	 */
+	formatDate(
+		value: Date | number,
+		options?: Intl.DateTimeFormatOptions,
+		formatting?: { replaceDefaults?: boolean },
+	): string;
 	formatCurrency(value: number, currency?: string, options?: Intl.NumberFormatOptions): string;
 	formatUnit(value: number, options?: UnitFormatOptions): string;
 	convertUnit(value: number, from: UnitId, to: UnitId): number;
@@ -55,15 +84,33 @@ export function createI18n<TKey extends string = string>(config: I18nConfig): I1
 	const locales: readonly LocaleConfig[] = [...config.locales];
 	const localesByCode = new Map(locales.map(locale => [locale.code, locale]));
 	const missingTranslation = config.missingTranslation ?? DEFAULT_MISSING;
-	const invalidFormat = config.invalidFormat ?? DEFAULT_INVALID;
+	const report = createReporter(config.onDiagnostic);
+	const invalidFormat: ResolvedInvalidFormatPolicy = {
+		...(config.invalidFormat ?? DEFAULT_INVALID),
+		report,
+	};
 	const persistenceEnabled = config.persistLocale !== false && !!config.storage;
 	const runtimeEntries = createRuntimeRegistry(config.runtimeEntries);
 
-	const store = createActiveLocaleStore({
-		code: config.primaryLocale,
-		source: 'primaryFallback',
-		recovered: false,
-	});
+	const store = createActiveLocaleStore(
+		{ code: config.primaryLocale, source: 'primaryFallback', recovered: false },
+		report,
+	);
+
+	// A language this package has no plural rule for falls back to
+	// `count === 1 ? one : other`, which is wrong for most of the world. Said
+	// once per locale, at creation, rather than never (I18N-12).
+	for (const locale of locales) {
+		if (!hasPluralRule(locale)) {
+			report({
+				code: 'plural_rule_default',
+				locale: locale.code,
+				message:
+					`No plural rule for "${locale.code}"; falling back to "count === 1 selects one". ` +
+					'Declare `pluralRule` on the locale if that is not how the language works.',
+			});
+		}
+	}
 
 	const resolverContext: ResolverContext = {
 		localesByCode,
@@ -71,6 +118,7 @@ export function createI18n<TKey extends string = string>(config: I18nConfig): I1
 		runtimeEntries,
 		missingTranslation,
 		warned: new Set(),
+		report,
 	};
 
 	const activeLocale = (): LocaleConfig => {
@@ -82,37 +130,75 @@ export function createI18n<TKey extends string = string>(config: I18nConfig): I1
 		return locale;
 	};
 
+	/** persisted → device → primary fallback; shared by `init` and `initSync`. */
+	const resolveInitialLocale = (persisted: string | null): void => {
+		if (persisted) {
+			if (localesByCode.has(persisted)) {
+				store.set({ code: persisted, source: 'persisted', recovered: false });
+				return;
+			}
+			report({
+				code: 'locale_unsupported',
+				locale: persisted,
+				message: `Persisted locale "${persisted}" is no longer supported; recovering to "${config.primaryLocale}".`,
+			});
+			store.set({ code: config.primaryLocale, source: 'primaryFallback', recovered: true });
+			return;
+		}
+		const provider = config.deviceLocale ?? defaultDeviceLocaleProvider;
+		const match = matchSupportedLocale(provider(), locales);
+		store.set(
+			match
+				? { code: match.code, source: match.source, recovered: false }
+				: { code: config.primaryLocale, source: 'primaryFallback', recovered: false },
+		);
+	};
+
+	/**
+	 * `init()` runs once, and loses to the user.
+	 *
+	 * It used to be re-run by every caller (StrictMode mounts an effect twice),
+	 * and the persisted value it had awaited was written in unconditionally — so
+	 * a locale the user picked, or a deep link set, while the read was in flight
+	 * was overwritten by the old one (I18N-07).
+	 */
+	let initialized: Promise<void> | undefined;
+	let switched = false;
+
+	const runInit = async (): Promise<void> => {
+		const persisted =
+			persistenceEnabled && config.storage
+				? await readPersistedLocale(config.storage, report)
+				: null;
+		if (switched) {
+			// The user chose while the read was in flight; their choice stands.
+			return;
+		}
+		resolveInitialLocale(persisted);
+	};
+
 	return {
-		async init() {
-			if (persistenceEnabled && config.storage) {
-				const persisted = await readPersistedLocale(config.storage);
-				if (persisted) {
-					if (localesByCode.has(persisted)) {
-						store.set({ code: persisted, source: 'persisted', recovered: false });
-						return;
-					}
-					console.warn(
-						`[rn-i18n] Persisted locale "${persisted}" is no longer supported; recovering to "${config.primaryLocale}".`,
-					);
-					store.set({
-						code: config.primaryLocale,
-						source: 'primaryFallback',
-						recovered: true,
-					});
-					return;
-				}
+		init() {
+			initialized ??= runInit();
+			return initialized;
+		},
+
+		initSync() {
+			if (!persistenceEnabled || !config.storage) {
+				resolveInitialLocale(null);
+				return true;
 			}
-			const provider = config.deviceLocale ?? defaultDeviceLocaleProvider;
-			const match = matchSupportedLocale(provider(), locales);
-			store.set(
-				match
-					? { code: match.code, source: match.source, recovered: false }
-					: {
-							code: config.primaryLocale,
-							source: 'primaryFallback',
-							recovered: false,
-						},
+			const { storage } = config;
+			if (typeof storage.getItemSync !== 'function') {
+				return false;
+			}
+			resolveInitialLocale(
+				readPersistedLocaleSync(
+					storage as typeof storage & { getItemSync(key: string): string | null },
+					report,
+				),
 			);
+			return true;
 		},
 
 		t(key, vars, options) {
@@ -127,12 +213,34 @@ export function createI18n<TKey extends string = string>(config: I18nConfig): I1
 			if (!localesByCode.has(code)) {
 				throw new Error(`[rn-i18n] Cannot switch to unsupported locale "${code}".`);
 			}
+			switched = true;
+			const current = store.get();
+			if (current.code === code && current.source === 'runtimeSwitch') {
+				// Already this locale, by this route: re-rendering the whole tree and
+				// rewriting storage would change nothing (I18N-07).
+				return;
+			}
 			store.set({ code, source: 'runtimeSwitch', recovered: false });
 			if (persistenceEnabled && config.storage) {
-				await writePersistedLocale(config.storage, code);
+				await writePersistedLocale(config.storage, code, report);
 			}
 		},
 
+		async useDeviceLocale() {
+			switched = true;
+			if (persistenceEnabled && config.storage) {
+				await clearPersistedLocale(config.storage, report);
+			}
+			const provider = config.deviceLocale ?? defaultDeviceLocaleProvider;
+			const match = matchSupportedLocale(provider(), locales);
+			store.set(
+				match
+					? { code: match.code, source: match.source, recovered: false }
+					: { code: config.primaryLocale, source: 'primaryFallback', recovered: false },
+			);
+			return store.get();
+		},
+
 		getSupportedLocales() {
 			return locales;
 		},
@@ -148,9 +256,16 @@ export function createI18n<TKey extends string = string>(config: I18nConfig): I1
 			);
 		},
 
-		formatDate(value, options) {
+		formatDate(value, options, formatting) {
 			const locale = activeLocale();
-			return formatDateValue(value, locale.code, locale.defaultDateFormat, options, invalidFormat);
+			return formatDateValue(
+				value,
+				locale.code,
+				locale.defaultDateFormat,
+				options,
+				invalidFormat,
+				formatting?.replaceDefaults === true,
+			);
 		},
 
 		formatCurrency(value, currency, options) {
@@ -183,6 +298,10 @@ export function createI18n<TKey extends string = string>(config: I18nConfig): I1
 
 		registerRuntimeEntries(entries) {
 			registerRuntimeEntries(runtimeEntries, entries);
+			// What `t()` answers has changed, so every subscriber has to read again:
+			// a feature that registered its entries after mounting used to leave the
+			// screen showing the key (I18N-06).
+			store.bump();
 		},
 
 		subscribe(listener) {

package/src/index.ts

@@ -11,6 +11,14 @@ export { createI18n } from './i18n';
 export type { I18n } from './i18n';
 
 export { I18nConfigError } from './config/types';
+export { runtimeEntriesFromCatalog } from './config/catalog';
+export { localeStorageFromKeyValue } from './locale/keyValueStorage';
+export type { I18nErrorCode } from './config/errors';
+export type {
+	I18nDiagnostic,
+	I18nDiagnosticCode,
+	I18nDiagnosticHandler,
+} from './config/diagnostics';
 export type {
 	ActiveLocalePreference,
 	DeviceLocaleProvider,

package/src/locale/activeLocale.ts

@@ -1,46 +1,52 @@
+import { createListenerSet } from '@chipmobilesdk/rn-core';
+
+import { defaultReporter, describeError, type I18nDiagnosticHandler } from '../config/diagnostics';
 import type { ActiveLocalePreference } from '../config/types';
 
 export interface ActiveLocaleStore {
 	get(): ActiveLocalePreference;
 	set(preference: ActiveLocalePreference): void;
 	subscribe(listener: () => void): () => void;
+	/**
+	 * Notifies subscribers without changing the locale: what reaches the screen
+	 * changed, not which language it is in (a runtime entry registered by a
+	 * lazily loaded feature, say).
+	 */
+	bump(): void;
 	/** Monotonic change counter consumed by useSyncExternalStore. */
 	getVersion(): number;
 }
 
-export function createActiveLocaleStore(initial: ActiveLocalePreference): ActiveLocaleStore {
+export function createActiveLocaleStore(
+	initial: ActiveLocalePreference,
+	report: I18nDiagnosticHandler = defaultReporter,
+): ActiveLocaleStore {
 	let preference = initial;
 	let version = 0;
-	const listeners = new Set<() => void>();
+	const listeners = createListenerSet<[]>({
+		onListenerError: error =>
+			report({
+				code: 'listener_threw',
+				message: `A locale listener threw; the locale change still applied: ${describeError(error)}`,
+			}),
+	});
 
 	return {
 		get: () => preference,
 		set(next) {
 			preference = next;
 			version += 1;
-			// Snapshot, and isolate each listener (CORE-03). One that threw used to
-			// skip every listener after it — useSyncExternalStore subscribers
-			// included — and made setLocale reject after the switch but before the
-			// choice was persisted, so the app showed one locale and stored another.
-			for (const listener of [...listeners]) {
-				// Unsubscribed by an earlier listener during this notification.
-				if (!listeners.has(listener)) continue;
-				try {
-					listener();
-				} catch (error) {
-					console.warn(
-						'[rn-i18n] A locale listener threw; the locale change still applied.',
-						error,
-					);
-				}
-			}
+			// Isolated (CORE-03). One that threw used to skip every listener after
+			// it — useSyncExternalStore subscribers included — and made setLocale
+			// reject after the switch but before the choice was persisted, so the
+			// app showed one locale and stored another.
+			listeners.notify();
 		},
-		subscribe(listener) {
-			listeners.add(listener);
-			return () => {
-				listeners.delete(listener);
-			};
+		bump() {
+			version += 1;
+			listeners.notify();
 		},
+		subscribe: listener => listeners.add(listener),
 		getVersion: () => version,
 	};
 }

package/src/locale/keyValueStorage.ts

@@ -0,0 +1,27 @@
+/**
+ * A `LocaleStorageAdapter` over rn-core's synchronous `KeyValuePort` (PERF-08).
+ *
+ * The adapter carries `getItemSync`, so `i18n.initSync()` resolves the persisted
+ * locale before the first render. Open the port the way the app opens its other
+ * durable state, for example `openDurable(() => createMMKV({ id: 'app' }))`.
+ */
+import type { KeyValuePort } from '@chipmobilesdk/rn-core';
+
+import type { LocaleStorageAdapter } from '../config/types';
+
+export function localeStorageFromKeyValue(
+	port: KeyValuePort,
+): LocaleStorageAdapter & { getItemSync(key: string): string | null } {
+	return {
+		getItemSync: key => port.getString(key) ?? null,
+		async getItem(key) {
+			return port.getString(key) ?? null;
+		},
+		async setItem(key, value) {
+			port.set(key, value);
+		},
+		async removeItem(key) {
+			port.remove(key);
+		},
+	};
+}

package/src/locale/persistence.ts

@@ -1,3 +1,4 @@
+import { defaultReporter, describeError, type I18nDiagnosticHandler } from '../config/diagnostics';
 import type { LocaleStorageAdapter } from '../config/types';
 
 export const LOCALE_STORAGE_KEY = '@chipmobilesdk/rn-i18n:locale';
@@ -6,11 +7,33 @@ export const LOCALE_STORAGE_KEY = '@chipmobilesdk/rn-i18n:locale';
  * Reads the persisted locale preference. Adapter failures are reported and
  * treated as "no persisted value" so locale selection never crashes (FR-015).
  */
-export async function readPersistedLocale(storage: LocaleStorageAdapter): Promise<string | null> {
+export async function readPersistedLocale(
+	storage: LocaleStorageAdapter,
+	report: I18nDiagnosticHandler = defaultReporter,
+): Promise<string | null> {
 	try {
 		return await storage.getItem(LOCALE_STORAGE_KEY);
 	} catch (error) {
-		console.warn(`[rn-i18n] Failed to read the persisted locale preference: ${String(error)}`);
+		report({
+			code: 'locale_read_failed',
+			message: `Failed to read the persisted locale preference: ${describeError(error)}`,
+		});
+		return null;
+	}
+}
+
+/** `readPersistedLocale` for a store with a synchronous read; same failure handling. */
+export function readPersistedLocaleSync(
+	storage: LocaleStorageAdapter & { getItemSync(key: string): string | null },
+	report: I18nDiagnosticHandler = defaultReporter,
+): string | null {
+	try {
+		return storage.getItemSync(LOCALE_STORAGE_KEY);
+	} catch (error) {
+		report({
+			code: 'locale_read_failed',
+			message: `Failed to read the persisted locale preference: ${describeError(error)}`,
+		});
 		return null;
 	}
 }
@@ -22,10 +45,34 @@ export async function readPersistedLocale(storage: LocaleStorageAdapter): Promis
 export async function writePersistedLocale(
 	storage: LocaleStorageAdapter,
 	code: string,
+	report: I18nDiagnosticHandler = defaultReporter,
 ): Promise<void> {
 	try {
 		await storage.setItem(LOCALE_STORAGE_KEY, code);
 	} catch (error) {
-		console.warn(`[rn-i18n] Failed to persist locale "${code}": ${String(error)}`);
+		report({
+			code: 'locale_write_failed',
+			locale: code,
+			message: `Failed to persist locale "${code}": ${describeError(error)}`,
+		});
+	}
+}
+
+/**
+ * Forgets the stored choice, so the next launch follows the device again. The
+ * adapter's `removeItem` was required by the contract and called by nothing
+ * until `useDeviceLocale()` (I18N-17). Best-effort, like the write.
+ */
+export async function clearPersistedLocale(
+	storage: LocaleStorageAdapter,
+	report: I18nDiagnosticHandler = defaultReporter,
+): Promise<void> {
+	try {
+		await storage.removeItem(LOCALE_STORAGE_KEY);
+	} catch (error) {
+		report({
+			code: 'locale_write_failed',
+			message: `Failed to forget the persisted locale preference: ${describeError(error)}`,
+		});
 	}
 }

package/src/react/hooks.ts

@@ -1,4 +1,4 @@
-import { useSyncExternalStore } from 'react';
+import { useCallback, useMemo, useSyncExternalStore } from 'react';
 import type {
 	ActiveLocalePreference,
 	LocaleConfig,
@@ -9,8 +9,8 @@ import type {
 import type { I18n } from '../i18n';
 import { useI18nContext } from './I18nProvider';
 
-function useLocaleVersion(i18n: I18n<string>): void {
-	useSyncExternalStore(i18n.subscribe, i18n.getVersion, i18n.getVersion);
+function useLocaleVersion(i18n: I18n<string>): number {
+	return useSyncExternalStore(i18n.subscribe, i18n.getVersion, i18n.getVersion);
 }
 
 export interface UseTranslationResult<TKey extends string> {
@@ -25,11 +25,19 @@ export interface UseTranslationResult<TKey extends string> {
  */
 export function useTranslation<TKey extends string = string>(): UseTranslationResult<TKey> {
 	const i18n = useI18nContext();
-	useLocaleVersion(i18n);
-	return {
-		t: (key, vars, options) => i18n.t(key, vars, options),
-		locale: i18n.getLocale().code,
-	};
+	const version = useLocaleVersion(i18n);
+	// One `t` and one result per locale version (I18N-05): a memoized child that
+	// takes `t` re-renders when the locale changes, not on every parent render.
+	return useMemo(
+		() => ({
+			t: (key: TKey, vars?: TranslateVars, options?: TranslateOptions) =>
+				i18n.t(key, vars, options),
+			locale: i18n.getLocale().code,
+		}),
+		// `version` is the dependency that matters: it changes with the locale.
+		// eslint-disable-next-line react-hooks/exhaustive-deps -- `version` is read to invalidate, not used
+		[i18n, version],
+	);
 }
 
 export interface UseLocaleResult {
@@ -44,6 +52,7 @@ export interface UseLocaleResult {
 export function useLocale(): UseLocaleResult {
 	const i18n = useI18nContext();
 	useLocaleVersion(i18n);
+	const setLocale = useCallback((code: string) => i18n.setLocale(code), [i18n]);
 	const preference = i18n.getLocale();
 	const supportedLocales = i18n.getSupportedLocales();
 	const active = supportedLocales.find(locale => locale.code === preference.code);
@@ -52,6 +61,6 @@ export function useLocale(): UseLocaleResult {
 		direction: active?.direction ?? 'ltr',
 		preference,
 		supportedLocales,
-		setLocale: code => i18n.setLocale(code),
+		setLocale,
 	};
 }

package/src/tooling/generateKeys.ts

@@ -17,8 +17,11 @@ export function renderKeysModule(
 		.map(entry => entry.key)
 		.sort((a, b) => a.localeCompare(b, 'en'));
 
+	// Escaped, not interpolated: a key holding an apostrophe or a backslash wrote
+	// a file that did not parse, and `tsc` then failed for the whole app (I18N-20).
+	const literal = (key: string) => `'${key.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
 	const renderList = (keys: readonly string[]) =>
-		keys.length === 0 ? '[]' : `[\n${keys.map(key => `\t'${key}',`).join('\n')}\n]`;
+		keys.length === 0 ? '[]' : `[\n${keys.map(key => `\t${literal(key)},`).join('\n')}\n]`;
 
 	return [
 		'// AUTO-GENERATED by @chipmobilesdk/rn-i18n tooling. Do not edit by hand.',

package/src/translation/plurals.ts

@@ -11,22 +11,91 @@ export const PLURAL_CATEGORIES: readonly PluralCategory[] = [
 
 const oneOtherRule: PluralRule = count => (count === 1 ? 'one' : 'other');
 const otherOnlyRule: PluralRule = () => 'other';
+/** French and Brazilian Portuguese: 0 and 1 are both singular. */
+const zeroOneRule: PluralRule = count => (count === 0 || count === 1 ? 'one' : 'other');
+
+/** Russian, Ukrainian, Polish, Czech and their neighbours (CLDR). */
+const slavicRule: PluralRule = count => {
+	if (!Number.isInteger(count)) {
+		return 'many';
+	}
+	const mod10 = Math.abs(count) % 10;
+	const mod100 = Math.abs(count) % 100;
+	if (mod10 === 1 && mod100 !== 11) {
+		return 'one';
+	}
+	if (mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14)) {
+		return 'few';
+	}
+	return 'many';
+};
+
+/** Arabic (CLDR), which uses every category. */
+const arabicRule: PluralRule = count => {
+	if (count === 0) return 'zero';
+	if (count === 1) return 'one';
+	if (count === 2) return 'two';
+	const mod100 = Math.abs(count) % 100;
+	if (mod100 >= 3 && mod100 <= 10) return 'few';
+	if (mod100 >= 11 && mod100 <= 99) return 'many';
+	return 'other';
+};
 
 /**
- * Package-owned plural rules. Intl.PluralRules is not implemented by Hermes,
- * so rules are resolved from configuration to keep behavior identical across
- * devices and test environments. Languages without a built-in rule use the
- * documented default (`count === 1` selects `one`, everything else `other`)
- * unless the locale configuration supplies a custom rule.
+ * Package-owned plural rules, a compact subset of CLDR. Intl.PluralRules is not
+ * implemented by Hermes, so rules are resolved from configuration to keep
+ * behavior identical across devices and test environments.
+ *
+ * A language that is not here falls back to `count === 1 ? one : other`, which
+ * is wrong for most of the world — Korean and Thai have no singular, French
+ * calls 0 singular, Russian has `few` and `many` — so the fallback now reports
+ * a diagnostic once per locale rather than being silently applied (I18N-12).
  */
 const BUILT_IN_RULES: Record<string, PluralRule> = {
+	// one/other
 	en: oneOtherRule,
+	de: oneOtherRule,
+	es: oneOtherRule,
+	it: oneOtherRule,
+	nl: oneOtherRule,
+	sv: oneOtherRule,
+	da: oneOtherRule,
+	nb: oneOtherRule,
+	fi: oneOtherRule,
+	el: oneOtherRule,
+	he: oneOtherRule,
+	// other only
 	ja: otherOnlyRule,
 	vi: otherOnlyRule,
+	ko: otherOnlyRule,
+	zh: otherOnlyRule,
+	th: otherOnlyRule,
+	id: otherOnlyRule,
+	ms: otherOnlyRule,
+	// 0 and 1 are singular
+	fr: zeroOneRule,
+	pt: zeroOneRule,
+	// Slavic
+	ru: slavicRule,
+	uk: slavicRule,
+	pl: slavicRule,
+	cs: slavicRule,
+	sk: slavicRule,
+	// Every category
+	ar: arabicRule,
 };
 
 export const DEFAULT_PLURAL_RULE: PluralRule = oneOtherRule;
 
+/** True when this package has a rule for the language, or the locale brought one. */
+export function hasPluralRule(locale: LocaleConfig): boolean {
+	if (locale.pluralRule) {
+		return true;
+	}
+	const language = locale.code.split('-')[0]?.toLowerCase() ?? '';
+	return language in BUILT_IN_RULES;
+}
+
 export function resolvePluralRule(locale: LocaleConfig): PluralRule {
 	if (locale.pluralRule) {
 		return locale.pluralRule;