@yahoo/uds 3.171.1 → 3.172.1

package/dist/css/dist/purger/optimized/ast/expressions.js

@@ -1,29 +1,14 @@
 /*! © 2026 Yahoo, Inc. UDS v0.0.0-development */
+import { findLocalDefinitions, forEachDescendant, getParent, getPropertyName, getStringLiteralValue, getText, isNoSubstitutionTemplate, isStringLiteral, parseSource } from "./oxc.js";
 import fs from "node:fs";
 import path from "node:path";
-import { Node, Project, SyntaxKind, ts } from "ts-morph";
+import { ResolverFactory } from "oxc-resolver";
 //#region ../css/dist/purger/optimized/ast/expressions.mjs
 /*! © 2026 Yahoo, Inc. UDS CSS v0.0.0-development */
-const importedSourceProject = new Project({ useInMemoryFileSystem: true });
-const importedSourceFileCache = /* @__PURE__ */ new Map();
+const importedSourceCache = /* @__PURE__ */ new Map();
 const tsConfigPathCache = /* @__PURE__ */ new Map();
-const compilerOptionsCache = /* @__PURE__ */ new Map();
+const resolverCache = /* @__PURE__ */ new Map();
 const hasImportQuery = (moduleSpecifier) => moduleSpecifier.includes("?");
-const getLocalDefinitionNodes = (node) => {
-	if (!Node.isIdentifier(node)) return [];
-	const name = node.getText();
-	const nodeStart = node.getStart();
-	const sourceFile = node.getSourceFile();
-	return [
-		...sourceFile.getDescendantsOfKind(SyntaxKind.VariableDeclaration).filter((definition) => definition.getName() === name && definition.getStart() <= nodeStart),
-		...sourceFile.getDescendantsOfKind(SyntaxKind.Parameter).filter((definition) => definition.getName() === name && definition.getStart() <= nodeStart),
-		...sourceFile.getDescendantsOfKind(SyntaxKind.BindingElement).filter((definition) => definition.getName() === name && definition.getStart() <= nodeStart),
-		...sourceFile.getFunctions().filter((definition) => definition.getName() === name && definition.getStart() <= nodeStart)
-	].sort((left, right) => right.getStart() - left.getStart()).slice(0, 1);
-};
-const getDefinitionNodesSafe = (node) => {
-	return getLocalDefinitionNodes(node);
-};
 const isExistingFile = (candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile();
 const resolveRelativeImportPath = (sourceFilePath, moduleSpecifier) => {
 	if (!path.isAbsolute(sourceFilePath) || !moduleSpecifier.startsWith(".") || hasImportQuery(moduleSpecifier)) return null;
@@ -68,55 +53,69 @@ const findNearestTypeScriptConfig = (sourceFilePath) => {
 		currentDir = parentDir;
 	}
 };
-const getCompilerOptionsForSourceFile = (sourceFilePath) => {
+const getResolverForConfig = (configPath) => {
+	const cached = resolverCache.get(configPath);
+	if (cached) return cached;
+	const resolver = new ResolverFactory({
+		tsconfig: {
+			configFile: configPath,
+			references: "auto"
+		},
+		extensions: [
+			".ts",
+			".tsx",
+			".mts",
+			".cts",
+			".js",
+			".jsx",
+			".mjs",
+			".cjs"
+		],
+		conditionNames: [
+			"import",
+			"require",
+			"node"
+		]
+	});
+	resolverCache.set(configPath, resolver);
+	return resolver;
+};
+const resolveConfigImportPath = (sourceFilePath, moduleSpecifier) => {
+	if (hasImportQuery(moduleSpecifier)) return null;
 	const configPath = findNearestTypeScriptConfig(sourceFilePath);
 	if (!configPath) return null;
-	const cached = compilerOptionsCache.get(configPath);
-	if (cached !== void 0) return cached;
-	const readResult = ts.readConfigFile(configPath, ts.sys.readFile);
-	if (readResult.error) {
-		compilerOptionsCache.set(configPath, null);
+	try {
+		const resolved = getResolverForConfig(configPath).sync(path.dirname(sourceFilePath), moduleSpecifier).path;
+		if (!resolved) return null;
+		if (resolved.includes(`${path.sep}node_modules${path.sep}`)) return null;
+		return isExistingFile(resolved) ? resolved : null;
+	} catch {
 		return null;
 	}
-	const parsed = ts.parseJsonConfigFileContent(readResult.config, ts.sys, path.dirname(configPath));
-	const compilerOptions = parsed.options.paths && !parsed.options.baseUrl ? {
-		...parsed.options,
-		baseUrl: path.dirname(configPath)
-	} : parsed.options;
-	compilerOptionsCache.set(configPath, compilerOptions);
-	return compilerOptions;
-};
-const resolveConfigImportPath = (sourceFilePath, moduleSpecifier) => {
-	if (hasImportQuery(moduleSpecifier)) return null;
-	const compilerOptions = getCompilerOptionsForSourceFile(sourceFilePath);
-	if (!compilerOptions) return null;
-	const resolvedModule = ts.resolveModuleName(moduleSpecifier, sourceFilePath, compilerOptions, ts.sys).resolvedModule;
-	if (!resolvedModule) return null;
-	return isExistingFile(resolvedModule.resolvedFileName) ? resolvedModule.resolvedFileName : null;
 };
 const resolveImportPath = (sourceFilePath, moduleSpecifier) => moduleSpecifier.startsWith(".") ? resolveRelativeImportPath(sourceFilePath, moduleSpecifier) : resolveConfigImportPath(sourceFilePath, moduleSpecifier);
-const getImportedSourceFile = (filePath) => {
-	const cached = importedSourceFileCache.get(filePath);
+const getImportedSource = (filePath) => {
+	const cached = importedSourceCache.get(filePath);
 	if (cached) return cached;
 	if (!fs.existsSync(filePath)) return null;
-	const sourceFile = importedSourceProject.createSourceFile(filePath, fs.readFileSync(filePath, "utf-8"), { overwrite: true });
-	importedSourceFileCache.set(filePath, sourceFile);
-	return sourceFile;
+	const source = parseSource(filePath, fs.readFileSync(filePath, "utf-8"));
+	importedSourceCache.set(filePath, source);
+	return source;
 };
-const extractImportedIdentifierValues = (node, visited) => {
-	if (!Node.isIdentifier(node)) return [];
-	const sourceFile = node.getSourceFile();
-	const sourceFilePath = sourceFile.getFilePath();
-	const importMatch = sourceFile.getImportDeclarations().find((importDecl) => importDecl.getNamedImports().some((namedImport) => (namedImport.getAliasNode()?.getText() ?? namedImport.getName()) === node.getText()));
-	if (!importMatch) return [];
-	const namedImport = importMatch.getNamedImports().find((candidate) => (candidate.getAliasNode()?.getText() ?? candidate.getName()) === node.getText());
-	if (!namedImport) return [];
-	const resolvedPath = resolveImportPath(sourceFilePath, importMatch.getModuleSpecifierValue());
+const extractImportedIdentifierValues = (node, source, visited) => {
+	if (node.type !== "Identifier") return [];
+	const localName = node.name;
+	const entry = source.staticImports.flatMap((staticImport) => staticImport.entries.map((importEntry) => ({
+		staticImport,
+		importEntry
+	}))).find(({ importEntry }) => importEntry.importName.kind === "Name" && importEntry.localName.value === localName);
+	if (!entry || !entry.importEntry.importName.name) return [];
+	const resolvedPath = resolveImportPath(source.filePath, entry.staticImport.moduleRequest.value);
 	if (!resolvedPath) return [];
-	const importedSourceFile = getImportedSourceFile(resolvedPath);
-	if (!importedSourceFile) return [];
-	const initializer = importedSourceFile.getVariableDeclaration(namedImport.getName())?.getInitializer();
-	return initializer ? extractStringLiterals(initializer, visited) : [];
+	const importedSource = getImportedSource(resolvedPath);
+	if (!importedSource) return [];
+	const initializer = importedSource.topLevelVariables.get(entry.importEntry.importName.name)?.init;
+	return initializer ? extractStringLiterals(initializer, importedSource, visited) : [];
 };
 /**
 * Extracts string literal values from an expression.
@@ -131,93 +130,102 @@ const extractImportedIdentifierValues = (node, visited) => {
 * - As expressions: value as Type
 *
 * @param node The expression node to extract values from
+* @param source The parsed source containing the node
 * @param visited Set of visited nodes to prevent infinite recursion
 * @returns Array of extracted string literal values
 */
-const extractStringLiterals = (node, visited = /* @__PURE__ */ new Set()) => {
+const extractStringLiterals = (node, source, visited = /* @__PURE__ */ new Set()) => {
 	if (visited.has(node)) return [];
 	visited.add(node);
-	const directValues = extractDirectLiteralValues(node);
+	if (node.type === "ChainExpression") return extractStringLiterals(node.expression, source, visited);
+	const directValues = extractDirectLiteralValues(node, source);
 	if (directValues) return directValues;
-	const templateValues = extractTemplateExpressionValues(node, visited);
+	const templateValues = extractTemplateExpressionValues(node, source, visited);
 	if (templateValues) return templateValues;
-	if (Node.isConditionalExpression(node)) return [...extractStringLiterals(node.getWhenTrue(), visited), ...extractStringLiterals(node.getWhenFalse(), visited)];
-	const binaryValues = extractBinaryExpressionValues(node, visited);
+	if (node.type === "ConditionalExpression") return [...extractStringLiterals(node.consequent, source, visited), ...extractStringLiterals(node.alternate, source, visited)];
+	const binaryValues = extractBinaryExpressionValues(node, source, visited);
 	if (binaryValues) return binaryValues;
-	const wrappedExpressionValues = extractWrappedExpressionValues(node, visited);
+	const wrappedExpressionValues = extractWrappedExpressionValues(node, source, visited);
 	if (wrappedExpressionValues) return wrappedExpressionValues;
-	const propertyAccessValues = extractPropertyAccessValues(node, visited);
+	const propertyAccessValues = extractPropertyAccessValues(node, source, visited);
 	if (propertyAccessValues) return propertyAccessValues;
-	const elementAccessValues = extractElementAccessValues(node, visited);
+	const elementAccessValues = extractElementAccessValues(node, source, visited);
 	if (elementAccessValues) return elementAccessValues;
-	const callExpressionValues = extractCallExpressionValues(node, visited);
+	const callExpressionValues = extractCallExpressionValues(node, source, visited);
 	if (callExpressionValues) return callExpressionValues;
-	const identifierValues = extractIdentifierValues(node, visited);
+	const identifierValues = extractIdentifierValues(node, source, visited);
 	if (identifierValues) return identifierValues;
 	return [];
 };
-const extractDirectLiteralValues = (node) => {
-	if (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node)) return [node.getLiteralValue()];
+const extractDirectLiteralValues = (node, _source) => {
+	if (isStringLiteral(node)) return [getStringLiteralValue(node)];
+	if (isNoSubstitutionTemplate(node) && node.type === "TemplateLiteral") return [node.quasis[0]?.value.cooked ?? ""];
 	return null;
 };
-const extractTemplateExpressionValues = (node, visited) => {
-	if (!Node.isTemplateExpression(node)) return null;
-	const parts = [[node.getHead().getLiteralText()]];
-	node.getTemplateSpans().forEach((span) => {
-		const exprValues = extractStringLiterals(span.getExpression(), visited);
-		const literalText = span.getLiteral().getLiteralText();
+const extractTemplateExpressionValues = (node, source, visited) => {
+	if (node.type !== "TemplateLiteral" || node.expressions.length === 0) return null;
+	const parts = [[node.quasis[0]?.value.cooked ?? ""]];
+	node.expressions.forEach((expression, index) => {
+		const exprValues = extractStringLiterals(expression, source, visited);
+		const literalText = node.quasis[index + 1]?.value.cooked ?? "";
 		parts.push(exprValues.length > 0 ? exprValues.map((value) => `${value}${literalText}`) : ["", literalText]);
 	});
 	return parts.reduce((acc, segment) => acc.flatMap((base) => segment.map((frag) => `${base}${frag}`)), [""]).filter((value) => value.length > 0);
 };
-const extractBinaryExpressionValues = (node, visited) => {
-	if (!Node.isBinaryExpression(node)) return null;
-	const operator = node.getOperatorToken().getText();
-	if (operator === "+") {
-		const left = extractStringLiterals(node.getLeft(), visited);
-		const right = extractStringLiterals(node.getRight(), visited);
-		const combined = left.flatMap((l) => right.map((r) => `${l}${r}`));
-		return combined.length > 0 ? combined : [];
+const extractBinaryExpressionValues = (node, source, visited) => {
+	if (node.type === "BinaryExpression") {
+		if (node.operator === "+") {
+			const left = extractStringLiterals(node.left, source, visited);
+			const right = extractStringLiterals(node.right, source, visited);
+			const combined = left.flatMap((l) => right.map((r) => `${l}${r}`));
+			return combined.length > 0 ? combined : [];
+		}
+		return [];
 	}
-	if (operator === "||" || operator === "??") return [...extractStringLiterals(node.getLeft(), visited), ...extractStringLiterals(node.getRight(), visited)];
-	return [];
+	if (node.type === "LogicalExpression") {
+		if (node.operator === "||" || node.operator === "??") return [...extractStringLiterals(node.left, source, visited), ...extractStringLiterals(node.right, source, visited)];
+		return [];
+	}
+	return null;
 };
-const extractWrappedExpressionValues = (node, visited) => {
-	if (Node.isParenthesizedExpression(node) || Node.isAsExpression(node)) return extractStringLiterals(node.getExpression(), visited);
+const extractWrappedExpressionValues = (node, source, visited) => {
+	if (node.type === "ParenthesizedExpression" || node.type === "TSAsExpression") return extractStringLiterals(node.expression, source, visited);
 	return null;
 };
-const extractPropertyAccessValues = (node, visited) => {
-	if (!Node.isPropertyAccessExpression(node)) return null;
-	const typeValues = extractLiteralValuesFromType(node);
+const extractPropertyAccessValues = (node, source, visited) => {
+	if (node.type !== "MemberExpression" || node.computed) return null;
+	if (node.property.type !== "Identifier") return null;
+	const typeValues = extractLiteralValuesFromType(node, source);
 	if (typeValues.length > 0) return typeValues;
-	const propertyName = node.getName();
-	return extractObjectValues(node.getExpression(), visited).filter((value) => typeof value === "object" && value !== null && propertyName in value).map((value) => value[propertyName]).filter((value) => typeof value === "string");
+	const propertyName = node.property.name;
+	return extractObjectValues(node.object, source, visited).filter((value) => typeof value === "object" && value !== null && propertyName in value).map((value) => value[propertyName]).filter((value) => typeof value === "string");
 };
-const extractElementAccessValues = (node, visited) => {
-	if (!Node.isElementAccessExpression(node)) return null;
-	const typeValues = extractLiteralValuesFromType(node);
+const extractElementAccessValues = (node, source, visited) => {
+	if (node.type !== "MemberExpression" || !node.computed) return null;
+	const typeValues = extractLiteralValuesFromType(node, source);
 	if (typeValues.length > 0) return typeValues;
-	return extractObjectValues(node.getExpression(), visited).flatMap((value) => {
+	return extractObjectValues(node.object, source, visited).flatMap((value) => {
 		if (typeof value === "string") return [value];
 		if (typeof value === "object" && value !== null) return Object.values(value).filter((entry) => typeof entry === "string");
 		return [];
 	});
 };
-const extractCallExpressionValues = (node, visited) => {
-	if (!Node.isCallExpression(node)) return null;
-	const expression = node.getExpression();
-	const fromDefinitions = Node.isIdentifier(expression) ? getDefinitionNodesSafe(expression).flatMap((definition) => {
-		if (Node.isFunctionDeclaration(definition)) return definition.getDescendantsOfKind(SyntaxKind.ReturnStatement).flatMap((returnStmt) => {
-			const expression = returnStmt.getExpression();
-			return expression ? extractStringLiterals(expression, visited) : [];
-		});
-		if (Node.isVariableDeclaration(definition)) {
-			const initializer = definition.getInitializer();
-			return initializer ? extractFromFunctionLike(initializer, visited) : [];
-		}
+const collectReturnExpressions = (node) => {
+	const returns = [];
+	forEachDescendant(node, (descendant) => {
+		if (descendant.type === "ReturnStatement" && descendant.argument) returns.push(descendant.argument);
+	});
+	return returns;
+};
+const extractCallExpressionValues = (node, source, visited) => {
+	if (node.type !== "CallExpression") return null;
+	const callee = node.callee;
+	const fromDefinitions = callee.type === "Identifier" ? findLocalDefinitions(source, callee).flatMap((definition) => {
+		if (definition.kind === "function") return collectReturnExpressions(definition.node).flatMap((expression) => extractStringLiterals(expression, source, visited));
+		if (definition.kind === "variable") return definition.init ? extractFromFunctionLike(definition.init, source, visited) : [];
 		return [];
 	}) : [];
-	const fromArguments = node.getArguments().flatMap((arg) => extractStringLiterals(arg, visited));
+	const fromArguments = node.arguments.flatMap((arg) => extractStringLiterals(arg, source, visited));
 	return [...fromDefinitions, ...fromArguments];
 };
 /** Array methods that return (a subset of) the receiver's elements. */
@@ -235,19 +243,18 @@ const ARRAY_CHAIN_METHODS = new Set([
 * If the definition is the first parameter of a `.map()`/`.flatMap()` callback,
 * return the expression being mapped over (the array source).
 */
-const getMappedArraySource = (definition) => {
-	if (!Node.isParameterDeclaration(definition)) return null;
-	const callback = definition.getParentIfKind(SyntaxKind.ArrowFunction);
-	if (!callback) return null;
-	const callExpression = callback.getParentIfKind(SyntaxKind.CallExpression);
-	if (!callExpression) return null;
-	const expression = callExpression.getExpression();
-	if (!Node.isPropertyAccessExpression(expression)) return null;
-	if (!["map", "flatMap"].includes(expression.getName())) return null;
-	if (callback.getParameters().findIndex((parameter) => {
-		return parameter.getNameNode().getText() === definition.getNameNode().getText();
-	}) !== 0) return null;
-	return expression.getExpression();
+const getMappedArraySource = (definition, source) => {
+	if (definition.kind !== "parameter" || !definition.paramFunction) return null;
+	const callback = definition.paramFunction;
+	if (callback.type !== "ArrowFunctionExpression") return null;
+	const callExpression = getParent(source, callback);
+	if (!callExpression || callExpression.type !== "CallExpression") return null;
+	const callee = callExpression.callee;
+	if (callee.type !== "MemberExpression" || callee.computed) return null;
+	if (callee.property.type !== "Identifier") return null;
+	if (!["map", "flatMap"].includes(callee.property.name)) return null;
+	if (definition.paramIndex !== 0) return null;
+	return callee.object;
 };
 /**
 * Resolve a node to the object-literal AST nodes it may evaluate to.
@@ -255,25 +262,23 @@ const getMappedArraySource = (definition) => {
 * array-method chains, and `.map()` callback parameters (UDS-2557 follow-up:
 * variant arrays nested inside const structures).
 */
-const resolveObjectLiteralNodes = (node, visited) => {
+const resolveObjectLiteralNodes = (node, source, visited) => {
 	if (visited.has(node)) return [];
 	visited.add(node);
-	if (Node.isObjectLiteralExpression(node)) return [node];
-	if (Node.isParenthesizedExpression(node) || Node.isAsExpression(node) || Node.isTypeAssertion(node) || Node.isSatisfiesExpression(node)) return resolveObjectLiteralNodes(node.getExpression(), visited);
-	if (Node.isArrayLiteralExpression(node)) return node.getElements().flatMap((element) => resolveObjectLiteralNodes(element, visited));
-	if (Node.isElementAccessExpression(node)) return resolveObjectLiteralNodes(node.getExpression(), visited);
-	if (Node.isCallExpression(node)) {
-		const expression = node.getExpression();
-		if (Node.isPropertyAccessExpression(expression) && ARRAY_CHAIN_METHODS.has(expression.getName())) return resolveObjectLiteralNodes(expression.getExpression(), visited);
+	if (node.type === "ChainExpression") return resolveObjectLiteralNodes(node.expression, source, visited);
+	if (node.type === "ObjectExpression") return [node];
+	if (node.type === "ParenthesizedExpression" || node.type === "TSAsExpression" || node.type === "TSTypeAssertion" || node.type === "TSSatisfiesExpression") return resolveObjectLiteralNodes(node.expression, source, visited);
+	if (node.type === "ArrayExpression") return node.elements.flatMap((element) => element ? resolveObjectLiteralNodes(element, source, visited) : []);
+	if (node.type === "MemberExpression" && node.computed) return resolveObjectLiteralNodes(node.object, source, visited);
+	if (node.type === "CallExpression") {
+		const callee = node.callee;
+		if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier" && ARRAY_CHAIN_METHODS.has(callee.property.name)) return resolveObjectLiteralNodes(callee.object, source, visited);
 		return [];
 	}
-	if (Node.isIdentifier(node)) return getLocalDefinitionNodes(node).flatMap((definition) => {
-		if (Node.isVariableDeclaration(definition)) {
-			const initializer = definition.getInitializer();
-			return initializer ? resolveObjectLiteralNodes(initializer, visited) : [];
-		}
-		const mappedSource = getMappedArraySource(definition);
-		if (mappedSource) return resolveObjectLiteralNodes(mappedSource, visited);
+	if (node.type === "Identifier") return findLocalDefinitions(source, node).flatMap((definition) => {
+		if (definition.kind === "variable") return definition.init ? resolveObjectLiteralNodes(definition.init, source, visited) : [];
+		const mappedSource = getMappedArraySource(definition, source);
+		if (mappedSource) return resolveObjectLiteralNodes(mappedSource, source, visited);
 		return [];
 	});
 	return [];
@@ -281,74 +286,82 @@ const resolveObjectLiteralNodes = (node, visited) => {
 /**
 * Collect the initializers of a named property across object-literal candidates.
 */
-const getPropertyInitializers = (objectLiterals, propertyName) => objectLiterals.flatMap((obj) => {
-	if (!Node.isObjectLiteralExpression(obj)) return [];
-	return obj.getProperties().flatMap((prop) => {
-		if (!Node.isPropertyAssignment(prop) || prop.getName() !== propertyName) return [];
-		const initializer = prop.getInitializer();
-		return initializer ? [initializer] : [];
+const getPropertyInitializers = (objectLiterals, propertyName, source) => objectLiterals.flatMap((obj) => {
+	if (obj.type !== "ObjectExpression") return [];
+	return obj.properties.flatMap((prop) => {
+		if (prop.type !== "Property" || prop.shorthand || getPropertyName(source, prop) !== propertyName) return [];
+		return prop.value ? [prop.value] : [];
 	});
 });
 /**
 * For a destructured binding (e.g. `({ variants }) =>` map param or
 * `const { variants } = GROUPS[0]`), resolve the bound property's initializers.
 */
-const getBindingElementSources = (definition) => {
-	if (!Node.isBindingElement(definition)) return [];
-	const bindingPattern = definition.getParent();
-	if (!Node.isObjectBindingPattern(bindingPattern)) return [];
-	const propertyName = definition.getPropertyNameNode()?.getText() ?? definition.getName();
-	const holder = bindingPattern.getParent();
-	let source = null;
-	if (Node.isParameterDeclaration(holder)) source = getMappedArraySource(holder);
-	else if (Node.isVariableDeclaration(holder)) source = holder.getInitializer() ?? null;
-	if (!source) return [];
-	return getPropertyInitializers(resolveObjectLiteralNodes(source, /* @__PURE__ */ new Set()), propertyName);
+const getBindingElementSources = (definition, source) => {
+	if (definition.kind !== "binding" || definition.bindingPattern?.type !== "ObjectPattern") return [];
+	const propertyName = definition.bindingPropertyName ?? definition.name;
+	const pattern = definition.bindingPattern;
+	const holder = getParent(source, pattern);
+	let arraySource = null;
+	if (holder && holder.type === "VariableDeclarator") arraySource = holder.init ?? null;
+	else {
+		const paramNode = holder && holder.type === "AssignmentPattern" ? holder : pattern;
+		const fn = holder && holder.type === "AssignmentPattern" ? getParent(source, holder) : holder;
+		if (fn && (fn.type === "ArrowFunctionExpression" || fn.type === "FunctionDeclaration" || fn.type === "FunctionExpression")) {
+			const paramIndex = fn.params.indexOf(paramNode);
+			if (paramIndex !== -1) arraySource = getMappedArraySource({
+				kind: "parameter",
+				name: propertyName,
+				start: pattern.start,
+				node: paramNode,
+				init: null,
+				typeNode: null,
+				paramFunction: fn,
+				paramIndex
+			}, source);
+		}
+	}
+	if (!arraySource) return [];
+	return getPropertyInitializers(resolveObjectLiteralNodes(arraySource, source, /* @__PURE__ */ new Set()), propertyName, source);
 };
-const extractArrayElementValues = (node, visited) => {
-	if (Node.isArrayLiteralExpression(node)) return node.getElements().flatMap((element) => extractStringLiterals(element, visited)).filter((value, index, values) => values.indexOf(value) === index);
-	if (Node.isParenthesizedExpression(node)) return extractArrayElementValues(node.getExpression(), visited);
-	if (Node.isAsExpression(node) || Node.isTypeAssertion(node) || Node.isSatisfiesExpression(node)) return extractArrayElementValues(node.getExpression(), visited);
-	if (Node.isPropertyAccessExpression(node)) return getPropertyInitializers(resolveObjectLiteralNodes(node.getExpression(), /* @__PURE__ */ new Set()), node.getName()).flatMap((initializer) => extractArrayElementValues(initializer, visited)).filter((value, index, values) => values.indexOf(value) === index);
-	if (Node.isCallExpression(node)) {
-		const expression = node.getExpression();
-		if (Node.isPropertyAccessExpression(expression) && ARRAY_CHAIN_METHODS.has(expression.getName())) return extractArrayElementValues(expression.getExpression(), visited);
+const extractArrayElementValues = (node, source, visited) => {
+	if (node.type === "ChainExpression") return extractArrayElementValues(node.expression, source, visited);
+	if (node.type === "ArrayExpression") return node.elements.flatMap((element) => element ? extractStringLiterals(element, source, visited) : []).filter((value, index, values) => values.indexOf(value) === index);
+	if (node.type === "ParenthesizedExpression") return extractArrayElementValues(node.expression, source, visited);
+	if (node.type === "TSAsExpression" || node.type === "TSTypeAssertion" || node.type === "TSSatisfiesExpression") return extractArrayElementValues(node.expression, source, visited);
+	if (node.type === "MemberExpression" && !node.computed) {
+		if (node.property.type !== "Identifier") return [];
+		return getPropertyInitializers(resolveObjectLiteralNodes(node.object, source, /* @__PURE__ */ new Set()), node.property.name, source).flatMap((initializer) => extractArrayElementValues(initializer, source, visited)).filter((value, index, values) => values.indexOf(value) === index);
+	}
+	if (node.type === "CallExpression") {
+		const callee = node.callee;
+		if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier" && ARRAY_CHAIN_METHODS.has(callee.property.name)) return extractArrayElementValues(callee.object, source, visited);
 		return [];
 	}
-	if (Node.isIdentifier(node)) return getLocalDefinitionNodes(node).flatMap((definition) => {
-		if (Node.isVariableDeclaration(definition)) {
-			const initializer = definition.getInitializer();
-			return initializer ? extractArrayElementValues(initializer, visited) : [];
-		}
-		return getBindingElementSources(definition).flatMap((source) => extractArrayElementValues(source, visited));
+	if (node.type === "Identifier") return findLocalDefinitions(source, node).flatMap((definition) => {
+		if (definition.kind === "variable") return definition.init ? extractArrayElementValues(definition.init, source, visited) : [];
+		return getBindingElementSources(definition, source).flatMap((elementSource) => extractArrayElementValues(elementSource, source, visited));
 	}).filter((value, index, values) => values.indexOf(value) === index);
 	return [];
 };
-const extractMappedParameterValues = (definition, visited) => {
-	const mappedSource = getMappedArraySource(definition);
+const extractMappedParameterValues = (definition, source, visited) => {
+	const mappedSource = getMappedArraySource(definition, source);
 	if (!mappedSource) return [];
-	return extractArrayElementValues(mappedSource, visited);
+	return extractArrayElementValues(mappedSource, source, visited);
 };
-const extractIdentifierValues = (node, visited) => {
-	if (!Node.isIdentifier(node)) return null;
-	const values = getDefinitionNodesSafe(node).flatMap((definition) => {
-		const mappedParameterValues = extractMappedParameterValues(definition, visited);
+const extractIdentifierValues = (node, source, visited) => {
+	if (node.type !== "Identifier") return null;
+	const values = findLocalDefinitions(source, node).flatMap((definition) => {
+		const mappedParameterValues = extractMappedParameterValues(definition, source, visited);
 		if (mappedParameterValues.length > 0) return mappedParameterValues;
-		if (Node.isVariableDeclaration(definition) || Node.isParameterDeclaration(definition) || Node.isBindingElement(definition)) {
-			const initializer = definition.getInitializer();
-			if (initializer) return extractStringLiterals(initializer, visited);
-			if (Node.isBindingElement(definition)) {
-				const bindingPattern = definition.getParent();
-				if (Node.isObjectBindingPattern(bindingPattern)) {
-					const parentDecl = bindingPattern.getParent();
-					if (Node.isVariableDeclaration(parentDecl)) {
-						const parentInit = parentDecl.getInitializer();
-						if (parentInit) {
-							const propName = definition.getNameNode().getText();
-							const propValues = extractObjectValues(parentInit, new Set(visited)).filter((obj) => typeof obj === "object" && obj !== null && propName in obj).map((obj) => obj[propName]).filter((v) => typeof v === "string");
-							if (propValues.length > 0) return propValues;
-						}
-					}
+		if (definition.kind === "variable" || definition.kind === "parameter" || definition.kind === "binding") {
+			if (definition.init) return extractStringLiterals(definition.init, source, visited);
+			if (definition.kind === "binding" && definition.bindingPattern?.type === "ObjectPattern") {
+				const holder = getParent(source, definition.bindingPattern);
+				if (holder && holder.type === "VariableDeclarator" && holder.init) {
+					const propName = definition.name;
+					const propValues = extractObjectValues(holder.init, source, new Set(visited)).filter((obj) => typeof obj === "object" && obj !== null && propName in obj).map((obj) => obj[propName]).filter((v) => typeof v === "string");
+					if (propValues.length > 0) return propValues;
 				}
 			}
 			return [];
@@ -356,25 +369,23 @@ const extractIdentifierValues = (node, visited) => {
 		return [];
 	});
 	if (values.length > 0) return values;
-	const importedValues = extractImportedIdentifierValues(node, visited);
+	const importedValues = extractImportedIdentifierValues(node, source, visited);
 	if (importedValues.length > 0) return importedValues;
-	return extractLiteralValuesFromType(node);
+	return extractLiteralValuesFromType(node, source);
 };
 /**
 * Extract string literals from arrow functions or function expressions
 */
-const extractFromFunctionLike = (node, visited) => {
+const extractFromFunctionLike = (node, source, visited) => {
 	const values = [];
-	if (Node.isArrowFunction(node)) {
-		const body = node.getBody();
-		if (Node.isBlock(body)) body.getDescendantsOfKind(SyntaxKind.ReturnStatement).forEach((returnStmt) => {
-			const returnExpr = returnStmt.getExpression();
-			if (returnExpr) values.push(...extractStringLiterals(returnExpr, visited));
+	if (node.type === "ArrowFunctionExpression") {
+		const body = node.body;
+		if (body.type === "BlockStatement") collectReturnExpressions(body).forEach((returnExpr) => {
+			values.push(...extractStringLiterals(returnExpr, source, visited));
 		});
-		else values.push(...extractStringLiterals(body, visited));
-	} else if (Node.isFunctionExpression(node)) node.getDescendantsOfKind(SyntaxKind.ReturnStatement).forEach((returnStmt) => {
-		const returnExpr = returnStmt.getExpression();
-		if (returnExpr) values.push(...extractStringLiterals(returnExpr, visited));
+		else values.push(...extractStringLiterals(body, source, visited));
+	} else if (node.type === "FunctionExpression") collectReturnExpressions(node).forEach((returnExpr) => {
+		values.push(...extractStringLiterals(returnExpr, source, visited));
 	});
 	return values;
 };
@@ -382,19 +393,20 @@ const extractFromFunctionLike = (node, visited) => {
 * Extract object literal values from an expression.
 * Returns an array of all possible object values (for union types or indexed access).
 */
-const extractObjectValues = (node, visited) => {
+const extractObjectValues = (node, source, visited) => {
 	if (visited.has(node)) return [];
 	visited.add(node);
+	if (node.type === "ChainExpression") return extractObjectValues(node.expression, source, visited);
 	const values = [];
-	if (Node.isObjectLiteralExpression(node)) {
+	if (node.type === "ObjectExpression") {
 		const obj = {};
-		node.getProperties().forEach((prop) => {
-			if (Node.isPropertyAssignment(prop)) {
-				const name = prop.getName();
-				const init = prop.getInitializer();
-				if (init && Node.isStringLiteral(init)) obj[name] = init.getLiteralValue();
-				else if (init && Node.isObjectLiteralExpression(init)) {
-					const nestedValues = extractObjectValues(init, visited);
+		node.properties.forEach((prop) => {
+			if (prop.type === "Property" && !prop.shorthand) {
+				const name = getPropertyName(source, prop);
+				const init = prop.value;
+				if (init && isStringLiteral(init)) obj[name] = getStringLiteralValue(init);
+				else if (init && init.type === "ObjectExpression") {
+					const nestedValues = extractObjectValues(init, source, visited);
 					if (nestedValues.length > 0) obj[name] = nestedValues[0];
 				}
 			}
@@ -402,58 +414,51 @@ const extractObjectValues = (node, visited) => {
 		values.push(obj);
 		return values;
 	}
-	if (Node.isIdentifier(node)) {
-		getDefinitionNodesSafe(node).forEach((definition) => {
-			if (Node.isVariableDeclaration(definition)) {
-				const initializer = definition.getInitializer();
-				if (initializer) if (Node.isAsExpression(initializer)) {
-					const inner = initializer.getExpression();
-					values.push(...extractObjectValues(inner, visited));
-				} else values.push(...extractObjectValues(initializer, visited));
+	if (node.type === "Identifier") {
+		findLocalDefinitions(source, node).forEach((definition) => {
+			if (definition.kind === "variable" && definition.init) {
+				const initializer = definition.init;
+				if (initializer.type === "TSAsExpression") values.push(...extractObjectValues(initializer.expression, source, visited));
+				else values.push(...extractObjectValues(initializer, source, visited));
 			}
 		});
-		const enumDecl = node.getSourceFile().getEnum(node.getText());
+		const enumDecl = source.topLevelEnums.get(node.name);
 		if (enumDecl) {
 			const obj = {};
-			enumDecl.getMembers().forEach((member) => {
-				const initializer = member.getInitializer();
-				if (initializer && Node.isStringLiteral(initializer)) obj[member.getName()] = initializer.getLiteralValue();
+			enumDecl.body.members.forEach((member) => {
+				const initializer = member.initializer;
+				if (initializer && isStringLiteral(initializer)) {
+					const memberName = member.id.type === "Identifier" ? member.id.name : isStringLiteral(member.id) ? getStringLiteralValue(member.id) : getText(source, member.id);
+					obj[memberName] = getStringLiteralValue(initializer);
+				}
 			});
 			if (Object.keys(obj).length > 0) values.push(obj);
 		}
 		return values;
 	}
-	if (Node.isCallExpression(node)) {
-		const expression = node.getExpression();
-		if (Node.isIdentifier(expression)) getDefinitionNodesSafe(expression).forEach((definition) => {
-			if (Node.isFunctionDeclaration(definition)) definition.getDescendantsOfKind(SyntaxKind.ReturnStatement).forEach((returnStmt) => {
-				const returnExpr = returnStmt.getExpression();
-				if (returnExpr) values.push(...extractObjectValues(returnExpr, visited));
+	if (node.type === "CallExpression") {
+		const callee = node.callee;
+		if (callee.type === "Identifier") findLocalDefinitions(source, callee).forEach((definition) => {
+			if (definition.kind === "function") collectReturnExpressions(definition.node).forEach((returnExpr) => {
+				values.push(...extractObjectValues(returnExpr, source, visited));
 			});
-			if (Node.isVariableDeclaration(definition)) {
-				const initializer = definition.getInitializer();
-				if (initializer) {
-					const extractFromFn = (fn) => {
-						if (Node.isArrowFunction(fn)) {
-							const body = fn.getBody();
-							if (Node.isBlock(body)) body.getDescendantsOfKind(SyntaxKind.ReturnStatement).forEach((returnStmt) => {
-								const returnExpr = returnStmt.getExpression();
-								if (returnExpr) values.push(...extractObjectValues(returnExpr, visited));
-							});
-							else values.push(...extractObjectValues(body, visited));
-						} else if (Node.isFunctionExpression(fn)) fn.getDescendantsOfKind(SyntaxKind.ReturnStatement).forEach((returnStmt) => {
-							const returnExpr = returnStmt.getExpression();
-							if (returnExpr) values.push(...extractObjectValues(returnExpr, visited));
-						});
-					};
-					extractFromFn(initializer);
-				}
+			if (definition.kind === "variable" && definition.init) {
+				const initializer = definition.init;
+				if (initializer.type === "ArrowFunctionExpression") {
+					const body = initializer.body;
+					if (body.type === "BlockStatement") collectReturnExpressions(body).forEach((returnExpr) => {
+						values.push(...extractObjectValues(returnExpr, source, visited));
+					});
+					else values.push(...extractObjectValues(body, source, visited));
+				} else if (initializer.type === "FunctionExpression") collectReturnExpressions(initializer).forEach((returnExpr) => {
+					values.push(...extractObjectValues(returnExpr, source, visited));
+				});
 			}
 		});
 		return values;
 	}
-	if (Node.isElementAccessExpression(node)) {
-		extractObjectValues(node.getExpression(), visited).forEach((obj) => {
+	if (node.type === "MemberExpression" && node.computed) {
+		extractObjectValues(node.object, source, visited).forEach((obj) => {
 			if (typeof obj === "object" && obj !== null) Object.values(obj).forEach((value) => values.push(value));
 		});
 		return values;
@@ -462,46 +467,42 @@ const extractObjectValues = (node, visited) => {
 };
 /**
 * Extract string literal values from a TypeScript type annotation AST node.
-* Pure AST traversal — avoids expensive TS Language Service `getType()` calls.
+* Pure AST traversal — no type checker involved.
 */
 const extractStringLiteralsFromTypeNode = (typeNode) => {
-	if (Node.isLiteralTypeNode(typeNode)) {
-		const literal = typeNode.getLiteral();
-		if (Node.isStringLiteral(literal)) return [literal.getLiteralValue()];
+	if (typeNode.type === "TSLiteralType") {
+		const literal = typeNode.literal;
+		if (isStringLiteral(literal)) return [getStringLiteralValue(literal)];
 		return [];
 	}
-	if (Node.isUnionTypeNode(typeNode)) return typeNode.getTypeNodes().flatMap(extractStringLiteralsFromTypeNode);
+	if (typeNode.type === "TSUnionType") return typeNode.types.flatMap(extractStringLiteralsFromTypeNode);
 	return [];
 };
 /**
 * Extract literal values from a TypeScript type annotation (for union types like 'brand' | 'secondary').
-* Uses pure AST traversal instead of the TS type checker to avoid expensive LS initialization.
+* Uses pure AST traversal instead of the TS type checker.
 */
-const extractLiteralValuesFromType = (node) => {
-	if (Node.isIdentifier(node)) {
-		const definitions = getLocalDefinitionNodes(node);
+const extractLiteralValuesFromType = (node, source) => {
+	if (node.type === "Identifier") {
+		const definitions = findLocalDefinitions(source, node);
 		for (const def of definitions) {
-			if (Node.isParameterDeclaration(def) || Node.isVariableDeclaration(def) || Node.isPropertyDeclaration(def) || Node.isPropertySignature(def)) {
-				const typeNode = def.getTypeNode?.();
-				if (typeNode) {
-					const values = extractStringLiteralsFromTypeNode(typeNode);
+			if (def.kind === "parameter" || def.kind === "variable") {
+				if (def.typeNode) {
+					const values = extractStringLiteralsFromTypeNode(def.typeNode);
 					if (values.length > 0) return values;
 				}
 			}
-			if (Node.isBindingElement(def)) {
-				const bindingPattern = def.getParent();
-				if (bindingPattern) {
-					const parentDecl = bindingPattern.getParent();
-					if (parentDecl && Node.isVariableDeclaration(parentDecl)) {
-						const parentType = parentDecl.getTypeNode();
-						if (parentType && Node.isTypeLiteral(parentType)) {
-							const propName = def.getNameNode().getText();
-							for (const member of parentType.getMembers()) if (Node.isPropertySignature(member) && member.getName() === propName) {
-								const memberType = member.getTypeNode();
-								if (memberType) {
-									const values = extractStringLiteralsFromTypeNode(memberType);
-									if (values.length > 0) return values;
-								}
+			if (def.kind === "binding" && def.bindingPattern) {
+				const holder = getParent(source, def.bindingPattern);
+				if (holder && holder.type === "VariableDeclarator") {
+					const parentType = holder.id.typeAnnotation?.typeAnnotation;
+					if (parentType && parentType.type === "TSTypeLiteral") {
+						const propName = def.name;
+						for (const member of parentType.members) if (member.type === "TSPropertySignature" && member.key.type === "Identifier" && member.key.name === propName) {
+							const memberType = member.typeAnnotation?.typeAnnotation;
+							if (memberType) {
+								const values = extractStringLiteralsFromTypeNode(memberType);
+								if (values.length > 0) return values;
 							}
 						}
 					}
@@ -509,7 +510,6 @@ const extractLiteralValuesFromType = (node) => {
 			}
 		}
 	}
-	if (Node.isPropertyAccessExpression(node) || Node.isElementAccessExpression(node)) return [];
 	return [];
 };
 //#endregion