@intlayer/lsp 8.11.4 → 9.0.0-canary.12

package/dist/esm/usageAnalyzer.mjs

@@ -0,0 +1,692 @@
+import { callers_exports } from "./callers/index.mjs";
+import { buildParentMap, getObjectPropertyNode, getObjectPropertyString, getPropertyKeyName, getStaticStringValue, nodeEnd, nodeStart, parseText, walkAst } from "./oxcUtils.mjs";
+
+//#region src/usageAnalyzer.ts
+/**
+* Property names that are framework accessors rather than content fields
+* (react `.value`, vue refs `.value`, editor `.raw`/`.use`): they are skipped
+* when building field paths.
+*/
+const ACCESSOR_PROPERTY_NAMES = new Set([
+	"value",
+	"raw",
+	"use"
+]);
+/**
+* Resolve a value source against a call expression's arguments.
+*/
+const readValueSource = (callNode, source) => {
+	const argumentsList = callNode["arguments"];
+	switch (source.from) {
+		case "argument": return getStaticStringValue(argumentsList?.[source.index]);
+		case "option": return getObjectPropertyString(argumentsList?.[source.argumentIndex], source.property);
+		case "fixed": return source.value;
+		case "path-first-segment": return null;
+	}
+};
+/** Read the first matching value from a list of sources. */
+const readValueSources = (callNode, sources) => {
+	for (const source of sources ?? []) {
+		const value = readValueSource(callNode, source);
+		if (value !== null) return value;
+	}
+	return null;
+};
+/**
+* Apply nested-namespace semantics: for descriptors flagged
+* `nestedNamespace`, a dotted namespace is split at the first `.` into the
+* dictionary key and a key-prefix path (next-intl:
+* `useTranslations('about.counter')` → dictionary `about`, prefix
+* `['counter']`).
+*/
+const splitNestedNamespace = (descriptor, rawNamespace) => {
+	if (!descriptor.nestedNamespace || !rawNamespace.includes(".")) return {
+		dictionaryKey: rawNamespace,
+		prefixPath: []
+	};
+	const segments = rawNamespace.split(".");
+	return {
+		dictionaryKey: segments[0],
+		prefixPath: segments.slice(1)
+	};
+};
+/**
+* Return the caller name matched by a call/tagged-template callee: the bare
+* identifier name, or the property name of a member expression when the
+* descriptor allows method matching.
+*/
+const getCalleeName = (calleeNode) => {
+	if (!calleeNode) return null;
+	if (calleeNode["type"] === "Identifier") return {
+		name: calleeNode["name"],
+		isMethod: false
+	};
+	if (calleeNode["type"] === "MemberExpression" && calleeNode["computed"] !== true) {
+		const propertyNode = calleeNode["property"];
+		if (propertyNode?.["type"] === "Identifier") return {
+			name: propertyNode["name"],
+			isMethod: true
+		};
+	}
+	return null;
+};
+/**
+* The message id of a self caller: either the first string argument or the
+* `id` property of a descriptor-object first argument
+* (`formatMessage({ id: 'home.title' })`, `i18n._({ id: '…' })`).
+*/
+const getSelfCallMessageId = (callNode) => {
+	const firstArgument = callNode["arguments"]?.[0];
+	if (!firstArgument) return null;
+	return getStaticStringValue(firstArgument) ?? getObjectPropertyString(firstArgument, "id");
+};
+/**
+* Split a message id into dictionary key + field path according to the
+* descriptor semantics.
+*/
+const resolveMessageId = (descriptor, fixedDictionaryKey, messageId) => {
+	if (fixedDictionaryKey !== null) return {
+		dictionaryKey: fixedDictionaryKey,
+		fieldPath: descriptor.flatKey ? [messageId] : messageId.split(".")
+	};
+	if (!descriptor.namespaceSources.some((source) => source.from === "path-first-segment")) return null;
+	const segments = messageId.split(".");
+	if (!segments[0]) return null;
+	return {
+		dictionaryKey: segments[0],
+		fieldPath: segments.slice(1)
+	};
+};
+/**
+* i18next-style `ns:key` ids override the bound namespace:
+* `t('about:title')` reads the `about` dictionary even when the translator
+* was created with another namespace.
+*/
+const splitNamespacePrefixedId = (messageId) => {
+	const separatorIndex = messageId.indexOf(":");
+	if (separatorIndex <= 0) return {
+		namespaceOverride: null,
+		messagePath: messageId
+	};
+	return {
+		namespaceOverride: messageId.slice(0, separatorIndex),
+		messagePath: messageId.slice(separatorIndex + 1)
+	};
+};
+/** Unwrap `await expression` down to the awaited expression. */
+const unwrapAwait = (node) => node?.["type"] === "AwaitExpression" ? node["argument"] : node;
+/** Collect every module specifier imported by the program. */
+const collectImportSources = (program) => {
+	const importSources = /* @__PURE__ */ new Set();
+	for (const statement of program["body"] ?? []) {
+		if (statement["type"] !== "ImportDeclaration") continue;
+		const sourceValue = statement["source"]?.["value"];
+		if (typeof sourceValue === "string") importSources.add(sourceValue);
+	}
+	return importSources;
+};
+/** Map each imported local name to its module specifier. */
+const collectImportedLocalNames = (program) => {
+	const localNameToSource = /* @__PURE__ */ new Map();
+	for (const statement of program["body"] ?? []) {
+		if (statement["type"] !== "ImportDeclaration") continue;
+		const sourceValue = statement["source"]?.["value"];
+		if (typeof sourceValue !== "string") continue;
+		for (const specifier of statement["specifiers"] ?? []) {
+			const localName = specifier["local"]?.["name"];
+			if (typeof localName === "string") localNameToSource.set(localName, sourceValue);
+		}
+	}
+	return localNameToSource;
+};
+/**
+* Find the descriptor matching a call (or tagged template) callee among the
+* active descriptors.
+*/
+const matchDescriptorForCallee = (state, calleeNode, filter) => {
+	const callee = getCalleeName(calleeNode);
+	if (!callee) return null;
+	for (const descriptor of state.activeDescriptors) {
+		if (descriptor.callerName !== callee.name) continue;
+		if (callee.isMethod && !descriptor.matchAsMethod) continue;
+		if (filter && !filter(descriptor)) continue;
+		return descriptor;
+	}
+	return null;
+};
+/** The module specifier a caller local name was imported from, if any. */
+const getModuleSource = (state, descriptor) => state.importedLocalNames.get(descriptor.callerName) ?? void 0;
+/**
+* Recursively register a content destructure pattern: each property key is a
+* field usage, each bound identifier becomes a content binding, and nested
+* patterns extend the field path.
+*
+*   const { searchInput: { text: alias } } = useIntlayer('key')
+*   → usages: ['searchInput'], ['searchInput', 'text']
+*   → binding: alias → ['searchInput', 'text']
+*/
+const collectContentDestructure = (state, pattern, dictionaryKey, basePath, descriptor, moduleSource) => {
+	for (const property of pattern["properties"] ?? []) {
+		const propertyType = property["type"];
+		if (propertyType !== "Property" && propertyType !== "ObjectProperty") continue;
+		const keyNode = property["key"];
+		const fieldName = getPropertyKeyName(keyNode);
+		if (!keyNode || !fieldName) continue;
+		const fieldPath = [...basePath, fieldName];
+		state.usages.push({
+			dictionaryKey,
+			fieldPath,
+			start: nodeStart(keyNode),
+			end: nodeEnd(keyNode),
+			kind: "destructure",
+			callerName: descriptor.callerName,
+			library: descriptor.library,
+			moduleSource
+		});
+		let valueNode = property["value"];
+		if (valueNode?.["type"] === "AssignmentPattern") valueNode = valueNode["left"];
+		if (valueNode?.["type"] === "Identifier") state.contentBindings.set(valueNode["name"], {
+			dictionaryKey,
+			basePath: fieldPath,
+			descriptor,
+			moduleSource
+		});
+		else if (valueNode?.["type"] === "ObjectPattern") collectContentDestructure(state, valueNode, dictionaryKey, fieldPath, descriptor, moduleSource);
+	}
+};
+/**
+* Register bindings created by `const … = caller(…)` declarations, and record
+* dictionary-level (`namespace`) usages for every matched caller call.
+*/
+const collectBindings = (state, program) => {
+	walkAst(program, (node) => {
+		if (node["type"] === "CallExpression") {
+			const descriptor = matchDescriptorForCallee(state, node["callee"], (candidate) => candidate.translationFunction !== "self");
+			if (descriptor) {
+				const rawNamespace = readValueSources(node, descriptor.namespaceSources);
+				if (rawNamespace) {
+					const { dictionaryKey } = splitNestedNamespace(descriptor, rawNamespace);
+					state.usages.push({
+						dictionaryKey,
+						fieldPath: [],
+						start: nodeStart(node),
+						end: nodeEnd(node),
+						kind: "namespace",
+						callerName: descriptor.callerName,
+						library: descriptor.library,
+						moduleSource: getModuleSource(state, descriptor)
+					});
+				}
+			}
+			return;
+		}
+		if (node["type"] !== "VariableDeclarator") return;
+		const initializer = unwrapAwait(node["init"]);
+		if (initializer?.["type"] !== "CallExpression") return;
+		const descriptor = matchDescriptorForCallee(state, initializer["callee"], (candidate) => candidate.translationFunction !== "self");
+		if (!descriptor) return;
+		const rawNamespace = readValueSources(initializer, descriptor.namespaceSources);
+		if (!rawNamespace && !descriptor.allowRootScope) return;
+		const namespaceSplit = rawNamespace ? splitNestedNamespace(descriptor, rawNamespace) : {
+			dictionaryKey: null,
+			prefixPath: []
+		};
+		const keyPrefixValue = readValueSources(initializer, descriptor.keyPrefixSources);
+		const keyPrefix = [...namespaceSplit.prefixPath, ...keyPrefixValue ? keyPrefixValue.split(".") : []];
+		const dictionaryKey = namespaceSplit.dictionaryKey;
+		const moduleSource = getModuleSource(state, descriptor);
+		const idNode = node["id"];
+		if (!idNode) return;
+		if (idNode["type"] === "Identifier") {
+			const variableName = idNode["name"];
+			if (descriptor.translationFunction === "return-value") state.translatorBindings.set(variableName, {
+				dictionaryKey,
+				keyPrefix,
+				descriptor,
+				moduleSource
+			});
+			else if (descriptor.translationFunction === "content" && dictionaryKey) state.contentBindings.set(variableName, {
+				dictionaryKey,
+				basePath: keyPrefix,
+				descriptor,
+				moduleSource
+			});
+			return;
+		}
+		if (idNode["type"] !== "ObjectPattern") return;
+		if (descriptor.translationFunction === "content") {
+			if (!dictionaryKey) return;
+			collectContentDestructure(state, idNode, dictionaryKey, keyPrefix, descriptor, moduleSource);
+			return;
+		}
+		if (descriptor.translationFunction !== "destructured-t") return;
+		for (const property of idNode["properties"] ?? []) {
+			const propertyType = property["type"];
+			if (propertyType !== "Property" && propertyType !== "ObjectProperty") continue;
+			const keyNode = property["key"];
+			const valueNode = property["value"];
+			const fieldName = getPropertyKeyName(keyNode);
+			const localName = valueNode?.["type"] === "Identifier" ? valueNode["name"] : null;
+			if (fieldName !== "t" || !localName) continue;
+			state.translatorBindings.set(localName, {
+				dictionaryKey,
+				keyPrefix,
+				descriptor,
+				moduleSource
+			});
+		}
+	});
+};
+/**
+* Record `t('path.to.field')` calls on translator bindings, and self-caller
+* calls (`formatMessage({ id })`, `i18n._('id')`).
+*/
+const collectCallUsages = (state, program) => {
+	walkAst(program, (node) => {
+		if (node["type"] === "TaggedTemplateExpression") {
+			collectTaggedTemplateUsage(state, node);
+			return;
+		}
+		if (node["type"] !== "CallExpression") return;
+		const callee = node["callee"];
+		if (callee?.["type"] === "Identifier") {
+			const binding = state.translatorBindings.get(callee["name"]);
+			if (binding) {
+				const argumentsList = node["arguments"];
+				const messageId = getStaticStringValue(argumentsList?.[0]);
+				if (messageId) {
+					const { namespaceOverride, messagePath } = splitNamespacePrefixedId(messageId);
+					let dictionaryKey = namespaceOverride ?? binding.dictionaryKey;
+					let fieldPath = namespaceOverride ? messagePath.split(".") : [...binding.keyPrefix, ...messagePath.split(".")];
+					if (dictionaryKey === null) {
+						const segments = messagePath.split(".");
+						dictionaryKey = segments[0] ?? null;
+						fieldPath = segments.slice(1);
+					}
+					if (dictionaryKey) state.usages.push({
+						dictionaryKey,
+						fieldPath,
+						start: nodeStart(node),
+						end: nodeEnd(node),
+						kind: "call",
+						callerName: binding.descriptor.callerName,
+						library: binding.descriptor.library,
+						moduleSource: binding.moduleSource
+					});
+				}
+				return;
+			}
+		}
+		const descriptor = matchDescriptorForCallee(state, callee, (candidate) => candidate.translationFunction === "self");
+		if (!descriptor) return;
+		const messageId = getSelfCallMessageId(node);
+		if (!messageId) return;
+		const resolved = resolveMessageId(descriptor, readValueSources(node, descriptor.namespaceSources), messageId);
+		if (!resolved) return;
+		state.usages.push({
+			...resolved,
+			start: nodeStart(node),
+			end: nodeEnd(node),
+			kind: "call",
+			callerName: descriptor.callerName,
+			library: descriptor.library,
+			moduleSource: getModuleSource(state, descriptor)
+		});
+	});
+};
+/**
+* Lingui macro tagged template: ``t`Hello ${name}` `` — the catalog id is the
+* template text with `{placeholder}` slots for each expression.
+*/
+const collectTaggedTemplateUsage = (state, node) => {
+	const descriptor = matchDescriptorForCallee(state, node["tag"], (candidate) => candidate.matchAsTaggedTemplate === true);
+	if (!descriptor) return;
+	const quasiNode = node["quasi"];
+	const quasis = quasiNode?.["quasis"] ?? [];
+	const expressions = quasiNode?.["expressions"] ?? [];
+	let messageId = "";
+	for (let index = 0; index < quasis.length; index++) {
+		const valueNode = quasis[index]?.["value"];
+		messageId += valueNode?.["cooked"] ?? valueNode?.["raw"] ?? "";
+		if (index < expressions.length) {
+			const expression = expressions[index];
+			const placeholder = expression["type"] === "Identifier" ? expression["name"] : String(index);
+			messageId += `{${placeholder}}`;
+		}
+	}
+	if (!messageId) return;
+	const resolved = resolveMessageId(descriptor, readValueSources(node, descriptor.namespaceSources), messageId);
+	if (!resolved) return;
+	state.usages.push({
+		...resolved,
+		start: nodeStart(node),
+		end: nodeEnd(node),
+		kind: "tagged-template",
+		callerName: descriptor.callerName,
+		library: descriptor.library,
+		moduleSource: getModuleSource(state, descriptor)
+	});
+};
+/** Read a static string JSX attribute from an opening element. */
+const getJsxAttributeString = (openingElement, attributeName) => {
+	for (const attribute of openingElement["attributes"] ?? []) {
+		if (attribute["type"] !== "JSXAttribute") continue;
+		if (attribute["name"]?.["name"] !== attributeName) continue;
+		const valueNode = attribute["value"];
+		if (!valueNode) return null;
+		const directValue = getStaticStringValue(valueNode);
+		if (directValue !== null) return directValue;
+		if (valueNode["type"] === "JSXExpressionContainer") return getStaticStringValue(valueNode["expression"]);
+		return null;
+	}
+	return null;
+};
+/**
+* Record JSX message components: `<FormattedMessage id="home.title" />`,
+* `<Trans i18nKey="richText" />`, `<Trans id="…" />`.
+*/
+const collectJsxUsages = (state, program) => {
+	const translatorNamespaces = new Set([...state.translatorBindings.values()].map((binding) => binding.dictionaryKey).filter((dictionaryKey) => dictionaryKey !== null));
+	const fallbackNamespace = translatorNamespaces.size === 1 ? [...translatorNamespaces][0] : null;
+	walkAst(program, (node) => {
+		if (node["type"] !== "JSXOpeningElement") return;
+		const nameNode = node["name"];
+		if (nameNode?.["type"] !== "JSXIdentifier") return;
+		const elementName = nameNode["name"];
+		for (const descriptor of state.activeDescriptors) {
+			if (!descriptor.jsxIdAttribute) continue;
+			if (descriptor.callerName !== elementName) continue;
+			const messageId = getJsxAttributeString(node, descriptor.jsxIdAttribute);
+			if (messageId === null) continue;
+			const namespaceFromAttribute = descriptor.jsxNamespaceAttribute ? getJsxAttributeString(node, descriptor.jsxNamespaceAttribute) : null;
+			const fixedNamespace = descriptor.namespaceSources.find((source) => source.from === "fixed");
+			const dictionaryKey = namespaceFromAttribute ?? (fixedNamespace?.from === "fixed" ? fixedNamespace.value : null) ?? fallbackNamespace;
+			let resolved;
+			if (dictionaryKey) resolved = {
+				dictionaryKey,
+				fieldPath: descriptor.flatKey ? [messageId] : messageId.split(".")
+			};
+			else resolved = resolveMessageId(descriptor, null, messageId);
+			if (!resolved) continue;
+			state.usages.push({
+				...resolved,
+				start: nodeStart(node),
+				end: nodeEnd(node),
+				kind: "jsx",
+				callerName: descriptor.callerName,
+				library: descriptor.library,
+				moduleSource: getModuleSource(state, descriptor)
+			});
+			return;
+		}
+	});
+};
+/** Identifier positions that are declarations, not references. */
+const isDeclarationPosition = (identifierNode, parentMap) => {
+	const parent = parentMap.get(identifierNode);
+	if (!parent) return false;
+	const parentType = parent["type"];
+	if (parentType === "VariableDeclarator" && parent["id"] === identifierNode) return true;
+	if ((parentType === "Property" || parentType === "ObjectProperty") && parentMap.get(parent)?.["type"] === "ObjectPattern") return true;
+	if (parentType === "ImportSpecifier" || parentType === "PropertyDefinition") return true;
+	if (parentType === "FunctionDeclaration" || parentType === "FunctionExpression" || parentType === "ArrowFunctionExpression") return true;
+	if ((parentType === "Property" || parentType === "ObjectProperty") && parent["key"] === identifierNode && parentMap.get(parent)?.["type"] === "ObjectExpression") return true;
+	return false;
+};
+/** Identifier used as the (non-computed) property name of a member access. */
+const isPropertyNamePosition = (identifierNode, parentMap) => {
+	const parent = parentMap.get(identifierNode);
+	if (!parent) return false;
+	const parentType = parent["type"];
+	return parentType === "MemberExpression" && parent["property"] === identifierNode && parent["computed"] !== true || parentType === "JSXMemberExpression" && parent["property"] === identifierNode;
+};
+/**
+* Record member-access / bare-reference usages of content bindings:
+* `content.section.title`, `{title}` (destructured field reference),
+* Svelte's `$content.title`, Vue's `content.value.title`.
+*/
+const collectMemberUsages = (state, program, parentMap) => {
+	if (state.contentBindings.size === 0) return;
+	walkAst(program, (node) => {
+		const nodeType = node["type"];
+		if (nodeType !== "Identifier" && nodeType !== "JSXIdentifier") return;
+		const rawName = node["name"];
+		const variableName = rawName.startsWith("$") ? rawName.slice(1) : rawName;
+		const binding = state.contentBindings.get(variableName);
+		if (!binding) return;
+		const parentType = parentMap.get(node)?.["type"];
+		if (parentType?.startsWith("TS") || parentType === "JSXAttribute") return;
+		if (isDeclarationPosition(node, parentMap)) return;
+		if (isPropertyNamePosition(node, parentMap)) return;
+		const fieldPath = [...binding.basePath];
+		const fieldSpans = fieldPath.map(() => ({
+			start: nodeStart(node),
+			end: nodeEnd(node)
+		}));
+		let currentNode = node;
+		while (true) {
+			const parent = parentMap.get(currentNode);
+			if (!parent) break;
+			const parentType = parent["type"];
+			if (parentType === "MemberExpression" && parent["object"] === currentNode && parent["computed"] !== true || parentType === "JSXMemberExpression" && parent["object"] === currentNode) {
+				const propertyNode = parent["property"];
+				const propertyName = propertyNode["name"];
+				if (!ACCESSOR_PROPERTY_NAMES.has(propertyName)) {
+					fieldPath.push(propertyName);
+					fieldSpans.push({
+						start: nodeStart(propertyNode),
+						end: nodeEnd(propertyNode)
+					});
+				}
+				currentNode = parent;
+				continue;
+			}
+			if (parentType === "MemberExpression" && parent["object"] === currentNode && parent["computed"] === true) {
+				const propertyValue = getStaticStringValue(parent["property"]);
+				if (propertyValue === null) break;
+				fieldPath.push(propertyValue);
+				fieldSpans.push({
+					start: nodeStart(parent["property"]),
+					end: nodeEnd(parent["property"])
+				});
+				currentNode = parent;
+				continue;
+			}
+			if (parentType === "CallExpression" && parent["callee"] === currentNode) {
+				currentNode = parent;
+				continue;
+			}
+			break;
+		}
+		state.usages.push({
+			dictionaryKey: binding.dictionaryKey,
+			fieldPath,
+			fieldSpans,
+			start: nodeStart(node),
+			end: nodeEnd(currentNode),
+			kind: "member",
+			callerName: binding.descriptor.callerName,
+			library: binding.descriptor.library,
+			moduleSource: binding.moduleSource,
+			isBareReference: fieldPath.length === binding.basePath.length
+		});
+		return true;
+	});
+};
+/**
+* Analyse a source file and return every resolvable translation usage:
+* base-intlayer content access and all compat-library forms (translation
+* functions, self calls, JSX message components, tagged templates).
+*
+* Pure and self-contained (oxc parse only) — shared by the LSP handlers and
+* the VS Code extension providers/decorations.
+*
+* @param text - Full source text (a script: TS/TSX or an extracted SFC block).
+* @returns Usages ordered by start offset.
+*/
+const collectMessageUsages = (text) => {
+	const program = parseText(text);
+	if (!program) return [];
+	const fileImportSources = collectImportSources(program);
+	const state = {
+		usages: [],
+		translatorBindings: /* @__PURE__ */ new Map(),
+		contentBindings: /* @__PURE__ */ new Map(),
+		activeDescriptors: callers_exports.ALL_CALLERS.filter((descriptor) => (0, callers_exports.isCallerActive)(descriptor, fileImportSources)),
+		importedLocalNames: collectImportedLocalNames(program)
+	};
+	collectBindings(state, program);
+	collectCallUsages(state, program);
+	collectJsxUsages(state, program);
+	collectMemberUsages(state, program, buildParentMap(program));
+	return state.usages.sort((first, second) => first.start - second.start);
+};
+/**
+* Resolve the dictionary key declared by a single call-expression node when
+* it matches any registered non-self caller (`useIntlayer("key")`,
+* `useI18n({ namespace })`, …). Used for on-the-fly checks where the full
+* file analysis is not needed (e.g. completion context).
+*
+* @param callNode - A candidate CallExpression node.
+*/
+const matchCallNamespace = (callNode) => {
+	if (callNode["type"] !== "CallExpression") return null;
+	const callee = getCalleeName(callNode["callee"]);
+	if (!callee) return null;
+	for (const descriptor of callers_exports.ALL_CALLERS) {
+		if (descriptor.translationFunction === "self") continue;
+		if (descriptor.callerName !== callee.name) continue;
+		if (callee.isMethod && !descriptor.matchAsMethod) continue;
+		const namespaceValue = readValueSources(callNode, descriptor.namespaceSources);
+		if (namespaceValue !== null) return splitNestedNamespace(descriptor, namespaceValue).dictionaryKey;
+	}
+	return null;
+};
+/**
+* The AST node holding the namespace string for a given value source, when
+* that source is addressable in the call (positional argument or options
+* property).
+*/
+const getNamespaceArgumentNode = (callNode, source) => {
+	const argumentsList = callNode["arguments"];
+	if (source.from === "argument") return argumentsList?.[source.index] ?? null;
+	if (source.from === "option") return getObjectPropertyNode(argumentsList?.[source.argumentIndex], source.property)?.["value"] ?? null;
+	return null;
+};
+/**
+* Collect every call site with an addressable namespace argument (positional
+* or options property) resolving to a static string. Powers the
+* unknown-dictionary diagnostics and `findKeyAtOffset`.
+*
+* Self callers (`formatMessage`, lingui `t`/`_`) don't declare a namespace at
+* the call site and are excluded.
+*
+* @param text - Full source text.
+*/
+const collectNamespaceReferences = (text) => {
+	const program = parseText(text);
+	if (!program) return [];
+	const fileImportSources = collectImportSources(program);
+	const activeDescriptors = callers_exports.ALL_CALLERS.filter((descriptor) => descriptor.translationFunction !== "self" && (0, callers_exports.isCallerActive)(descriptor, fileImportSources));
+	const references = [];
+	walkAst(program, (node) => {
+		if (node["type"] !== "CallExpression") return;
+		const calleeNode = node["callee"];
+		const callee = getCalleeName(calleeNode);
+		if (!callee) return;
+		for (const descriptor of activeDescriptors) {
+			if (descriptor.callerName !== callee.name) continue;
+			if (callee.isMethod && !descriptor.matchAsMethod) continue;
+			const calleeNameNode = callee.isMethod && calleeNode ? calleeNode["property"] : calleeNode;
+			for (const source of descriptor.namespaceSources) {
+				const namespaceNode = getNamespaceArgumentNode(node, source);
+				const namespaceValue = getStaticStringValue(namespaceNode ?? void 0);
+				if (!namespaceNode || namespaceValue === null) continue;
+				references.push({
+					dictionaryKey: splitNestedNamespace(descriptor, namespaceValue).dictionaryKey,
+					callerName: descriptor.callerName,
+					library: descriptor.library,
+					callStart: nodeStart(node),
+					callEnd: nodeEnd(node),
+					calleeStart: nodeStart(calleeNameNode),
+					calleeEnd: nodeEnd(calleeNameNode),
+					namespaceStart: nodeStart(namespaceNode),
+					namespaceEnd: nodeEnd(namespaceNode)
+				});
+				return;
+			}
+		}
+	});
+	return references;
+};
+/**
+* Collect every variable bound to a dictionary in the file. Used by consumers
+* that scan non-script regions (Vue/Angular templates) for references to
+* those variables, or that need to know which dictionaries a file consumes.
+*
+* @param text - Full source text (a script: TS/TSX or an extracted SFC block).
+*/
+const collectCallerBindings = (text) => {
+	const program = parseText(text);
+	if (!program) return [];
+	const fileImportSources = collectImportSources(program);
+	const state = {
+		usages: [],
+		translatorBindings: /* @__PURE__ */ new Map(),
+		contentBindings: /* @__PURE__ */ new Map(),
+		activeDescriptors: callers_exports.ALL_CALLERS.filter((descriptor) => (0, callers_exports.isCallerActive)(descriptor, fileImportSources)),
+		importedLocalNames: collectImportedLocalNames(program)
+	};
+	collectBindings(state, program);
+	return [...[...state.contentBindings.entries()].map(([variableName, binding]) => ({
+		variableName,
+		dictionaryKey: binding.dictionaryKey,
+		basePath: binding.basePath,
+		bindingKind: "content",
+		callerName: binding.descriptor.callerName,
+		library: binding.descriptor.library
+	})), ...[...state.translatorBindings.entries()].filter(([, binding]) => binding.dictionaryKey !== null).map(([variableName, binding]) => ({
+		variableName,
+		dictionaryKey: binding.dictionaryKey,
+		basePath: binding.keyPrefix,
+		bindingKind: "translator",
+		callerName: binding.descriptor.callerName,
+		library: binding.descriptor.library
+	}))];
+};
+/**
+* Find the most specific translation usage at `offset`.
+*
+* For member chains the field path is trimmed to the segment under the
+* cursor: hovering `section` in `content.section.title` yields
+* `['section']`, not the full chain.
+*
+* Dictionary-level `namespace` usages are only returned when no field-level
+* usage matches the offset.
+*
+* @param text - Full source text.
+* @param offset - Cursor offset in `text`.
+*/
+const findMessageUsageAtOffset = (text, offset) => {
+	const usages = collectMessageUsages(text);
+	let bestMatch = null;
+	for (const usage of usages) {
+		if (offset < usage.start || offset > usage.end) continue;
+		if (!bestMatch || bestMatch.kind === "namespace" && usage.kind !== "namespace" || usage.end - usage.start < bestMatch.end - bestMatch.start && !(bestMatch.kind !== "namespace" && usage.kind === "namespace")) bestMatch = usage;
+	}
+	if (!bestMatch) return null;
+	if (bestMatch.kind === "member" && bestMatch.fieldSpans) {
+		let lastIncludedIndex = -1;
+		for (let index = 0; index < bestMatch.fieldSpans.length; index++) if (offset >= bestMatch.fieldSpans[index].start) lastIncludedIndex = index;
+		return {
+			...bestMatch,
+			fieldPath: bestMatch.fieldPath.slice(0, lastIncludedIndex + 1),
+			fieldSpans: bestMatch.fieldSpans.slice(0, lastIncludedIndex + 1)
+		};
+	}
+	return bestMatch;
+};
+
+//#endregion
+export { collectCallerBindings, collectMessageUsages, collectNamespaceReferences, findMessageUsageAtOffset, matchCallNamespace };
+//# sourceMappingURL=usageAnalyzer.mjs.map