webpack-easyi18n 0.5.2 → 0.6.0-rc.0

package/README.md

@@ -48,6 +48,20 @@ module.exports = Object.keys(Locales).map(function(locale) {
         ])
     };
 });
+
+### React / JSX support
+
+This plugin transforms nuggets at **source level** (via an injected webpack loader), so nuggets can span JSX text, `{expressions}`, and even nested JSX elements.
+
+Example:
+
+```jsx
+<p>
+  [[[Just {changeStatusBtn} to change your status.]]]
+</p>
+```
+
+Internally this becomes a translated JSX children sequence rather than a single string, so placeholders like `%0` can be reordered per-locale without breaking React.
 ```
 
 ### Options

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "webpack-easyi18n",
-    "version": "0.5.2",
+    "version": "0.6.0-rc.0",
     "description": "Go from gettext catalog (.po files) to embeded localization in your Webpack bundles",
     "engines": {
         "node": ">=4.3.0 <5.0.0 || >=5.10"
@@ -10,13 +10,10 @@
     ],
     "main": "src/index.js",
     "scripts": {
-        "test": "echo \"Error: no test specified\" && exit 1",
-        "example:clean": "rimraf example\\dist example\\locale\\webpack-easyi18n-temp",
-        "example:build": "npm run example:clean && webpack -c example\\webpack.config.js",
-        "example:generatetranslations": "dotnet tool restore && dotnet tool run generatepot --app-settings-paths=\"./example/appsettings.json\""
+		"test": "node --experimental-vm-modules ./node_modules/jest/bin/jest.js"
     },
     "dependencies": {
-        "i18next-conv": "^4.0.3"
+        "i18next-conv": "^16.0.0"
     },
     "repository": {
         "type": "git",
@@ -33,7 +30,16 @@
     },
     "homepage": "https://github.com/SimplyDating/webpack-easyi18n#readme",
     "devDependencies": {
+        "@babel/core": "^7.26.3",
+        "@babel/generator": "^7.26.3",
+        "@babel/parser": "^7.26.3",
+        "@babel/preset-env": "^7.26.3",
+        "@babel/preset-react": "^7.26.3",
+        "@babel/traverse": "^7.26.3",
+        "@babel/types": "^7.26.3",
         "html-webpack-plugin": "^5.3.1",
+        "jest": "^29.7.0",
+        "react": "^18.3.1",
         "rimraf": "^6.0.1",
         "webpack": "^5.99.9",
         "webpack-cli": "^4.6.0"

package/src/index.js

@@ -1,11 +1,25 @@
-const { SourceMapSource } = require("webpack").sources;
 const path = require("path");
 const {
     readFileSync,
     writeFileSync,
     mkdirSync
 } = require("fs");
-const gettextToI18Next = require("i18next-conv").gettextToI18next;
+
+async function loadGettextToI18next() {
+	// i18next-conv@16+ is ESM-only (and Node>=20). Requiring it from CommonJS breaks Jest with
+	// "Unexpected token 'export'". We support both:
+	// - CJS: require('i18next-conv').gettextToI18next
+	// - ESM: (await import('i18next-conv')).gettextToI18next
+	try {
+		// eslint-disable-next-line global-require
+		const mod = require('i18next-conv');
+		return mod.gettextToI18next || mod.gettextToI18Next || mod.default;
+	} catch (err) {
+		// If it's ESM-only, fall back to dynamic import.
+		const mod = await import('i18next-conv');
+		return mod.gettextToI18next || mod.gettextToI18Next || mod.default;
+	}
+}
 
 class EasyI18nPlugin {
     static defaultOptions = {
@@ -28,6 +42,8 @@ class EasyI18nPlugin {
             ...EasyI18nPlugin.defaultOptions,
             ...options
         };
+
+		this.translationLookup = null;
     }
 
     apply(compiler) {
@@ -39,189 +55,79 @@ class EasyI18nPlugin {
             }
         };
 
-        /**
-         * Decode (a small subset of) JavaScript-style escape sequences from *bundle text* into
-         * their real runtime characters.
-         *
-         * Why this exists:
-         * - When targeting older environments, Babel/minifiers sometimes emit non-ASCII
-         *   characters using unicode escapes, e.g. "don\u2019t" instead of "don’t".
-         * - If we then call escapeNuggets(), it will escape backslashes, turning "\u2019" into
-         *   "\\u2019".
-         * - In the final JS bundle, "\\u2019" is *not* a unicode escape anymore; it becomes a
-         *   literal backslash-u sequence and the browser renders "don\u2019t".
-         *
-         * Example:
-         * - Bundle text contains:  "don\u2019t"
-         * - Without decode:         escapeNuggets => "don\\u2019t"  (renders as don\u2019t)
-         * - With decode first:      unescapeJsLike => "don’t"; then escapeNuggets keeps it as don’t
-         *
-         * Notes:
-         * - This intentionally decodes only "\uXXXX" and "\xXX" sequences.
-         * - It avoids decoding when the backslash itself is escaped (e.g. "\\u2019"), because
-         *   that usually means the author intended a literal "\u2019" to be displayed.
-         */
-        const unescapeJsLike = (value) => {
-            if (typeof value !== 'string') return value;
-
-            const isHex = (c) => (c >= '0' && c <= '9')
-                || (c >= 'a' && c <= 'f')
-                || (c >= 'A' && c <= 'F');
-
-            let out = '';
-            for (let i = 0; i < value.length; i++) {
-                const ch = value[i];
-                if (ch !== '\\') {
-                    out += ch;
-                    continue;
-                }
-
-                // If we have an escaped backslash ("\\u...." in text), do not decode.
-                if (i > 0 && value[i - 1] === '\\') {
-                    out += ch;
-                    continue;
-                }
-
-                const next = value[i + 1];
-                if (next === 'u') {
-                    const a = value[i + 2], b = value[i + 3], c = value[i + 4], d = value[i + 5];
-                    if (isHex(a) && isHex(b) && isHex(c) && isHex(d)) {
-                        out += String.fromCharCode(parseInt(`${a}${b}${c}${d}`, 16));
-                        i += 5;
-                        continue;
-                    }
-                } else if (next === 'x') {
-                    const a = value[i + 2], b = value[i + 3];
-                    if (isHex(a) && isHex(b)) {
-                        out += String.fromCharCode(parseInt(`${a}${b}`, 16));
-                        i += 3;
-                        continue;
-                    }
-                }
-
-                // Not a recognized escape; keep the backslash.
-                out += ch;
-            }
-
-            return out;
-        };
-
-        compiler.hooks.thisCompilation.tap('EasyI18nPlugin', (compilation) => {
-            compilation.hooks.processAssets.tapPromise(
-                {
-                    name: 'EasyI18nPlugin',
-                    stage: compilation.PROCESS_ASSETS_STAGE_DERIVED,
-                },
-                async () => {
-                    const localeKey = this.locale[0];
-                    const localePoPath = this.locale[1];
-
-                    if (localePoPath !== null) {
-                        var poPath = path.join(this.options.localesPath, localePoPath);
-
-                        mkdir(path.resolve(path.join(this.options.localesPath, "/webpack-easyi18n-temp/")));
-
-                        console.log(`Reading translations from ${poPath}`)
-                        var lookupData = await gettextToI18Next(localeKey, readFileSync(poPath), {});
-                        var translationLookupPath = path.join(this.options.localesPath, `/webpack-easyi18n-temp/${localeKey}.json`);
-                        writeFileSync(translationLookupPath, lookupData);
-                        console.log(`${localeKey} translation lookup file created ${translationLookupPath}`);
-                    }
-
-                    let translationLookup = null;
-                    if (localePoPath !== null) {
-                        translationLookup = require(path.join(this.options.localesPath, `/webpack-easyi18n-temp/${localeKey}.json`));
-                    }
-
-                    compilation.getAssets().forEach((asset) => {
-                        const filename = asset.name;
-                        const originalSourceObj = compilation.assets[filename];
-                        const originalSource = originalSourceObj.source();
-
-                        // skip any files that have been excluded
-                        const modifyFile = typeof originalSource === 'string'
-                            && (this.options.excludeUrls == null || !this.options.excludeUrls.some(excludedUrl => filename.includes(excludedUrl)))
-                            && (this.options.includeUrls == null || this.options.includeUrls.some(includedUrl => filename.includes(includedUrl)));
-                        if (!modifyFile) return;
-
-                        // Unfortunately the regex below doesn't work as js flavoured regex makes only the last capture included
-                        // in a capture group available (unlike .NET which lets you iterate over all captures in a group).
-                        // This means formatable nuggets with multiple formatable items will fail.
-                        //
-                        // Take the following nugget for example:
-                        // - [[[%0 %1|||1|||2]]]
-                        //
-                        // The regex below will only include "2" in the second capture group, rather than all captures "1|||2".
-                        // We need to do multiple rounds of parsing in order to work around this
-                        //const regex = /\[\[\[(.+?)(?:\|\|\|(.+?))*(?:\/\/\/(.+?))?\]\]\]/sg;
-                        const regex = /\[\[\[(.+?)(?:\|\|\|.+?)*(?:\/\/\/(.+?))?\]\]\]/sg;
-
-                        let source = originalSource.replace(regex, (originalText, nuggetSyntaxRemoved) => {
-                            let replacement = null;
-
-                            if (localePoPath === null) {
-                                if (this.options.alwaysRemoveBrackets) {
-                                    replacement = nuggetSyntaxRemoved;
-                                } else {
-                                    return originalText; // leave this nugget alone
-                                }
-                            } else {
-                                // .po files use \n notation for line breaks
-                                const translationKeyRaw = nuggetSyntaxRemoved.replace(/\r\n/g, '\n');
-                                const translationKey = unescapeJsLike(translationKeyRaw);
-
-                                // find this nugget in the locale's array of translations
-                                replacement = translationLookup[translationKey];
-                                if (typeof (replacement) === "undefined") {
-                                    replacement = translationLookup[translationKeyRaw];
-                                }
-                                if (typeof (replacement) === "undefined" || replacement === "") {
-                                    if (this.options.warnOnMissingTranslations) {
-                                        compilation.warnings.push(
-                                            new Error(`Missing translation in ${filename}.\n '${nuggetSyntaxRemoved}' : ${localeKey}`));
-                                    }
-
-                                    if (this.options.alwaysRemoveBrackets) {
-                                        replacement = nuggetSyntaxRemoved;
-                                    } else {
-                                        return originalText; // leave this nugget alone
-                                    }
-                                }
-                            }
-
-                            // Escape the translated text BEFORE formatting/splicing
-                            replacement = EasyI18nPlugin.escapeNuggets(unescapeJsLike(replacement));
-
-                            // format nuggets
-                            var formatItemsMatch = originalText.match(/\|\|\|(.+?)(?:\/\/\/.+?)?\]\]\]/s)
-                            if (formatItemsMatch) {
-                                const formatItems = formatItemsMatch[1]
-                                    .split('|||');
-
-                                replacement = replacement.replace(/(%\d+)/g, (value) => {
-                                    var identifier = parseInt(value.slice(1));
-                                    if (!isNaN(identifier) && formatItems.length > identifier) {
-                                        return formatItems[identifier];
-                                    } else {
-                                        return value;
-                                    }
-                                });
-                            }
-
-                            return replacement;
-                        });
-
-                        compilation.updateAsset(filename, new SourceMapSource(
-                            source,
-                            filename,
-                            originalSourceObj.map(),
-                            originalSource,
-                            null,
-                            true));
-                    });
-                }
-            );
-        });
+		const localeKey = this.locale[0];
+		const localePoPath = this.locale[1];
+
+		const prepareTranslations = async () => {
+			if (localePoPath === null) {
+				this.translationLookup = null;
+				return;
+			}
+
+			const poPath = path.join(this.options.localesPath, localePoPath);
+			mkdir(path.resolve(path.join(this.options.localesPath, "/webpack-easyi18n-temp/")));
+
+			const gettextToI18next = await loadGettextToI18next();
+			if (typeof gettextToI18next !== 'function') {
+				throw new Error('Failed to load i18next-conv gettextToI18next()');
+			}
+
+			// Keep the temp json file behavior for backward-compatibility/debugging.
+			const lookupData = await gettextToI18next(localeKey, readFileSync(poPath), {});
+			const translationLookupPath = path.join(this.options.localesPath, `/webpack-easyi18n-temp/${localeKey}.json`);
+			writeFileSync(translationLookupPath, lookupData);
+
+			try {
+				this.translationLookup = typeof lookupData === 'string' ? JSON.parse(lookupData) : lookupData;
+			} catch {
+				// Fallback to requiring the generated file.
+				// eslint-disable-next-line global-require, import/no-dynamic-require
+				this.translationLookup = require(translationLookupPath);
+			}
+		};
+
+		compiler.hooks.beforeCompile.tapPromise('EasyI18nPlugin', prepareTranslations);
+		compiler.hooks.watchRun.tapPromise('EasyI18nPlugin', prepareTranslations);
+
+		// Inject our loader so nuggets are transformed at source-level (before Babel turns JSX into string concatenations).
+		compiler.hooks.normalModuleFactory.tap('EasyI18nPlugin', (normalModuleFactory) => {
+			normalModuleFactory.hooks.afterResolve.tap('EasyI18nPlugin', (resolveData) => {
+				if (!resolveData) return;
+
+				// webpack 5 can expose resource on different fields depending on stage.
+				const resourcePath = resolveData.resource
+					|| (resolveData.resourceResolveData && resolveData.resourceResolveData.path)
+					|| (resolveData.createData && resolveData.createData.resource);
+				if (!resourcePath) return;
+
+				// Skip dependencies
+				if (resourcePath.includes(`${path.sep}node_modules${path.sep}`)) return;
+
+				// Only transform JS/TS sources.
+				if (!/\.[cm]?[jt]sx?$/.test(resourcePath)) return;
+
+				// Apply include/exclude patterns against the full resource path.
+				if (this.options.excludeUrls != null && this.options.excludeUrls.some(excludedUrl => resourcePath.includes(excludedUrl))) return;
+				if (this.options.includeUrls != null && !this.options.includeUrls.some(includedUrl => resourcePath.includes(includedUrl))) return;
+
+				// In webpack 5, mutate createData.loaders to affect the final NormalModule.
+				if (!resolveData.createData) resolveData.createData = {};
+				if (!Array.isArray(resolveData.createData.loaders)) {
+					resolveData.createData.loaders = Array.isArray(resolveData.loaders) ? resolveData.loaders : [];
+				}
+
+				resolveData.createData.loaders.push({
+					loader: path.resolve(__dirname, 'loader.js'),
+					options: {
+						localeKey,
+						localePoPath,
+						alwaysRemoveBrackets: this.options.alwaysRemoveBrackets,
+						warnOnMissingTranslations: this.options.warnOnMissingTranslations,
+						translationLookup: this.translationLookup,
+					},
+				});
+			});
+		});
     }
 }
 

package/src/loader.js

@@ -0,0 +1,22 @@
+const { transformSource } = require('./transform');
+
+module.exports = function easyI18nLoader(source) {
+	const callback = this.async();
+	const options = this.getOptions ? this.getOptions() : {};
+
+	try {
+		const code = transformSource(source.toString(), {
+			localeKey: options.localeKey,
+			localePoPath: options.localePoPath,
+			alwaysRemoveBrackets: options.alwaysRemoveBrackets,
+			warnOnMissingTranslations: options.warnOnMissingTranslations,
+			translationLookup: options.translationLookup,
+			fileNameForWarnings: this.resourcePath,
+			emitWarning: (err) => this.emitWarning(err),
+		});
+
+		callback(null, code);
+	} catch (err) {
+		callback(err);
+	}
+};

package/src/transform.js

@@ -0,0 +1,360 @@
+const parser = require('@babel/parser');
+const traverse = require('@babel/traverse').default;
+const t = require('@babel/types');
+const generate = require('@babel/generator').default;
+
+const NUGGET_START = '[[[';
+const NUGGET_END = ']]]';
+
+function normalizeKey(value) {
+	if (typeof value !== 'string') return value;
+	// .po files use \n; source may have CRLF
+	return value.replace(/\r\n/g, '\n');
+}
+
+function getTranslation({ localePoPath, alwaysRemoveBrackets, translationLookup, key, rawKey }) {
+	if (localePoPath == null) {
+		if (alwaysRemoveBrackets) return rawKey;
+		return null;
+	}
+
+	if (!translationLookup) return null;
+	const normalized = normalizeKey(key);
+	const normalizedRaw = normalizeKey(rawKey);
+	let value = translationLookup[normalized];
+	if (typeof value === 'undefined') value = translationLookup[normalizedRaw];
+	if (typeof value === 'undefined' || value === '') return null;
+	return value;
+}
+
+function splitByPlaceholder(text) {
+	// Returns array of {type:'text', value} or {type:'ph', index}
+	const parts = [];
+	const re = /(%\d+)/g;
+	let last = 0;
+	let match;
+	while ((match = re.exec(text)) != null) {
+		if (match.index > last) {
+			parts.push({ type: 'text', value: text.slice(last, match.index) });
+		}
+		const index = Number(match[1].slice(1));
+		parts.push({ type: 'ph', index });
+		last = match.index + match[1].length;
+	}
+	if (last < text.length) parts.push({ type: 'text', value: text.slice(last) });
+	return parts;
+}
+
+function normalizeJsxTextForKey(text) {
+	// Make translation keys resilient to formatting/indentation inside JSX.
+	// React itself collapses most whitespace in JSXText; we mirror that for keys.
+	return text.replace(/\s+/g, ' ');
+}
+
+function replaceNuggetsInPlainString(input, { localePoPath, alwaysRemoveBrackets, warnOnMissingTranslations, translationLookup, onMissing }) {
+	if (typeof input !== 'string' || input.indexOf(NUGGET_START) === -1) return input;
+
+	// Note: this regex intentionally does NOT attempt to parse format items across multiple groups.
+	const regex = /\[\[\[(.+?)(?:\|\|\|.+?)*(?:\/\/\/(.+?))?\]\]\]/gs;
+
+	return input.replace(regex, (originalText, nuggetSyntaxRemoved) => {
+		const rawKey = nuggetSyntaxRemoved;
+		const translated = getTranslation({
+			localePoPath,
+			alwaysRemoveBrackets,
+			translationLookup,
+			key: nuggetSyntaxRemoved,
+			rawKey,
+		});
+
+		if (translated == null) {
+			if (localePoPath != null && warnOnMissingTranslations && typeof onMissing === 'function') {
+				onMissing(rawKey);
+			}
+			if (localePoPath == null && !alwaysRemoveBrackets) return originalText;
+			return rawKey;
+		}
+
+		let replacement = translated;
+
+		// Format nuggets: [[[Hello %0|||A|||B]]]
+		const formatItemsMatch = originalText.match(/\|\|\|(.+?)(?:\/\/\/.+?)?\]\]\]/s);
+		if (formatItemsMatch) {
+			const formatItems = formatItemsMatch[1].split('|||');
+			replacement = replacement.replace(/(%\d+)/g, (value) => {
+				const identifier = Number(value.slice(1));
+				if (!Number.isNaN(identifier) && formatItems.length > identifier) return formatItems[identifier];
+				return value;
+			});
+		}
+
+		return replacement;
+	});
+}
+
+function transformJsxNuggets(children, state, fileNameForWarnings) {
+	const out = [];
+	let i = 0;
+
+	const emitMissing = (key) => {
+		if (!state.warnOnMissingTranslations) return;
+		if (typeof state.emitWarning === 'function') {
+			state.emitWarning(new Error(`Missing translation${fileNameForWarnings ? ` in ${fileNameForWarnings}` : ''}.\n '${key}' : ${state.localeKey}`));
+		}
+	};
+
+	while (i < children.length) {
+		const child = children[i];
+
+		// We only start nuggets from JSXText containing [[[.
+		if (!t.isJSXText(child) || child.value.indexOf(NUGGET_START) === -1) {
+			out.push(child);
+			i++;
+			continue;
+		}
+
+		const startIndex = child.value.indexOf(NUGGET_START);
+		const before = child.value.slice(0, startIndex);
+		const afterStart = child.value.slice(startIndex + NUGGET_START.length);
+
+		if (before) out.push(t.jsxText(before));
+
+		// Begin capturing nugget content across subsequent children.
+		let message = '';
+		const values = [];
+		let done = false;
+
+		// Seed with remaining text after [[[ in the starting node.
+		let seed = afterStart;
+		let localIndex = i;
+
+		const consumeText = (text) => {
+			if (!text) return;
+			const endIdx = text.indexOf(NUGGET_END);
+			if (endIdx === -1) {
+				message += normalizeJsxTextForKey(text);
+				return { done: false };
+			}
+			message += normalizeJsxTextForKey(text.slice(0, endIdx));
+			const remainder = text.slice(endIdx + NUGGET_END.length);
+			return { done: true, remainder };
+		};
+
+		// Consume seed (which may contain ]]]).
+		{
+			const res = consumeText(seed);
+			if (res.done) {
+				// Entire nugget is within the first JSXText.
+				const keyRaw = message;
+				const key = keyRaw;
+				const translated = getTranslation({
+					localePoPath: state.localePoPath,
+					alwaysRemoveBrackets: state.alwaysRemoveBrackets,
+					translationLookup: state.translationLookup,
+					key,
+					rawKey: keyRaw,
+				});
+
+				if (translated == null) {
+					if (state.localePoPath != null && state.warnOnMissingTranslations) emitMissing(keyRaw);
+					if (state.localePoPath == null && !state.alwaysRemoveBrackets) {
+						// Leave original unmodified
+						out.push(child);
+						i++;
+						continue;
+					}
+					out.push(t.jsxText(keyRaw + res.remainder));
+					i++;
+					continue;
+				}
+
+				out.push(...buildJsxChildrenFromTranslation(translated, values));
+				if (res.remainder) out.push(t.jsxText(res.remainder));
+				i++;
+				continue;
+			}
+		}
+
+		localIndex = i + 1;
+
+		while (localIndex < children.length) {
+			const current = children[localIndex];
+
+			if (t.isJSXText(current)) {
+				const res = consumeText(current.value);
+				if (res.done) {
+					done = true;
+					// Finish: translate and emit remainder
+					const keyRaw = message;
+					const key = keyRaw;
+					const translated = getTranslation({
+						localePoPath: state.localePoPath,
+						alwaysRemoveBrackets: state.alwaysRemoveBrackets,
+						translationLookup: state.translationLookup,
+						key,
+						rawKey: keyRaw,
+					});
+
+					if (translated == null) {
+						if (state.localePoPath != null && state.warnOnMissingTranslations) emitMissing(keyRaw);
+						if (state.localePoPath == null && !state.alwaysRemoveBrackets) {
+							// Leave original sequence unmodified
+							out.push(child);
+							for (let k = i + 1; k <= localIndex; k++) out.push(children[k]);
+							i = localIndex + 1;
+							continue;
+						}
+
+						out.push(...buildJsxChildrenFromTranslation(keyRaw, values));
+					} else {
+						out.push(...buildJsxChildrenFromTranslation(translated, values));
+					}
+
+					if (res.remainder) out.push(t.jsxText(res.remainder));
+					i = localIndex + 1;
+					break;
+				}
+
+				localIndex++;
+				continue;
+			}
+
+			if (t.isJSXExpressionContainer(current)) {
+				// Ignore empty expressions (comments)
+				if (t.isJSXEmptyExpression(current.expression)) {
+					localIndex++;
+					continue;
+				}
+				const index = values.length;
+				values.push(current.expression);
+				message += `%${index}`;
+				localIndex++;
+				continue;
+			}
+
+			if (t.isJSXElement(current) || t.isJSXFragment(current)) {
+				const index = values.length;
+				values.push(current);
+				message += `%${index}`;
+				localIndex++;
+				continue;
+			}
+
+			// Other child types: keep them as placeholders to avoid losing content.
+			const index = values.length;
+			values.push(current);
+			message += `%${index}`;
+			localIndex++;
+		}
+
+		if (!done) {
+			// Unclosed nugget: leave original child
+			out.push(child);
+			i++;
+		}
+	}
+
+	return out;
+}
+
+function buildJsxChildrenFromTranslation(translated, values) {
+	const parts = splitByPlaceholder(translated);
+	const out = [];
+	for (const part of parts) {
+		if (part.type === 'text') {
+			if (part.value) out.push(t.jsxText(part.value));
+			continue;
+		}
+
+		const value = values[part.index];
+		if (typeof value === 'undefined') {
+			out.push(t.jsxText(`%${part.index}`));
+			continue;
+		}
+
+		if (t.isJSXElement(value) || t.isJSXFragment(value)) {
+			out.push(value);
+			continue;
+		}
+
+		// Expressions must be wrapped
+		out.push(t.jsxExpressionContainer(value));
+	}
+
+	return out;
+}
+
+function transformSource(source, options = {}) {
+	const state = {
+		localeKey: options.localeKey || '',
+		localePoPath: options.localePoPath ?? null,
+		alwaysRemoveBrackets: Boolean(options.alwaysRemoveBrackets),
+		warnOnMissingTranslations: options.warnOnMissingTranslations !== false,
+		translationLookup: options.translationLookup || null,
+		emitWarning: options.emitWarning,
+	};
+
+	const ast = parser.parse(source, {
+		sourceType: 'unambiguous',
+		plugins: [
+			'jsx',
+			'typescript',
+			'classProperties',
+			'objectRestSpread',
+			'optionalChaining',
+			'nullishCoalescingOperator',
+			'dynamicImport',
+			'topLevelAwait',
+			'importMeta',
+		],
+	});
+
+	traverse(ast, {
+		JSXElement(path) {
+			path.node.children = transformJsxNuggets(path.node.children, state, options.fileNameForWarnings);
+		},
+		JSXFragment(path) {
+			path.node.children = transformJsxNuggets(path.node.children, state, options.fileNameForWarnings);
+		},
+		StringLiteral(path) {
+			const before = path.node.value;
+			const after = replaceNuggetsInPlainString(before, {
+				...state,
+				onMissing: (key) => {
+					if (state.emitWarning) state.emitWarning(new Error(`Missing translation${options.fileNameForWarnings ? ` in ${options.fileNameForWarnings}` : ''}.\n '${key}' : ${state.localeKey}`));
+				},
+			});
+			if (after !== before) path.node.value = after;
+		},
+		TemplateLiteral(path) {
+			for (const quasi of path.node.quasis) {
+				const before = quasi.value.cooked;
+				if (typeof before !== 'string') continue;
+				const after = replaceNuggetsInPlainString(before, {
+					...state,
+					onMissing: (key) => {
+						if (state.emitWarning) state.emitWarning(new Error(`Missing translation${options.fileNameForWarnings ? ` in ${options.fileNameForWarnings}` : ''}.\n '${key}' : ${state.localeKey}`));
+					},
+				});
+				if (after !== before) {
+					quasi.value.cooked = after;
+					quasi.value.raw = after;
+				}
+			}
+		},
+	});
+
+	const output = generate(ast, {
+		jsescOption: { minimal: true },
+		retainLines: true,
+	}, source);
+
+	return output.code;
+}
+
+module.exports = {
+	transformSource,
+	replaceNuggetsInPlainString,
+	transformJsxNuggets,
+	buildJsxChildrenFromTranslation,
+};