@zintljs/extractor 0.1.0-alpha.6

package/dist/index.mjs

@@ -0,0 +1,2433 @@
+import { parseSync } from "oxc-parser";
+import { dirname, join } from "node:path";
+import { createHash } from "node:crypto";
+//#region src/logger.ts
+const COLORS = {
+	reset: "\x1B[0m",
+	bold: "\x1B[1m",
+	dim: "\x1B[2m",
+	red: "\x1B[31m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m",
+	blue: "\x1B[34m",
+	magenta: "\x1B[35m",
+	cyan: "\x1B[36m",
+	gray: "\x1B[90m"
+};
+const LEVEL_WEIGHTS = {
+	silent: 0,
+	error: 1,
+	warn: 2,
+	info: 3
+};
+var ZintlLogger = class ZintlLogger {
+	level;
+	prefix;
+	debugEnabled = false;
+	debugScope = null;
+	lastDebugTime = Date.now();
+	constructor(options = {}) {
+		const envLevel = typeof process !== "undefined" ? process.env?.ZINTL_LOG_LEVEL : void 0;
+		const isTest = typeof process !== "undefined" && (process.env?.NODE_ENV === "test" || process.env?.VITEST === "true");
+		this.prefix = options.prefix || "Zintl";
+		this.setupDebug(options.debug);
+		const resolvedLevel = envLevel || options.level || (isTest && !this.debugEnabled ? "silent" : "info");
+		this.level = LEVEL_WEIGHTS[resolvedLevel] ?? LEVEL_WEIGHTS.info;
+	}
+	setupDebug(debugOption) {
+		const envDebug = (typeof process !== "undefined" ? process.env?.DEBUG : "") || "";
+		const isZintlAll = envDebug.includes("zintl:*");
+		if (debugOption === true || isZintlAll || envDebug === "*") {
+			this.debugEnabled = true;
+			return;
+		}
+		if (typeof debugOption === "string") {
+			this.debugScope = debugOption;
+			this.debugEnabled = true;
+			return;
+		}
+		const normalizedScope = this.prefix.toLowerCase().split("/").pop();
+		if (normalizedScope && envDebug.includes(`zintl:${normalizedScope}`)) this.debugEnabled = true;
+	}
+	formatMessage(levelStr, color, message) {
+		const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString([], { hour12: false });
+		return `${`${COLORS.gray}[${timestamp}]${COLORS.reset} ${color}${COLORS.bold}[${this.prefix}/${levelStr}]${COLORS.reset}`} ${message}`;
+	}
+	formatDebugMessage(message) {
+		const now = Date.now();
+		const diff = now - this.lastDebugTime;
+		this.lastDebugTime = now;
+		const namespace = `zintl:${this.prefix.toLowerCase().replace(/^zintl\//i, "")}`;
+		const colors = [
+			COLORS.magenta,
+			COLORS.cyan,
+			COLORS.blue,
+			COLORS.green,
+			COLORS.yellow
+		];
+		return `  ${colors[namespace.length % colors.length]}${namespace}${COLORS.reset} ${message} ${COLORS.gray}+${diff}ms${COLORS.reset}`;
+	}
+	error(message, ...args) {
+		if (this.level >= LEVEL_WEIGHTS.error) console.error(this.formatMessage("ERROR", COLORS.red, message), ...args);
+	}
+	warn(message, ...args) {
+		if (this.level >= LEVEL_WEIGHTS.warn) console.warn(this.formatMessage("WARN", COLORS.yellow, message), ...args);
+	}
+	info(message, ...args) {
+		if (this.level >= LEVEL_WEIGHTS.info) console.info(this.formatMessage("INFO", COLORS.cyan, message), ...args);
+	}
+	debug(message, ...args) {
+		if (this.debugEnabled) {
+			if (this.debugScope && !this.prefix.toLowerCase().includes(this.debugScope.toLowerCase())) return;
+			console.debug(this.formatDebugMessage(message), ...args);
+		}
+	}
+	/**
+	* Create a sub-logger with a combined prefix.
+	*/
+	withPrefix(subPrefix) {
+		const newPrefix = `${this.prefix}/${subPrefix}`;
+		const subLogger = new ZintlLogger({
+			level: Object.keys(LEVEL_WEIGHTS).find((key) => LEVEL_WEIGHTS[key] === this.level),
+			prefix: newPrefix,
+			debug: this.debugEnabled || this.debugScope || void 0
+		});
+		subLogger.lastDebugTime = this.lastDebugTime;
+		return subLogger;
+	}
+	setLevel(level) {
+		this.level = LEVEL_WEIGHTS[level];
+	}
+};
+/** Global default logger */
+const logger = new ZintlLogger();
+//#endregion
+//#region src/constants.ts
+/**
+* The extractor's only constants.
+*
+* The former `DEFAULT_UI_ATTRIBUTES` / `DEFAULT_UI_OBJECT_FIELDS` /
+* `DEFAULT_UI_SINK_PROPERTIES` sets and `TEMPLATE_ATTR_REGEX` lived here and
+* encoded opinions about which DOM and JSX attributes are translatable. That is
+* facet knowledge — it now lives in `@zintljs/compiler/facets` and reaches the
+* extractor as descriptors. All four were already unreferenced (one survived
+* only inside a commented-out line) and have been removed.
+*/
+const ZINTL_MACRO = "zintl";
+const RUNTIME_PACKAGE = "zintl";
+/**
+* Module specifiers that carry the Zintl runtime surface.
+*
+* This list was previously inlined at four call sites (`parser.ts`, two in
+* `visitors/program.ts`, one in `visitors/bindings.ts`) and the four had drifted:
+* the `bindings.ts` copy omitted the bare `"zintl"` literal, so a project with a
+* custom `runtimePackage` would have had its bare `"zintl"` imports recognised
+* by three of the four checks and missed by the fourth.
+*/
+const RUNTIME_SPECIFIERS = [
+	"zintl",
+	"zintl/internal",
+	"zintl/macro",
+	"virtual:zintl/runtime/internal"
+];
+/** Whether an import specifier resolves to the Zintl runtime. */
+function isRuntimeSpecifier(source, runtimePackage = RUNTIME_PACKAGE) {
+	return source === runtimePackage || RUNTIME_SPECIFIERS.includes(source);
+}
+const HTML_TAG_SPLIT_REGEX = /(<[^>]+>)/g;
+//#endregion
+//#region src/targets.ts
+let pluginIdCounter = 0;
+const pluginIds = /* @__PURE__ */ new WeakMap();
+function getTargetKey(t) {
+	if (typeof t === "string") return t;
+	if (t && typeof t === "object") {
+		let id = pluginIds.get(t);
+		if (!id) {
+			id = `plugin:${pluginIdCounter++}`;
+			pluginIds.set(t, id);
+		}
+		return id;
+	}
+	return String(t);
+}
+/**
+* Memoized per unique descriptor set. Callers must treat the result as
+* read-only — it is shared. The compiler's `compileExtractionState` copies it
+* before attaching rules, which is what keeps two compilers with identical
+* descriptors from clobbering each other.
+*/
+const targetsCache = /* @__PURE__ */ new Map();
+function resolveTargets(targets) {
+	const cacheKey = targets.map(getTargetKey).join("|");
+	const cached = targetsCache.get(cacheKey);
+	if (cached) return cached;
+	const jsxAttributes = /* @__PURE__ */ new Set();
+	const jsxElementAttributes = /* @__PURE__ */ new Map();
+	const domProperties = /* @__PURE__ */ new Set();
+	const objectFields = /* @__PURE__ */ new Set();
+	const htmlAttributes = /* @__PURE__ */ new Set();
+	const plugins = [];
+	const fastPathHints = [];
+	for (const item of new Set(targets)) if (typeof item === "string") {
+		if (item.startsWith("jsx:")) {
+			const parts = item.split(":");
+			if (parts.length === 3) {
+				const [, element, attr] = parts;
+				if (element === "*") jsxAttributes.add(attr);
+				else {
+					let attrs = jsxElementAttributes.get(element);
+					if (!attrs) {
+						attrs = /* @__PURE__ */ new Set();
+						jsxElementAttributes.set(element, attrs);
+					}
+					attrs.add(attr);
+				}
+				fastPathHints.push(attr);
+			}
+		} else if (item.startsWith("dom:prop:")) {
+			const prop = item.substring(9);
+			domProperties.add(prop);
+			fastPathHints.push(prop);
+		} else if (item.startsWith("dom:attr:")) {
+			const attr = item.substring(9);
+			fastPathHints.push(attr);
+		} else if (item.startsWith("obj:field:")) {
+			const field = item.substring(10);
+			objectFields.add(field);
+			fastPathHints.push(field);
+		} else if (item.startsWith("html:attr:")) {
+			const attr = item.substring(10);
+			htmlAttributes.add(attr);
+			fastPathHints.push(attr);
+		}
+	} else if (item && typeof item === "object") {
+		plugins.push(item);
+		if (item.fastPathHint) if (Array.isArray(item.fastPathHint)) fastPathHints.push(...item.fastPathHint);
+		else fastPathHints.push(item.fastPathHint);
+	}
+	const uniqueHints = Array.from(new Set(fastPathHints));
+	const hasDomSinks = domProperties.size > 0;
+	const hasJsxSinks = jsxAttributes.size > 0 || jsxElementAttributes.size > 0;
+	const hasHtmlSinks = htmlAttributes.size > 0;
+	const patternParts = [
+		"zintl",
+		"loadI18nInstance",
+		"t\\(",
+		...uniqueHints.map((h) => h.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+	];
+	if (hasJsxSinks || hasHtmlSinks) patternParts.push("<");
+	const resolved = {
+		jsxAttributes,
+		jsxElementAttributes,
+		domProperties,
+		objectFields,
+		htmlAttributes,
+		plugins,
+		fastPathHints,
+		uniqueHints,
+		fastPathRegex: new RegExp(patternParts.join("|")),
+		hasDomSinks,
+		hasJsxSinks,
+		sfcRules: [],
+		suppressionRules: [],
+		mustacheRegex: null
+	};
+	targetsCache.set(cacheKey, resolved);
+	return resolved;
+}
+//#endregion
+//#region src/comments.ts
+function parseZintlComments(nodeStart, trivias, code) {
+	const result = {
+		contextVars: {},
+		ignore: false
+	};
+	if (!trivias) return result;
+	for (const trivia of trivias) {
+		if (trivia.start > nodeStart) continue;
+		const gap = code.slice(trivia.end, nodeStart);
+		if ((gap.match(/\n/g) || []).length > 1) continue;
+		if (/[^ \t\r\n{}/ *]/.test(gap)) continue;
+		const text = trivia.value.trim();
+		if (!text.includes("@zintl-")) continue;
+		const parts = text.split(/(@zintl-[a-z]+)/);
+		for (let i = 1; i < parts.length; i += 2) {
+			const directive = parts[i];
+			const content = (parts[i + 1] || "").trim();
+			if (directive === "@zintl-ignore") result.ignore = true;
+			else if (directive === "@zintl-note") {
+				if (!result.note) result.note = content.startsWith(":") ? content.slice(1).trim() : content;
+			} else if (directive === "@zintl-pass") {
+				const varRegex = /([a-zA-Z0-9_]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|\{([^}]*)\}|([^\s]+))/g;
+				let match;
+				while ((match = varRegex.exec(content)) !== null) {
+					const name = match[1];
+					const doubleQuoted = match[2];
+					const singleQuoted = match[3];
+					const expression = match[4];
+					const unquoted = match[5];
+					if (expression !== void 0) result.contextVars[name] = expression.trim();
+					else if (doubleQuoted !== void 0) result.contextVars[name] = `"${doubleQuoted}"`;
+					else if (singleQuoted !== void 0) result.contextVars[name] = `'${singleQuoted}'`;
+					else if (unquoted !== void 0) if (!isNaN(Number(unquoted)) || unquoted === "true" || unquoted === "false") result.contextVars[name] = unquoted;
+					else result.contextVars[name] = `"${unquoted}"`;
+				}
+			}
+		}
+	}
+	return result;
+}
+/**
+* Heuristic to find comments attached to a node or its logical parents.
+*/
+function getAttachedComments(node, parents, trivias, code) {
+	if (!trivias) return {
+		contextVars: {},
+		ignore: false
+	};
+	return parseZintlComments(node.start, trivias, code);
+}
+/**
+* Extracts directives from a raw string (e.g. an HTML comment tag)
+*/
+function parseHTMLDirectives(text) {
+	const result = {
+		contextVars: {},
+		ignore: false
+	};
+	const cleanText = text.replace(/^<!--/, "").replace(/-->$/, "").trim();
+	if (!cleanText.includes("@zintl-")) return result;
+	const parts = cleanText.split(/(@zintl-[a-z]+)/);
+	for (let i = 1; i < parts.length; i += 2) {
+		const directive = parts[i];
+		let content = (parts[i + 1] || "").trim();
+		if (content.startsWith(":")) content = content.slice(1).trim();
+		if (directive === "@zintl-ignore") result.ignore = true;
+		else if (directive === "@zintl-note") {
+			if (!result.note) result.note = content;
+		} else if (directive === "@zintl-pass") {
+			const varRegex = /([a-zA-Z0-9_]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|\{([^}]*)\}|([^\s]+))/g;
+			let match;
+			while ((match = varRegex.exec(content)) !== null) {
+				const name = match[1];
+				const doubleQuoted = match[2];
+				const singleQuoted = match[3];
+				const expression = match[4];
+				const unquoted = match[5];
+				if (expression !== void 0) result.contextVars[name] = expression.trim();
+				else if (doubleQuoted !== void 0) result.contextVars[name] = `"${doubleQuoted}"`;
+				else if (singleQuoted !== void 0) result.contextVars[name] = `'${singleQuoted}'`;
+				else if (unquoted !== void 0) if (!isNaN(Number(unquoted)) || unquoted === "true" || unquoted === "false") result.contextVars[name] = unquoted;
+				else result.contextVars[name] = `"${unquoted}"`;
+			}
+		}
+	}
+	return result;
+}
+//#endregion
+//#region src/context.ts
+const VOID_ELEMENTS = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+function getTagName(token) {
+	const match = token.match(/^<\/?([a-zA-Z0-9:-]+)/);
+	return match ? match[1].toLowerCase() : "";
+}
+function isSingleWrappingPhrasingTag(html) {
+	const trimmed = html.trim();
+	if (!trimmed.startsWith("<") || !trimmed.endsWith(">")) return false;
+	if (trimmed.endsWith("/>")) return false;
+	const tokens = trimmed.split(/(<[^>]+>)/g).filter((t) => t.length > 0);
+	if (tokens.length < 3) return false;
+	const first = tokens[0];
+	if (!first.startsWith("<") || first.startsWith("</") || first.startsWith("<!--")) return false;
+	const firstTagName = getTagName(first);
+	if (!INLINE_PHRASING_TAGS.has(firstTagName.replace(/\d+$/, ""))) return false;
+	const last = tokens[tokens.length - 1];
+	if (last !== `</${firstTagName}>` && !last.startsWith(`</${firstTagName}`)) return false;
+	const stack = [];
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token.startsWith("<") && token.endsWith(">")) {
+			if (token.startsWith("<!--")) continue;
+			const isClosing = token.startsWith("</");
+			if (token.endsWith("/>")) continue;
+			const tagName = getTagName(token);
+			if (isClosing) {
+				if (stack.length === 0) return false;
+				if (stack.pop() !== tagName) return false;
+				if (stack.length === 0 && i < tokens.length - 1) return false;
+			} else stack.push(tagName);
+		}
+	}
+	return stack.length === 0;
+}
+function hasTranslatableText(text) {
+	let stripped = text.replace(/<[^>]+>/g, "");
+	stripped = stripped.replace(/\{[^}]+\}/g, "");
+	return stripped.trim().length > 0;
+}
+function hasNonWhitespaceOutsidePhrasing(html) {
+	const tokens = html.split(/(<[^>]+>)/g);
+	let textOutside = "";
+	const stack = [];
+	for (const token of tokens) if (token.startsWith("<") && token.endsWith(">")) {
+		if (token.startsWith("<!--")) continue;
+		const isClosing = token.startsWith("</");
+		if (token.endsWith("/>")) continue;
+		const tagName = getTagName(token);
+		if (isClosing) {
+			if (stack.length > 0) stack.pop();
+		} else stack.push(tagName);
+	} else if (stack.length === 0) textOutside += token;
+	return textOutside.trim().length > 0;
+}
+const INLINE_PHRASING_TAGS = /* @__PURE__ */ new Set([
+	"span",
+	"code",
+	"strong",
+	"em",
+	"a",
+	"b",
+	"i",
+	"u",
+	"mark",
+	"small",
+	"s",
+	"del",
+	"ins",
+	"sub",
+	"sup",
+	"abbr",
+	"time",
+	"q",
+	"img",
+	"br",
+	"picture",
+	"svg",
+	"use",
+	"path",
+	"circle",
+	"rect",
+	"g",
+	"defs",
+	"symbol",
+	"clippath",
+	"mask",
+	"pattern",
+	"polygon",
+	"polyline",
+	"line",
+	"ellipse",
+	"text",
+	"tspan",
+	"stop",
+	"lineargradient",
+	"radialgradient",
+	"image"
+]);
+function normalizeTags(html) {
+	const tokens = html.split(/(<[^>]+>)/g);
+	const tagMap = [];
+	const distinctOpenTags = {};
+	for (const token of tokens) if (token.startsWith("<") && token.endsWith(">")) {
+		const isClosing = token.startsWith("</");
+		if (!token.startsWith("<!--") && !isClosing) {
+			const tagName = getTagName(token);
+			if (INLINE_PHRASING_TAGS.has(tagName)) {
+				if (!distinctOpenTags[tagName]) distinctOpenTags[tagName] = [];
+				if (!distinctOpenTags[tagName].includes(token)) distinctOpenTags[tagName].push(token);
+			}
+		}
+	}
+	const activeStacks = {};
+	let normalized = "";
+	const offsetMap = [];
+	let origIdx = 0;
+	for (const token of tokens) {
+		if (token.startsWith("<") && token.endsWith(">")) {
+			const isClosing = token.startsWith("</");
+			if (token.startsWith("<!--")) {
+				for (let i = 0; i < token.length; i++) offsetMap.push(origIdx + i);
+				normalized += token;
+			} else {
+				const tagName = getTagName(token);
+				if (INLINE_PHRASING_TAGS.has(tagName)) {
+					const list = distinctOpenTags[tagName] || [];
+					const totalConfigs = list.length;
+					let normToken = "";
+					if (isClosing) if (totalConfigs > 1) normToken = `</${tagName}${(activeStacks[tagName] || []).pop() || 1}>`;
+					else normToken = `</${tagName}>`;
+					else {
+						let alias = tagName;
+						const isVoid = VOID_ELEMENTS.has(tagName) || token.endsWith("/>");
+						if (totalConfigs > 1) {
+							const idx = list.indexOf(token) + 1;
+							if (!isVoid) {
+								if (!activeStacks[tagName]) activeStacks[tagName] = [];
+								activeStacks[tagName].push(idx);
+							}
+							alias = `${tagName}${idx}`;
+						}
+						normToken = isVoid ? `<${alias}/>` : `<${alias}>`;
+						if (!tagMap.some((entry) => entry.alias === alias)) tagMap.push({
+							alias,
+							originalOpen: token,
+							tagName
+						});
+					}
+					for (let i = 0; i < normToken.length; i++) {
+						const origOffset = origIdx + Math.min(token.length - 1, Math.floor(i / normToken.length * token.length));
+						offsetMap.push(origOffset);
+					}
+					normalized += normToken;
+				} else {
+					for (let i = 0; i < token.length; i++) offsetMap.push(origIdx + i);
+					normalized += token;
+				}
+			}
+		} else {
+			for (let i = 0; i < token.length; i++) offsetMap.push(origIdx + i);
+			normalized += token;
+		}
+		origIdx += token.length;
+	}
+	offsetMap.push(origIdx);
+	return {
+		normalized,
+		tagMap,
+		offsetMap
+	};
+}
+var ExtractionContext = class {
+	code;
+	filePath;
+	fileBoundaryId;
+	options;
+	_localBoundaries;
+	_internalDeps;
+	_exportedBoundaries;
+	boundaryHashes = {};
+	trivias = [];
+	hasZintlMacro = false;
+	hasZintlMarker = false;
+	hasTopLevelAnchor = false;
+	isZeroConfig = true;
+	mode = "boundary";
+	zintlImportGroup;
+	componentFunctions = /* @__PURE__ */ new Set();
+	registerComponentFunction(parents) {
+		const funcNode = parents.find((p) => [
+			"FunctionDeclaration",
+			"FunctionExpression",
+			"ArrowFunctionExpression"
+		].includes(p.type));
+		if (funcNode && funcNode.body && funcNode.body.type === "BlockStatement") this.componentFunctions.add(funcNode.body.start + 1);
+	}
+	_rawSinks;
+	_seenSinks;
+	handledNodes = /* @__PURE__ */ new Set();
+	_rawManualTranslations;
+	_messages;
+	_transforms;
+	_runtimeImports;
+	_usedKeys;
+	_anchorSites;
+	_dependencyPaths;
+	_scopeBoundaries;
+	_logicTaintedIdentifiers;
+	_dependencyBindings;
+	get messages() {
+		return this._messages ??= /* @__PURE__ */ new Map();
+	}
+	get transforms() {
+		return this._transforms ??= [];
+	}
+	get runtimeImports() {
+		return this._runtimeImports ??= [];
+	}
+	get usedKeys() {
+		return this._usedKeys ??= /* @__PURE__ */ new Set();
+	}
+	get anchorSites() {
+		return this._anchorSites ??= [];
+	}
+	get dependencyPaths() {
+		return this._dependencyPaths ??= /* @__PURE__ */ new Map();
+	}
+	get scopeBoundaries() {
+		return this._scopeBoundaries ??= /* @__PURE__ */ new Map();
+	}
+	get logicTaintedIdentifiers() {
+		return this._logicTaintedIdentifiers ??= /* @__PURE__ */ new Set();
+	}
+	get dependencyBindings() {
+		return this._dependencyBindings ??= /* @__PURE__ */ new Map();
+	}
+	get localBoundaries() {
+		return this._localBoundaries ??= /* @__PURE__ */ new Map();
+	}
+	get internalDeps() {
+		return this._internalDeps ??= /* @__PURE__ */ new Map();
+	}
+	get exportedBoundaries() {
+		return this._exportedBoundaries ??= /* @__PURE__ */ new Map();
+	}
+	get rawSinks() {
+		return this._rawSinks ??= [];
+	}
+	get rawManualTranslations() {
+		return this._rawManualTranslations ??= [];
+	}
+	get seenSinks() {
+		return this._seenSinks ??= /* @__PURE__ */ new Set();
+	}
+	runtimePackage;
+	uiAttributes;
+	uiObjectFields;
+	uiSinkProperties;
+	jsxElementAttributes;
+	htmlAttributes;
+	targetPlugins;
+	boundaryStack;
+	logger;
+	isIgnoredFile = false;
+	suppressionLevel = 0;
+	/** Pre-built fast-path regex derived from the active target configuration. */
+	fastPathRegex;
+	/** True when at least one dom:prop target is configured (e.g. innerHTML). */
+	hasDomSinks;
+	/** True when at least one jsx: target is configured. */
+	hasJsxSinks;
+	sfcRules;
+	suppressionRules;
+	mustacheRegex;
+	constructor(code, filePath, fileBoundaryId, options = {}) {
+		this.code = code;
+		this.filePath = filePath;
+		this.fileBoundaryId = fileBoundaryId;
+		this.options = options;
+		this.logger = options.logger || logger;
+		this.runtimePackage = options.runtimePackage || "zintl";
+		this.uiAttributes = options.uiAttributes ? new Set(options.uiAttributes) : /* @__PURE__ */ new Set();
+		this.uiObjectFields = options.uiObjectFields ? new Set(options.uiObjectFields) : /* @__PURE__ */ new Set();
+		this.uiSinkProperties = options.uiSinkProperties ? [...options.uiSinkProperties] : [];
+		this.jsxElementAttributes = /* @__PURE__ */ new Map();
+		this.htmlAttributes = /* @__PURE__ */ new Set();
+		this.targetPlugins = [];
+		const compiledState = options.compiledState ?? resolveTargets(options.targets || []);
+		options.compiledState = compiledState;
+		for (const attr of compiledState.jsxAttributes) this.uiAttributes.add(attr);
+		for (const field of compiledState.objectFields) this.uiObjectFields.add(field);
+		for (const prop of compiledState.domProperties) if (!this.uiSinkProperties.includes(prop)) this.uiSinkProperties.push(prop);
+		this.jsxElementAttributes = compiledState.jsxElementAttributes;
+		this.htmlAttributes = compiledState.htmlAttributes;
+		this.targetPlugins = compiledState.plugins;
+		this.hasDomSinks = compiledState.hasDomSinks;
+		this.hasJsxSinks = compiledState.hasJsxSinks;
+		this.sfcRules = [...compiledState.sfcRules, ...options.sfcRules || []];
+		this.suppressionRules = [...compiledState.suppressionRules, ...options.suppressionRules || []];
+		let mustacheRegex = compiledState.mustacheRegex ?? null;
+		if (!mustacheRegex && compiledState.mustacheRules) {
+			const rule = compiledState.mustacheRules.find((r) => r.extensions.some((ext) => filePath.endsWith(ext) || filePath.includes(ext + ".")));
+			if (rule) mustacheRegex = rule.pattern;
+		}
+		this.mustacheRegex = mustacheRegex;
+		const extraHints = [
+			...options.uiObjectFields || [],
+			...options.uiSinkProperties || [],
+			...options.uiAttributes || []
+		];
+		if (extraHints.length > 0) {
+			const parts = [...compiledState.fastPathRegex.source.split("|"), ...extraHints.map((h) => h.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))];
+			this.fastPathRegex = new RegExp(parts.join("|"));
+		} else this.fastPathRegex = compiledState.fastPathRegex;
+		this.isZeroConfig = options.isZeroConfig ?? true;
+		this.boundaryStack = [{
+			id: fileBoundaryId,
+			active: true
+		}];
+	}
+	getActiveBoundary() {
+		return this.boundaryStack[this.boundaryStack.length - 1];
+	}
+	pushSuppression(comments) {
+		if (comments.ignore) this.suppressionLevel++;
+	}
+	popSuppression(comments) {
+		if (comments.ignore) this.suppressionLevel--;
+	}
+	addMessage(id, text, context, boundaryId, location, variables = [], note, sinkType, passVars) {
+		const fullId = `${boundaryId}:${id}`;
+		const existing = this.messages.get(fullId);
+		if (existing) {
+			if (context && !existing.contexts.includes(context)) existing.contexts.push(context);
+			if (sinkType && !existing.sinkTypes.includes(sinkType)) existing.sinkTypes.push(sinkType);
+		} else this.messages.set(fullId, {
+			id,
+			text,
+			contexts: context ? [context] : [],
+			boundaryId,
+			location,
+			variables,
+			note,
+			sinkTypes: sinkType ? [sinkType] : [],
+			passVars
+		});
+		this.usedKeys.add(fullId);
+	}
+	addTransform(start, end, replacement, msgId, boundaryId, argNode, originalText) {
+		this.transforms.push({
+			start,
+			end,
+			replacement,
+			msgId,
+			boundaryId: boundaryId || this.getActiveBoundary().id,
+			argNode,
+			originalText
+		});
+	}
+	addDependency(id, dynamic, bindings = []) {
+		const depId = id.startsWith(".") ? join(dirname(this.fileBoundaryId), id).replace(/\\/g, "/") : id;
+		const cleanId = /\.(tsx?|jsx?|mts|mjs|cts|cjs)$/i.test(depId) ? depId.replace(/\.[^/.]+$/, "") : depId;
+		if (!this.dependencyPaths.has(cleanId)) this.dependencyPaths.set(cleanId, dynamic);
+		else if (!dynamic) this.dependencyPaths.set(cleanId, false);
+		if (bindings.length > 0) {
+			if (!this.dependencyBindings.has(cleanId)) this.dependencyBindings.set(cleanId, /* @__PURE__ */ new Set());
+			for (const b of bindings) this.dependencyBindings.get(cleanId).add(b);
+		}
+	}
+	addInternalDependency(targetBoundaryId) {
+		const current = this.getActiveBoundary().id;
+		if (current === targetBoundaryId) return;
+		if (!this.internalDeps.has(current)) this.internalDeps.set(current, /* @__PURE__ */ new Set());
+		this.internalDeps.get(current).add(targetBoundaryId);
+	}
+	addRawSink(sink) {
+		const key = `${sink.boundaryId}:${sink.start}:${sink.end}:${sink.sinkType}`;
+		if (this.seenSinks.has(key)) return;
+		this.seenSinks.add(key);
+		this.rawSinks.push(sink);
+	}
+	pushNormalizedSource(source, sources) {
+		if (source.variables?.length) {
+			let counter = 1;
+			const mapping = {}, newVariables = [];
+			let newText = source.text;
+			const existingNames = new Set(source.variables.filter((v) => !/^var\d+$/.test(v)));
+			for (const vName of source.variables) if (/^var\d+$/.test(vName)) {
+				let newName = counter === 1 ? "input" : `input${counter}`;
+				while (existingNames.has(newName)) newName = `input${++counter}`;
+				counter++;
+				mapping[vName] = newName;
+				newVariables.push(newName);
+				newText = newText.replace(new RegExp(`\\{${vName}\\}`, "g"), `{${newName}}`);
+			} else newVariables.push(vName);
+			source.text = newText;
+			source.variables = newVariables;
+			if (Object.keys(mapping).length) source.normalizedVariables = mapping;
+		}
+		sources.push(source);
+	}
+	stitchHTML(text, onFragment, initialNote, initialPassVars = {}, getOffsets) {
+		const { normalized, tagMap, offsetMap } = normalizeTags(text);
+		const tokens = normalized.split(/(<[^>]+>)/g);
+		const isPartition = (t) => {
+			if (t.startsWith("<") && t.endsWith(">")) {
+				if (t.startsWith("<!--")) return false;
+				const baseTagName = getTagName(t).replace(/\d+$/, "");
+				return !INLINE_PHRASING_TAGS.has(baseTagName);
+			}
+			return false;
+		};
+		const skipStitchTokenIndices = /* @__PURE__ */ new Set();
+		let currentSegment = [];
+		const processSegment = (indices) => {
+			if (indices.length === 0) return;
+			const segmentStr = indices.map((idx) => tokens[idx]).join("");
+			if (!hasNonWhitespaceOutsidePhrasing(segmentStr)) for (const idx of indices) {
+				const t = tokens[idx];
+				if (t.startsWith("<") && t.endsWith(">") && !t.startsWith("<!--")) skipStitchTokenIndices.add(idx);
+			}
+			else if (isSingleWrappingPhrasingTag(segmentStr)) {
+				let openIdx = -1;
+				let closeIdx = -1;
+				for (const idx of indices) {
+					const t = tokens[idx];
+					if (t.startsWith("<") && t.endsWith(">") && !t.startsWith("<!--") && !t.startsWith("</")) {
+						openIdx = idx;
+						break;
+					}
+				}
+				for (let i = indices.length - 1; i >= 0; i--) {
+					const idx = indices[i];
+					const t = tokens[idx];
+					if (t.startsWith("</") && t.endsWith(">")) {
+						closeIdx = idx;
+						break;
+					}
+				}
+				if (openIdx !== -1 && closeIdx !== -1) {
+					skipStitchTokenIndices.add(openIdx);
+					skipStitchTokenIndices.add(closeIdx);
+				}
+			}
+		};
+		for (let i = 0; i < tokens.length; i++) if (isPartition(tokens[i])) {
+			processSegment(currentSegment);
+			currentSegment = [];
+		} else currentSegment.push(i);
+		processSegment(currentSegment);
+		let currentIdx = 0, pendingIgnore = false;
+		const ignoreStack = [];
+		let localNote = initialNote;
+		const localPassVars = { ...initialPassVars };
+		let buffer = "";
+		let bufferStartIdx = 0;
+		const flushBuffer = () => {
+			if (buffer.trim() && hasTranslatableText(buffer)) {
+				const trimmed = buffer.trim();
+				const leadingWhitespaceLen = buffer.length - buffer.trimStart().length;
+				const trailingWhitespaceLen = buffer.length - buffer.trimEnd().length;
+				const sInNorm = bufferStartIdx + leadingWhitespaceLen;
+				const eInNorm = currentIdx - trailingWhitespaceLen;
+				const sInOrig = offsetMap[sInNorm];
+				const eInOrig = offsetMap[eInNorm];
+				const offsets = getOffsets?.(sInOrig, eInOrig);
+				onFragment(trimmed, localNote, localPassVars, offsets?.start, offsets?.end, tagMap.length ? tagMap : void 0);
+				localNote = initialNote;
+				for (const k in localPassVars) if (!(k in initialPassVars)) delete localPassVars[k];
+				else localPassVars[k] = initialPassVars[k];
+			}
+			buffer = "";
+			bufferStartIdx = 0;
+		};
+		let tokenIdx = 0;
+		for (const token of tokens) {
+			if (token.startsWith("<") && token.endsWith(">")) {
+				const isClosing = token.startsWith("</"), isComment = token.startsWith("<!--"), tagName = isComment ? "" : getTagName(token);
+				const directives = parseHTMLDirectives(token);
+				if (isComment) {
+					if (directives.ignore) pendingIgnore = true;
+					if (directives.note) localNote = directives.note;
+					Object.assign(localPassVars, directives.contextVars);
+					currentIdx += token.length;
+					tokenIdx++;
+					continue;
+				}
+				const hasIgnore = directives.ignore || pendingIgnore || ignoreStack.length > 0;
+				const baseTagName = tagName.replace(/\d+$/, "");
+				let isPhrasing = INLINE_PHRASING_TAGS.has(baseTagName);
+				if (skipStitchTokenIndices.has(tokenIdx) || hasIgnore) isPhrasing = false;
+				if (isPhrasing && !isComment) {
+					if (ignoreStack.length === 0 && !pendingIgnore) {
+						if (buffer === "") bufferStartIdx = currentIdx;
+						buffer += token;
+					}
+				} else {
+					flushBuffer();
+					if (directives.ignore) {
+						if (isComment) pendingIgnore = true;
+						else if (!isClosing && !token.endsWith("/>") && !VOID_ELEMENTS.has(tagName)) ignoreStack.push(tagName);
+					} else if (pendingIgnore && !isComment) {
+						if (!isClosing && !token.endsWith("/>") && !VOID_ELEMENTS.has(tagName)) ignoreStack.push(tagName);
+						pendingIgnore = false;
+					}
+					if (isClosing && ignoreStack.length && ignoreStack[ignoreStack.length - 1] === tagName) ignoreStack.pop();
+					if (directives.note) localNote = directives.note;
+					Object.assign(localPassVars, directives.contextVars);
+				}
+			} else if (ignoreStack.length === 0 && !pendingIgnore) {
+				if (buffer === "") bufferStartIdx = currentIdx;
+				buffer += token;
+			}
+			currentIdx += token.length;
+			tokenIdx++;
+		}
+		flushBuffer();
+	}
+	findLiteralsInExpression(node, inheritedDirectives, defaultContext) {
+		if (!node) return [];
+		const comments = parseZintlComments(node.start, this.trivias, this.code);
+		if (inheritedDirectives) {
+			if (inheritedDirectives.note) comments.note = inheritedDirectives.note;
+			if (inheritedDirectives.ignore) comments.ignore = true;
+			Object.assign(comments.contextVars, inheritedDirectives.contextVars);
+		}
+		if (this.isIgnoredFile || this.suppressionLevel > 0 || comments.ignore) return [];
+		const sources = [];
+		const isLit = (n) => n.type === "StringLiteral" || n.type === "Literal" && typeof n.value === "string";
+		if (isLit(node)) {
+			const text = node.value;
+			if (/<[^>]+>/.test(text)) this.stitchHTML(text, (trimmed, note, passVars, start, end, tagMap) => {
+				this.pushNormalizedSource({
+					node,
+					text: trimmed,
+					context: defaultContext || "Literal",
+					location: {
+						line: 0,
+						column: 0
+					},
+					variables: [],
+					note,
+					transformStart: start,
+					transformEnd: end,
+					inlineReplacement: true,
+					passVars: Object.keys(passVars || {}).length ? { ...passVars } : void 0,
+					tagMap
+				}, sources);
+			}, comments.note, comments.contextVars, (s, e) => ({
+				start: node.start + 1 + s,
+				end: node.start + 1 + e
+			}));
+			else if (node.value) this.pushNormalizedSource({
+				node,
+				text: node.value,
+				context: defaultContext || "Literal",
+				location: {
+					line: 0,
+					column: 0
+				},
+				passVars: Object.keys(comments.contextVars).length ? { ...comments.contextVars } : void 0
+			}, sources);
+		} else if (node.type === "TemplateLiteral") {
+			let text = "";
+			const variables = [], chunks = [];
+			for (let i = 0; i < node.quasis.length; i++) {
+				const raw = node.quasis[i].value.raw;
+				text += raw;
+				chunks.push({
+					isVar: false,
+					text: raw,
+					sourceStart: node.quasis[i].start + 1,
+					sourceEnd: i === node.quasis.length - 1 ? node.quasis[i].end - 1 : node.quasis[i].end - 2
+				});
+				if (i < node.expressions.length) {
+					const expr = node.expressions[i];
+					let vName = "var" + i;
+					if (expr.type === "Identifier") vName = expr.name;
+					else if (expr.type === "MemberExpression") {
+						const parts = [];
+						let curr = expr;
+						while (curr && curr.type === "MemberExpression" && curr.property.type === "Identifier") {
+							parts.unshift(curr.property.name);
+							curr = curr.object;
+						}
+						if (curr && curr.type === "Identifier") {
+							parts.unshift(curr.name);
+							vName = parts.join("_");
+						} else if (parts.length > 0) vName = parts[parts.length - 1];
+					}
+					const varFragment = `{${vName}}`;
+					text += varFragment;
+					variables.push(vName);
+					chunks.push({
+						isVar: true,
+						text: varFragment,
+						sourceStart: expr.start - 2,
+						sourceEnd: expr.end + 1
+					});
+				}
+			}
+			const getSourceIndex = (tIdx) => {
+				let curr = 0;
+				for (const chunk of chunks) {
+					if (tIdx === curr) return chunk.sourceStart;
+					if (tIdx > curr && tIdx < curr + chunk.text.length) {
+						if (chunk.isVar) throw new Error("Split inside variable");
+						return chunk.sourceStart + (tIdx - curr);
+					}
+					curr += chunk.text.length;
+				}
+				return chunks[chunks.length - 1].sourceEnd;
+			};
+			if (/<[^>]+>/.test(text)) this.stitchHTML(text, (trimmed, note, passVars, start, end, tagMap) => {
+				if (trimmed.replace(/{[a-zA-Z0-9_]+}/g, "").trim() || !!comments.note || Object.keys(comments.contextVars).length) this.pushNormalizedSource({
+					node,
+					text: trimmed,
+					context: defaultContext || "Template",
+					location: {
+						line: 0,
+						column: 0
+					},
+					variables: (trimmed.match(/{[a-zA-Z0-9_]+}/g) || []).map((v) => v.slice(1, -1)),
+					note,
+					transformStart: start,
+					transformEnd: end,
+					inlineReplacement: true,
+					passVars: Object.keys(passVars || {}).length ? { ...passVars } : void 0,
+					tagMap
+				}, sources);
+			}, comments.note, comments.contextVars, (s, e) => ({
+				start: getSourceIndex(s),
+				end: getSourceIndex(e)
+			}));
+			else {
+				const trimmed = text.trim();
+				if (trimmed && (trimmed.replace(/{[a-zA-Z0-9_]+}/g, "").trim() || !!comments.note || Object.keys(comments.contextVars).length)) this.pushNormalizedSource({
+					node,
+					text: trimmed,
+					context: defaultContext || "Template",
+					location: {
+						line: 0,
+						column: 0
+					},
+					variables,
+					note: comments.note,
+					passVars: Object.keys(comments.contextVars).length ? { ...comments.contextVars } : void 0
+				}, sources);
+			}
+		} else if (node.type === "ConditionalExpression") sources.push(...this.findLiteralsInExpression(node.consequent, inheritedDirectives, defaultContext), ...this.findLiteralsInExpression(node.alternate, inheritedDirectives, defaultContext));
+		else if (node.type === "BinaryExpression" && node.operator === "+") sources.push(...this.findLiteralsInExpression(node.left, inheritedDirectives, defaultContext), ...this.findLiteralsInExpression(node.right, inheritedDirectives, defaultContext));
+		else if (node.type === "LogicalExpression") sources.push(...this.findLiteralsInExpression(node.left, inheritedDirectives, defaultContext), ...this.findLiteralsInExpression(node.right, inheritedDirectives, defaultContext));
+		else if (node.type === "ObjectExpression") node.properties.forEach((prop) => {
+			if (prop.type === "Property") {
+				const key = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "StringLiteral" ? prop.key.value : "";
+				if (key) this.findLiteralsInExpression(prop.value, inheritedDirectives).forEach((s) => {
+					s.context = s.context === "Literal" ? key : `${key}.${s.context}`;
+					sources.push(s);
+				});
+			}
+		});
+		return sources;
+	}
+	sha1(content) {
+		return createHash("sha1").update(content).digest("hex");
+	}
+	computeBoundaryHashes() {
+		const hashes = {}, allBIds = /* @__PURE__ */ new Set();
+		if (this._messages) for (const msg of this._messages.values()) allBIds.add(msg.boundaryId);
+		for (const b of this.boundaryStack) allBIds.add(b.id);
+		if (this._anchorSites) for (const site of this._anchorSites) allBIds.add(site.boundaryId);
+		for (const bId of allBIds) if (this.boundaryHashes[bId]) hashes[bId] = this.boundaryHashes[bId];
+		else hashes[bId] = this.boundaryHashes[bId] = "b_" + this.sha1(bId).substring(0, 12);
+		return hashes;
+	}
+};
+//#endregion
+//#region src/hashing.ts
+/**
+* Generates a stable ID for a message based on its text, context, and note.
+* Including the note ensures that identical strings with different translator
+* context are treated as unique entries.
+*/
+const idCache = /* @__PURE__ */ new Map();
+function generateMessageId(messageText, _context = "", _note = "") {
+	const cached = idCache.get(messageText);
+	if (cached) return cached;
+	const id = createHash("sha1").update(messageText).digest("hex").slice(0, 8);
+	idCache.set(messageText, id);
+	return id;
+}
+//#endregion
+//#region src/visitors/jsx.ts
+function getJsxTagName(element) {
+	if (element.openingElement?.name?.type === "JSXIdentifier") return element.openingElement.name.name.toLowerCase();
+	return "";
+}
+function isPhrasingOnly(node) {
+	if (node.type === "JSXText") return true;
+	if (node.type === "JSXExpressionContainer") return true;
+	if (node.type === "JSXElement") {
+		const tagName = getJsxTagName(node);
+		if (!INLINE_PHRASING_TAGS.has(tagName)) return false;
+		return (node.children || []).every(isPhrasingOnly);
+	}
+	if (node.type === "JSXFragment") return (node.children || []).every(isPhrasingOnly);
+	return false;
+}
+function processJsxChildren(node, ctx) {
+	if (ctx.suppressionLevel > 0) return;
+	const { id: boundaryId, active } = ctx.getActiveBoundary();
+	if (!active) return;
+	const children = node.children;
+	if (!children?.length) return;
+	const comments = parseZintlComments(node.start, ctx.trivias, ctx.code);
+	for (let i = 0; i < children.length; i++) {
+		const child = children[i];
+		if (child.type === "JSXExpressionContainer" && child.expression.type === "JSXEmptyExpression") {
+			const childComments = parseZintlComments(child.expression.start, ctx.trivias, ctx.code);
+			if (childComments.ignore) for (let j = i + 1; j < children.length; j++) {
+				const nextChild = children[j];
+				if (nextChild.type === "JSXText" && !nextChild.value.trim()) continue;
+				ctx.handledNodes.add(nextChild.start);
+				break;
+			}
+			if (childComments.note) comments.note = childComments.note;
+			Object.assign(comments.contextVars, childComments.contextVars);
+		}
+	}
+	if (comments.ignore) return;
+	const hasDirectives = !!comments.note || Object.keys(comments.contextVars).length > 0;
+	if (!children.some((c) => c.type === "JSXText" && c.value.trim()) && !hasDirectives) return;
+	if (children.some((c) => c.type === "JSXElement" || c.type === "JSXFragment")) {
+		if (!children.every(isPhrasingOnly)) return;
+		function shouldStitchChildren(childrenList) {
+			let elementCount = 0;
+			let hasNonWhitespaceText = false;
+			for (const child of childrenList) {
+				if (ctx.handledNodes.has(child) || ctx.handledNodes.has(child.start)) continue;
+				if (child.type === "JSXElement" || child.type === "JSXFragment") elementCount++;
+				else if (child.type === "JSXText") {
+					if (child.value.trim().length > 0) hasNonWhitespaceText = true;
+				} else if (child.type === "JSXExpressionContainer") {
+					if (child.expression.type !== "JSXEmptyExpression") hasNonWhitespaceText = true;
+				}
+			}
+			if (elementCount === 0) return false;
+			return hasNonWhitespaceText;
+		}
+		if (!shouldStitchChildren(children)) return;
+	}
+	let text = "", variables = [], pairs = [];
+	const exprNodes = [];
+	const tagMap = [];
+	const distinctOpenTags = {};
+	function countTags(childNode) {
+		if (ctx.handledNodes.has(childNode) || ctx.handledNodes.has(childNode.start)) return;
+		if (childNode.type === "JSXElement") {
+			const tagName = getJsxTagName(childNode);
+			if (INLINE_PHRASING_TAGS.has(tagName)) {
+				const openStart = childNode.openingElement.start;
+				const openEnd = childNode.openingElement.end;
+				const originalOpen = ctx.code.slice(openStart, openEnd);
+				if (!distinctOpenTags[tagName]) distinctOpenTags[tagName] = [];
+				if (!distinctOpenTags[tagName].includes(originalOpen)) distinctOpenTags[tagName].push(originalOpen);
+			}
+			(childNode.children || []).forEach(countTags);
+		} else if (childNode.type === "JSXFragment") (childNode.children || []).forEach(countTags);
+	}
+	children.forEach(countTags);
+	const activeStacks = {};
+	function serializeNode(childNode) {
+		if (ctx.handledNodes.has(childNode) || ctx.handledNodes.has(childNode.start)) return;
+		if (childNode.type === "JSXText") {
+			text += childNode.value;
+			ctx.handledNodes.add(childNode);
+		} else if (childNode.type === "JSXExpressionContainer") {
+			const expr = childNode.expression;
+			if (expr.type === "JSXEmptyExpression") return;
+			if (expr.type === "StringLiteral" || expr.type === "Literal" && typeof expr.value === "string") {
+				text += expr.value;
+				ctx.handledNodes.add(childNode);
+				return;
+			}
+			let vName = `var${variables.length}`;
+			if (expr.type === "Identifier") vName = expr.name;
+			else if (expr.type === "MemberExpression") {
+				const parts = [];
+				let curr = expr;
+				while (curr && curr.type === "MemberExpression" && curr.property.type === "Identifier") {
+					parts.unshift(curr.property.name);
+					curr = curr.object;
+				}
+				if (curr && curr.type === "Identifier") {
+					parts.unshift(curr.name);
+					vName = parts.join("_");
+				} else if (parts.length > 0) vName = parts[parts.length - 1];
+			}
+			if (/^var\d+$/.test(vName)) vName = variables.length === 0 ? "input" : `input${variables.length + 1}`;
+			text += `{${vName}}`;
+			variables.push(vName);
+			pairs.push(`${vName}: ${ctx.code.slice(expr.start, expr.end)}`);
+			exprNodes.push(expr);
+			ctx.handledNodes.add(childNode);
+		} else if (childNode.type === "JSXElement") {
+			const tagName = getJsxTagName(childNode);
+			const list = distinctOpenTags[tagName] || [];
+			const totalConfigs = list.length;
+			const isSelfClosing = childNode.openingElement.selfClosing;
+			let alias = tagName;
+			const openStart = childNode.openingElement.start;
+			const openEnd = childNode.openingElement.end;
+			const originalOpen = ctx.code.slice(openStart, openEnd);
+			if (totalConfigs > 1) {
+				const idx = list.indexOf(originalOpen) + 1;
+				if (!isSelfClosing) {
+					if (!activeStacks[tagName]) activeStacks[tagName] = [];
+					activeStacks[tagName].push(idx);
+				}
+				alias = `${tagName}${idx}`;
+			}
+			tagMap.push({
+				alias,
+				originalOpen,
+				tagName
+			});
+			text += isSelfClosing ? `<${alias}/>` : `<${alias}>`;
+			ctx.handledNodes.add(childNode);
+			ctx.handledNodes.add(childNode.openingElement);
+			if (childNode.closingElement) ctx.handledNodes.add(childNode.closingElement);
+			if (!isSelfClosing) {
+				(childNode.children || []).forEach(serializeNode);
+				if (totalConfigs > 1) {
+					const idx = (activeStacks[tagName] || []).pop() || 1;
+					text += `</${tagName}${idx}>`;
+				} else text += `</${tagName}>`;
+			}
+		} else if (childNode.type === "JSXFragment") {
+			ctx.handledNodes.add(childNode);
+			ctx.handledNodes.add(childNode.openingFragment);
+			if (childNode.closingFragment) ctx.handledNodes.add(childNode.closingFragment);
+			(childNode.children || []).forEach(serializeNode);
+		}
+	}
+	children.forEach(serializeNode);
+	text = text.replace(/\s+/g, " ").trim();
+	if (!text) return;
+	const context = node.openingElement?.name?.type === "JSXIdentifier" ? node.openingElement.name.name : "";
+	const id = generateMessageId(text, context, comments.note);
+	ctx.addMessage(id, text, context, boundaryId, {
+		line: 0,
+		column: 0
+	}, variables, comments.note, void 0, Object.keys(comments.contextVars).length ? comments.contextVars : void 0);
+	const start = children[0].start, end = children[children.length - 1].end;
+	ctx.addRawSink({
+		text,
+		sinkType: context,
+		start,
+		end,
+		line: 0,
+		column: 0,
+		boundaryId,
+		isFragment: false,
+		requiresJsxBraces: true,
+		note: comments.note,
+		variables: pairs.map((pair, i) => ({
+			name: pair.split(":")[0].trim(),
+			originalName: pair.split(":")[0].trim(),
+			expression: pair.split(":")[1].trim(),
+			start: exprNodes[i]?.start ?? 0,
+			end: exprNodes[i]?.end ?? 0
+		})),
+		passVars: Object.keys(comments.contextVars).length ? comments.contextVars : void 0,
+		tagMap: tagMap.length ? tagMap : void 0
+	});
+}
+function createJsxVisitor(_ctx) {
+	return {
+		JSXElement: {
+			enter(node, ctx, parents) {
+				if (ctx.handledNodes.has(node) || ctx.handledNodes.has(node.start)) return;
+				ctx.registerComponentFunction(parents);
+				const comments = parseZintlComments(node.start, ctx.trivias, ctx.code);
+				if (comments.ignore) {
+					ctx.pushSuppression(comments);
+					return;
+				}
+				processJsxChildren(node, ctx);
+			},
+			exit(node, ctx) {
+				ctx.popSuppression(parseZintlComments(node.start, ctx.trivias, ctx.code));
+			}
+		},
+		JSXFragment: {
+			enter(node, ctx, parents) {
+				if (ctx.handledNodes.has(node) || ctx.handledNodes.has(node.start)) return;
+				ctx.registerComponentFunction(parents);
+				const comments = parseZintlComments(node.start, ctx.trivias, ctx.code);
+				if (comments.ignore) {
+					ctx.pushSuppression(comments);
+					return;
+				}
+				processJsxChildren(node, ctx);
+			},
+			exit(node, ctx) {
+				ctx.popSuppression(parseZintlComments(node.start, ctx.trivias, ctx.code));
+			}
+		},
+		JSXText(node, ctx, parents) {
+			if (ctx.suppressionLevel > 0 || ctx.handledNodes.has(node)) return;
+			ctx.registerComponentFunction(parents);
+			const { id: boundaryId, active } = ctx.getActiveBoundary();
+			if (!active) return;
+			const comments = getAttachedComments(node, parents, ctx.trivias, ctx.code);
+			if (comments.ignore) return;
+			const text = node.value.trim();
+			if (!text) return;
+			const context = parents[0]?.openingElement?.name?.name || "";
+			ctx.addMessage(generateMessageId(text, context, comments.note), text, context, boundaryId, {
+				line: 0,
+				column: 0
+			}, [], comments.note, void 0, Object.keys(comments.contextVars).length ? comments.contextVars : void 0);
+			ctx.addRawSink({
+				text,
+				sinkType: context,
+				start: node.start,
+				end: node.end,
+				line: 0,
+				column: 0,
+				boundaryId,
+				variables: [],
+				note: comments.note,
+				passVars: Object.keys(comments.contextVars).length ? comments.contextVars : void 0,
+				isFragment: false,
+				requiresJsxBraces: true
+			});
+		},
+		JSXAttribute: {
+			enter(node, ctx, parents) {
+				if (ctx.suppressionLevel > 0 || ctx.handledNodes.has(node.start)) return;
+				ctx.registerComponentFunction(parents);
+				const { id: boundaryId, active } = ctx.getActiveBoundary();
+				if (!active) return;
+				const comments = getAttachedComments(node, parents, ctx.trivias, ctx.code);
+				if (comments.ignore) {
+					ctx.pushSuppression(comments);
+					return;
+				}
+				const attrName = node.name.type === "JSXIdentifier" ? node.name.name : "";
+				let isTranslatable = ctx.uiAttributes.has(attrName);
+				if (!isTranslatable) {
+					const parentElement = parents.slice().reverse().find((p) => p.type === "JSXOpeningElement");
+					if (parentElement && parentElement.name && parentElement.name.type === "JSXIdentifier") {
+						const elementName = parentElement.name.name;
+						const scopedAttrs = ctx.jsxElementAttributes?.get(elementName);
+						if (scopedAttrs && scopedAttrs.has(attrName)) isTranslatable = true;
+					}
+				}
+				if (isTranslatable && (node.value?.type === "StringLiteral" || node.value?.type === "Literal")) {
+					const text = node.value.value;
+					if (!text || !text.trim()) return;
+					ctx.addMessage(generateMessageId(text, attrName), text, attrName, boundaryId, {
+						line: 0,
+						column: 0
+					});
+					ctx.addRawSink({
+						text,
+						sinkType: attrName,
+						start: node.value.start,
+						end: node.value.end,
+						line: 0,
+						column: 0,
+						boundaryId,
+						variables: [],
+						isFragment: false,
+						requiresJsxBraces: true
+					});
+				}
+			},
+			exit(node, ctx, parents) {
+				ctx.popSuppression(getAttachedComments(node, parents, ctx.trivias, ctx.code));
+			}
+		},
+		JSXExpressionContainer(node, ctx, parents) {
+			if (ctx.suppressionLevel > 0 || ctx.handledNodes.has(node)) return;
+			ctx.registerComponentFunction(parents);
+			const parentAttr = parents[0] && parents[0].type === "JSXAttribute" ? parents[0] : null;
+			if (parentAttr) {
+				const attrName = parentAttr.name.type === "JSXIdentifier" ? parentAttr.name.name : "";
+				let isTranslatable = ctx.uiAttributes.has(attrName);
+				if (!isTranslatable) {
+					const parentElement = parents.slice().reverse().find((p) => p.type === "JSXOpeningElement");
+					if (parentElement && parentElement.name && parentElement.name.type === "JSXIdentifier") {
+						const elementName = parentElement.name.name;
+						const scopedAttrs = ctx.jsxElementAttributes?.get(elementName);
+						if (scopedAttrs && scopedAttrs.has(attrName)) isTranslatable = true;
+					}
+				}
+				if (!isTranslatable) return;
+			}
+			const { id: boundaryId, active } = ctx.getActiveBoundary();
+			if (!active) return;
+			const expr = node.expression;
+			if (expr.type !== "Identifier" && !(expr.type === "MemberExpression" && expr.object.type === "Identifier" && expr.property.type === "Identifier")) {
+				const comments = getAttachedComments(node, parents, ctx.trivias, ctx.code);
+				if (comments.ignore) return;
+				ctx.findLiteralsInExpression(expr, comments).forEach((source) => {
+					if (!source.text || !source.text.trim()) return;
+					const id = generateMessageId(source.text, source.context, source.note);
+					ctx.addMessage(id, source.text, source.context, boundaryId, source.location, source.variables, source.note, void 0, source.passVars);
+					const rawVars = [];
+					if (source.variables?.length && source.node.type === "TemplateLiteral") source.node.expressions.forEach((e, i) => {
+						const vName = e.type === "Identifier" ? e.name : "var" + i;
+						const finalName = source.normalizedVariables && source.normalizedVariables[vName] || vName;
+						if (source.variables.includes(finalName)) rawVars.push({
+							name: finalName,
+							originalName: vName,
+							expression: ctx.code.slice(e.start, e.end),
+							start: e.start,
+							end: e.end
+						});
+					});
+					ctx.addRawSink({
+						text: source.text,
+						sinkType: source.context,
+						start: source.node.start,
+						end: source.node.end,
+						line: source.location.line,
+						column: source.location.column,
+						boundaryId,
+						variables: rawVars,
+						isFragment: false,
+						note: source.note,
+						passVars: source.passVars
+					});
+				});
+			}
+		}
+	};
+}
+//#endregion
+//#region src/visitors/bindings.ts
+function resolveBoundaryId(ctx, sourcePath) {
+	const isRelative = sourcePath.startsWith("./") || sourcePath.startsWith("../");
+	if (!isRelative && !sourcePath.match(/\.(ts|tsx|js|jsx)$/) && sourcePath.includes(".")) return null;
+	if (isRelative && sourcePath.match(/\.(css|svg|png|jpg|jpeg|gif|webp|woff2?|ttf)$/i)) return null;
+	const currentDir = ctx.fileBoundaryId.includes("/") ? ctx.fileBoundaryId.substring(0, ctx.fileBoundaryId.lastIndexOf("/")) : "";
+	let resolved = sourcePath;
+	if (sourcePath.startsWith("./")) {
+		const name = sourcePath.substring(2);
+		resolved = currentDir ? `${currentDir}/${name}` : name;
+	} else if (sourcePath.startsWith("../")) {
+		const depth = (sourcePath.match(/\.\.\//g) || []).length;
+		const parts = currentDir.split("/").filter(Boolean);
+		const up = Math.max(0, parts.length - depth);
+		const name = sourcePath.replace(/\.\.\//g, "");
+		const base = parts.slice(0, up).join("/");
+		resolved = base ? `${base}/${name}` : name;
+	}
+	return resolved.replace(/\.(tsx?|jsx?)$/, "");
+}
+function extractRawVariables(source, ctx) {
+	if (!source.variables?.length || source.node.type !== "TemplateLiteral") return [];
+	const node = source.node;
+	const variables = [];
+	node.expressions.forEach((expr, i) => {
+		const vName = resolveExpressionName(expr, i);
+		const finalName = source.normalizedVariables?.[vName] ?? vName;
+		const withinRange = !source.transformStart || expr.start >= source.transformStart && source.transformEnd !== void 0 && expr.end <= source.transformEnd;
+		if (source.variables.includes(finalName) && withinRange) variables.push({
+			name: finalName,
+			originalName: vName,
+			expression: ctx.code.slice(expr.start, expr.end),
+			start: expr.start,
+			end: expr.end
+		});
+	});
+	return variables;
+}
+/** Infer a readable variable name from a template expression node. */
+function resolveExpressionName(expr, index) {
+	if (expr.type === "Identifier") return expr.name;
+	if (expr.type === "MemberExpression") {
+		const parts = [];
+		let curr = expr;
+		while (curr && curr.type === "MemberExpression" && curr.property.type === "Identifier") {
+			parts.unshift(curr.property.name);
+			curr = curr.object;
+		}
+		if (curr && curr.type === "Identifier") {
+			parts.unshift(curr.name);
+			return parts.join("_");
+		} else if (parts.length > 0) return parts[parts.length - 1];
+	}
+	return `var${index}`;
+}
+/**
+* Process a single literal source found on a UI sink property.
+* Registers the message, records the raw sink, and queues the code transform.
+*/
+function processSinkSource(source, sinkType, boundaryId, parentStart, ctx) {
+	const msgId = generateMessageId(source.text, source.context, source.note);
+	ctx.addMessage(msgId, source.text, source.context, boundaryId, source.location, source.variables, source.note, sinkType, source.passVars);
+	const rawVars = extractRawVariables(source, ctx);
+	const isFragment = !!source.inlineReplacement;
+	const requiresQuoteConversion = isFragment && source.node.type === "StringLiteral";
+	ctx.addRawSink({
+		text: source.text,
+		sinkType,
+		start: isFragment ? source.transformStart : source.node.start,
+		end: isFragment ? source.transformEnd : source.node.end,
+		line: source.location.line,
+		column: source.location.column,
+		boundaryId,
+		variables: rawVars,
+		note: source.note,
+		passVars: source.passVars,
+		isFragment,
+		fragmentStart: isFragment ? source.transformStart : void 0,
+		fragmentEnd: isFragment ? source.transformEnd : void 0,
+		hostStart: isFragment ? source.node.start : void 0,
+		hostEnd: isFragment ? source.node.end : void 0,
+		requiresQuoteConversion,
+		tagMap: source.tagMap
+	});
+}
+function createBindingVisitor(ctx) {
+	const visitor = {
+		ImportDeclaration(node, ctx) {
+			if (node.source.type !== "StringLiteral" && node.source.type !== "Literal") return;
+			const sourceVal = node.source.value;
+			if (isRuntimeSpecifier(sourceVal, ctx.runtimePackage)) node.specifiers?.forEach((spec) => {
+				if (spec.type === "ImportSpecifier" && spec.imported.type === "Identifier") ctx.runtimeImports.push(spec.imported.name);
+			});
+			else if (sourceVal.startsWith(".")) {
+				if (resolveBoundaryId(ctx, sourceVal) !== null) {
+					const bindings = [];
+					node.specifiers?.forEach((spec) => {
+						if (spec.type === "ImportSpecifier") {
+							const name = spec.imported.name || spec.imported.value;
+							if (name) bindings.push(name);
+						} else if (spec.type === "ImportDefaultSpecifier") bindings.push("default");
+					});
+					ctx.addDependency(sourceVal, false, bindings);
+				}
+			}
+		},
+		ImportExpression(node, ctx) {
+			const src = node.source;
+			if ((src.type === "StringLiteral" || src.type === "Literal") && src.value.startsWith(".")) {
+				const resolved = resolveBoundaryId(ctx, src.value);
+				if (resolved !== null && !ctx.dependencyPaths.has(resolved)) ctx.dependencyPaths.set(resolved, true);
+			}
+		},
+		VariableDeclaration: {
+			enter(node, ctx, parents) {
+				if (getAttachedComments(node, parents, ctx.trivias, ctx.code).ignore) ctx.suppressionLevel++;
+			},
+			exit(node, ctx, parents) {
+				if (getAttachedComments(node, parents, ctx.trivias, ctx.code).ignore) ctx.suppressionLevel--;
+			}
+		}
+	};
+	if (ctx.hasDomSinks) visitor.AssignmentExpression = function(node, ctx, parents) {
+		if (ctx.suppressionLevel > 0) return;
+		const { id: boundaryId, active } = ctx.getActiveBoundary();
+		if (!active || node.left.type !== "MemberExpression") return;
+		const prop = node.left.property.type === "Identifier" ? node.left.property.name : "";
+		if (!ctx.uiSinkProperties.includes(prop)) return;
+		const stmtComments = getAttachedComments(node, parents, ctx.trivias, ctx.code);
+		ctx.findLiteralsInExpression(node.right, stmtComments, prop).forEach((source) => processSinkSource(source, prop, boundaryId, parents[0]?.start ?? node.start, ctx));
+	};
+	if (ctx.uiObjectFields.size > 0) visitor.Property = function(node, ctx, parents) {
+		if (ctx.suppressionLevel > 0) return;
+		if (ctx.handledNodes.has(node.start)) return;
+		const { id: boundaryId, active } = ctx.getActiveBoundary();
+		if (!active) return;
+		if (getAttachedComments(node, parents, ctx.trivias, ctx.code).ignore) return;
+		const keyName = node.key.type === "Identifier" ? node.key.name : node.key.type === "StringLiteral" || node.key.type === "Literal" ? node.key.value : "";
+		if (!ctx.uiObjectFields.has(keyName)) return;
+		const stmtComments = getAttachedComments(node, parents, ctx.trivias, ctx.code);
+		ctx.findLiteralsInExpression(node.value, stmtComments, keyName).forEach((source) => processSinkSource(source, keyName, boundaryId, parents[0]?.start ?? node.start, ctx));
+	};
+	return visitor;
+}
+//#endregion
+//#region src/walker.ts
+function walk(node, visitors, ctx, parents = []) {
+	if (!node || typeof node !== "object") return;
+	if (ctx.isIgnoredFile) return;
+	const type = node.type;
+	if (ctx.handledNodes.has(node.start)) return;
+	const visitor = visitors[type];
+	if (visitor) try {
+		if (typeof visitor === "function") visitor(node, ctx, parents);
+		else if (visitor.enter) visitor.enter(node, ctx, parents);
+	} catch (e) {
+		ctx.logger.error(`ERROR in visitor [${type}] at offset ${node.start}:`, e);
+		throw e;
+	}
+	const nextParents = [node, ...parents];
+	const type_ = node.type;
+	if (type_ === "Program") for (const stmt of node.body) walk(stmt, visitors, ctx, nextParents);
+	else if (type_ === "JSXElement") {
+		walk(node.openingElement, visitors, ctx, nextParents);
+		for (const child of node.children) walk(child, visitors, ctx, nextParents);
+		if (node.closingElement) walk(node.closingElement, visitors, ctx, nextParents);
+	} else if (type_ === "JSXOpeningElement") {
+		walk(node.name, visitors, ctx, nextParents);
+		for (const attr of node.attributes) walk(attr, visitors, ctx, nextParents);
+	} else if (type_ === "JSXAttribute") {
+		if (node.value) walk(node.value, visitors, ctx, nextParents);
+	} else if (type_ === "JSXExpressionContainer") walk(node.expression, visitors, ctx, nextParents);
+	else if (type_ === "FunctionDeclaration" || type_ === "FunctionExpression" || type_ === "ArrowFunctionExpression") {
+		if (node.id) walk(node.id, visitors, ctx, nextParents);
+		const params = node.params?.items || node.params || [];
+		for (const param of params) walk(param, visitors, ctx, nextParents);
+		walk(node.body, visitors, ctx, nextParents);
+	} else if (type_ === "BlockStatement") for (const stmt of node.body) walk(stmt, visitors, ctx, nextParents);
+	else if (type_ === "CallExpression") {
+		walk(node.callee, visitors, ctx, nextParents);
+		for (const arg of node.arguments) walk(arg, visitors, ctx, nextParents);
+	} else if (type_ === "ExpressionStatement") walk(node.expression, visitors, ctx, nextParents);
+	else if (type_ === "VariableDeclaration") for (const decl of node.declarations) walk(decl, visitors, ctx, nextParents);
+	else if (type_ === "VariableDeclarator") {
+		walk(node.id, visitors, ctx, nextParents);
+		if (node.init) walk(node.init, visitors, ctx, nextParents);
+	} else if (type_ === "ReturnStatement") {
+		if (node.argument) walk(node.argument, visitors, ctx, nextParents);
+	} else for (const key in node) {
+		if (key === "parent") continue;
+		const child = node[key];
+		if (Array.isArray(child)) {
+			for (const item of child) if (item && typeof item === "object" && item.type) walk(item, visitors, ctx, nextParents);
+		} else if (child && typeof child === "object" && child.type) walk(child, visitors, ctx, nextParents);
+	}
+	if (visitor && typeof visitor !== "function" && visitor.exit) visitor.exit(node, ctx, parents);
+}
+//#endregion
+//#region src/visitors/program.ts
+const GLOBALS = /* @__PURE__ */ new Set([
+	"window",
+	"document",
+	"location",
+	"URLSearchParams",
+	"localStorage",
+	"navigator",
+	"history",
+	"Intl",
+	"console"
+]);
+function checkSuppression(node, ctx, parents, isInitStart) {
+	if (ctx.suppressionRules.length === 0) return false;
+	if (!node.id || node.id.type !== "Identifier") return false;
+	const name = node.id.name;
+	for (const rule of ctx.suppressionRules) {
+		if (!rule.match.types.includes(node.type)) continue;
+		if (!rule.match.names.includes(name)) continue;
+		if (rule.match.isTopLevel && !isTopLevelDecl(parents)) continue;
+		if (rule.bypassIf === "hasAnchor") {
+			const initStart = isInitStart !== void 0 ? isInitStart : node.start;
+			if (ctx.hasTopLevelAnchor || (ctx.hasZintlMacro || ctx.hasZintlMarker) && (ctx.scopeBoundaries.has(node.start) || ctx.scopeBoundaries.has(initStart))) continue;
+		}
+		return true;
+	}
+	return false;
+}
+function isTopLevelDecl(parents) {
+	for (const p of parents) if (p.type === "FunctionDeclaration" || p.type === "FunctionExpression" || p.type === "ArrowFunctionExpression" || p.type === "MethodDefinition" || p.type === "ClassBody") return false;
+	return true;
+}
+const SCOPE_TYPES = /* @__PURE__ */ new Set([
+	"Program",
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression",
+	"BlockStatement"
+]);
+function createProgramVisitor(_ctx) {
+	function getAnchorInfo(node, parents) {
+		let isAnchor = false, isTopLevel = false, current = node, idx = 0;
+		while (idx < parents.length) {
+			const parent = parents[idx];
+			if (parent.type === "AwaitExpression" || parent.type === "UnaryExpression" && parent.operator === "void" || parent.type === "MemberExpression" && !parent.computed && parent.property.type === "Identifier" && parent.property.name === "then" || parent.type === "CallExpression" && parent.callee === current) {
+				current = parent;
+				idx++;
+			} else break;
+		}
+		const immediateParent = parents[idx];
+		let statementRange;
+		if (immediateParent) {
+			if ([
+				"ExpressionStatement",
+				"ArrowFunctionExpression",
+				"ReturnStatement",
+				"BlockStatement",
+				"VariableDeclarator"
+			].includes(immediateParent.type)) {
+				isAnchor = true;
+				if (immediateParent.type === "ExpressionStatement") statementRange = {
+					start: immediateParent.start,
+					end: immediateParent.end
+				};
+				else statementRange = {
+					start: current.start,
+					end: current.end
+				};
+				let stmtIdx = idx;
+				while (stmtIdx < parents.length) {
+					const p = parents[stmtIdx];
+					if (p.type === "Program") {
+						isTopLevel = true;
+						break;
+					}
+					if (p.type === "BlockStatement") break;
+					stmtIdx++;
+				}
+			}
+		}
+		return {
+			isAnchor,
+			isTopLevel,
+			statementRange
+		};
+	}
+	const scopeCache = /* @__PURE__ */ new Map();
+	const getScopeDecls = (scope) => {
+		if (scopeCache.has(scope)) return scopeCache.get(scope);
+		const decls = /* @__PURE__ */ new Map();
+		const body = scope.body?.type === "BlockStatement" ? scope.body.body : scope.body;
+		if (Array.isArray(body)) {
+			for (const stmt of body) if (stmt.type === "VariableDeclaration") {
+				for (const decl of stmt.declarations) if (decl.id.type === "Identifier" && decl.init) decls.set(decl.id.name, {
+					stmt,
+					decl
+				});
+			}
+		}
+		scopeCache.set(scope, decls);
+		return decls;
+	};
+	function traceIdentifier(name, parents, seen = /* @__PURE__ */ new Set()) {
+		if (seen.has(name) || GLOBALS.has(name)) return void 0;
+		seen.add(name);
+		for (let i = 0; i < parents.length; i++) {
+			const p = parents[i];
+			if (!SCOPE_TYPES.has(p.type)) continue;
+			const entry = getScopeDecls(p).get(name);
+			if (entry) {
+				const { stmt, decl } = entry;
+				let code = _ctx.code.slice(stmt.start, stmt.end);
+				if (!code.endsWith(";")) code += ";";
+				const deps = [];
+				const extractIds = (n) => {
+					if (!n || typeof n !== "object") return;
+					if (n.type === "Identifier") deps.push(n.name);
+					for (const key in n) {
+						if (n.type === "MemberExpression" && key === "property" && !n.computed) continue;
+						const val = n[key];
+						if (val && typeof val === "object") if (Array.isArray(val)) val.forEach(extractIds);
+						else extractIds(val);
+					}
+				};
+				extractIds(decl.init);
+				const results = [];
+				for (const dep of deps) {
+					const depCode = traceIdentifier(dep, parents.slice(i), seen);
+					if (depCode) results.push(depCode);
+				}
+				results.push(code);
+				return results.join("\n");
+			}
+		}
+	}
+	return {
+		Program: { enter(node, ctx) {
+			if (ctx.isZeroConfig) ctx.boundaryStack[0].active = true;
+			const hasMaybeUI = ctx.fastPathRegex.test(ctx.code);
+			const hasDynamicImport = ctx.code.includes("import(");
+			if (!hasMaybeUI && !hasDynamicImport) {
+				for (const stmt of node.body) {
+					const register = (fn, name) => {
+						if (fn && [
+							"FunctionDeclaration",
+							"ArrowFunctionExpression",
+							"FunctionExpression"
+						].includes(fn.type)) {
+							if (ctx.isZeroConfig) {
+								const bId = `${ctx.fileBoundaryId}:${name}`;
+								ctx.scopeBoundaries.set(fn.start, bId);
+								ctx.localBoundaries.set(name, bId);
+							}
+						}
+					};
+					if (stmt.type === "ImportDeclaration") {
+						if (["StringLiteral", "Literal"].includes(stmt.source.type)) {
+							const sourceVal = stmt.source.value, bindings = [];
+							if (stmt.specifiers) {
+								for (const spec of stmt.specifiers) if (spec.type === "ImportSpecifier") bindings.push(spec.imported.name || spec.imported.value);
+								else if (spec.type === "ImportDefaultSpecifier") bindings.push("default");
+							}
+							if (isRuntimeSpecifier(sourceVal, ctx.runtimePackage)) {
+								ctx.zintlImportGroup = {
+									start: stmt.start,
+									end: stmt.end,
+									source: sourceVal
+								};
+								for (const name of bindings) ctx.runtimeImports.push(name);
+								if (!stmt.specifiers?.length) {
+									ctx.mode = "entry";
+									ctx.hasZintlMarker = true;
+								}
+							}
+							ctx.addDependency(sourceVal, false, bindings);
+						}
+					} else if (stmt.type === "FunctionDeclaration" && stmt.id) register(stmt, stmt.id.name);
+					else if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+						const decl = stmt.declaration;
+						if (decl.type === "FunctionDeclaration" && decl.id) {
+							register(decl, decl.id.name);
+							ctx.exportedBoundaries.set(decl.id.name, `${ctx.fileBoundaryId}:${decl.id.name}`);
+						} else if (decl.type === "VariableDeclaration") {
+							for (const d of decl.declarations) if (d.id.type === "Identifier" && d.init) {
+								register(d.init, d.id.name);
+								ctx.exportedBoundaries.set(d.id.name, `${ctx.fileBoundaryId}:${d.id.name}`);
+							}
+						}
+					} else if (stmt.type === "ExportDefaultDeclaration") {
+						register(stmt.declaration, "default");
+						ctx.exportedBoundaries.set("default", `${ctx.fileBoundaryId}:default`);
+					}
+				}
+				return;
+			}
+			const topLevelAnchors = [], functionalAnchors = [];
+			walk(node, { CallExpression(child, _ctx, parents) {
+				const isZintl = child.callee.type === "Identifier" && child.callee.name === "zintl";
+				const isLoader = child.callee.type === "Identifier" && child.callee.name === "loadI18nInstance";
+				if (isZintl || isLoader) {
+					if (isZintl) _ctx.hasZintlMacro = true;
+					const anchorInfo = getAnchorInfo(child, parents);
+					if (anchorInfo.isAnchor) if (anchorInfo.isTopLevel) topLevelAnchors.push(child);
+					else {
+						const fnParent = parents.find((p) => [
+							"FunctionDeclaration",
+							"FunctionExpression",
+							"ArrowFunctionExpression",
+							"MethodDefinition"
+						].includes(p.type));
+						if (fnParent) functionalAnchors.push({
+							node: child,
+							fnParent
+						});
+					}
+				}
+			} }, ctx);
+			for (const { node: anchorNode, fnParent } of functionalAnchors) {
+				let fnId = fnParent.type === "FunctionDeclaration" && fnParent.id?.name || fnParent.type === "MethodDefinition" && fnParent.key.type === "Identifier" && fnParent.key.name || `f_${anchorNode.start}`;
+				const bId = `${ctx.fileBoundaryId}:${fnId}`;
+				ctx.scopeBoundaries.set(fnParent.start, bId);
+				if (fnParent.type === "FunctionDeclaration" && fnParent.id) ctx.localBoundaries.set(fnParent.id.name, bId);
+			}
+			const assignBoundary = (fn, name) => {
+				if (!fn || ![
+					"FunctionDeclaration",
+					"ArrowFunctionExpression",
+					"FunctionExpression"
+				].includes(fn.type)) return;
+				if (ctx.scopeBoundaries.has(fn.start)) return;
+				const bId = `${ctx.fileBoundaryId}:${name}`;
+				ctx.scopeBoundaries.set(fn.start, bId);
+				ctx.localBoundaries.set(name, bId);
+			};
+			for (const stmt of node.body) if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+				if (stmt.declaration.type === "FunctionDeclaration" && stmt.declaration.id) assignBoundary(stmt.declaration, stmt.declaration.id.name);
+				else if (stmt.declaration.type === "VariableDeclaration") {
+					for (const decl of stmt.declaration.declarations) if (decl.id.type === "Identifier" && decl.init) assignBoundary(decl.init, decl.id.name);
+				}
+			} else if (stmt.type === "ExportDefaultDeclaration") assignBoundary(stmt.declaration, "default");
+			else if (ctx.isZeroConfig) {
+				if (stmt.type === "FunctionDeclaration" && stmt.id) assignBoundary(stmt, stmt.id.name);
+				else if (stmt.type === "VariableDeclaration") {
+					for (const decl of stmt.declarations) if (decl.id.type === "Identifier" && decl.init) assignBoundary(decl.init, decl.id.name);
+				}
+			}
+			if (topLevelAnchors.length > 0) {
+				ctx.hasTopLevelAnchor = true;
+				ctx.scopeBoundaries.set(node.start, ctx.fileBoundaryId);
+			}
+			for (const stmt of node.body) if (stmt.type === "ExportNamedDeclaration") {
+				if (stmt.declaration) {
+					if (stmt.declaration.type === "FunctionDeclaration" && stmt.declaration.id) {
+						const name = stmt.declaration.id.name;
+						const bId = ctx.scopeBoundaries.get(stmt.declaration.start) || ctx.localBoundaries.get(name) || ctx.fileBoundaryId;
+						ctx.exportedBoundaries.set(name, bId);
+					} else if (stmt.declaration.type === "VariableDeclaration") {
+						for (const decl of stmt.declaration.declarations) if (decl.id.type === "Identifier") {
+							const name = decl.id.name;
+							const bId = decl.init && ctx.scopeBoundaries.get(decl.init.start) || ctx.localBoundaries.get(name) || ctx.fileBoundaryId;
+							ctx.exportedBoundaries.set(name, bId);
+						}
+					}
+				} else if (stmt.specifiers) for (const spec of stmt.specifiers) {
+					const localName = spec.local.name;
+					const exportedName = spec.exported.name;
+					const bId = ctx.localBoundaries.get(localName) || ctx.fileBoundaryId;
+					ctx.exportedBoundaries.set(exportedName, bId);
+				}
+			} else if (stmt.type === "ExportDefaultDeclaration") {
+				let bId = ctx.fileBoundaryId;
+				const decl = stmt.declaration;
+				if (decl.type === "Identifier") bId = ctx.localBoundaries.get(decl.name) || ctx.fileBoundaryId;
+				else if (decl.type === "FunctionDeclaration" && decl.id) bId = ctx.scopeBoundaries.get(decl.start) || ctx.localBoundaries.get(decl.id.name) || ctx.fileBoundaryId;
+				else bId = ctx.scopeBoundaries.get(decl.start) || ctx.fileBoundaryId;
+				ctx.exportedBoundaries.set("default", bId);
+			}
+		} },
+		FunctionDeclaration: {
+			enter(node, ctx, parents) {
+				const comments = getAttachedComments(node, parents, ctx.trivias, ctx.code);
+				if (comments.ignore) ctx.pushSuppression(comments);
+				if (checkSuppression(node, ctx, parents)) {
+					ctx.suppressionLevel++;
+					node.__zintl_suppressed = true;
+				}
+				const pb = ctx.getActiveBoundary(), id = ctx.scopeBoundaries.get(node.start);
+				ctx.boundaryStack.push({
+					id: id || pb.id,
+					active: id ? true : pb.active
+				});
+			},
+			exit(node, ctx, parents) {
+				ctx.popSuppression(getAttachedComments(node, parents, ctx.trivias, ctx.code));
+				if (node.__zintl_suppressed) ctx.suppressionLevel--;
+				ctx.boundaryStack.pop();
+			}
+		},
+		FunctionExpression: {
+			enter(node, ctx, parents) {
+				const comments = getAttachedComments(node, parents, ctx.trivias, ctx.code);
+				if (comments.ignore) ctx.pushSuppression(comments);
+				const pb = ctx.getActiveBoundary(), id = ctx.scopeBoundaries.get(node.start);
+				ctx.boundaryStack.push({
+					id: id || pb.id,
+					active: id ? true : pb.active
+				});
+			},
+			exit(node, ctx, parents) {
+				ctx.popSuppression(getAttachedComments(node, parents, ctx.trivias, ctx.code));
+				ctx.boundaryStack.pop();
+			}
+		},
+		ArrowFunctionExpression: {
+			enter(node, ctx, parents) {
+				const comments = getAttachedComments(node, parents, ctx.trivias, ctx.code);
+				if (comments.ignore) ctx.pushSuppression(comments);
+				const pb = ctx.getActiveBoundary(), id = ctx.scopeBoundaries.get(node.start);
+				ctx.boundaryStack.push({
+					id: id || pb.id,
+					active: id ? true : pb.active
+				});
+			},
+			exit(node, ctx, parents) {
+				ctx.popSuppression(getAttachedComments(node, parents, ctx.trivias, ctx.code));
+				ctx.boundaryStack.pop();
+			}
+		},
+		VariableDeclarator: {
+			enter(node, ctx, parents) {
+				if (checkSuppression(node, ctx, parents, node.init?.start)) {
+					ctx.suppressionLevel++;
+					node.__zintl_suppressed = true;
+				}
+			},
+			exit(node, ctx, _parents) {
+				if (node.__zintl_suppressed) ctx.suppressionLevel--;
+			}
+		},
+		CallExpression(node, ctx, parents) {
+			if (ctx.suppressionLevel > 0) return;
+			if (node.callee.type === "Identifier") {
+				const lbId = ctx.localBoundaries.get(node.callee.name);
+				if (lbId) ctx.addInternalDependency(lbId);
+			}
+			const isZintl = node.callee.type === "Identifier" && node.callee.name === "zintl";
+			const isLoader = node.callee.type === "Identifier" && node.callee.name === "loadI18nInstance";
+			if (isZintl || isLoader) {
+				const anchorInfo = getAnchorInfo(node, parents);
+				if (!anchorInfo.isAnchor) return;
+				const { isTopLevel } = anchorInfo;
+				if (isLoader && node.arguments[0]?.type === "ObjectExpression" && node.arguments[0].properties.some((p) => p.key.name === "loaders")) return;
+				if (isZintl) ctx.hasZintlMacro = true;
+				if (isTopLevel) ctx.mode = "entry";
+				let originalArgs = "", argType = "expression";
+				if (node.arguments[0]) {
+					originalArgs = ctx.code.slice(node.arguments[0].start, node.arguments[0].end);
+					if (["StringLiteral", "Literal"].includes(node.arguments[0].type)) argType = "literal";
+				}
+				ctx.anchorSites.push({
+					start: node.start,
+					end: node.end,
+					scope: isTopLevel ? "module" : "function",
+					boundaryId: ctx.getActiveBoundary().id,
+					originalArgs,
+					argType,
+					isTopLevel,
+					originalName: node.callee.name,
+					statementRange: anchorInfo.statementRange,
+					detectionCode: (() => {
+						if (argType !== "expression" || !node.arguments[0]) return void 0;
+						const ids = /* @__PURE__ */ new Set();
+						const collectIds = (n) => {
+							if (!n || typeof n !== "object") return;
+							if (n.type === "Identifier") ids.add(n.name);
+							for (const k in n) {
+								if (n.type === "MemberExpression" && k === "property" && !n.computed) continue;
+								const v = n[k];
+								if (Array.isArray(v)) v.forEach(collectIds);
+								else if (v && typeof v === "object") collectIds(v);
+							}
+						};
+						collectIds(node.arguments[0]);
+						const results = /* @__PURE__ */ new Set();
+						for (const id of ids) {
+							const code = traceIdentifier(id, parents);
+							if (code) results.add(code);
+						}
+						return results.size > 0 ? Array.from(results).join("\n") : void 0;
+					})()
+				});
+				ctx.getActiveBoundary().active = true;
+			} else if (node.callee.type === "Identifier" && node.callee.name === "t") {
+				ctx.registerComponentFunction(parents);
+				if (getAttachedComments(node, parents, ctx.trivias, ctx.code).ignore) return;
+				if (node.arguments[0] && ["StringLiteral", "Literal"].includes(node.arguments[0].type)) {
+					const text = node.arguments[0].value;
+					ctx.usedKeys.add(generateMessageId(text, "Manual"));
+					ctx.rawManualTranslations.push({
+						start: node.start,
+						end: node.end,
+						key: text,
+						line: node.start,
+						column: node.start,
+						boundaryId: ctx.getActiveBoundary().id,
+						paramsSource: node.arguments.length > 1 ? ctx.code.slice(node.arguments[1].start, node.arguments[node.arguments.length - 1].end) : void 0
+					});
+				}
+			}
+		},
+		ImportExpression(node, ctx) {
+			if (node.source && ["StringLiteral", "Literal"].includes(node.source.type)) ctx.addDependency(node.source.value, true);
+		},
+		ImportDeclaration(node, ctx) {
+			if (["StringLiteral", "Literal"].includes(node.source.type)) {
+				const sourceVal = node.source.value, bindings = [];
+				if (node.specifiers) {
+					for (const spec of node.specifiers) if (spec.type === "ImportSpecifier") bindings.push(spec.imported.name || spec.imported.value);
+					else if (spec.type === "ImportDefaultSpecifier") bindings.push("default");
+				}
+				if (isRuntimeSpecifier(sourceVal, ctx.runtimePackage)) {
+					ctx.zintlImportGroup = {
+						start: node.start,
+						end: node.end,
+						source: sourceVal
+					};
+					for (const name of bindings) ctx.runtimeImports.push(name);
+					if (!node.specifiers?.length) {
+						ctx.mode = "entry";
+						ctx.hasZintlMarker = true;
+					}
+				}
+				ctx.addDependency(sourceVal, false, bindings);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/visitors/index.ts
+function createCombinedVisitor(ctx) {
+	for (const trivia of ctx.trivias) if (trivia.value.includes("@zintl-ignore-file")) {
+		ctx.isIgnoredFile = true;
+		break;
+	}
+	const visitors = ctx.fastPathRegex.test(ctx.code) ? [
+		...ctx.hasJsxSinks ? [createJsxVisitor(ctx)] : [],
+		createBindingVisitor(ctx),
+		createProgramVisitor(ctx)
+	] : [createProgramVisitor(ctx)];
+	if (ctx.targetPlugins) {
+		for (const plugin of ctx.targetPlugins) if (plugin.createVisitor) visitors.push(plugin.createVisitor(ctx));
+	}
+	const combined = {};
+	for (const visitor of visitors) for (const [key, value] of Object.entries(visitor)) {
+		if (!combined[key]) {
+			combined[key] = value;
+			continue;
+		}
+		const existing = combined[key];
+		const next = value;
+		combined[key] = {
+			enter(node, ctx, parents) {
+				if (typeof existing === "function") existing(node, ctx, parents);
+				else if (existing.enter) existing.enter(node, ctx, parents);
+				if (typeof next === "function") next(node, ctx, parents);
+				else if (next.enter) next.enter(node, ctx, parents);
+			},
+			exit(node, ctx, parents) {
+				if (typeof existing !== "function" && existing.exit) existing.exit(node, ctx, parents);
+				if (typeof next !== "function" && next.exit) next.exit(node, ctx, parents);
+			}
+		};
+	}
+	return combined;
+}
+//#endregion
+//#region src/html.ts
+/**
+* Extracts translatable configuration and template strings from HTML files/templates.
+* Supports: <title>, <meta name="description">, module <script src="...">,
+* HTML text nodes (using stitchHTML), and translatable attributes (alt, placeholder, aria-label, title).
+*/
+function extractHtml(code, filePath, fileBoundaryId, options = {}) {
+	code = code.replace(/\r\n/g, "\n");
+	const ctx = new ExtractionContext(code, filePath, fileBoundaryId, options);
+	ctx.logger.debug(`Extracting HTML configurations from ${filePath}`);
+	const projection = { scripts: [] };
+	const cleanCode = code.replace(/<!--[\s\S]*?-->/g, (m) => " ".repeat(m.length));
+	const htmlDirMatch = cleanCode.match(/<html[^>]*dir=["'](ltr|rtl|auto)["']/i);
+	if (htmlDirMatch) projection.dir = htmlDirMatch[1].toLowerCase();
+	const titleMatch = cleanCode.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+	if (titleMatch) projection.title = titleMatch[1].trim();
+	const descMatch = cleanCode.match(/<meta[^>]*name=["']description["'][^>]*content=["']([^"']*)["']/i) || cleanCode.match(/<meta[^>]*content=["']([^"']*)["'][^>]*name=["']description["']/i);
+	if (descMatch) projection.description = descMatch[1].trim();
+	const scriptRegex = /<script[^>]*src=["']([^"']*)["']/gi;
+	let match;
+	while ((match = scriptRegex.exec(cleanCode)) !== null) projection.scripts.push(match[1]);
+	let activeContent = code;
+	let contentOffset = 0;
+	if (options.activeRange) {
+		activeContent = code.substring(options.activeRange.start, options.activeRange.end);
+		contentOffset = options.activeRange.start;
+	} else if (options.isSfcTemplate) {
+		activeContent = code;
+		contentOffset = 0;
+	} else if (filePath.endsWith(".html")) {
+		const bodyMatch = /<body\b[^>]*>([\s\S]*?)<\/body>/i.exec(code);
+		if (bodyMatch) {
+			activeContent = bodyMatch[1];
+			contentOffset = code.indexOf(bodyMatch[1], bodyMatch.index);
+		} else activeContent = "";
+	} else {
+		activeContent = code;
+		contentOffset = 0;
+	}
+	if (activeContent.trim()) {
+		ctx.stitchHTML(activeContent, (trimmed, note, passVars, start, end, tagMap) => {
+			let processedText = trimmed;
+			const variables = [];
+			if (ctx.mustacheRegex) {
+				const regex = ctx.mustacheRegex;
+				regex.lastIndex = 0;
+				let match;
+				let offsetShift = 0;
+				let varIndex = 0;
+				const matches = [];
+				while ((match = regex.exec(trimmed)) !== null) matches.push({
+					raw: match[0],
+					expr: match[1].trim(),
+					index: match.index
+				});
+				for (const m of matches) {
+					let varName = m.expr;
+					if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(varName)) varName = `var${varIndex++}`;
+					const replacement = `{${varName}}`;
+					const matchIndexInProcessed = m.index + offsetShift;
+					processedText = processedText.substring(0, matchIndexInProcessed) + replacement + processedText.substring(matchIndexInProcessed + m.raw.length);
+					offsetShift += replacement.length - m.raw.length;
+					variables.push({
+						name: varName,
+						originalName: varName,
+						expression: m.expr,
+						start: contentOffset + start + m.index,
+						end: contentOffset + start + m.index + m.raw.length
+					});
+				}
+			}
+			if (processedText.replace(/\{[a-zA-Z_$][a-zA-Z0-9_$]*\}/g, "").trim() === "") return;
+			const msgId = generateMessageId(processedText, "HTML_TEXT", note);
+			ctx.addMessage(msgId, processedText, "HTML_TEXT", fileBoundaryId, {
+				line: 0,
+				column: 0
+			}, variables.map((v) => v.name), note, "HTML_TEXT", passVars);
+			ctx.addRawSink({
+				text: processedText,
+				sinkType: "HTML_TEXT",
+				start: contentOffset + start,
+				end: contentOffset + end,
+				line: 0,
+				column: 0,
+				boundaryId: fileBoundaryId,
+				variables,
+				note,
+				passVars,
+				isFragment: false,
+				tagMap
+			});
+		}, void 0, {}, (s, e) => ({
+			start: s,
+			end: e
+		}));
+		const tagRegex = /<([a-zA-Z0-9:-]+)\s*([^>]*?)\/?>/g;
+		let tagMatch;
+		while ((tagMatch = tagRegex.exec(activeContent)) !== null) {
+			tagMatch[1].toLowerCase();
+			const attrsString = tagMatch[2];
+			if (!attrsString) continue;
+			const attrRegex = /\b([a-zA-Z0-9:-]+)\s*=\s*(?:'([^']*)'|"([^"]*)"|([^\s>]+))/gi;
+			let attrMatch;
+			const attrsIndex = tagMatch[0].indexOf(attrsString);
+			while ((attrMatch = attrRegex.exec(attrsString)) !== null) {
+				const attrName = attrMatch[1].toLowerCase();
+				const attrVal = attrMatch[2] || attrMatch[3] || attrMatch[4] || "";
+				if (attrVal && ctx.htmlAttributes.has(attrName)) {
+					const attrStart = contentOffset + tagMatch.index + attrsIndex + attrMatch.index;
+					const attrEnd = attrStart + attrMatch[0].length;
+					const msgId = generateMessageId(attrVal, "HTML_ATTR");
+					ctx.addMessage(msgId, attrVal, "HTML_ATTR", fileBoundaryId, {
+						line: 0,
+						column: 0
+					}, [], void 0, `html:attr:${attrName}`);
+					ctx.addRawSink({
+						text: attrVal,
+						sinkType: `html:attr:${attrName}`,
+						start: attrStart,
+						end: attrEnd,
+						line: 0,
+						column: 0,
+						boundaryId: fileBoundaryId,
+						variables: [],
+						isFragment: false
+					});
+				}
+			}
+		}
+	}
+	return {
+		messages: Array.from(ctx.messages.values()),
+		code,
+		transforms: ctx.transforms,
+		needsLoader: ctx.messages.size > 0 || ctx.usedKeys.size > 0,
+		hasZintlMacro: ctx.hasZintlMacro,
+		hasZintlMarker: ctx.hasZintlMarker,
+		anchorSites: ctx.anchorSites,
+		mode: ctx.mode,
+		runtimeImports: ctx.runtimeImports,
+		dependencies: projection.scripts.map((s) => ({
+			id: s,
+			dynamic: false
+		})),
+		usedKeys: ctx.usedKeys,
+		boundaryHashes: ctx.computeBoundaryHashes(),
+		exportedBoundaries: Object.fromEntries(ctx.exportedBoundaries),
+		internalDeps: Object.fromEntries(Array.from(ctx.internalDeps.entries()).map(([k, v]) => [k, Array.from(v)])),
+		rawSinks: ctx.rawSinks,
+		rawManualTranslations: ctx.rawManualTranslations,
+		htmlProjection: options.isSfcTemplate ? void 0 : projection
+	};
+}
+//#endregion
+//#region src/parser.ts
+function extract(code, filePath, fileBoundaryId, options = {}) {
+	code = code.replace(/\r\n/g, "\n");
+	const compiledState = options.compiledState ?? resolveTargets(options.targets ?? []);
+	const normalizedOptions = {
+		...options,
+		compiledState
+	};
+	const sfcRules = [...compiledState.sfcRules, ...normalizedOptions.sfcRules || []];
+	const ext = "." + filePath.split(".").pop();
+	const sfcRule = sfcRules.find((rule) => rule.extensions.includes(ext));
+	const isLikelyUI = compiledState.fastPathRegex.test(code);
+	const isLikelyBridge = code.includes("import");
+	if (!isLikelyUI && !isLikelyBridge) return {
+		messages: [],
+		code,
+		transforms: [],
+		needsLoader: false,
+		hasZintlMacro: false,
+		hasZintlMarker: false,
+		anchorSites: [],
+		mode: "boundary",
+		runtimeImports: [],
+		dependencies: [],
+		usedKeys: /* @__PURE__ */ new Set(),
+		boundaryHashes: {},
+		exportedBoundaries: {},
+		internalDeps: {},
+		rawSinks: [],
+		rawManualTranslations: []
+	};
+	if (filePath.endsWith(".html")) return extractHtml(code, filePath, fileBoundaryId, normalizedOptions);
+	if (sfcRule) return extractSfc(code, filePath, fileBoundaryId, normalizedOptions, sfcRule);
+	const ctx = new ExtractionContext(code, filePath, fileBoundaryId, normalizedOptions);
+	ctx.logger.debug(`Extracting messages from ${filePath}`);
+	const result = parseSync(code.includes("<") && !filePath.endsWith(".tsx") ? filePath + ".tsx" : filePath, code, { sourceType: "module" });
+	if (result.errors.length > 0) ctx.logger.warn(`OXC Parse Errors in ${filePath}:`, result.errors);
+	ctx.trivias = result.comments;
+	result.program.body.forEach((stmt) => {
+		if (stmt.type === "ImportDeclaration") {
+			const sourceVal = stmt.source?.value ?? "";
+			const isZintl = isRuntimeSpecifier(sourceVal, ctx.runtimePackage);
+			const hasNoSpecifiers = !stmt.specifiers || stmt.specifiers.length === 0;
+			if (isZintl) {
+				ctx.zintlImportGroup = {
+					start: stmt.start,
+					end: stmt.end,
+					source: sourceVal
+				};
+				if (hasNoSpecifiers) {
+					ctx.hasZintlMarker = true;
+					ctx.mode = "entry";
+				}
+			}
+		}
+	});
+	const visitor = createCombinedVisitor(ctx);
+	walk(result.program, visitor, ctx);
+	return {
+		messages: Array.from(ctx.messages.values()),
+		code,
+		transforms: ctx.transforms,
+		needsLoader: ctx.messages.size > 0 || ctx.usedKeys.size > 0,
+		hasZintlMacro: ctx.hasZintlMacro,
+		hasZintlMarker: ctx.hasZintlMarker,
+		anchorSites: ctx.anchorSites,
+		mode: ctx.mode,
+		runtimeImports: ctx.runtimeImports,
+		zintlImportGroup: ctx.zintlImportGroup,
+		rawSinks: ctx.rawSinks,
+		rawManualTranslations: ctx.rawManualTranslations,
+		exportedBoundaries: Object.fromEntries(ctx.exportedBoundaries),
+		internalDeps: Object.fromEntries(Array.from(ctx.internalDeps.entries()).map(([k, v]) => [k, Array.from(v)])),
+		usedKeys: ctx.usedKeys,
+		boundaryHashes: ctx.computeBoundaryHashes(),
+		dependencies: Array.from(ctx.dependencyPaths, ([id, dynamic]) => ({
+			id,
+			dynamic,
+			bindings: Array.from(ctx.dependencyBindings.get(id) || [])
+		})),
+		componentFunctions: Array.from(ctx.componentFunctions)
+	};
+}
+function extractSfc(code, filePath, fileBoundaryId, options, rule) {
+	const jsBlocks = [];
+	const ignoreMatches = [];
+	const htmlMatches = [];
+	for (const block of rule.blocks) {
+		block.pattern.lastIndex = 0;
+		let match;
+		while ((match = block.pattern.exec(code)) !== null) {
+			let attrs = "";
+			let blockContent = "";
+			if (match.length >= 3) {
+				attrs = match[1] || "";
+				blockContent = match[2] || "";
+			} else if (match.length === 2) blockContent = match[1] || "";
+			else blockContent = match[0] || "";
+			const matchStart = code.indexOf(blockContent, match.index);
+			const matchEnd = matchStart + blockContent.length;
+			if (block.action === "javascript") {
+				const startLine = (code.substring(0, matchStart).match(/\n/g) || []).length;
+				const virtualExt = block.resolveVirtualExtension ? block.resolveVirtualExtension(attrs) : ".ts";
+				jsBlocks.push({
+					id: block.id,
+					content: blockContent,
+					start: matchStart,
+					startLine,
+					virtualExt
+				});
+				ignoreMatches.push({
+					start: match.index,
+					end: match.index + match[0].length
+				});
+			} else if (block.action === "ignore") ignoreMatches.push({
+				start: match.index,
+				end: match.index + match[0].length
+			});
+			else if (block.action === "html") htmlMatches.push({
+				start: matchStart,
+				end: matchEnd,
+				isActive: block.isActiveContent || false
+			});
+		}
+	}
+	const jsResults = [];
+	for (const block of jsBlocks) {
+		if (!block.content.trim()) continue;
+		const res = extract(block.content, filePath + block.virtualExt, fileBoundaryId, options);
+		if (res.messages) for (const msg of res.messages) msg.location.line += block.startLine;
+		if (res.transforms) for (const t of res.transforms) {
+			t.start += block.start;
+			t.end += block.start;
+		}
+		if (res.rawSinks) for (const s of res.rawSinks) {
+			s.start += block.start;
+			s.end += block.start;
+			s.line += block.startLine;
+			if (s.hostStart !== void 0) s.hostStart += block.start;
+			if (s.hostEnd !== void 0) s.hostEnd += block.start;
+			if (s.fragmentStart !== void 0) s.fragmentStart += block.start;
+			if (s.fragmentEnd !== void 0) s.fragmentEnd += block.start;
+			if (s.variables) for (const v of s.variables) {
+				v.start += block.start;
+				v.end += block.start;
+			}
+		}
+		if (res.rawManualTranslations) for (const t of res.rawManualTranslations) {
+			t.start += block.start;
+			t.end += block.start;
+			t.line += block.start;
+		}
+		if (res.anchorSites) for (const s of res.anchorSites) {
+			s.start += block.start;
+			s.end += block.start;
+			if (s.statementRange) {
+				s.statementRange.start += block.start;
+				s.statementRange.end += block.start;
+			}
+		}
+		if (res.zintlImportGroup) {
+			res.zintlImportGroup.start += block.start;
+			res.zintlImportGroup.end += block.start;
+		}
+		jsResults.push(res);
+	}
+	let templateHtml = code;
+	const sortedIgnores = [...ignoreMatches].sort((a, b) => b.start - a.start);
+	for (const m of sortedIgnores) {
+		const len = m.end - m.start;
+		templateHtml = templateHtml.substring(0, m.start) + " ".repeat(len) + templateHtml.substring(m.end);
+	}
+	const activeHtml = htmlMatches.find((m) => m.isActive);
+	const templateExt = extractHtml(templateHtml, filePath + ".html", fileBoundaryId, {
+		...options,
+		isSfcTemplate: true,
+		activeRange: activeHtml ? {
+			start: activeHtml.start,
+			end: activeHtml.end
+		} : void 0
+	});
+	const messages = [...jsResults.flatMap((r) => r.messages), ...templateExt?.messages || []];
+	const transforms = [...jsResults.flatMap((r) => r.transforms), ...templateExt?.transforms || []];
+	const dependencies = [...jsResults.flatMap((r) => r.dependencies), ...templateExt?.dependencies || []];
+	const rawSinks = [...jsResults.flatMap((r) => r.rawSinks), ...templateExt?.rawSinks || []];
+	const rawManualTranslations = [...jsResults.flatMap((r) => r.rawManualTranslations), ...templateExt?.rawManualTranslations || []];
+	const usedKeys = /* @__PURE__ */ new Set([...jsResults.flatMap((r) => Array.from(r.usedKeys)), ...templateExt?.usedKeys || []]);
+	const boundaryHashes = {};
+	for (const r of jsResults) Object.assign(boundaryHashes, r.boundaryHashes);
+	if (templateExt) Object.assign(boundaryHashes, templateExt.boundaryHashes);
+	const exportedBoundaries = {};
+	for (const r of jsResults) Object.assign(exportedBoundaries, r.exportedBoundaries);
+	if (templateExt) Object.assign(exportedBoundaries, templateExt.exportedBoundaries);
+	const internalDeps = {};
+	const allDeps = [...jsResults.map((r) => r.internalDeps), templateExt?.internalDeps || {}];
+	for (const deps of allDeps) for (const [k, v] of Object.entries(deps)) internalDeps[k] = [...internalDeps[k] || [], ...v];
+	return {
+		messages,
+		code,
+		transforms,
+		needsLoader: jsResults.some((r) => r.needsLoader) || (templateExt?.needsLoader ?? false),
+		hasZintlMacro: jsResults.some((r) => r.hasZintlMacro) || (templateExt?.hasZintlMacro ?? false),
+		hasZintlMarker: jsResults.some((r) => r.hasZintlMarker) || (templateExt?.hasZintlMarker ?? false),
+		anchorSites: [...jsResults.flatMap((r) => r.anchorSites), ...templateExt?.anchorSites || []],
+		mode: jsResults.some((r) => r.mode === "entry") || templateExt?.mode === "entry" ? "entry" : "boundary",
+		runtimeImports: [...jsResults.flatMap((r) => r.runtimeImports), ...templateExt?.runtimeImports || []],
+		dependencies,
+		usedKeys,
+		boundaryHashes,
+		zintlImportGroup: jsResults.find((r) => r.zintlImportGroup)?.zintlImportGroup || templateExt?.zintlImportGroup,
+		exportedBoundaries,
+		internalDeps,
+		rawSinks,
+		rawManualTranslations,
+		componentFunctions: [...jsResults.flatMap((r) => r.componentFunctions || []), ...templateExt?.componentFunctions || []],
+		htmlProjection: templateExt?.htmlProjection
+	};
+}
+//#endregion
+export { HTML_TAG_SPLIT_REGEX, RUNTIME_PACKAGE, RUNTIME_SPECIFIERS, ZINTL_MACRO, ZintlLogger, extract, generateMessageId, isRuntimeSpecifier, logger, resolveTargets };