@let-value/translate-extract 1.0.30 → 1.0.31

package/dist/run-DcO6U79B.js

@@ -0,0 +1,1439 @@
+import { isDeepStrictEqual } from "node:util";
+import glob from "fast-glob";
+import fs, { readFile } from "node:fs/promises";
+import path, { dirname, extname, join, relative, resolve } from "node:path";
+import * as gettextParser from "gettext-parser";
+import fs$1 from "node:fs";
+import Parser from "tree-sitter";
+import JavaScript from "tree-sitter-javascript";
+import TS from "tree-sitter-typescript";
+import { ResolverFactory } from "oxc-resolver";
+import { getFormula, getNPlurals } from "plural-forms";
+
+//#region src/defer.ts
+var Defer = class {
+	pending = 0;
+	promise = Promise.resolve();
+	resolve;
+	enqueue() {
+		if (this.pending++ === 0) this.promise = new Promise((res) => {
+			this.resolve = res;
+		});
+	}
+	dequeue() {
+		if (this.pending > 0 && --this.pending === 0) this.resolve?.();
+	}
+};
+
+//#endregion
+//#region src/plugins/cleanup/cleanup.ts
+const namespace$2 = "cleanup";
+function cleanup() {
+	return {
+		name: "cleanup",
+		setup(build) {
+			build.context.logger?.debug("cleanup plugin initialized");
+			const processed = /* @__PURE__ */ new Set();
+			const generated = /* @__PURE__ */ new Set();
+			const dirs = /* @__PURE__ */ new Set();
+			let dispatched = false;
+			build.onResolve({
+				namespace: namespace$2,
+				filter: /.*/
+			}, ({ path: path$1 }) => {
+				generated.add(path$1);
+				dirs.add(dirname(path$1));
+				Promise.all([
+					build.defer("source"),
+					build.defer("translate"),
+					build.defer(namespace$2)
+				]).then(() => {
+					if (dispatched) return;
+					dispatched = true;
+					for (const path$2 of dirs.values()) build.process({
+						entrypoint: path$2,
+						path: path$2,
+						namespace: namespace$2,
+						data: void 0
+					});
+				});
+			});
+			build.onProcess({
+				namespace: namespace$2,
+				filter: /.*/
+			}, async ({ path: path$1 }) => {
+				if (processed.has(path$1)) return;
+				processed.add(path$1);
+				const files = await fs.readdir(path$1).catch(() => []);
+				for (const f of files.filter((p) => p.endsWith(".po"))) {
+					const full = join(path$1, f);
+					const contents = await fs.readFile(full).catch(() => void 0);
+					if (!contents) continue;
+					const parsed = gettextParser.po.parse(contents);
+					const hasTranslations = Object.entries(parsed.translations || {}).some(([ctx, msgs]) => Object.keys(msgs).some((id) => !(ctx === "" && id === "")));
+					if (!hasTranslations && generated.has(full)) await fs.unlink(full);
+					if (hasTranslations && !generated.has(full)) build.context.logger?.warn({ path: full }, "stray translation file");
+				}
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/core/queries/comment.ts
+function getReference(node, { path: path$1 }) {
+	const line = node.startPosition.row + 1;
+	return `${relative(process.cwd(), path$1).replace(/\\+/g, "/")}:${line}`;
+}
+function getComment(node) {
+	const text = node.text;
+	if (text.startsWith("/*")) return text.slice(2, -2).replace(/^\s*\*?\s*/gm, "").trim();
+	return text.replace(/^\/\/\s?/, "").trim();
+}
+const withComment = (query) => ({
+	pattern: `(
+	((comment) @comment)?
+    .
+	(_ ${query.pattern})
+)`,
+	extract(match) {
+		const result = query.extract(match);
+		if (!result?.translation) return result;
+		const comment = match.captures.find((c) => c.name === "comment")?.node;
+		if (!comment) return result;
+		if (comment) result.translation.comments = {
+			...result.translation.comments,
+			extracted: getComment(comment)
+		};
+		return result;
+	}
+});
+
+//#endregion
+//#region src/plugins/core/queries/import.ts
+const importQuery = {
+	pattern: `
+    [
+      (import_statement
+        source: (string (string_fragment) @import))
+      (export_statement
+        source: (string (string_fragment) @import))
+      (call_expression
+        function: (identifier) @func
+        arguments: (arguments (string (string_fragment) @import))
+        (#eq? @func "require"))
+      (call_expression
+        function: (member_expression
+            object: (identifier) @obj
+            property: (property_identifier) @method)
+        arguments: (arguments (string (string_fragment) @import))
+        (#eq? @obj "require")
+        (#eq? @method "resolve"))
+      (call_expression
+        function: (import)
+        arguments: (arguments (string (string_fragment) @import)))
+    ]
+  `,
+	extract(match) {
+		return (match.captures.find((c) => c.name === "import")?.node)?.text;
+	}
+};
+
+//#endregion
+//#region src/plugins/core/queries/utils.ts
+const callPattern = (fnName, args, allowMember = true) => `(
+  (call_expression
+    function: ${allowMember ? `[
+      (identifier) @func
+      (member_expression property: (property_identifier) @func)
+    ]` : `(identifier) @func`}
+    arguments: ${args}
+  ) @call
+  (#eq? @func "${fnName}")
+)`;
+function isDescendant(node, ancestor) {
+	let current = node;
+	while (current) {
+		if (current.id === ancestor.id) return true;
+		current = current.parent;
+	}
+	return false;
+}
+
+//#endregion
+//#region src/plugins/core/queries/message.ts
+const notInPlural = (query) => ({
+	pattern: query.pattern,
+	extract(match) {
+		const result = query.extract(match);
+		if (!result?.node) return result;
+		let parent = result.node.parent;
+		if (parent && parent.type === "arguments") parent = parent.parent;
+		if (parent && parent.type === "call_expression") {
+			const fn = parent.childForFieldName("function");
+			if (fn) {
+				if (fn.type === "identifier" && (fn.text === "plural" || fn.text === "ngettext" || fn.text === "pgettext" || fn.text === "npgettext") || fn.type === "member_expression" && [
+					"plural",
+					"ngettext",
+					"pgettext",
+					"npgettext"
+				].includes(fn.childForFieldName("property")?.text ?? "")) return;
+			}
+		}
+		return result;
+	}
+});
+const messageArg = `[
+    (string (string_fragment) @msgid)
+    (object
+            (_)*
+            (pair
+                key: (property_identifier) @id_key
+                value: (string (string_fragment) @id)
+                (#eq? @id_key "id")
+            )?
+            (_)*
+            (pair
+                key: (property_identifier) @msg_key
+                value: (string (string_fragment) @message)
+                (#eq? @msg_key "message")
+            )?
+            (_)*
+    )
+    (template_string) @tpl
+]`;
+const messageArgs = `[ (arguments ${messageArg}) (template_string) @tpl ]`;
+const extractMessage = (name) => (match) => {
+	const node = match.captures.find((c) => c.name === "call")?.node;
+	if (!node) return;
+	const msgid = match.captures.find((c) => c.name === "msgid")?.node.text;
+	if (msgid) return {
+		node,
+		translation: {
+			id: msgid,
+			message: [msgid]
+		}
+	};
+	const tpl = match.captures.find((c) => c.name === "tpl")?.node;
+	if (tpl) {
+		for (const child of tpl.children) {
+			if (child.type !== "template_substitution") continue;
+			const expr = child.namedChildren[0];
+			if (!expr || expr.type !== "identifier") return {
+				node,
+				error: `${name}() template expressions must be simple identifiers`
+			};
+		}
+		const text = tpl.text.slice(1, -1);
+		return {
+			node,
+			translation: {
+				id: text,
+				message: [text]
+			}
+		};
+	}
+	const id = match.captures.find((c) => c.name === "id")?.node.text;
+	const message = match.captures.find((c) => c.name === "message")?.node.text;
+	const msgId = id ?? message;
+	if (!msgId) return;
+	return {
+		node,
+		translation: {
+			id: msgId,
+			message: [message ?? id ?? ""]
+		}
+	};
+};
+const messageQuery$1 = notInPlural(withComment({
+	pattern: callPattern("message", messageArgs),
+	extract: extractMessage("message")
+}));
+const allowed$1 = new Set([
+	"string",
+	"object",
+	"template_string"
+]);
+const messageInvalidQuery = notInPlural({
+	pattern: callPattern("message", "(arguments (_) @arg)"),
+	extract(match) {
+		const call = match.captures.find((c) => c.name === "call")?.node;
+		const node = match.captures.find((c) => c.name === "arg")?.node;
+		if (!call || !node) return;
+		if (allowed$1.has(node.type)) return;
+		return {
+			node,
+			error: "message() argument must be a string literal, object literal, or template literal"
+		};
+	}
+});
+
+//#endregion
+//#region src/plugins/core/queries/plural-utils.ts
+const extractPluralForms = (name) => (match) => {
+	const call = match.captures.find((c) => c.name === "call")?.node;
+	const n = match.captures.find((c) => c.name === "n")?.node;
+	if (!call || !n || n.nextNamedSibling) return;
+	const msgctxt = match.captures.find((c) => c.name === "msgctxt")?.node?.text;
+	const msgNodes = match.captures.filter((c) => c.name === "msg").map((c) => c.node);
+	const ids = [];
+	const strs = [];
+	for (const node of msgNodes) {
+		const relevant = match.captures.filter((c) => [
+			"msgid",
+			"id",
+			"message",
+			"tpl"
+		].includes(c.name) && isDescendant(c.node, node));
+		const subMatch = {
+			pattern: 0,
+			captures: [{
+				name: "call",
+				node
+			}, ...relevant]
+		};
+		const result = extractMessage(name)(subMatch);
+		if (!result) continue;
+		if (result.error) return {
+			node: call,
+			error: result.error
+		};
+		if (result.translation) {
+			ids.push(result.translation.id);
+			strs.push(result.translation.message[0] ?? "");
+		}
+	}
+	if (ids.length === 0) return;
+	const translation = {
+		id: ids[0],
+		plural: ids[1],
+		message: strs
+	};
+	if (msgctxt) translation.context = msgctxt;
+	return {
+		node: call,
+		translation
+	};
+};
+
+//#endregion
+//#region src/plugins/core/queries/context.ts
+const ctxCall = callPattern("context", `[
+  (arguments (string (string_fragment) @msgctxt))
+  (template_string) @msgctxt
+]`).replace(/@call/g, "@ctx").replace(/@func/g, "@ctxfn");
+const contextMsgQuery = withComment({
+	pattern: `(
+  (call_expression
+    function: (member_expression
+      object: ${ctxCall}
+      property: (property_identifier) @func
+    )
+    arguments: ${messageArgs}
+  ) @call
+  (#eq? @func "message")
+)`,
+	extract(match) {
+		const result = extractMessage("context.message")(match);
+		const contextNode = match.captures.find((c) => c.name === "msgctxt")?.node;
+		if (!result || !result.translation || !contextNode) return result;
+		if (contextNode.type === "template_string") for (const child of contextNode.children) {
+			if (child.type !== "template_substitution") continue;
+			const expr = child.namedChildren[0];
+			if (!expr || expr.type !== "identifier") return {
+				node: contextNode,
+				error: "context() template expressions must be simple identifiers"
+			};
+		}
+		const contextText = contextNode.type === "template_string" ? contextNode.text.slice(1, -1) : contextNode.text;
+		return {
+			node: result.node,
+			translation: {
+				...result.translation,
+				context: contextText
+			}
+		};
+	}
+});
+const msgCall$3 = callPattern("message", messageArgs, false).replace(/@call/g, "@msg").replace(/@func/g, "@msgfn");
+const contextPluralQuery = withComment({
+	pattern: `(
+  (call_expression
+    function: (member_expression
+      object: ${ctxCall}
+      property: (property_identifier) @func
+    )
+    arguments: (arguments (
+      (${msgCall$3} ("," )?)+
+      (number) @n
+    ))
+  ) @call
+  (#eq? @func "plural")
+)`,
+	extract: extractPluralForms("context.plural")
+});
+const contextInvalidQuery = withComment({
+	pattern: ctxCall,
+	extract(match) {
+		const call = match.captures.find((c) => c.name === "ctx")?.node;
+		if (!call) return;
+		const parent = call.parent;
+		if (parent && parent.type === "member_expression" && parent.childForFieldName("object")?.id === call.id) {
+			const property = parent.childForFieldName("property")?.text;
+			const grandparent = parent.parent;
+			if (grandparent && grandparent.type === "call_expression" && grandparent.childForFieldName("function")?.id === parent.id && (property === "message" || property === "plural")) return;
+		}
+		return {
+			node: call,
+			error: "context() must be used with message() or plural() in the same expression"
+		};
+	}
+});
+
+//#endregion
+//#region src/plugins/core/queries/gettext.ts
+const gettextQuery = withComment({
+	pattern: callPattern("gettext", messageArgs),
+	extract: extractMessage("gettext")
+});
+const allowed = new Set([
+	"string",
+	"object",
+	"template_string",
+	"identifier",
+	"call_expression"
+]);
+const gettextInvalidQuery = {
+	pattern: callPattern("gettext", "(arguments (_) @arg)"),
+	extract(match) {
+		const call = match.captures.find((c) => c.name === "call")?.node;
+		const node = match.captures.find((c) => c.name === "arg")?.node;
+		if (!call || !node) return;
+		if (allowed.has(node.type)) return;
+		return {
+			node,
+			error: "gettext() argument must be a string literal, object literal, or template literal"
+		};
+	}
+};
+
+//#endregion
+//#region src/plugins/core/queries/ngettext.ts
+const msgCall$2 = callPattern("message", messageArgs).replace(/@call/g, "@msg").replace(/@func/g, "@msgfn");
+const plainMsg$1 = `(${messageArg}) @msg`;
+const msgArg$1 = `[${msgCall$2} ${plainMsg$1}]`;
+const ngettextQuery = withComment({
+	pattern: callPattern("ngettext", `(arguments ${msgArg$1} "," ${msgArg$1} ("," ${msgArg$1})* "," (_) @n)`),
+	extract: extractPluralForms("ngettext")
+});
+
+//#endregion
+//#region src/plugins/core/queries/npgettext.ts
+const msgCall$1 = callPattern("message", messageArgs).replace(/@call/g, "@msg").replace(/@func/g, "@msgfn");
+const plainMsg = `(${messageArg}) @msg`;
+const msgArg = `[${msgCall$1} ${plainMsg}]`;
+const npgettextQuery = withComment({
+	pattern: callPattern("npgettext", `(arguments (string (string_fragment) @msgctxt) "," ${msgArg} "," ${msgArg} ("," ${msgArg})* "," (_) @n)`),
+	extract: extractPluralForms("npgettext")
+});
+
+//#endregion
+//#region src/plugins/core/queries/pgettext.ts
+const pgettextQuery = withComment({
+	pattern: callPattern("pgettext", `(arguments (string (string_fragment) @msgctxt) "," ${messageArg})`),
+	extract(match) {
+		const result = extractMessage("pgettext")(match);
+		const contextNode = match.captures.find((c) => c.name === "msgctxt")?.node;
+		if (!result || !contextNode || !result.translation) return result;
+		return {
+			node: result.node,
+			translation: {
+				...result.translation,
+				context: contextNode.text
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/plugins/core/queries/plural.ts
+const msgCall = callPattern("message", messageArgs, false).replace(/@call/g, "@msg").replace(/@func/g, "@msgfn");
+const pluralQuery$1 = withComment({
+	pattern: callPattern("plural", `(arguments (
+            (${msgCall} ("," )?)+
+            (number) @n
+        ))`, false),
+	extract: extractPluralForms("plural")
+});
+
+//#endregion
+//#region src/plugins/core/queries/index.ts
+const queries$1 = [
+	contextMsgQuery,
+	contextPluralQuery,
+	contextInvalidQuery,
+	messageQuery$1,
+	messageInvalidQuery,
+	gettextQuery,
+	gettextInvalidQuery,
+	pluralQuery$1,
+	ngettextQuery,
+	pgettextQuery,
+	npgettextQuery
+];
+
+//#endregion
+//#region src/plugins/core/parse.ts
+function getLanguage(ext) {
+	switch (ext) {
+		case ".ts": return TS.typescript;
+		case ".tsx": return TS.tsx;
+		default: return JavaScript;
+	}
+}
+const parserCache = /* @__PURE__ */ new Map();
+const queryCache = /* @__PURE__ */ new WeakMap();
+function getCachedParser(ext) {
+	let cached = parserCache.get(ext);
+	if (!cached) {
+		const parser = new Parser();
+		const language = getLanguage(ext);
+		parser.setLanguage(language);
+		cached = {
+			parser,
+			language
+		};
+		parserCache.set(ext, cached);
+	}
+	return cached;
+}
+function getCachedQuery(language, pattern) {
+	let cache = queryCache.get(language);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		queryCache.set(language, cache);
+	}
+	let query = cache.get(pattern);
+	if (!query) {
+		query = new Parser.Query(language, pattern);
+		cache.set(pattern, query);
+	}
+	return query;
+}
+function getParser(path$1) {
+	const ext = extname(path$1);
+	return getCachedParser(ext);
+}
+function getQuery(language, pattern) {
+	return getCachedQuery(language, pattern);
+}
+function parseSource$1(source, path$1) {
+	const context = { path: path$1 };
+	const { parser, language } = getParser(path$1);
+	const tree = parser.parse(source);
+	const translations = [];
+	const warnings = [];
+	const imports = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const spec of queries$1) {
+		const query = getCachedQuery(language, spec.pattern);
+		for (const match of query.matches(tree.rootNode)) {
+			const message = spec.extract(match);
+			if (!message) continue;
+			const { node, translation, error } = message;
+			if (seen.has(node.id)) continue;
+			seen.add(node.id);
+			const reference = getReference(node, context);
+			if (translation) translations.push({
+				...translation,
+				comments: {
+					...translation.comments,
+					reference
+				}
+			});
+			if (error) warnings.push({
+				error,
+				reference
+			});
+		}
+	}
+	const importTreeQuery = getCachedQuery(language, importQuery.pattern);
+	for (const match of importTreeQuery.matches(tree.rootNode)) {
+		const imp = importQuery.extract(match);
+		if (imp) imports.push(imp);
+	}
+	return {
+		translations,
+		imports,
+		warnings
+	};
+}
+
+//#endregion
+//#region src/plugins/core/resolve.ts
+function findTsconfig(dir) {
+	let current = dir;
+	while (true) {
+		const config = path.join(current, "tsconfig.json");
+		if (fs$1.existsSync(config)) return config;
+		const parent = path.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+const resolverCache = /* @__PURE__ */ new Map();
+function getResolver(dir) {
+	const tsconfig = findTsconfig(dir);
+	const key = tsconfig ?? "__default__";
+	let resolver = resolverCache.get(key);
+	if (!resolver) {
+		resolver = new ResolverFactory({
+			extensions: [
+				".ts",
+				".tsx",
+				".js",
+				".jsx",
+				".mjs",
+				".cjs",
+				".json"
+			],
+			conditionNames: [
+				"import",
+				"require",
+				"node"
+			],
+			...tsconfig ? { tsconfig: { configFile: tsconfig } } : {}
+		});
+		resolverCache.set(key, resolver);
+	}
+	return resolver;
+}
+function resolveImports(file, imports) {
+	const dir = path.dirname(path.resolve(file));
+	const resolver = getResolver(dir);
+	const resolved = [];
+	for (const spec of imports) {
+		const res = resolver.sync(dir, spec);
+		if (res.path) resolved.push(res.path);
+	}
+	return resolved;
+}
+
+//#endregion
+//#region src/plugins/core/core.ts
+const filter$1 = /\.([cm]?tsx?|jsx?)$/;
+const namespace$1 = "source";
+function core() {
+	return {
+		name: "core",
+		setup(build) {
+			build.context.logger?.debug("core plugin initialized");
+			build.onResolve({
+				filter: filter$1,
+				namespace: namespace$1
+			}, ({ entrypoint, path: path$1 }) => {
+				return {
+					entrypoint,
+					namespace: namespace$1,
+					path: resolve(path$1)
+				};
+			});
+			build.onLoad({
+				filter: filter$1,
+				namespace: namespace$1
+			}, async ({ entrypoint, path: path$1 }) => {
+				const data = await readFile(path$1, "utf8");
+				return {
+					entrypoint,
+					path: path$1,
+					namespace: namespace$1,
+					data
+				};
+			});
+			build.onProcess({
+				filter: filter$1,
+				namespace: namespace$1
+			}, ({ entrypoint, path: path$1, data }) => {
+				const { translations, imports, warnings } = parseSource$1(data, path$1);
+				if (build.context.config.walk) {
+					const paths = resolveImports(path$1, imports);
+					for (const path$2 of paths) build.resolve({
+						entrypoint,
+						path: path$2,
+						namespace: namespace$1
+					});
+				}
+				for (const warning of warnings) build.context.logger?.warn(`${warning.error} at ${warning.reference}`);
+				build.resolve({
+					entrypoint,
+					path: path$1,
+					namespace: "translate",
+					data: translations
+				});
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/po/collect.ts
+function collect(source, locale) {
+	const translations = { "": {} };
+	const nplurals = locale ? getNPlurals(locale) : void 0;
+	for (const { context, id, message, comments, obsolete, plural } of source) {
+		const ctx = context || "";
+		if (!translations[ctx]) translations[ctx] = {};
+		const length = plural ? nplurals ?? message.length : 1;
+		const existing = translations[ctx][id];
+		const refs = /* @__PURE__ */ new Set();
+		if (existing?.comments?.reference) existing.comments.reference.split(/\r?\n|\r/).forEach((r) => {
+			refs.add(r);
+		});
+		if (comments?.reference) comments.reference.split(/\r?\n|\r/).forEach((r) => {
+			refs.add(r);
+		});
+		const msgstr = existing?.msgstr ? existing.msgstr.slice(0, length) : Array.from({ length }, () => "");
+		while (msgstr.length < length) msgstr.push("");
+		translations[ctx][id] = {
+			msgctxt: context || void 0,
+			msgid: id,
+			msgid_plural: plural,
+			msgstr,
+			comments: {
+				...existing?.comments,
+				...comments,
+				reference: refs.size ? Array.from(refs).join("\n") : void 0
+			},
+			obsolete: existing?.obsolete ?? obsolete
+		};
+	}
+	return translations;
+}
+
+//#endregion
+//#region src/plugins/po/hasChanges.ts
+const IGNORED_HEADER_KEYS = new Set(["pot-creation-date", "po-revision-date"]);
+const IGNORED_HEADER_LINE_PREFIXES = ["pot-creation-date:", "po-revision-date:"];
+function normalizeHeaderString(value) {
+	const lines = value.split("\n");
+	const hadTrailingNewline = value.endsWith("\n");
+	const filtered = lines.filter((line) => {
+		const trimmed = line.trimStart().toLowerCase();
+		return !IGNORED_HEADER_LINE_PREFIXES.some((prefix) => trimmed.startsWith(prefix));
+	}).map((line) => {
+		const separatorIndex = line.indexOf(":");
+		if (separatorIndex === -1) return line;
+		const key = line.slice(0, separatorIndex).trim().toLowerCase();
+		const value$1 = line.slice(separatorIndex + 1);
+		return `${key}:${value$1}`;
+	});
+	if (hadTrailingNewline && filtered[filtered.length - 1] !== "") filtered.push("");
+	return filtered.join("\n");
+}
+function normalize(translations) {
+	const compiled = gettextParser.po.compile(translations);
+	const parsed = gettextParser.po.parse(compiled);
+	if (parsed.headers) {
+		const normalizedHeaders = {};
+		for (const [key, value] of Object.entries(parsed.headers)) if (!IGNORED_HEADER_KEYS.has(key.toLowerCase())) normalizedHeaders[key.toLowerCase()] = value;
+		parsed.headers = normalizedHeaders;
+	}
+	const headerMessage = parsed.translations?.[""]?.[""];
+	if (headerMessage?.msgstr) headerMessage.msgstr = headerMessage.msgstr.map((item) => normalizeHeaderString(item));
+	return parsed;
+}
+function hasChanges(left, right) {
+	if (!right) return true;
+	const normalizedLeft = normalize(left);
+	const normalizedRight = normalize(right);
+	return !isDeepStrictEqual(normalizedLeft, normalizedRight);
+}
+
+//#endregion
+//#region src/plugins/po/merge.ts
+function formatDate(date) {
+	const pad = (n) => n.toString().padStart(2, "0");
+	const year = date.getFullYear();
+	const month = pad(date.getMonth() + 1);
+	const day = pad(date.getDate());
+	const hours = pad(date.getHours());
+	const minutes = pad(date.getMinutes());
+	const tzo = -date.getTimezoneOffset();
+	const sign = tzo >= 0 ? "+" : "-";
+	const offsetHours = pad(Math.floor(Math.abs(tzo) / 60));
+	const offsetMinutes = pad(Math.abs(tzo) % 60);
+	return `${year}-${month}-${day} ${hours}:${minutes}${sign}${offsetHours}${offsetMinutes}`;
+}
+function merge(sources, existing, obsolete, locale, generatedAt) {
+	let headers = {};
+	let translations = { "": {} };
+	let obsoleteTranslations = {};
+	const nplurals = getNPlurals(locale);
+	if (existing) {
+		headers = existing.headers ? structuredClone(existing.headers) : {};
+		translations = existing.translations ? structuredClone(existing.translations) : { "": {} };
+		obsoleteTranslations = existing.obsolete ? structuredClone(existing.obsolete) : {};
+		for (const ctx of Object.keys(translations)) for (const id of Object.keys(translations[ctx])) {
+			if (ctx === "" && id === "") continue;
+			translations[ctx][id].obsolete = true;
+		}
+	}
+	const collected = { "": {} };
+	for (const { translations: translations$1 } of sources) for (const [ctx, msgs] of Object.entries(translations$1)) {
+		if (!collected[ctx]) collected[ctx] = {};
+		for (const [id, entry] of Object.entries(msgs)) {
+			const existing$1 = collected[ctx][id];
+			const refs = /* @__PURE__ */ new Set();
+			if (existing$1?.comments?.reference) existing$1.comments.reference.split(/\r?\n|\r/).forEach((r) => {
+				refs.add(r);
+			});
+			if (entry.comments?.reference) entry.comments.reference.split(/\r?\n|\r/).forEach((r) => {
+				refs.add(r);
+			});
+			collected[ctx][id] = {
+				...existing$1,
+				...entry,
+				comments: {
+					...existing$1?.comments,
+					...entry.comments,
+					reference: refs.size ? Array.from(refs).join("\n") : void 0
+				}
+			};
+		}
+	}
+	for (const [ctx, msgs] of Object.entries(collected)) {
+		if (!translations[ctx]) translations[ctx] = {};
+		for (const [id, entry] of Object.entries(msgs)) {
+			const existingEntry = translations[ctx][id] ?? obsoleteTranslations[ctx]?.[id];
+			if (existingEntry) {
+				entry.msgstr = existingEntry.msgstr;
+				entry.comments = {
+					...entry.comments,
+					translator: existingEntry.comments?.translator
+				};
+			}
+			delete entry.obsolete;
+			entry.msgstr = entry.msgstr.slice(0, nplurals);
+			while (entry.msgstr.length < nplurals) entry.msgstr.push("");
+			translations[ctx][id] = entry;
+			if (obsoleteTranslations[ctx]) delete obsoleteTranslations[ctx][id];
+		}
+	}
+	for (const ctx of Object.keys(translations)) for (const id of Object.keys(translations[ctx])) {
+		if (ctx === "" && id === "") continue;
+		const entry = translations[ctx][id];
+		if (entry.obsolete) {
+			if (!obsoleteTranslations[ctx]) obsoleteTranslations[ctx] = {};
+			obsoleteTranslations[ctx][id] = entry;
+			delete translations[ctx][id];
+		}
+	}
+	headers = {
+		...headers,
+		"Content-Type": headers["Content-Type"] || "text/plain; charset=UTF-8",
+		"Plural-Forms": `nplurals=${nplurals}; plural=${getFormula(locale)};`,
+		language: locale,
+		"MIME-Version": "1.0",
+		"Content-Transfer-Encoding": "8bit",
+		"POT-Creation-Date": formatDate(generatedAt),
+		"x-generator": "@let-value/translate-extract"
+	};
+	return {
+		charset: "utf-8",
+		headers,
+		translations,
+		...obsolete === "mark" && Object.keys(obsoleteTranslations).length ? { obsolete: obsoleteTranslations } : {}
+	};
+}
+
+//#endregion
+//#region src/plugins/po/po.ts
+const namespace = "translate";
+function po() {
+	return {
+		name: "po",
+		setup(build) {
+			build.context.logger?.debug("po plugin initialized");
+			const collections = /* @__PURE__ */ new Map();
+			let dispatched = false;
+			build.onResolve({
+				filter: /.*/,
+				namespace
+			}, async ({ entrypoint, path: path$1, data }) => {
+				if (!data || !Array.isArray(data)) return;
+				for (const locale of build.context.config.locales) {
+					const destination = build.context.config.destination({
+						entrypoint,
+						locale,
+						path: path$1
+					});
+					if (!collections.has(destination)) collections.set(destination, {
+						locale,
+						translations: []
+					});
+					collections.get(destination)?.translations.push(...data);
+				}
+				Promise.all([build.defer("source"), build.defer(namespace)]).then(() => {
+					if (dispatched) return;
+					dispatched = true;
+					for (const path$2 of collections.keys()) build.load({
+						entrypoint,
+						path: path$2,
+						namespace
+					});
+				});
+			});
+			build.onLoad({
+				filter: /.*\.po$/,
+				namespace
+			}, async ({ entrypoint, path: path$1 }) => {
+				const contents = await fs.readFile(path$1).catch(() => void 0);
+				const data = contents ? gettextParser.po.parse(contents) : void 0;
+				return {
+					entrypoint,
+					path: path$1,
+					namespace,
+					data
+				};
+			});
+			build.onProcess({
+				filter: /.*\.po$/,
+				namespace
+			}, async ({ entrypoint, path: path$1, data }) => {
+				const collected = collections.get(path$1);
+				if (!collected) {
+					build.context.logger?.warn({ path: path$1 }, "no translations collected for this path");
+					return;
+				}
+				const { locale, translations } = collected;
+				const record = collect(translations, locale);
+				const out = merge([{ translations: record }], data, build.context.config.obsolete, locale, build.context.generatedAt);
+				if (hasChanges(out, data)) {
+					await fs.mkdir(dirname(path$1), { recursive: true });
+					await fs.writeFile(path$1, gettextParser.po.compile(out));
+				}
+				build.resolve({
+					entrypoint,
+					path: path$1,
+					namespace: "cleanup",
+					data: translations
+				});
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/react/queries/utils.ts
+function buildTemplate(node) {
+	const source = node.tree.rootNode.text;
+	const open = node.childForFieldName("open_tag");
+	const close = node.childForFieldName("close_tag");
+	const contentStart = open?.endIndex ?? node.startIndex;
+	const contentEnd = close?.startIndex ?? node.endIndex;
+	const parts = [];
+	let segmentStart = contentStart;
+	const pushRawText = (endIndex) => {
+		if (endIndex <= segmentStart) {
+			segmentStart = Math.max(segmentStart, endIndex);
+			return;
+		}
+		const text$1 = source.slice(segmentStart, endIndex);
+		if (text$1) parts.push({
+			kind: "text",
+			text: text$1,
+			raw: true
+		});
+		segmentStart = endIndex;
+	};
+	const children = node.namedChildren.slice(1, -1);
+	for (const child of children) if (child.type === "jsx_expression") {
+		pushRawText(child.startIndex);
+		const expr = child.namedChildren[0];
+		if (!expr) return {
+			text: "",
+			error: "Empty JSX expression"
+		};
+		if (expr.type === "identifier") parts.push({
+			kind: "expr",
+			value: expr.text
+		});
+		else if (expr.type === "string") parts.push({
+			kind: "text",
+			text: expr.text.slice(1, -1),
+			raw: false
+		});
+		else if (expr.type === "template_string") {
+			if (expr.children.some((c) => c.type === "template_substitution")) return {
+				text: "",
+				error: "JSX expressions with template substitutions are not supported"
+			};
+			parts.push({
+				kind: "text",
+				text: expr.text.slice(1, -1),
+				raw: false
+			});
+		} else return {
+			text: "",
+			error: "JSX expressions must be simple identifiers, strings, or template literals"
+		};
+		segmentStart = child.endIndex;
+	} else if (child.type === "string") {
+		pushRawText(child.startIndex);
+		parts.push({
+			kind: "text",
+			text: child.text.slice(1, -1),
+			raw: false
+		});
+		segmentStart = child.endIndex;
+	} else if (child.type === "jsx_text" || child.type === "html_character_reference" || child.isError) {} else return {
+		text: "",
+		error: "Unsupported JSX child"
+	};
+	pushRawText(contentEnd);
+	const firstRawIndex = parts.findIndex((part) => part.kind === "text" && part.raw);
+	if (firstRawIndex === 0) {
+		const part = parts[firstRawIndex];
+		part.text = part.text.replace(/^\s+/, "");
+	}
+	let lastRawIndex = -1;
+	for (let i = parts.length - 1; i >= 0; i--) {
+		const part = parts[i];
+		if (part.kind === "text" && part.raw) {
+			lastRawIndex = i;
+			break;
+		}
+	}
+	if (lastRawIndex !== -1 && lastRawIndex === parts.length - 1) {
+		const part = parts[lastRawIndex];
+		part.text = part.text.replace(/\s+$/, "");
+	}
+	const strings = [""];
+	const values = [];
+	for (const part of parts) if (part.kind === "text") {
+		if (part.text) strings[strings.length - 1] += part.text;
+	} else {
+		values.push(part.value);
+		strings.push("");
+	}
+	let text = "";
+	for (let i = 0; i < strings.length; i++) {
+		text += strings[i];
+		if (values[i]) text += `\${${values[i]}}`;
+	}
+	return { text };
+}
+function buildAttrValue(node) {
+	if (node.type === "string") return { text: node.text.slice(1, -1) };
+	if (node.type === "jsx_expression") {
+		const expr = node.namedChildren[0];
+		if (!expr) return {
+			text: "",
+			error: "Empty JSX expression"
+		};
+		if (expr.type === "identifier") return { text: `\${${expr.text}}` };
+		else if (expr.type === "string") return { text: expr.text.slice(1, -1) };
+		else if (expr.type === "template_string") {
+			if (expr.children.some((c) => c.type === "template_substitution")) return {
+				text: "",
+				error: "JSX expressions with template substitutions are not supported"
+			};
+			return { text: expr.text.slice(1, -1) };
+		} else return {
+			text: "",
+			error: "JSX expressions must be simple identifiers, strings, or template literals"
+		};
+	}
+	return {
+		text: "",
+		error: "Unsupported JSX child"
+	};
+}
+
+//#endregion
+//#region src/plugins/react/queries/message.ts
+const messageQuery = withComment({
+	pattern: `(
+        [
+            (jsx_element (jsx_opening_element name: (identifier) @name)) @call
+            (jsx_self_closing_element name: (identifier) @name) @call
+            (lexical_declaration 
+                (variable_declarator 
+                    value: [
+                        (jsx_element (jsx_opening_element name: (identifier) @name)) @call
+                        (jsx_self_closing_element name: (identifier) @name) @call
+                    ]
+                )
+            )
+        ]
+        (#eq? @name "Message")
+    )`,
+	extract(match) {
+		const node = match.captures.find((c) => c.name === "call")?.node;
+		if (!node) return void 0;
+		let attrs = [];
+		if (node.type === "jsx_element") {
+			const open = node.childForFieldName("open_tag");
+			if (open) attrs = open.namedChildren;
+		} else if (node.type === "jsx_self_closing_element") attrs = node.namedChildren.slice(1);
+		let msgctxt;
+		let childValue;
+		for (const child of attrs) {
+			if (child.type !== "jsx_attribute") continue;
+			const name = child.child(0);
+			const value = child.child(child.childCount - 1);
+			if (name?.text === "context" && value?.type === "string") msgctxt = value.text.slice(1, -1);
+			else if (name?.text === "children" && value) childValue = value;
+		}
+		let text = "";
+		let error;
+		if (node.type === "jsx_element") ({text, error} = buildTemplate(node));
+		else if (childValue) ({text, error} = buildAttrValue(childValue));
+		if (error) return {
+			node,
+			error
+		};
+		if (!text) return void 0;
+		const translation = {
+			id: text,
+			message: [text]
+		};
+		if (msgctxt) translation.context = msgctxt;
+		return {
+			node,
+			translation
+		};
+	}
+});
+
+//#endregion
+//#region src/plugins/react/queries/plural.ts
+function parseForms(node) {
+	const forms = [];
+	if (node.type === "jsx_expression") {
+		const arr = node.namedChildren[0];
+		if (!arr || arr.type !== "array") return {
+			forms: [],
+			error: "Plural forms must be an array"
+		};
+		for (const el of arr.namedChildren) if (el.type === "jsx_element" || el.type === "jsx_fragment") {
+			const { text, error } = buildTemplate(el);
+			if (error) return {
+				forms: [],
+				error
+			};
+			forms.push(text);
+		} else if (el.type === "string") forms.push(el.text.slice(1, -1));
+		else return {
+			forms: [],
+			error: "Unsupported plural form"
+		};
+	}
+	return { forms };
+}
+const pluralQuery = withComment({
+	pattern: `(
+        [
+            (jsx_element (jsx_opening_element name: (identifier) @name))
+            (jsx_self_closing_element name: (identifier) @name)
+        ] @call
+        (#eq? @name "Plural")
+    )`,
+	extract(match) {
+		const node = match.captures.find((c) => c.name === "call")?.node;
+		if (!node) return void 0;
+		let attrs = [];
+		if (node.type === "jsx_element") {
+			const open = node.childForFieldName("open_tag");
+			if (open) attrs = open.namedChildren;
+		} else if (node.type === "jsx_self_closing_element") attrs = node.namedChildren.slice(1);
+		let msgctxt;
+		let formsNode;
+		for (const child of attrs) {
+			if (child.type !== "jsx_attribute") continue;
+			const name = child.child(0);
+			const value = child.child(child.childCount - 1);
+			if (name?.text === "context" && value?.type === "string") msgctxt = value.text.slice(1, -1);
+			else if (name?.text === "forms" && value) formsNode = value;
+		}
+		if (!formsNode) return void 0;
+		const { forms, error } = parseForms(formsNode);
+		if (error) return {
+			node,
+			error
+		};
+		if (forms.length === 0) return void 0;
+		const translation = {
+			id: forms[0],
+			plural: forms[1],
+			message: forms
+		};
+		if (msgctxt) translation.context = msgctxt;
+		return {
+			node,
+			translation
+		};
+	}
+});
+
+//#endregion
+//#region src/plugins/react/queries/index.ts
+const queries = [messageQuery, pluralQuery];
+
+//#endregion
+//#region src/plugins/react/parse.ts
+function parseSource(source, path$1) {
+	const context = { path: path$1 };
+	const { parser, language } = getParser(path$1);
+	const tree = parser.parse(source);
+	const translations = [];
+	const warnings = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const spec of queries) {
+		const query = getQuery(language, spec.pattern);
+		for (const match of query.matches(tree.rootNode)) {
+			const message = spec.extract(match);
+			if (!message) continue;
+			const { node, translation, error } = message;
+			if (seen.has(node.id)) continue;
+			seen.add(node.id);
+			const reference = getReference(node, context);
+			if (translation) translations.push({
+				...translation,
+				comments: {
+					...translation.comments,
+					reference
+				}
+			});
+			if (error) warnings.push({
+				error,
+				reference
+			});
+		}
+	}
+	return {
+		translations,
+		warnings
+	};
+}
+
+//#endregion
+//#region src/plugins/react/react.ts
+const filter = /\.[cm]?[jt]sx$/;
+function react() {
+	return {
+		name: "react",
+		setup(build) {
+			build.context.logger?.debug("react plugin initialized");
+			build.onResolve({
+				filter: /.*/,
+				namespace: "source"
+			}, ({ entrypoint, path: path$1, namespace: namespace$3 }) => {
+				return {
+					entrypoint,
+					namespace: namespace$3,
+					path: resolve(path$1)
+				};
+			});
+			build.onLoad({
+				filter,
+				namespace: "source"
+			}, async ({ entrypoint, path: path$1, namespace: namespace$3 }) => {
+				const data = await readFile(path$1, "utf8");
+				return {
+					entrypoint,
+					path: path$1,
+					namespace: namespace$3,
+					data
+				};
+			});
+			build.onProcess({
+				filter,
+				namespace: "source"
+			}, ({ entrypoint, path: path$1, data }) => {
+				const { translations, warnings } = parseSource(data, path$1);
+				for (const warning of warnings) build.context.logger?.warn(`${warning.error} at ${warning.reference}`);
+				build.resolve({
+					entrypoint,
+					path: path$1,
+					namespace: "translate",
+					data: translations
+				});
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/static.ts
+const original = {
+	cleanup,
+	core,
+	po,
+	react
+};
+function resolveStaticPlugin(item) {
+	if ("static" in item) return original[item.static.name](...item.static.props);
+	return item;
+}
+
+//#endregion
+//#region src/run.ts
+async function run(entrypoint, { config, logger }) {
+	const destination = entrypoint.destination ?? config.destination;
+	const obsolete = entrypoint.obsolete ?? config.obsolete;
+	const exclude = entrypoint.exclude ?? config.exclude;
+	const walk = entrypoint.walk ?? config.walk;
+	const context = {
+		config: {
+			...config,
+			destination,
+			obsolete,
+			exclude,
+			walk
+		},
+		generatedAt: /* @__PURE__ */ new Date(),
+		logger
+	};
+	logger?.info(entrypoint, "starting extraction");
+	const resolvers = [];
+	const loaders = [];
+	const processors = [];
+	const hooks = {
+		resolve: resolvers,
+		load: loaders,
+		process: processors
+	};
+	const pending = /* @__PURE__ */ new Map();
+	const queue = [];
+	function getDeferred(namespace$3) {
+		let defer$1 = pending.get(namespace$3);
+		if (defer$1 === void 0) {
+			defer$1 = new Defer();
+			pending.set(namespace$3, defer$1);
+		}
+		return defer$1;
+	}
+	function defer(namespace$3) {
+		return getDeferred(namespace$3).promise;
+	}
+	function resolve$1(args) {
+		const { entrypoint: entrypoint$1, path: path$1, namespace: namespace$3 } = args;
+		const skipped = context.config.exclude.some((ex) => typeof ex === "function" ? ex(args) : ex.test(args.path));
+		logger?.debug({
+			entrypoint: entrypoint$1,
+			path: path$1,
+			namespace: namespace$3,
+			skipped
+		}, "resolve");
+		if (skipped) return;
+		queue.push({
+			type: "resolve",
+			args
+		});
+		getDeferred(namespace$3).enqueue();
+	}
+	function load(args) {
+		const { entrypoint: entrypoint$1, path: path$1, namespace: namespace$3 } = args;
+		logger?.debug({
+			entrypoint: entrypoint$1,
+			path: path$1,
+			namespace: namespace$3
+		}, "load");
+		queue.push({
+			type: "load",
+			args
+		});
+		getDeferred(namespace$3).enqueue();
+	}
+	function process$1(args) {
+		const { entrypoint: entrypoint$1, path: path$1, namespace: namespace$3 } = args;
+		logger?.debug({
+			entrypoint: entrypoint$1,
+			path: path$1,
+			namespace: namespace$3
+		}, "process");
+		queue.push({
+			type: "process",
+			args
+		});
+		getDeferred(namespace$3).enqueue();
+	}
+	const build = {
+		context,
+		resolve: resolve$1,
+		load,
+		process: process$1,
+		defer,
+		onResolve(filter$2, hook) {
+			resolvers.push({
+				filter: filter$2,
+				hook
+			});
+		},
+		onLoad(filter$2, hook) {
+			loaders.push({
+				filter: filter$2,
+				hook
+			});
+		},
+		onProcess(filter$2, hook) {
+			processors.push({
+				filter: filter$2,
+				hook
+			});
+		}
+	};
+	for (const item of config.plugins) {
+		const plugin = resolveStaticPlugin(item);
+		logger?.debug({ plugin: plugin.name }, "setting up plugin");
+		plugin.setup(build);
+	}
+	const pattern = entrypoint.entrypoint.replace(/\\/g, "/");
+	const paths = glob.isDynamicPattern(pattern) ? await glob(pattern, { onlyFiles: true }) : [entrypoint.entrypoint];
+	logger?.debug({
+		entrypoint: entrypoint.entrypoint,
+		paths
+	}, "resolved paths");
+	for (const path$1 of paths) resolve$1({
+		entrypoint: path$1,
+		path: path$1,
+		namespace: "source"
+	});
+	async function processTask(task) {
+		const { type } = task;
+		let args = task.args;
+		const { entrypoint: entrypoint$1, path: path$1, namespace: namespace$3 } = args;
+		logger?.trace({
+			type,
+			entrypoint: entrypoint$1,
+			path: path$1,
+			namespace: namespace$3
+		}, "processing task");
+		for (const { filter: filter$2, hook } of hooks[type]) {
+			if (filter$2.namespace !== namespace$3) continue;
+			if (filter$2.filter && !filter$2.filter.test(path$1)) continue;
+			const result = await hook(args);
+			if (result !== void 0) args = result;
+		}
+		if (args !== void 0) {
+			if (type === "resolve") load(args);
+			else if (type === "load") process$1(args);
+		}
+		getDeferred(namespace$3).dequeue();
+	}
+	while (queue.length || Array.from(pending.values()).some((d) => d.pending > 0)) {
+		while (queue.length) {
+			const task = queue.shift();
+			if (!task) break;
+			await processTask(task);
+		}
+		await Promise.all(Array.from(pending.values()).map((d) => d.promise));
+		await Promise.resolve();
+	}
+	logger?.info(entrypoint, "extraction completed");
+}
+
+//#endregion
+export { cleanup, core, po, react, run };
+//# sourceMappingURL=run-DcO6U79B.js.map