@x18n/builtins 0.0.2 → 0.0.5

package/dist/presets-DNnE_2MQ.mjs

@@ -0,0 +1,1124 @@
+import { defaultTemplates } from "./extractors.mjs";
+import { n as sfcFluentBlocks, t as sfcBlocks } from "./sfc-blocks-BwJwCUka.mjs";
+import { braces, colon, dollars, doubleBraces, fluent, icu, linked, nesting, percentBraces, placeholders, printf } from "./placeholders.mjs";
+import { r as regexScopes } from "./regex-B9TBGgXC.mjs";
+import { isMessageLeaf } from "@x18n/core";
+//#region src/presets/shared.ts
+/** One plugin holding a library's call specs, regexes, namespace rules, defaults and extraction templates. */
+function library(options) {
+	return {
+		name: `x18n:${options.name}`,
+		async config(draft, ctx) {
+			if (options.namespace) draft.namespace = {
+				separator: options.namespace.separator ?? draft.namespace.separator,
+				default: draft.namespace.default ?? options.namespace.default,
+				fromPath: options.namespace.fromPath ?? draft.namespace.fromPath
+			};
+			if (options.resources) draft.resources = [...draft.resources, ...options.resources.filter((spec) => !draft.resources.some((r) => r.pattern === spec.pattern))];
+			if (options.keyStyle && draft.keyStyle === "auto" && !ctx.user.keyStyle) draft.keyStyle = options.keyStyle;
+			draft.usage = {
+				...draft.usage,
+				calls: [...draft.usage.calls, ...options.calls ?? []],
+				regex: [...draft.usage.regex, ...options.regex ?? []],
+				derivedKeys: [...draft.usage.derivedKeys, ...options.derivedKeys ?? []]
+			};
+			await options.extra?.(draft, ctx);
+		},
+		localeFinders: options.finders,
+		normalizeKey: options.normalizeKey,
+		transformResource: options.transformResource,
+		translatePrompt: options.translatePrompt,
+		extractors: options.templates ? [{
+			id: options.name,
+			templates: options.templates
+		}] : void 0
+	};
+}
+function dependsOn(names, prefixes = []) {
+	return (ctx) => ctx.hasAnyDependency(names) || [...ctx.dependencies].some((dep) => prefixes.some((prefix) => dep.startsWith(prefix)));
+}
+/** Extensions of JS and TS sources. */
+const scriptExtensions = [
+	"js",
+	"jsx",
+	"mjs",
+	"cjs",
+	"ts",
+	"tsx",
+	"mts",
+	"cts"
+];
+//#endregion
+//#region src/presets/angular.ts
+const templates = [
+	"html",
+	"ts",
+	"js"
+];
+function ngxTranslate() {
+	return {
+		name: "ngx-translate",
+		detect: dependsOn(["@ngx-translate/core"]),
+		plugins: [library({
+			name: "ngx-translate",
+			calls: [{ callee: [
+				"translate.instant",
+				"translate.get",
+				"translate.stream",
+				"translateService.instant",
+				"translateService.get",
+				"translateService.stream",
+				"_"
+			] }],
+			regex: [{
+				extensions: templates,
+				patterns: [
+					"[`'\"]({key})[`'\"][\\s\\n]*\\|[\\s\\n]*translate\\b",
+					"[\\s\\n]translate>[\\s\\n]*({key})[\\s\\n]*</",
+					"\\[translate\\]=[\"']'({key})'[\"']",
+					"\\stranslate=[\"']({key})[\"']"
+				]
+			}],
+			resources: [{ pattern: "src/assets/i18n/{locale}.json" }, { pattern: "src/assets/i18n/{locale}/{namespaces}.json" }],
+			templates: [{
+				template: "{{ '{key}' | translate }}",
+				kinds: ["html-text"]
+			}, {
+				template: "this.translate.instant('{key}'{args})",
+				kinds: ["js-string", "js-template"]
+			}]
+		}), placeholders(doubleBraces)]
+	};
+}
+function transloco() {
+	return {
+		name: "transloco",
+		detect: dependsOn(["@jsverse/transloco", "@ngneat/transloco"]),
+		plugins: [
+			library({
+				name: "transloco",
+				namespace: { fromPath: "camel" },
+				calls: [{ callee: [
+					"translate",
+					"translocoService.translate",
+					"transloco.translate",
+					"translocoService.selectTranslate",
+					"transloco.selectTranslate"
+				] }],
+				regex: [{
+					extensions: templates,
+					patterns: [
+						"[`'\"]({key})[`'\"][\\s\\n]*\\|[\\s\\n]*transloco\\b",
+						"[^\\w\\d]t\\([\\s\\n]*['\"`]({key})['\"`]",
+						"[^*\\w\\d]transloco=['\"`]({key})['\"`]"
+					]
+				}],
+				resources: [{ pattern: "src/assets/i18n/{locale}.json" }, { pattern: "src/assets/i18n/{namespaces}/{locale}.json" }],
+				templates: [{
+					template: "{{ '{key}' | transloco }}",
+					kinds: ["html-text"]
+				}, {
+					template: "translate('{key}'{args})",
+					kinds: ["js-string", "js-template"],
+					imports: ["import { translate } from '@jsverse/transloco'"]
+				}]
+			}),
+			regexScopes("\\*transloco=\"[^\"]*read:\\s*'([^']+)'", "transloco-read", {
+				as: "keyPrefix",
+				extensions: ["html"]
+			}),
+			placeholders(doubleBraces)
+		]
+	};
+}
+//#endregion
+//#region src/presets/nls.ts
+const nlsFile = /^(?:(.*)\/)?package\.nls(?:\.([\w-]+))?\.json$/;
+const bundleFile = /^(?:(.*)\/)?bundle\.l10n(?:\.([\w-]+))?\.json$/;
+/** VS Code extension strings: `package.nls[.locale].json` and `l10n/bundle.l10n[.locale].json`. */
+const nlsFinder = {
+	id: "nls",
+	async find(ctx) {
+		const paths = await ctx.host.glob(["**/package.nls*.json", "**/bundle.l10n*.json"], {
+			ignore: ["**/node_modules/**"],
+			gitignore: true
+		});
+		const out = [];
+		for (const path of paths) {
+			const nls = nlsFile.exec(path);
+			const bundle = nls ? void 0 : bundleFile.exec(path);
+			const match = nls ?? bundle;
+			if (!match) continue;
+			out.push({
+				path,
+				locale: match[2] ?? ctx.config.sourceLocale,
+				namespace: void 0,
+				format: "json"
+			});
+		}
+		return out;
+	}
+};
+//#endregion
+//#region src/presets/js.ts
+const vueI18nCalls = [{ callee: [
+	"$t",
+	"t",
+	"tc",
+	"$tc",
+	"te",
+	"$te",
+	"tm",
+	"$tm",
+	"i18n.t",
+	"i18n.global.t",
+	"$i18n.t",
+	"i18n.tc",
+	"i18n.te"
+] }, {
+	callee: "useI18n",
+	factory: true,
+	returns: [
+		"t",
+		"tc",
+		"te",
+		"tm"
+	]
+}];
+function vueI18n() {
+	return {
+		name: "vue-i18n",
+		detect: dependsOn([
+			"vue-i18n",
+			"vuex-i18n",
+			"petite-vue-i18n",
+			"vue-i18n-bridge"
+		], ["@intlify/"]),
+		plugins: [
+			library({
+				name: "vue-i18n",
+				calls: vueI18nCalls,
+				templates: [
+					{
+						template: "{{ $t('{key}'{args}) }}",
+						kinds: ["vue-template-text"]
+					},
+					{
+						template: ":{attr}=\"$t('{key}'{args})\"",
+						kinds: ["vue-attribute"]
+					},
+					{
+						template: "t('{key}'{args})",
+						kinds: ["js-string", "js-template"],
+						files: ["**/*.vue"],
+						imports: ["import { useI18n } from 'vue-i18n'", "const { t } = useI18n()"]
+					}
+				]
+			}),
+			placeholders({
+				...braces,
+				implicit: ["n", "count"]
+			}, linked),
+			sfcBlocks()
+		]
+	};
+}
+function nuxtI18n() {
+	return {
+		name: "nuxt-i18n",
+		detect: dependsOn(["@nuxtjs/i18n", "nuxt-i18n"]),
+		plugins: [...vueI18n().plugins, {
+			name: "x18n:nuxt-i18n",
+			async config(draft, ctx) {
+				const nuxtConfig = await ctx.host.readFile("nuxt.config.ts") ?? await ctx.host.readFile("nuxt.config.js");
+				const langDir = nuxtConfig ? /langDir:\s*['"]([^'"]+)['"]/.exec(nuxtConfig)?.[1]?.replace(/^\.\/|\/$/g, "") : void 0;
+				const dirs = langDir ? [`i18n/${langDir}`, langDir] : [
+					"i18n/locales",
+					"locales",
+					"lang"
+				];
+				draft.resources = [...draft.resources, ...dirs.map((dir) => ({ pattern: `${dir}/{locale}.{ext}` }))];
+			}
+		}]
+	};
+}
+/** `defaultNS` from the i18next init code (`i18n.ts`, `next-i18next.config.js`), as keys without a namespace use it. */
+async function findDefaultNamespace(host) {
+	const files = await host.glob(["**/*i18n*.{js,mjs,cjs,ts,mts,cts}", "**/i18n/index.{js,ts}"], {
+		ignore: ["**/node_modules/**", "**/dist/**"],
+		gitignore: true
+	});
+	for (const file of files.slice(0, 20)) {
+		const found = /\bdefaultNS\s*:\s*['"`]([^'"`]+)['"`]/.exec(await host.readFile(file) ?? "");
+		if (found) return found[1];
+	}
+}
+const i18nextPlugin = library({
+	name: "i18next",
+	namespace: {
+		separator: ":",
+		default: "translation",
+		fromPath: "slash"
+	},
+	extra: async (draft, ctx) => {
+		const found = ctx.user.namespace?.default ? void 0 : await findDefaultNamespace(ctx.host);
+		if (found) draft.namespace = {
+			...draft.namespace,
+			default: found
+		};
+	},
+	calls: [
+		{
+			callee: [
+				"t",
+				"i18next.t",
+				"i18n.t"
+			],
+			namespace: {
+				arg: 1,
+				property: "ns"
+			}
+		},
+		{
+			callee: [
+				"getFixedT",
+				"i18next.getFixedT",
+				"i18n.getFixedT"
+			],
+			factory: true,
+			returns: ["t"],
+			namespace: { arg: 1 },
+			keyPrefix: { arg: 2 }
+		},
+		{
+			callee: "tr",
+			types: ["TFunction"]
+		}
+	],
+	derivedKeys: ["{key}_*"],
+	translatePrompt: (draft, ctx) => {
+		draft.notes.push(`i18next plural keys end in _${ctx.localeInfo.pluralCategories.join(", _")} for ${ctx.targetLocale}; write one key per category.`);
+	},
+	templates: [{
+		template: "i18next.t('{key}'{args})",
+		kinds: ["js-string", "js-template"],
+		imports: ["import i18next from 'i18next'"]
+	}]
+});
+function i18next() {
+	return {
+		name: "i18next",
+		detect: dependsOn(["i18next"]),
+		plugins: [i18nextPlugin, placeholders(doubleBraces, nesting)]
+	};
+}
+function reactI18next() {
+	return {
+		name: "react-i18next",
+		detect: dependsOn(["react-i18next", "next-i18next"]),
+		plugins: [
+			i18nextPlugin,
+			placeholders(doubleBraces, nesting),
+			library({
+				name: "react-i18next",
+				calls: [
+					{
+						callee: "useTranslation",
+						factory: true,
+						returns: ["t"],
+						namespace: { arg: 0 },
+						keyPrefix: {
+							arg: 1,
+							property: "keyPrefix"
+						}
+					},
+					{
+						callee: "Trans",
+						key: {
+							arg: 0,
+							property: "i18nKey"
+						},
+						namespace: {
+							arg: 0,
+							property: "ns"
+						}
+					},
+					{
+						callee: "Translation",
+						factory: true,
+						returns: ["t"],
+						namespace: {
+							arg: 0,
+							property: "ns"
+						}
+					}
+				],
+				templates: [{
+					template: "<Trans i18nKey=\"{key}\" />",
+					kinds: ["jsx-text"],
+					imports: ["import { Trans } from 'react-i18next'"]
+				}, {
+					template: "{attr}={i18next.t('{key}'{args})}",
+					kinds: ["jsx-attribute"],
+					imports: ["import i18next from 'i18next'"]
+				}]
+			}),
+			regexScopes("\\bwithTranslation\\(\\s*\\[?\\s*['\"`]([^'\"`]+)['\"`]", "react-i18next-hoc", {
+				wholeFile: true,
+				extensions: scriptExtensions
+			})
+		]
+	};
+}
+function nextIntl() {
+	return {
+		name: "next-intl",
+		detect: dependsOn(["next-intl", "use-intl"]),
+		plugins: [library({
+			name: "next-intl",
+			calls: [{
+				callee: ["useTranslations", "getTranslations"],
+				factory: true,
+				returns: [
+					"t",
+					"t.rich",
+					"t.markup",
+					"t.raw",
+					"t.has"
+				],
+				keyPrefix: { arg: 0 }
+			}, {
+				callee: "getTranslations",
+				factory: true,
+				returns: [
+					"t",
+					"t.rich",
+					"t.markup",
+					"t.raw",
+					"t.has"
+				],
+				keyPrefix: {
+					arg: 0,
+					property: "namespace"
+				}
+			}],
+			resources: [{ pattern: "messages/{locale}.json" }, { pattern: "src/messages/{locale}.json" }],
+			templates: [
+				{
+					template: "{t('{key}'{args})}",
+					kinds: ["jsx-text"]
+				},
+				{
+					template: "{attr}={t('{key}'{args})}",
+					kinds: ["jsx-attribute"]
+				},
+				{
+					template: "t('{key}'{args})",
+					kinds: ["js-string", "js-template"]
+				}
+			]
+		}), placeholders(icu)]
+	};
+}
+function reactIntl() {
+	return {
+		name: "react-intl",
+		detect: dependsOn(["react-intl"], ["@formatjs/"]),
+		plugins: [library({
+			name: "react-intl",
+			calls: [{
+				callee: [
+					"intl.formatMessage",
+					"formatMessage",
+					"defineMessage",
+					"FormattedMessage"
+				],
+				key: {
+					arg: 0,
+					property: "id"
+				}
+			}, {
+				callee: "defineMessages",
+				key: {
+					arg: 0,
+					property: "*.id"
+				}
+			}],
+			templates: [
+				{
+					template: "<FormattedMessage id=\"{key}\" />",
+					kinds: ["jsx-text"],
+					imports: ["import { FormattedMessage } from 'react-intl'"]
+				},
+				{
+					template: "{attr}={intl.formatMessage({ id: '{key}' }{args})}",
+					kinds: ["jsx-attribute"]
+				},
+				{
+					template: "intl.formatMessage({ id: '{key}' }{args})",
+					kinds: ["js-string", "js-template"]
+				}
+			]
+		}), placeholders(icu)]
+	};
+}
+function svelteI18n() {
+	return {
+		name: "svelte-i18n",
+		detect: dependsOn([
+			"svelte-i18n",
+			"sveltekit-i18n",
+			"@sveltekit-i18n/base"
+		]),
+		plugins: [library({
+			name: "svelte-i18n",
+			calls: [{ callee: [
+				"$_",
+				"$t",
+				"$format",
+				"_",
+				"t",
+				"format",
+				"$json",
+				"json"
+			] }],
+			templates: [{
+				template: "{$_('{key}'{args})}",
+				kinds: ["svelte-text"],
+				imports: ["import { _ } from 'svelte-i18n'"]
+			}, {
+				template: "{attr}={$_('{key}'{args})}",
+				kinds: ["svelte-attribute"],
+				imports: ["import { _ } from 'svelte-i18n'"]
+			}]
+		}), placeholders(icu)]
+	};
+}
+function vscodeExtension() {
+	return {
+		name: "vscode-extension",
+		detect: (ctx) => ctx.hasAnyDependency(["vscode", "@types/vscode"]),
+		plugins: [library({
+			name: "vscode-extension",
+			calls: [{ callee: ["l10n.t", "vscode.l10n.t"] }],
+			finders: [nlsFinder],
+			extra: (draft) => {
+				draft.usage = {
+					...draft.usage,
+					regex: [...draft.usage.regex, {
+						extensions: ["json"],
+						patterns: ["\"%({key})%\""]
+					}]
+				};
+			}
+		}), placeholders(braces)]
+	};
+}
+/** Always last: hard-string extraction templates for plain JS, TS and HTML. */
+function general() {
+	return {
+		name: "general",
+		detect: () => true,
+		plugins: [{
+			name: "x18n:general",
+			extractors: [{
+				id: "general",
+				templates: defaultTemplates
+			}]
+		}]
+	};
+}
+//#endregion
+//#region src/presets/mobile.ts
+/** Flutter with `flutter_i18n`: JSON or YAML assets, `FlutterI18n.translate(context, 'key')`. */
+function flutter() {
+	return {
+		name: "flutter",
+		detect: dependsOn(["flutter_i18n"]),
+		plugins: [library({
+			name: "flutter",
+			regex: [{
+				extensions: ["dart"],
+				patterns: ["[^\\w\\d]FlutterI18n\\.(?:plural|translate)\\(\\s*[\\w\\d.]+,\\s*['\"`]({key})['\"`]", "[^\\w\\d]I18n(?:Plural|Text)\\(\\s*['\"`]({key})['\"`]"]
+			}],
+			resources: [{ pattern: "assets/flutter_i18n/{locale}.{ext}" }, { pattern: "assets/i18n/{locale}.{ext}" }],
+			templates: [{ template: "FlutterI18n.translate(context, '{key}')" }]
+		}), placeholders(braces)]
+	};
+}
+//#endregion
+//#region src/presets/server.ts
+/** Laravel: `lang/{locale}/{file}.php` arrays and `lang/{locale}.json`; keys are `file.key`. Exclusive like i18n-ally. */
+function laravel() {
+	return {
+		name: "laravel",
+		detect: dependsOn(["laravel/framework"]),
+		exclusive: true,
+		plugins: [library({
+			name: "laravel",
+			regex: [{
+				extensions: ["php"],
+				patterns: ["[^\\w\\d](?:__|trans|@lang|trans_choice|Lang::get|Lang::choice)\\(\\s*'([^']+)'", "[^\\w\\d](?:__|trans|@lang|trans_choice|Lang::get|Lang::choice)\\(\\s*\"([^\"]+)\""]
+			}],
+			resources: [
+				{ pattern: "lang/{locale}/{namespaces}.php" },
+				{ pattern: "resources/lang/{locale}/{namespaces}.php" },
+				{ pattern: "lang/{locale}.json" },
+				{ pattern: "resources/lang/{locale}.json" }
+			],
+			normalizeKey: (raw) => raw.includes("/") ? raw.replace(/\//g, ".") : void 0,
+			templates: [{ template: "__('{key}')" }]
+		}), placeholders(colon)]
+	};
+}
+/** Joomla: INI language files, `Text::_('KEY')`. */
+function phpJoomla() {
+	return {
+		name: "php-joomla",
+		detect: dependsOn(["joomla/application", "joomla/cms"]),
+		plugins: [library({
+			name: "php-joomla",
+			regex: [{
+				extensions: ["php"],
+				patterns: ["J?Text::(?:_|[\\w]+)\\(\\s*['\"]({key})['\"]"]
+			}],
+			resources: [{ pattern: "language/{locale}/*.ini" }, { pattern: "administrator/language/{locale}/*.ini" }],
+			keyStyle: "flat",
+			templates: [{ template: "Text::_('{key}')" }]
+		}), placeholders(printf)]
+	};
+}
+/** PHP gettext with `.po` files. Exclusive and never detected, as in i18n-ally: list it in `presets`. */
+function phpGettext() {
+	return {
+		name: "php-gettext",
+		exclusive: true,
+		plugins: [library({
+			name: "php-gettext",
+			regex: [{
+				extensions: ["php"],
+				patterns: ["[^\\w\\d](?:gettext|_|__)\\(\\s*['\"`]({key})['\"`]"]
+			}],
+			resources: [{ pattern: "locale/{locale}/LC_MESSAGES/*.po" }, { pattern: "locales/{locale}.po" }],
+			extra: (draft) => {
+				draft.extract = {
+					keygen: "source",
+					...draft.extract
+				};
+			},
+			templates: [{ template: "gettext('{key}')" }]
+		}), placeholders(printf)]
+	};
+}
+const viewSuffix = /(?:\.html)?\.(?:erb|haml|slim)$/;
+/** `t('.title')` in `app/views/users/index.html.erb` means `users.index.title`. */
+function railsLazyKey(raw, path) {
+	if (!raw.startsWith(".")) return void 0;
+	const match = /(?:^|\/)app\/views\/(.+)$/.exec(path);
+	if (!match) return void 0;
+	return `${match[1].replace(viewSuffix, "").split("/").map((segment) => segment.replace(/^_/, "")).join(".")}${raw}`;
+}
+function rubyRails() {
+	return {
+		name: "ruby-rails",
+		detect: dependsOn([
+			"rails",
+			"rails-i18n",
+			"railties"
+		]),
+		plugins: [library({
+			name: "ruby-rails",
+			regex: [{
+				extensions: [
+					"rb",
+					"erb",
+					"haml",
+					"slim"
+				],
+				patterns: [
+					"[^\\w\\d]t(?:\\(| )\\s*['\"`]({key})['\"`]",
+					"[^\\w\\d]t\\(:({key})\\)",
+					"I18n\\.t\\(\\s*['\"`]({key})['\"`]"
+				]
+			}],
+			resources: [
+				{ pattern: "config/locales/{locale}.yml" },
+				{ pattern: "config/locales/**/*.{locale}.yml" },
+				{ pattern: "config/locales/{locale}/**/*.yml" }
+			],
+			normalizeKey: (raw, ctx) => railsLazyKey(raw, ctx.path),
+			transformResource: {
+				applies: (ctx) => /\.ya?ml$/.test(ctx.path),
+				read(tree, ctx) {
+					const root = tree[ctx.locale];
+					return root !== void 0 && !isMessageLeaf(root) ? root : {};
+				},
+				toStored: (path, ctx) => [ctx.locale, ...path]
+			},
+			templates: [{ template: "t('{key}')" }]
+		}), placeholders(percentBraces)]
+	};
+}
+function jekyll() {
+	return {
+		name: "jekyll",
+		detect: dependsOn(["jekyll-multiple-languages-plugin"]),
+		plugins: [library({
+			name: "jekyll",
+			regex: [{
+				extensions: [
+					"html",
+					"md",
+					"liquid"
+				],
+				patterns: ["\\{%\\s+t\\s+({key})\\s+%\\}"]
+			}],
+			resources: [{ pattern: "_i18n/{locale}.yml" }],
+			keyStyle: "nested",
+			templates: [{ template: "{% t {key} %}" }]
+		})]
+	};
+}
+//#endregion
+//#region src/presets/web.ts
+const jsxTemplates = [
+	{
+		template: "{t('{key}'{args})}",
+		kinds: ["jsx-text"]
+	},
+	{
+		template: "{attr}={t('{key}'{args})}",
+		kinds: ["jsx-attribute"]
+	},
+	{
+		template: "t('{key}'{args})",
+		kinds: ["js-string", "js-template"]
+	}
+];
+function nextInternational() {
+	return {
+		name: "next-international",
+		detect: dependsOn(["next-international"]),
+		plugins: [library({
+			name: "next-international",
+			calls: [{
+				callee: ["useI18n", "getI18n"],
+				factory: true,
+				returns: ["t"]
+			}, {
+				callee: ["useScopedI18n", "getScopedI18n"],
+				factory: true,
+				returns: ["t"],
+				keyPrefix: { arg: 0 }
+			}],
+			resources: [{ pattern: "locales/{locale}.{ext}" }, { pattern: "src/locales/{locale}.{ext}" }],
+			templates: jsxTemplates
+		}), placeholders(braces)]
+	};
+}
+function nextTranslate() {
+	return {
+		name: "next-translate",
+		detect: dependsOn(["next-translate"]),
+		plugins: [library({
+			name: "next-translate",
+			namespace: {
+				separator: ":",
+				default: "common"
+			},
+			calls: [
+				{
+					callee: "useTranslation",
+					factory: true,
+					returns: ["t"],
+					namespace: { arg: 0 }
+				},
+				{
+					callee: "getT",
+					factory: true,
+					returns: ["t"],
+					namespace: { arg: 1 }
+				},
+				{
+					callee: "Trans",
+					key: {
+						arg: 0,
+						property: "i18nKey"
+					},
+					namespace: {
+						arg: 0,
+						property: "ns"
+					}
+				},
+				{ callee: "t" }
+			],
+			regex: [{
+				extensions: scriptExtensions,
+				patterns: ["[^\\w\\d]t`({key})`"]
+			}],
+			resources: [{ pattern: "locales/{locale}/{namespace}.json" }],
+			keyStyle: "nested",
+			templates: jsxTemplates
+		}), placeholders(doubleBraces)]
+	};
+}
+/** Shopify's i18next format: plural and ordinal forms as nested keys (`{key}.one`). */
+function i18nextShopify() {
+	const forms = [
+		"plural",
+		"zero",
+		"one",
+		"two",
+		"few",
+		"many",
+		"other",
+		...Array.from({ length: 10 }, (_, i) => String(i))
+	];
+	return {
+		name: "i18next-shopify",
+		detect: dependsOn(["@shopify/i18next-shopify"]),
+		plugins: [
+			...reactI18next().plugins,
+			library({
+				name: "i18next-shopify",
+				derivedKeys: forms.map((form) => `{key}.${form}`),
+				keyStyle: "nested"
+			}),
+			placeholders(braces)
+		]
+	};
+}
+function i18nTag() {
+	return {
+		name: "i18n-tag",
+		detect: dependsOn(["es2015-i18n-tag"]),
+		plugins: [library({
+			name: "i18n-tag",
+			regex: [{
+				extensions: [...scriptExtensions, "vue"],
+				patterns: ["i18n`({key})`"]
+			}],
+			templates: [{
+				template: "i18n`{key}`",
+				kinds: ["js-string", "js-template"]
+			}]
+		})]
+	};
+}
+function fluentVue() {
+	return {
+		name: "fluent-vue",
+		detect: dependsOn([
+			"fluent-vue",
+			"fluent-vue-loader",
+			"rollup-plugin-fluent-vue",
+			"unplugin-fluent-vue"
+		]),
+		plugins: [
+			library({
+				name: "fluent-vue",
+				calls: [{ callee: [
+					"$t",
+					"$ta",
+					"fluent.format",
+					"fluent.formatAttrs",
+					"this.$t",
+					"this.$ta"
+				] }, {
+					callee: "useFluent",
+					factory: true,
+					returns: [
+						"$t",
+						"$ta",
+						"format",
+						"formatAttrs"
+					]
+				}],
+				regex: [{
+					extensions: ["vue"],
+					patterns: ["v-t:({key})[\\s\\n=>]", "<i18n[\\s\\n]+path=['\"`]({key})['\"`]"]
+				}],
+				resources: [{ pattern: "locales/{locale}.ftl" }, { pattern: "src/locales/{locale}.ftl" }],
+				templates: [
+					{
+						template: "{{ $t('{key}'{args}) }}",
+						kinds: ["vue-template-text"]
+					},
+					{
+						template: ":{attr}=\"$t('{key}'{args})\"",
+						kinds: ["vue-attribute"]
+					},
+					{
+						template: "$t('{key}'{args})",
+						kinds: ["js-string", "js-template"]
+					}
+				]
+			}),
+			sfcFluentBlocks(),
+			placeholders(fluent)
+		]
+	};
+}
+function polyglot() {
+	return {
+		name: "polyglot",
+		detect: dependsOn(["node-polyglot"]),
+		plugins: [library({
+			name: "polyglot",
+			calls: [{ callee: ["polyglot.t", "I18n.t"] }],
+			regex: [{
+				extensions: ["rb"],
+				patterns: ["(?:polyglot|I18n)\\.t\\(\\s*['\"`]({key})['\"`]"]
+			}],
+			templates: [{
+				template: "polyglot.t('{key}'{args})",
+				kinds: ["js-string", "js-template"]
+			}]
+		}), placeholders(percentBraces)]
+	};
+}
+function globalize() {
+	return {
+		name: "globalize",
+		detect: dependsOn(["globalize"]),
+		plugins: [library({
+			name: "globalize",
+			calls: [{ callee: [
+				"Globalize.messageFormatter",
+				"Globalize.formatMessage",
+				"globalize.messageFormatter",
+				"globalize.formatMessage"
+			] }],
+			normalizeKey: (raw) => raw.includes("/") ? raw.replace(/\//g, ".") : void 0,
+			templates: [{
+				template: "Globalize.formatMessage('{key}'{args})",
+				kinds: ["js-string", "js-template"]
+			}]
+		}), placeholders(icu)]
+	};
+}
+function ui5() {
+	return {
+		name: "ui5",
+		detect: dependsOn(["@ui5/cli"]),
+		plugins: [library({
+			name: "ui5",
+			regex: [{
+				extensions: [
+					"xml",
+					"json",
+					...scriptExtensions
+				],
+				patterns: ["\\{i18n>({key})\\}"]
+			}, {
+				extensions: scriptExtensions,
+				patterns: ["getResourceBundle\\(\\)\\.getText\\(\\s*['\"`]({key})['\"`]"]
+			}],
+			resources: [{ pattern: "webapp/i18n/i18n_{locale}.properties" }, { pattern: "webapp/i18n/i18n.properties" }],
+			keyStyle: "flat",
+			templates: [{
+				template: "{i18n>{key}}",
+				files: ["**/*.xml"]
+			}, {
+				template: "this.getResourceBundle().getText('{key}')",
+				kinds: ["js-string", "js-template"]
+			}]
+		}), placeholders(braces)]
+	};
+}
+function lingui() {
+	return {
+		name: "lingui",
+		detect: dependsOn([
+			"@lingui/core",
+			"@lingui/react",
+			"@lingui/macro"
+		]),
+		plugins: [library({
+			name: "lingui",
+			calls: [
+				{ callee: [
+					"i18n._",
+					"i18n.t",
+					"t",
+					"_"
+				] },
+				{
+					callee: [
+						"t",
+						"msg",
+						"defineMessage",
+						"i18n._",
+						"Trans"
+					],
+					key: {
+						arg: 0,
+						property: "id"
+					}
+				},
+				{
+					callee: "useLingui",
+					factory: true,
+					returns: ["t", "_"]
+				}
+			],
+			regex: [{
+				extensions: scriptExtensions,
+				patterns: ["\\bt`({key})`", "<Trans>[\\s]*({key})[\\s]*<\\/Trans>"]
+			}],
+			resources: [{ pattern: "src/locales/{locale}/messages.po" }, { pattern: "locales/{locale}/messages.po" }],
+			extra: (draft) => {
+				draft.extract = {
+					keygen: "source",
+					...draft.extract
+				};
+			},
+			templates: [{
+				template: "<Trans>{key}</Trans>",
+				kinds: ["jsx-text"],
+				imports: ["import { Trans } from '@lingui/react/macro'"]
+			}, {
+				template: "t`{key}`",
+				kinds: ["js-string", "js-template"],
+				imports: ["import { t } from '@lingui/core/macro'"]
+			}]
+		}), placeholders(icu)]
+	};
+}
+function emberIntl() {
+	return {
+		name: "ember-intl",
+		detect: dependsOn(["ember-intl"]),
+		plugins: [library({
+			name: "ember-intl",
+			calls: [{ callee: ["intl.t"] }],
+			regex: [{
+				extensions: [
+					"hbs",
+					"gjs",
+					"gts"
+				],
+				patterns: ["\\{\\{\\s*t\\s+['\"`]({key})['\"`]", "\\(\\s*t\\s+['\"`]({key})['\"`]"]
+			}],
+			resources: [{ pattern: "translations/{locale}.{ext}" }, { pattern: "translations/{namespaces}/{locale}.{ext}" }],
+			templates: [{
+				template: "{{t '{key}'}}",
+				files: ["**/*.hbs"]
+			}, {
+				template: "this.intl.t('{key}'{args})",
+				kinds: ["js-string", "js-template"]
+			}]
+		}), placeholders(icu)]
+	};
+}
+function i18nJs() {
+	return {
+		name: "i18n-js",
+		detect: dependsOn(["i18n-js"]),
+		plugins: [library({
+			name: "i18n-js",
+			calls: [{ callee: ["I18n.t", "i18n.t"] }],
+			templates: [{
+				template: "i18n.t('{key}'{args})",
+				kinds: ["js-string", "js-template"]
+			}]
+		}), placeholders(percentBraces)]
+	};
+}
+/** Chrome and WebExtension `_locales/{locale}/messages.json`: `{ "name": { "message": "..." } }` reads as `name`. */
+function chromeExtension() {
+	return {
+		name: "chrome-extension",
+		async detect(ctx) {
+			for (const path of [
+				"manifest.json",
+				"src/manifest.json",
+				"public/manifest.json"
+			]) if ((await ctx.host.readFile(path))?.includes("\"default_locale\"")) return true;
+			return false;
+		},
+		plugins: [
+			library({
+				name: "chrome-extension",
+				calls: [{ callee: [
+					"chrome.i18n.getMessage",
+					"browser.i18n.getMessage",
+					"i18n.getMessage"
+				] }],
+				regex: [{
+					extensions: [
+						"json",
+						"html",
+						"css"
+					],
+					patterns: ["__MSG_({key})__"]
+				}],
+				resources: [{ pattern: "_locales/{locale}/messages.json" }, { pattern: "{src,public,extension}/_locales/{locale}/messages.json" }],
+				transformResource: {
+					applies: (ctx) => /(?:^|\/)_locales\/[^/]+\/messages\.json$/.test(ctx.path),
+					read(tree) {
+						const out = {};
+						for (const [name, entry] of Object.entries(tree)) {
+							const message = isMessageLeaf(entry) ? void 0 : entry.message;
+							if (message !== void 0 && isMessageLeaf(message)) out[name] = message;
+						}
+						return out;
+					},
+					toStored: (path) => [path.join("."), "message"]
+				},
+				templates: [{
+					template: "chrome.i18n.getMessage('{key}')",
+					kinds: ["js-string", "js-template"]
+				}]
+			}),
+			{
+				name: "x18n:chrome-extension-source-locale",
+				async config(draft, ctx) {
+					const manifest = await ctx.host.readFile("manifest.json") ?? await ctx.host.readFile("src/manifest.json") ?? await ctx.host.readFile("public/manifest.json");
+					const locale = manifest ? /"default_locale"\s*:\s*"([^"]+)"/.exec(manifest)?.[1] : void 0;
+					if (locale) draft.sourceLocale = locale;
+				}
+			},
+			placeholders(dollars)
+		]
+	};
+}
+//#endregion
+//#region src/presets/index.ts
+/**
+* Presets by name, in detection order: every i18n-ally framework has one.
+* Presets that share plugins (react-i18next and i18next) apply them once.
+*/
+const presets = {
+	"nuxt-i18n": () => nuxtI18n(),
+	"vue-i18n": () => vueI18n(),
+	"fluent-vue": () => fluentVue(),
+	"i18next-shopify": () => i18nextShopify(),
+	"react-i18next": () => reactI18next(),
+	"next-translate": () => nextTranslate(),
+	"next-international": () => nextInternational(),
+	"i18next": () => i18next(),
+	"next-intl": () => nextIntl(),
+	"react-intl": () => reactIntl(),
+	"svelte-i18n": () => svelteI18n(),
+	"ngx-translate": () => ngxTranslate(),
+	"transloco": () => transloco(),
+	"lingui": () => lingui(),
+	"ember-intl": () => emberIntl(),
+	"polyglot": () => polyglot(),
+	"globalize": () => globalize(),
+	"i18n-tag": () => i18nTag(),
+	"i18n-js": () => i18nJs(),
+	"ui5": () => ui5(),
+	"chrome-extension": () => chromeExtension(),
+	"vscode-extension": () => vscodeExtension(),
+	"laravel": () => laravel(),
+	"php-joomla": () => phpJoomla(),
+	"php-gettext": () => phpGettext(),
+	"ruby-rails": () => rubyRails(),
+	"jekyll": () => jekyll(),
+	"flutter": () => flutter(),
+	"general": () => general()
+};
+//#endregion
+export { ngxTranslate as A, nextIntl as C, svelteI18n as D, reactIntl as E, vscodeExtension as O, i18next as S, reactI18next as T, phpJoomla as _, globalize as a, flutter as b, i18nextShopify as c, nextTranslate as d, polyglot as f, phpGettext as g, laravel as h, fluentVue as i, transloco as j, vueI18n as k, lingui as l, jekyll as m, chromeExtension as n, i18nJs as o, ui5 as p, emberIntl as r, i18nTag as s, presets as t, nextInternational as u, railsLazyKey as v, nuxtI18n as w, general as x, rubyRails as y };