@bamboocss/extractor 1.49.0 → 1.50.0

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { BambooError } from "@bamboocss/shared";
-import { Node, SyntaxKind, ts } from "ts-morph";
+import { Node, SKIP, SyntaxKind, childOf, forEachDescendant, getAliasNode, getChildIndex, getDefaultImport, getDescendantsOfKind, getExportDeclarations, getFirstAncestor, getImportDeclarations, getLineAndColumnAtPos, getLiteralText, getMember, getModuleSpecifierValue, getName, getNamedExports, getNamedImports, getNamespaceImport, getProperty, getVariableDeclaration, getVariableDeclarations, is, isInNodeModules, isReadonly, kindNameOf, literalValueOf, nameNodeOf, pathOf, stringLiteralValue, ts } from "@bamboocss/ts-ast";
 import { evaluate } from "ts-evaluator";
 //#region src/get-typeof-literal.ts
 const getTypeOfLiteral = (value) => {
@@ -24,15 +24,15 @@ const isPrimitiveType = (value) => {
 	return type === "string" || type === "number" || type === "boolean" || value === null || value === void 0;
 };
 const unwrapExpression = (node) => {
-	if (Node.isAsExpression(node)) return unwrapExpression(node.getExpression());
-	if (Node.isParenthesizedExpression(node)) return unwrapExpression(node.getExpression());
-	if (Node.isNonNullExpression(node)) return unwrapExpression(node.getExpression());
-	if (Node.isTypeAssertion(node)) return unwrapExpression(node.getExpression());
-	if (Node.isSatisfiesExpression(node)) return unwrapExpression(node.getExpression());
+	if (Node.isAsExpression(node)) return unwrapExpression(node.expression);
+	if (Node.isParenthesizedExpression(node)) return unwrapExpression(node.expression);
+	if (Node.isNonNullExpression(node)) return unwrapExpression(node.expression);
+	if (Node.isTypeAssertion(node)) return unwrapExpression(node.expression);
+	if (Node.isSatisfiesExpression(node)) return unwrapExpression(node.expression);
 	return node;
 };
 const getComponentName = (node) => {
-	return node.getTagNameNode().getText();
+	return node.tagName.getText();
 };
 const whitespaceRegex = /\s+/g;
 const trimWhitespace = (str) => {
@@ -43,8 +43,8 @@ const trimWhitespace = (str) => {
 const getNodeRange = (node) => {
 	const src = node.getSourceFile();
 	const [startPosition, endPosition] = [node.getStart(), node.getEnd()];
-	const startInfo = src.getLineAndColumnAtPos(startPosition);
-	const endInfo = src.getLineAndColumnAtPos(endPosition);
+	const startInfo = getLineAndColumnAtPos(src, startPosition);
+	const endInfo = getLineAndColumnAtPos(src, endPosition);
 	return {
 		startPosition,
 		startLineNumber: startInfo.line,
@@ -77,7 +77,7 @@ var BoxNodeType = class {
 		return {
 			type: this.type,
 			value: this.value,
-			node: this.node.getKindName(),
+			node: kindNameOf(this.node.kind),
 			line: range.startLineNumber,
 			column: range.startColumn,
 			endLineNumber: range.endLineNumber,
@@ -445,15 +445,15 @@ const clearImportedValueCache = () => {
 */
 const importBindingsFor = (sourceFile) => {
 	const bindings = /* @__PURE__ */ new Map();
-	for (const declaration of sourceFile.getImportDeclarations()) {
-		for (const specifier of declaration.getNamedImports()) {
-			const local = (specifier.getAliasNode() ?? specifier.getNameNode()).getText();
-			bindings.set(local, {
+	for (const declaration of getImportDeclarations(sourceFile)) {
+		for (const specifier of getNamedImports(declaration)) {
+			const local = (getAliasNode(specifier) ?? nameNodeOf(specifier))?.getText();
+			bindings.set(local ?? "", {
 				declaration,
-				exportedName: specifier.getNameNode().getText()
+				exportedName: nameNodeOf(specifier)?.getText() ?? ""
 			});
 		}
-		const defaultImport = declaration.getDefaultImport();
+		const defaultImport = getDefaultImport(declaration);
 		if (defaultImport) bindings.set(defaultImport.getText(), {
 			declaration,
 			exportedName: "default"
@@ -465,7 +465,7 @@ const importBindingsFor = (sourceFile) => {
 const valueForBinding = (binding, ctx, stack, depth, evaluateExpression) => {
 	const sourceFile = getModuleSpecifierSourceFile(binding.declaration, ctx);
 	if (!sourceFile) return;
-	if (sourceFile.isInNodeModules()) return;
+	if (isInNodeModules(sourceFile)) return;
 	const declaration = getExportedVarDeclarationWithName(binding.exportedName, sourceFile, stack, ctx);
 	if (!declaration) return;
 	const cached = evaluatedValues.get(declaration);
@@ -473,7 +473,7 @@ const valueForBinding = (binding, ctx, stack, depth, evaluateExpression) => {
 		const replayed = replayDependencyCache(cached, ctx);
 		if (replayed.hit) return { value: replayed.value };
 	}
-	const initializer = declaration.getInitializer();
+	const initializer = declaration.initializer;
 	if (!initializer) return;
 	const capture = beginDependencyCapture(ctx);
 	let value;
@@ -499,7 +499,7 @@ const importedEnvironmentFor = (node, ctx, stack, depth, evaluateExpression) =>
 	if (depth >= MAX_DEPTH) return;
 	const bindings = importBindingsFor(node.getSourceFile());
 	if (!bindings.size) return;
-	const references = node.getDescendantsOfKind(SyntaxKind.Identifier);
+	const references = getDescendantsOfKind(node, SyntaxKind.Identifier);
 	if (Node.isIdentifier(node)) references.unshift(node);
 	if (!references.length) return;
 	let environment;
@@ -571,7 +571,7 @@ const evaluateNodeUncached = (node, stack, ctx, depth, dependencyEntry) => {
 	let options = {
 		policy: { ...POLICY },
 		...ctx.getEvaluateOptions?.(node, stack),
-		node: node.compilerNode,
+		node,
 		typescript: ts
 	};
 	let imported = depth > 0 ? importedEnvironmentFor(node, ctx, stack, depth, safeEvaluateNode) : void 0;
@@ -632,19 +632,19 @@ function isScope(node) {
 	return Node.isFunctionDeclaration(node) || Node.isFunctionExpression(node) || Node.isArrowFunction(node) || Node.isSourceFile(node);
 }
 function getDeclarationFor(node, stack, ctx) {
-	const parent = node.getParent();
+	const parent = node.parent;
 	if (!parent) return;
 	const declarationStack = [];
 	let declaration;
-	if ((Node.isVariableDeclaration(parent) || Node.isParameterDeclaration(parent) || Node.isFunctionDeclaration(parent) || Node.isEnumDeclaration(parent) || Node.isBindingElement(parent)) && parent.getNameNode() == node) {
+	if ((Node.isVariableDeclaration(parent) || Node.isParameterDeclaration(parent) || Node.isFunctionDeclaration(parent) || Node.isEnumDeclaration(parent) || Node.isBindingElement(parent)) && parent.name == node) {
 		declarationStack.push(parent);
 		declaration = parent;
-	} else if (Node.isImportSpecifier(parent) && (parent.getNameNode() == node || parent.getAliasNode() == node)) {
+	} else if (Node.isImportSpecifier(parent) && (nameNodeOf(parent) == node || getAliasNode(parent) == node)) {
 		if (ctx.flags?.skipTraverseFiles) return;
-		const sourceFile = getModuleSpecifierSourceFile(parent.getImportDeclaration(), ctx);
+		const sourceFile = getModuleSpecifierSourceFile(parent.parent?.parent?.parent, ctx);
 		if (sourceFile) {
 			const exportStack = [parent, sourceFile];
-			const maybeVar = getExportedVarDeclarationWithName(parent.getNameNode().getText(), sourceFile, exportStack, ctx);
+			const maybeVar = getExportedVarDeclarationWithName(nameNodeOf(parent)?.getText() ?? "", sourceFile, exportStack, ctx);
 			if (maybeVar) {
 				declarationStack.push(...exportStack.concat(maybeVar));
 				declaration = maybeVar;
@@ -655,8 +655,8 @@ function getDeclarationFor(node, stack, ctx) {
 	return declaration;
 }
 const getInnermostScope = (from) => {
-	let scope = from.getParent();
-	while (scope && !isScope(scope)) scope = scope.getParent();
+	let scope = from.parent;
+	while (scope && !isScope(scope)) scope = scope.parent;
 	return scope;
 };
 /**
@@ -670,8 +670,8 @@ const getInnermostScope = (from) => {
 */
 const declarationIndexes = /* @__PURE__ */ new WeakMap();
 const isDeclarationName = (node, parent) => {
-	if (Node.isVariableDeclaration(parent) || Node.isParameterDeclaration(parent) || Node.isFunctionDeclaration(parent) || Node.isEnumDeclaration(parent) || Node.isBindingElement(parent)) return parent.getNameNode() == node;
-	return Node.isImportSpecifier(parent) && (parent.getNameNode() == node || parent.getAliasNode() == node);
+	if (Node.isVariableDeclaration(parent) || Node.isParameterDeclaration(parent) || Node.isFunctionDeclaration(parent) || Node.isEnumDeclaration(parent) || Node.isBindingElement(parent)) return parent.name == node;
+	return Node.isImportSpecifier(parent) && (nameNodeOf(parent) == node || getAliasNode(parent) == node);
 };
 /**
 * Walk a scope once, so that every later lookup inside it is a map read.
@@ -682,19 +682,19 @@ const isDeclarationName = (node, parent) => {
 * ts-morph charges for wrapping each node — it measured ~10% of extraction on its own.
 */
 const declarationIndexFor = (scope) => {
-	const cached = declarationIndexes.get(scope.compilerNode);
+	const cached = declarationIndexes.get(scope);
 	if (cached) return cached;
 	const index = /* @__PURE__ */ new Map();
-	scope.forEachDescendant((node) => {
+	forEachDescendant(scope, (node) => {
 		if (!Node.isIdentifier(node)) return;
-		const parent = node.getParent();
+		const parent = node.parent;
 		if (!parent || !isDeclarationName(node, parent)) return;
 		const name = node.getText();
 		const declared = index.get(name);
 		if (declared) declared.push(node);
 		else index.set(name, [node]);
 	});
-	declarationIndexes.set(scope.compilerNode, index);
+	declarationIndexes.set(scope, index);
 	return index;
 };
 function findIdentifierValueDeclaration(identifier, stack, ctx, visitedsWithStack = /* @__PURE__ */ new Map()) {
@@ -714,10 +714,10 @@ function findIdentifierValueDeclaration(identifier, stack, ctx, visitedsWithStac
 			const maybeDeclaration = getDeclarationFor(candidate, declarationStack, ctx);
 			if (!maybeDeclaration) continue;
 			if (Node.isParameterDeclaration(maybeDeclaration)) {
-				const initializer = maybeDeclaration.getInitializer();
-				const typeNode = maybeDeclaration.getTypeNode();
+				const initializer = maybeDeclaration.initializer;
+				const typeNode = maybeDeclaration.type;
 				if (initializer) innerStack.push(...declarationStack.concat(initializer));
-				else if (typeNode && Node.isTypeLiteral(typeNode)) innerStack.push(...declarationStack.concat(typeNode));
+				else if (typeNode && Node.isTypeLiteralNode(typeNode)) innerStack.push(...declarationStack.concat(typeNode));
 				else return;
 				stack.push(...innerStack);
 				return maybeDeclaration;
@@ -733,34 +733,34 @@ function findIdentifierValueDeclaration(identifier, stack, ctx, visitedsWithStac
 const getPropertyName = (property, stack, ctx) => {
 	if (!property) return;
 	if (Node.isPropertyAssignment(property)) {
-		const node = unwrapExpression(property.getNameNode());
+		const node = unwrapExpression(property.name);
 		if (Node.isIdentifier(node)) return box.from(node.getText(), node, stack);
 		if (Node.isComputedPropertyName(node)) {
-			const expression = node.getExpression();
+			const expression = node.expression;
 			stack.push(expression);
 			return maybePropName(expression, stack, ctx);
 		}
-		if (Node.isStringLiteral(node) || Node.isNumericLiteral(node)) return box.from(node.getLiteralText(), node, stack);
+		if (Node.isStringLiteral(node) || Node.isNumericLiteral(node)) return box.from(getLiteralText(node), node, stack);
 	}
 	if (Node.isShorthandPropertyAssignment(property)) {
-		const name = property.getName();
+		const name = getName(property);
 		if (name != null) return box.from(name, property, stack);
 	}
 	if (Node.isGetAccessorDeclaration(property)) {
-		const node = unwrapExpression(property.getNameNode());
+		const node = unwrapExpression(property.name);
 		if (Node.isIdentifier(node)) return box.from(node.getText(), node, stack);
 		if (Node.isComputedPropertyName(node)) {
-			const expression = node.getExpression();
+			const expression = node.expression;
 			stack.push(expression);
 			return maybePropName(expression, stack, ctx);
 		}
-		if (Node.isStringLiteral(node) || Node.isNumericLiteral(node)) return box.from(node.getLiteralText(), node, stack);
+		if (Node.isStringLiteral(node) || Node.isNumericLiteral(node)) return box.from(getLiteralText(node), node, stack);
 	}
 };
 //#endregion
 //#region src/get-object-literal-expression-prop-pairs.ts
 const getObjectLiteralExpressionPropPairs = (expression, expressionStack, ctx, matchProp) => {
-	const properties = expression.getProperties();
+	const properties = expression.properties;
 	if (properties.length === 0) return box.emptyObject(expression, expressionStack);
 	const extractedPropValues = [];
 	const spreadConditions = [];
@@ -779,7 +779,7 @@ const getObjectLiteralExpressionPropPairs = (expression, expressionStack, ctx, m
 				propNode: property
 			})) return;
 			if (Node.isShorthandPropertyAssignment(property)) {
-				const initializer = property.getNameNode();
+				const initializer = property.name;
 				stack.push(initializer);
 				const maybeValue = maybeBoxNode(initializer, stack, ctx);
 				if (maybeValue) {
@@ -789,11 +789,11 @@ const getObjectLiteralExpressionPropPairs = (expression, expressionStack, ctx, m
 			}
 			let init;
 			if (Node.isGetAccessorDeclaration(property)) {
-				const body = property.getBody();
-				init = Node.isBlock(body) ? body.getStatements().at(-1) : void 0;
-			} else init = property.getInitializer();
+				const body = property.body;
+				init = body !== void 0 && Node.isBlock(body) ? body.statements.at(-1) : void 0;
+			} else init = childOf(property, "initializer");
 			if (!init) return;
-			const initializer = unwrapExpression((Node.isReturnStatement(init) ? init.getExpression() : void 0) ?? init);
+			const initializer = unwrapExpression((Node.isReturnStatement(init) ? init.expression : void 0) ?? init);
 			stack.push(initializer);
 			const maybeValue = maybeBoxNode(initializer, stack, ctx);
 			if (maybeValue) {
@@ -802,7 +802,7 @@ const getObjectLiteralExpressionPropPairs = (expression, expressionStack, ctx, m
 			}
 		}
 		if (Node.isSpreadAssignment(property)) {
-			const initializer = unwrapExpression(property.getExpression());
+			const initializer = unwrapExpression(property.expression);
 			stack.push(initializer);
 			const maybeObject = maybeBoxNode(initializer, stack, ctx, matchProp);
 			if (!maybeObject) return;
@@ -883,28 +883,28 @@ function maybeBoxNodeUncached(node, stack, ctx, matchProp, dependencyEntry) {
 		return value;
 	};
 	if (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node)) {
-		const value = trimWhitespace(node.getLiteralValue());
+		const value = trimWhitespace(stringLiteralValue(node));
 		return cache(box.literal(value, node, stack));
 	}
 	if (Node.isObjectLiteralExpression(node)) return cache(getObjectLiteralExpressionPropPairs(node, stack, ctx, matchProp));
 	if (Node.isTrueLiteral(node) || Node.isFalseLiteral(node)) {
-		const value = node.getLiteralValue();
+		const value = literalValueOf(node);
 		return cache(box.literal(value, node, stack));
 	}
 	if (Node.isNumericLiteral(node)) {
-		const value = node.getLiteralValue();
+		const value = literalValueOf(node);
 		return cache(box.literal(value, node, stack));
 	}
 	if (Node.isNullLiteral(node)) return cache(box.literal(null, node, stack));
 	if (Node.isPrefixUnaryExpression(node)) {
-		const operand = node.getOperand();
-		const operator = node.getOperatorToken();
+		const operand = node.operand;
+		const operator = node.operator;
 		const boxNode = maybeBoxNode(operand, stack, ctx);
 		if (!box.isNumberLiteral(boxNode)) return;
 		return cache(operator === ts.SyntaxKind.MinusToken ? box.literal(-Number(boxNode.value), node, stack) : boxNode);
 	}
 	if (Node.isArrayLiteralExpression(node)) {
-		const boxNodes = node.getElements().map((element) => {
+		const boxNodes = node.elements.map((element) => {
 			return maybeBoxNode(element, stack, ctx) ?? cache(box.unresolvable(element, stack));
 		});
 		return cache(box.array(boxNodes, node, stack));
@@ -913,45 +913,45 @@ function maybeBoxNodeUncached(node, stack, ctx, matchProp, dependencyEntry) {
 		if (node.getText() === "undefined") return cache(box.literal(void 0, node, stack));
 		return cache(maybeIdentifierValue(node, stack, ctx));
 	}
-	if (Node.isTemplateHead(node)) return cache(box.literal(node.getLiteralText(), node, stack));
+	if (Node.isTemplateHead(node)) return cache(box.literal(getLiteralText(node), node, stack));
 	if (Node.isTemplateExpression(node)) {
 		const value = maybeTemplateStringValue(node, stack, ctx);
 		return cache(box.literal(value, node, stack));
 	}
-	if (Node.isTaggedTemplateExpression(node)) return cache(maybeBoxNode(node.getTemplate(), stack, ctx));
+	if (Node.isTaggedTemplateExpression(node)) return cache(maybeBoxNode(node.template, stack, ctx));
 	if (Node.isElementAccessExpression(node)) return cache(getElementAccessedExpressionValue(node, stack, ctx));
 	if (Node.isPropertyAccessExpression(node)) return cache(getPropertyAccessedExpressionValue(node, [], stack, ctx));
 	if (Node.isConditionalExpression(node)) {
 		if (ctx.flags?.skipConditions) return cache(box.unresolvable(node, stack));
-		const condExpr = unwrapExpression(node.getCondition());
+		const condExpr = unwrapExpression(node.condition);
 		const condBoxNode = (Node.isIdentifier(condExpr) ? maybeBoxNode(condExpr, [], ctx) : safeEvaluateNode(condExpr, stack, ctx)) ?? box.unresolvable(condExpr, stack);
 		const condValue = isBoxNode(condBoxNode) ? condBoxNode : box.from(condBoxNode, node, stack);
 		if (box.isEmptyInitializer(condValue)) return;
 		const isFromDefaultBinding = condValue.getStack().some((node) => Node.isBindingElement(node));
 		if (box.isUnresolvable(condValue) || box.isConditional(condValue) || isFromDefaultBinding) return cache(maybeResolveConditionalExpression({
-			whenTrueExpr: unwrapExpression(node.getWhenTrue()),
-			whenFalseExpr: unwrapExpression(node.getWhenFalse()),
+			whenTrueExpr: unwrapExpression(node.whenTrue),
+			whenFalseExpr: unwrapExpression(node.whenFalse),
 			node,
 			stack
 		}, ctx));
 		if (condValue.value) {
-			const whenTrueExpr = unwrapExpression(node.getWhenTrue());
+			const whenTrueExpr = unwrapExpression(node.whenTrue);
 			return cache(maybeBoxNode(whenTrueExpr, [...stack], ctx) ?? box.unresolvable(whenTrueExpr, stack));
 		}
-		return cache(maybeBoxNode(unwrapExpression(node.getWhenFalse()), [...stack], ctx) ?? box.unresolvable(node, stack));
+		return cache(maybeBoxNode(unwrapExpression(node.whenFalse), [...stack], ctx) ?? box.unresolvable(node, stack));
 	}
 	if (Node.isCallExpression(node)) {
 		if (ctx.tokens) {
-			const expr = node.getExpression();
+			const expr = node.expression;
 			let fnName = "";
 			let isValueMethod = false;
 			if (Node.isIdentifier(expr)) fnName = expr.getText();
-			else if (Node.isPropertyAccessExpression(expr)) if (expr.getName() === "value") {
+			else if (Node.isPropertyAccessExpression(expr)) if (getName(expr) === "value") {
 				isValueMethod = true;
-				fnName = expr.getExpression().getText();
+				fnName = expr.expression.getText();
 			} else fnName = expr.getText();
 			if (ctx.tokens.isTokenFn ? ctx.tokens.isTokenFn(fnName) : fnName === "token") {
-				const tokenPathArg = node.getArguments()[0];
+				const tokenPathArg = node.arguments[0];
 				const tokenPath = tokenPathArg ? literalStringOf(tokenPathArg, stack, ctx) : void 0;
 				if (tokenPath !== void 0) {
 					const resolvedValue = isValueMethod ? ctx.tokens.view.get(tokenPath) : ctx.tokens.view.getVar(tokenPath);
@@ -964,7 +964,7 @@ function maybeBoxNodeUncached(node, stack, ctx, matchProp, dependencyEntry) {
 		return cache(box.from(value, node, stack));
 	}
 	if (Node.isBinaryExpression(node)) {
-		const operatorKind = node.getOperatorToken().getKind();
+		const operatorKind = node.operatorToken.kind;
 		if (isPlusSyntax(operatorKind)) {
 			const value = tryComputingPlusTokenBinaryExpressionToString(node, stack, ctx) ?? safeEvaluateNode(node, stack, ctx);
 			if (!value) return;
@@ -972,8 +972,8 @@ function maybeBoxNodeUncached(node, stack, ctx, matchProp, dependencyEntry) {
 			return cache(box.from(value, node, stack));
 		}
 		if (isLogicalSyntax(operatorKind)) return cache(maybeResolveConditionalExpression({
-			whenTrueExpr: unwrapExpression(node.getLeft()),
-			whenFalseExpr: unwrapExpression(node.getRight()),
+			whenTrueExpr: unwrapExpression(node.left),
+			whenFalseExpr: unwrapExpression(node.right),
 			node,
 			stack,
 			canReturnWhenTrue: canReturnWhenTrueInLogicalExpression(operatorKind)
@@ -990,7 +990,7 @@ function maybeBoxNodeUncached(node, stack, ctx, matchProp, dependencyEntry) {
 * Returning `undefined` leaves the call unresolved, exactly as before.
 */
 function literalStringOf(node, stack, ctx) {
-	if (Node.isStringLiteral(node)) return node.getLiteralValue();
+	if (Node.isStringLiteral(node)) return stringLiteralValue(node);
 	const resolved = onlyStringLiteral(maybeBoxNode(node, stack, ctx));
 	return resolved && typeof resolved.value === "string" ? resolved.value : void 0;
 }
@@ -1014,7 +1014,7 @@ const maybeResolveConditionalExpression = ({ whenTrueExpr, whenFalseExpr, node,
 	const whenTrueValue = maybeBoxNode(whenTrueExpr, stack, ctx);
 	const whenFalseValue = maybeBoxNode(whenFalseExpr, stack, ctx);
 	if (canReturnWhenTrue && whenTrueValue && !box.isUnresolvable(whenTrueValue)) return whenTrueValue;
-	if (Node.isBinaryExpression(node) && node.getOperatorToken().getKind() === ts.SyntaxKind.AmpersandAmpersandToken && whenTrueValue && whenFalseValue && box.isLiteral(whenTrueValue) && whenTrueValue.value === true) return whenFalseValue;
+	if (Node.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken && whenTrueValue && whenFalseValue && box.isLiteral(whenTrueValue) && whenTrueValue.value === true) return whenFalseValue;
 	if (!whenTrueValue && !whenFalseValue) return;
 	if (whenTrueValue && !whenFalseValue) return whenTrueValue;
 	if (!whenTrueValue && whenFalseValue) return whenFalseValue;
@@ -1026,17 +1026,17 @@ const maybeResolveConditionalExpression = ({ whenTrueExpr, whenFalseExpr, node,
 const findProperty = (node, propName, _stack, ctx) => {
 	const stack = [..._stack];
 	if (Node.isPropertyAssignment(node)) {
-		const name = node.getNameNode();
+		const name = node.name;
 		if (Node.isIdentifier(name) && name.getText() === propName) {
 			stack.push(name);
 			return node;
 		}
-		if (Node.isStringLiteral(name) && name.getLiteralText() === propName) {
+		if (Node.isStringLiteral(name) && getLiteralText(name) === propName) {
 			stack.push(name);
-			return name.getLiteralText();
+			return getLiteralText(name);
 		}
 		if (Node.isComputedPropertyName(name)) {
-			const expression = unwrapExpression(name.getExpression());
+			const expression = unwrapExpression(name.expression);
 			const computedPropNameBox = maybePropName(expression, stack, ctx);
 			if (!computedPropNameBox) return;
 			if (String(computedPropNameBox.value) === propName) {
@@ -1046,7 +1046,7 @@ const findProperty = (node, propName, _stack, ctx) => {
 		}
 	}
 	if (Node.isShorthandPropertyAssignment(node)) {
-		const name = node.getNameNode();
+		const name = node.name;
 		if (Node.isIdentifier(name) && name.getText() === propName) {
 			stack.push(name);
 			return node;
@@ -1056,11 +1056,11 @@ const findProperty = (node, propName, _stack, ctx) => {
 const getObjectLiteralPropValue = (initializer, accessList, _stack, ctx) => {
 	const stack = [..._stack];
 	const propName = accessList.pop();
-	const property = initializer.getProperty(propName) ?? initializer.getProperties().find((p) => findProperty(p, propName, stack, ctx));
+	const property = getProperty(initializer, propName) ?? initializer.properties.find((p) => findProperty(p, propName, stack, ctx));
 	if (!property) return;
 	stack.push(property);
 	if (Node.isPropertyAssignment(property)) {
-		const propInit = property.getInitializer();
+		const propInit = property.initializer;
 		if (!propInit) return;
 		if (Node.isObjectLiteralExpression(propInit)) {
 			if (accessList.length > 0) return getObjectLiteralPropValue(propInit, accessList, stack, ctx);
@@ -1070,39 +1070,40 @@ const getObjectLiteralPropValue = (initializer, accessList, _stack, ctx) => {
 		if (maybePropValue) return maybePropValue;
 	}
 	if (Node.isShorthandPropertyAssignment(property)) {
-		const identifier = property.getNameNode();
+		const identifier = property.name;
 		if (accessList.length > 0) return maybePropIdentifierValue(identifier, accessList, stack, ctx);
 		const maybePropValue = maybeBoxNode(identifier, stack, ctx);
 		if (maybePropValue) return maybePropValue;
 	}
 };
 const maybeTemplateStringValue = (template, stack, ctx) => {
-	const head = template.getHead();
-	const tail = template.getTemplateSpans();
+	const head = template.head;
+	const tail = template.templateSpans;
 	const headValue = maybeStringLiteral(head, stack, ctx);
 	if (!headValue) return;
 	const tailValues = tail.map((t) => {
-		const propBox = maybePropName(t.getExpression(), stack, ctx);
+		const expression = t.expression;
+		const propBox = maybePropName(expression, stack, ctx);
 		if (!propBox) return;
-		const literal = t.getLiteral();
-		return propBox.value + literal.getLiteralText();
+		const literal = t.literal;
+		return propBox.value + getLiteralText(literal);
 	});
 	if (tailValues.every(isNotNullish)) return headValue.value + tailValues.join("");
 };
 const maybeBindingElementValue = (def, stack, propName, ctx) => {
-	const parent = def.getParent();
+	const parent = def.parent;
 	if (!parent) return;
-	const grandParent = parent.getParent();
+	const grandParent = parent.parent;
 	if (!grandParent) return;
 	if (Node.isArrayBindingPattern(parent)) {
-		const index = parent.getChildIndex();
+		const index = getChildIndex(parent);
 		if (Number.isNaN(index)) return;
 		if (Node.isVariableDeclaration(grandParent)) {
-			const init = grandParent.getInitializer();
+			const init = grandParent.initializer;
 			if (!init) return;
 			const initializer = unwrapExpression(init);
 			if (!Node.isArrayLiteralExpression(initializer)) return;
-			const element = initializer.getElements()[index + 1];
+			const element = initializer.elements[index + 1];
 			if (!element) return;
 			const innerStack = [
 				...stack,
@@ -1126,22 +1127,22 @@ const maybeBindingElementValue = (def, stack, propName, ctx) => {
 function maybePropDefinitionValue(def, accessList, _stack, ctx) {
 	const propName = accessList.at(-1);
 	if (Node.isVariableDeclaration(def)) {
-		const init = def.getInitializer();
+		const init = def.initializer;
 		if (!init) {
-			const type = def.getTypeNode();
+			const type = def.type;
 			if (!type) return;
-			if (Node.isTypeLiteral(type)) {
+			if (Node.isTypeLiteralNode(type)) {
 				if (accessList.length > 0) {
 					const stack = [..._stack];
 					stack.push(type);
 					let propName = accessList.pop();
-					let typeProp = type.getProperty(propName);
-					let typeLiteral = typeProp?.getTypeNode();
-					while (typeProp && accessList.length > 0 && typeLiteral && Node.isTypeLiteral(typeLiteral)) {
+					let typeProp = getProperty(type, propName);
+					let typeLiteral = typeProp && childOf(typeProp, "type");
+					while (typeProp && accessList.length > 0 && typeLiteral && Node.isTypeLiteralNode(typeLiteral)) {
 						stack.push(typeProp, typeLiteral);
 						propName = accessList.pop();
-						typeProp = typeLiteral.getProperty(propName);
-						typeLiteral = typeProp?.getTypeNode();
+						typeProp = getProperty(typeLiteral, propName);
+						typeLiteral = typeProp && childOf(typeProp, "type");
 					}
 					if (!typeLiteral) return;
 					const typeValue = getTypeNodeValue(typeLiteral, stack, ctx);
@@ -1163,7 +1164,7 @@ function maybePropDefinitionValue(def, accessList, _stack, ctx) {
 		if (Node.isArrayLiteralExpression(initializer)) {
 			const index = Number(propName);
 			if (Number.isNaN(index)) return;
-			const element = initializer.getElements()[index];
+			const element = initializer.elements[index];
 			if (!element) return;
 			_stack.push(initializer);
 			const boxed = maybeBoxNode(element, _stack, ctx);
@@ -1177,9 +1178,9 @@ function maybePropDefinitionValue(def, accessList, _stack, ctx) {
 		if (value) return value;
 	}
 	if (Node.isEnumDeclaration(def)) {
-		const member = def.getMember(propName);
+		const member = getMember(def, propName);
 		if (!member) return;
-		const initializer = member.getInitializer();
+		const initializer = childOf(member, "initializer");
 		if (!initializer) return;
 		const maybeValue = maybeBoxNode(initializer, [..._stack, initializer], ctx);
 		if (maybeValue) return maybeValue;
@@ -1199,9 +1200,9 @@ const getTypeLiteralNodePropValue = (type, propName, stack, ctx) => {
 		if (map === null) return;
 		if (map?.has(propName)) return map.get(propName);
 	}
-	const prop = type.getMembers().find((member) => Node.isPropertySignature(member) && member.getName() === propName);
-	if (Node.isPropertySignature(prop) && prop.isReadonly()) {
-		const propType = prop.getTypeNode();
+	const prop = type.members.find((member) => Node.isPropertySignatureDeclaration(member) && getName(member) === propName);
+	if (prop !== void 0 && Node.isPropertySignatureDeclaration(prop) && isReadonly(prop)) {
+		const propType = prop.type;
 		if (!propType) {
 			typeLiteralCache.set(type, null);
 			return;
@@ -1216,29 +1217,28 @@ const getTypeLiteralNodePropValue = (type, propName, stack, ctx) => {
 	typeLiteralCache.set(type, null);
 };
 function getNameLiteral(wrapper) {
-	if (Node.isStringLiteral(wrapper)) return wrapper.getLiteralText();
+	if (Node.isStringLiteral(wrapper)) return getLiteralText(wrapper);
 	return wrapper.getText();
 }
 const typeNodeCache = /* @__PURE__ */ new WeakMap();
 const getTypeNodeValue = (type, stack, ctx) => {
 	if (typeNodeCache.has(type)) return typeNodeCache.get(type);
 	if (Node.isLiteralTypeNode(type)) {
-		const literal = type.getLiteral();
+		const literal = type.literal;
 		if (Node.isStringLiteral(literal)) {
-			const result = literal.getLiteralText();
+			const result = getLiteralText(literal);
 			typeNodeCache.set(type, result);
 			return result;
 		}
 	}
-	if (Node.isTypeLiteral(type)) {
-		const members = type.getMembers();
-		if (!members.some((member) => !Node.isPropertySignature(member) || !member.isReadonly())) {
+	if (Node.isTypeLiteralNode(type)) {
+		const members = type.members;
+		if (!members.some((member) => !Node.isPropertySignatureDeclaration(member) || !isReadonly(member))) {
 			const entries = members.map((member) => {
-				const nameNode = member.getNameNode();
-				const nameText = nameNode.getText();
+				const nameNode = member.name;
 				const name = getNameLiteral(nameNode);
 				if (!name) return;
-				return [name, getTypeLiteralNodePropValue(type, nameText, stack, ctx)];
+				return [name, getTypeLiteralNodePropValue(type, name, stack, ctx)];
 			}).filter(isNotNullish);
 			const result = Object.fromEntries(entries);
 			typeNodeCache.set(type, result);
@@ -1249,15 +1249,15 @@ const getTypeNodeValue = (type, stack, ctx) => {
 };
 const maybeDefinitionValue = (def, stack, ctx) => {
 	if (Node.isShorthandPropertyAssignment(def)) {
-		const propNameNode = def.getNameNode();
+		const propNameNode = def.name;
 		return maybePropIdentifierValue(propNameNode, [propNameNode.getText()], stack, ctx);
 	}
 	if (Node.isVariableDeclaration(def)) {
-		const init = def.getInitializer();
+		const init = def.initializer;
 		if (!init) {
-			const type = def.getTypeNode();
+			const type = def.type;
 			if (!type) return;
-			if (Node.isTypeLiteral(type)) {
+			if (Node.isTypeLiteralNode(type)) {
 				stack.push(type);
 				const maybeTypeValue = getTypeNodeValue(type, stack, ctx);
 				if (isNotNullish(maybeTypeValue)) return box.from(maybeTypeValue, def, stack);
@@ -1269,11 +1269,11 @@ const maybeDefinitionValue = (def, stack, ctx) => {
 		if (maybeValue) return maybeValue;
 	}
 	if (Node.isBindingElement(def)) {
-		const init = def.getInitializer();
+		const init = def.initializer;
 		if (!init) {
-			const nameNode = def.getPropertyNameNode() ?? def.getNameNode();
-			const propName = nameNode.getText();
-			const value = maybeBindingElementValue(def, [...stack, nameNode], propName, ctx);
+			const nameNode = def.propertyName ?? def.name;
+			const propName = nameNode?.getText() ?? "";
+			const value = maybeBindingElementValue(def, [...stack, nameNode].filter(Boolean), propName, ctx);
 			if (value) return value;
 			return box.unresolvable(def, stack);
 		}
@@ -1283,11 +1283,11 @@ const maybeDefinitionValue = (def, stack, ctx) => {
 	}
 };
 const getExportedVarDeclarationWithName = (varName, sourceFile, stack, ctx, visited = /* @__PURE__ */ new Set()) => {
-	ctx.recordExportRead?.(sourceFile.getFilePath(), varName);
-	const key = `${sourceFile.getFilePath()}:${varName}`;
+	ctx.recordExportRead?.(pathOf(sourceFile), varName);
+	const key = `${pathOf(sourceFile)}:${varName}`;
 	if (visited.has(key)) return;
 	visited.add(key);
-	const maybeVar = sourceFile.getVariableDeclaration(varName);
+	const maybeVar = getVariableDeclaration(sourceFile, varName);
 	if (maybeVar) return maybeVar;
 	const exportDeclaration = resolveVarDeclarationFromExportWithName(varName, sourceFile, stack, ctx, visited);
 	if (!exportDeclaration) return;
@@ -1303,9 +1303,9 @@ const getExportedVarDeclarationWithName = (varName, sourceFile, stack, ctx, visi
 * module does export and resolves names it does not.
 */
 const resolveExportedName = (name, exportDeclaration) => {
-	const namedExports = exportDeclaration.getNamedExports();
+	const namedExports = getNamedExports(exportDeclaration);
 	if (namedExports.length === 0) return name;
-	for (const namedExport of namedExports) if ((namedExport.getAliasNode() ?? namedExport.getNameNode()).getText() === name) return namedExport.getNameNode().getText();
+	for (const namedExport of namedExports) if (((getAliasNode(namedExport) ?? nameNodeOf(namedExport))?.getText() ?? "") === name) return nameNodeOf(namedExport)?.getText();
 };
 /**
 * Faster than declaration.getModuleSpecifierSourceFile()
@@ -1317,20 +1317,20 @@ const resolveExportedName = (name, exportDeclaration) => {
 * @see https://github.com/dsherret/ts-morph/blob/42d811ed9a5177fc678a5bfec4923a2048124fe0/packages/ts-morph/src/compiler/ast/module/ExportDeclaration.ts#L160
 */
 const getModuleSpecifierSourceFile = (declaration, ctx) => {
-	const moduleName = declaration.getModuleSpecifierValue();
+	const moduleName = getModuleSpecifierValue(declaration);
 	if (!moduleName) return;
 	const sourceFile = ctx.resolveModule?.(moduleName, declaration.getSourceFile());
-	if (sourceFile) recordModuleDependency(ctx, sourceFile.getFilePath());
+	if (sourceFile) recordModuleDependency(ctx, pathOf(sourceFile));
 	return sourceFile;
 };
 function resolveVarDeclarationFromExportWithName(symbolName, sourceFile, stack, ctx, visited) {
-	for (const exportDeclaration of sourceFile.getExportDeclarations()) {
+	for (const exportDeclaration of getExportDeclarations(sourceFile)) {
 		const exportStack = [exportDeclaration];
 		const sourceName = resolveExportedName(symbolName, exportDeclaration);
 		if (sourceName === void 0) continue;
 		const maybeFile = getModuleSpecifierSourceFile(exportDeclaration, ctx);
 		if (!maybeFile) {
-			const localVar = sourceFile.getVariableDeclaration(sourceName);
+			const localVar = getVariableDeclaration(sourceFile, sourceName);
 			if (localVar) {
 				stack.push(...exportStack.concat(localVar));
 				return localVar;
@@ -1355,16 +1355,16 @@ const maybeIdentifierValue = (identifier, _stack, ctx) => {
 	return box.unresolvable(identifier, stack);
 };
 const tryComputingPlusTokenBinaryExpressionToString = (node, stack, ctx) => {
-	const left = unwrapExpression(node.getLeft());
-	const right = unwrapExpression(node.getRight());
+	const left = unwrapExpression(node.left);
+	const right = unwrapExpression(node.right);
 	const leftValue = maybePropName(left, stack, ctx);
 	const rightValue = maybePropName(right, stack, ctx);
 	if (!leftValue || !rightValue) return;
 	if (isNotNullish(leftValue.value) && isNotNullish(rightValue.value)) return box.literal(String(leftValue.value) + String(rightValue.value), node, stack);
 };
 const getElementAccessedExpressionValue = (expression, _stack, ctx) => {
-	const elementAccessed = unwrapExpression(expression.getExpression());
-	const argExpr = expression.getArgumentExpression();
+	const elementAccessed = unwrapExpression(expression.expression);
+	const argExpr = expression.argumentExpression;
 	if (!argExpr) return;
 	const arg = unwrapExpression(argExpr);
 	const stack = [
@@ -1378,7 +1378,7 @@ const getElementAccessedExpressionValue = (expression, _stack, ctx) => {
 		return maybePropIdentifierValue(elementAccessed, [argLiteral.value.toString()], stack, ctx);
 	}
 	if (Node.isBinaryExpression(arg)) {
-		if (arg.getOperatorToken().getKind() !== ts.SyntaxKind.PlusToken) return;
+		if (arg.operatorToken.kind !== ts.SyntaxKind.PlusToken) return;
 		const propName = tryComputingPlusTokenBinaryExpressionToString(arg, stack, ctx) ?? maybePropName(arg, stack, ctx);
 		if (propName && Node.isIdentifier(elementAccessed)) {
 			if (!isNotNullish(propName.value)) return;
@@ -1435,8 +1435,8 @@ const getElementAccessedExpressionValue = (expression, _stack, ctx) => {
 		if (isNotNullish(propName) && isNotNullish(propName.value)) {
 			if (Node.isIdentifier(elementAccessed)) return maybePropIdentifierValue(elementAccessed, [propName.value.toString()], stack, ctx);
 		}
-		const whenTrueExpr = unwrapExpression(arg.getWhenTrue());
-		const whenFalseExpr = unwrapExpression(arg.getWhenFalse());
+		const whenTrueExpr = unwrapExpression(arg.whenTrue);
+		const whenFalseExpr = unwrapExpression(arg.whenFalse);
 		const whenTrueValue = maybePropName(whenTrueExpr, stack, ctx);
 		const whenFalseValue = maybePropName(whenFalseExpr, stack, ctx);
 		if (Node.isIdentifier(elementAccessed)) {
@@ -1450,15 +1450,15 @@ const getElementAccessedExpressionValue = (expression, _stack, ctx) => {
 	}
 };
 const getArrayElementValueAtIndex = (array, index, stack, ctx) => {
-	const element = array.getElements()[index];
+	const element = array.elements[index];
 	if (!element) return;
 	const value = maybeBoxNode(element, stack, ctx);
 	if (isNotNullish(value)) return value;
 };
 const getPropertyAccessedExpressionValue = (expression, _accessList, stack, ctx) => {
-	const propName = expression.getName();
-	const elementAccessed = unwrapExpression(expression.getExpression());
-	const accessList = _accessList.concat(propName);
+	const propName = getName(expression);
+	const elementAccessed = unwrapExpression(expression.expression);
+	const accessList = _accessList.concat(String(propName));
 	stack.push(elementAccessed);
 	if (Node.isIdentifier(elementAccessed)) return maybePropIdentifierValue(elementAccessed, accessList, stack, ctx);
 	if (Node.isPropertyAccessExpression(elementAccessed)) return getPropertyAccessedExpressionValue(elementAccessed, accessList, stack, ctx);
@@ -1466,11 +1466,11 @@ const getPropertyAccessedExpressionValue = (expression, _accessList, stack, ctx)
 		const leftElementAccessed = getElementAccessedExpressionValue(elementAccessed, stack, ctx);
 		if (!leftElementAccessed) return;
 		if (box.isObject(leftElementAccessed)) {
-			const propValue = leftElementAccessed.value[propName];
+			const propValue = leftElementAccessed.value[String(propName)];
 			return box.from(propValue, expression, stack);
 		}
 		if (box.isMap(leftElementAccessed)) {
-			const propValue = leftElementAccessed.value.get(propName);
+			const propValue = leftElementAccessed.value.get(propName ?? "");
 			return box.from(propValue, expression, stack);
 		}
 	}
@@ -1479,8 +1479,8 @@ const getPropertyAccessedExpressionValue = (expression, _accessList, stack, ctx)
 //#region src/call-expression.ts
 const trueFn = () => true;
 const extractCallExpressionArguments = (node, ctx, matchProp = trueFn, matchArg = trueFn) => {
-	const fnArguments = node.getArguments();
-	const fnName = node.getExpression().getText();
+	const fnArguments = node.arguments;
+	const fnName = node.expression.getText();
 	if (fnArguments.length === 0) return box.array([], node, []);
 	return box.array(fnArguments.map((argument, index) => {
 		const argNode = unwrapExpression(argument);
@@ -1578,7 +1578,7 @@ const collectImports = (sourceFile) => {
 		if (!node) return;
 		const expression = unwrapExpression(node);
 		if (Node.isCallExpression(expression)) {
-			const callee = unwrapExpression(expression.getExpression());
+			const callee = unwrapExpression(expression.expression);
 			if (!Node.isIdentifier(callee)) return;
 			const calleeName = callee.getText();
 			if (/requirejsxdevruntime/i.test(calleeName)) return "react/jsx-dev-runtime";
@@ -1587,70 +1587,70 @@ const collectImports = (sourceFile) => {
 		}
 	};
 	const bundledCandidates = mayHoldBundledOutput(sourceFile.getFullText());
-	(bundledCandidates ? sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression) : []).forEach((callExpression) => {
-		const callee = unwrapExpression(callExpression.getExpression());
+	(bundledCandidates ? getDescendantsOfKind(sourceFile, SyntaxKind.CallExpression) : []).forEach((callExpression) => {
+		const callee = unwrapExpression(childOf(callExpression, "expression"));
 		if (!Node.isIdentifier(callee) || callee.getText() !== "parcelRegister") return;
-		const [idArg, factoryArg] = callExpression.getArguments();
+		const [idArg, factoryArg] = childOf(callExpression, "arguments") ?? [];
 		if (!Node.isStringLiteral(idArg)) return;
 		if (!Node.isArrowFunction(factoryArg) && !Node.isFunctionExpression(factoryArg)) return;
-		const factoryText = factoryArg.getBody().getText();
-		if (factoryText.includes("\"Fragment\"") && factoryText.includes("\"jsx\"") && factoryText.includes("\"jsxs\"") && factoryText.includes("module.exports")) parcelRuntimeModuleIds.set(idArg.getLiteralValue(), "react/jsx-runtime");
+		const factoryText = factoryArg.body.getText();
+		if (factoryText.includes("\"Fragment\"") && factoryText.includes("\"jsx\"") && factoryText.includes("\"jsxs\"") && factoryText.includes("module.exports")) parcelRuntimeModuleIds.set(stringLiteralValue(idArg), "react/jsx-runtime");
 	});
-	sourceFile.getImportDeclarations().forEach((declaration) => {
-		const mod = declaration.getModuleSpecifierValue();
+	getImportDeclarations(sourceFile).forEach((declaration) => {
+		const mod = getModuleSpecifierValue(declaration);
 		if (!mod) return;
-		const defaultImport = declaration.getDefaultImport();
+		const defaultImport = getDefaultImport(declaration);
 		if (defaultImport) defaultImports.set(defaultImport.getText(), mod);
-		const namespaceImport = declaration.getNamespaceImport();
+		const namespaceImport = getNamespaceImport(declaration);
 		if (namespaceImport) namespace.set(namespaceImport.getText(), mod);
-		declaration.getNamedImports().forEach((specifier) => {
-			const importedName = specifier.getNameNode().getText();
-			const alias = specifier.getAliasNode()?.getText() || importedName;
-			named.set(alias, {
-				importedName,
+		getNamedImports(declaration).forEach((specifier) => {
+			const importedName = nameNodeOf(specifier)?.getText();
+			const alias = getAliasNode(specifier)?.getText() || importedName;
+			named.set(alias ?? "", {
+				importedName: importedName ?? "",
 				mod
 			});
 		});
 	});
-	sourceFile.getVariableDeclarations().forEach((declaration) => {
-		if (!Node.isIdentifier(declaration.getNameNode())) return;
-		const variableName = declaration.getName();
-		const initializer = declaration.getInitializer();
-		const bundledImport = resolveBundledHelperImport(variableName, initializer);
-		if (bundledImport) bundledNamed.set(variableName, bundledImport);
-		let mod = getBundledRuntimeModFromName(variableName) ?? resolveBundledNamespaceMod(initializer);
+	getVariableDeclarations(sourceFile).forEach((declaration) => {
+		if (!Node.isIdentifier(nameNodeOf(declaration))) return;
+		const variableName = getName(declaration);
+		const initializer = childOf(declaration, "initializer");
+		const bundledImport = resolveBundledHelperImport(variableName ?? "", initializer);
+		if (bundledImport) bundledNamed.set(variableName ?? "", bundledImport);
+		let mod = getBundledRuntimeModFromName(variableName ?? "") ?? resolveBundledNamespaceMod(initializer);
 		if (!mod && initializer && Node.isCallExpression(initializer)) {
-			const callee = unwrapExpression(initializer.getExpression());
-			const [firstArg] = initializer.getArguments();
-			if (Node.isIdentifier(callee) && callee.getText() === "parcelRequire" && Node.isStringLiteral(firstArg)) mod = parcelRuntimeModuleIds.get(firstArg.getLiteralValue());
+			const callee = unwrapExpression(initializer.expression);
+			const [firstArg] = initializer.arguments;
+			if (Node.isIdentifier(callee) && callee.getText() === "parcelRequire" && Node.isStringLiteral(firstArg)) mod = parcelRuntimeModuleIds.get(stringLiteralValue(firstArg));
 		}
 		if (!mod && initializer && Node.isObjectLiteralExpression(initializer)) {
-			const propertyNames = new Set(initializer.getProperties().map((property) => {
-				if (Node.isPropertyAssignment(property)) return property.getName();
+			const propertyNames = new Set(initializer.properties.map((property) => {
+				if (Node.isPropertyAssignment(property)) return getName(property);
 			}).filter(Boolean));
 			if (propertyNames.has("jsx") && propertyNames.has("Fragment")) mod = "preact/jsx-runtime";
 		}
 		if (!mod) return;
-		bundledNamespace.set(variableName, mod);
+		bundledNamespace.set(variableName ?? "", mod);
 	});
-	(bundledCandidates ? sourceFile.getDescendantsOfKind(SyntaxKind.FunctionDeclaration) : []).forEach((declaration) => {
-		const bundledImport = resolveBundledHelperImport(declaration.getName() ?? "", declaration);
-		if (!bundledImport || !declaration.getName()) return;
-		bundledNamed.set(declaration.getName(), bundledImport);
+	(bundledCandidates ? getDescendantsOfKind(sourceFile, SyntaxKind.FunctionDeclaration) : []).forEach((declaration) => {
+		const bundledImport = resolveBundledHelperImport(getName(declaration) ?? "", declaration);
+		if (!bundledImport || !getName(declaration)) return;
+		bundledNamed.set(getName(declaration), bundledImport);
 	});
 	const resolveBundledAliasImport = (node) => {
 		if (!node) return;
 		const expression = unwrapExpression(node);
 		if (Node.isIdentifier(expression)) return bundledNamed.get(expression.getText());
-		if (Node.isConditionalExpression(expression)) return resolveBundledAliasImport(expression.getWhenTrue()) ?? resolveBundledAliasImport(expression.getWhenFalse());
-		if (Node.isBinaryExpression(expression) && expression.getOperatorToken().getKind() === SyntaxKind.CommaToken) return resolveBundledAliasImport(expression.getRight());
+		if (Node.isConditionalExpression(expression)) return resolveBundledAliasImport(expression.whenTrue) ?? resolveBundledAliasImport(expression.whenFalse);
+		if (Node.isBinaryExpression(expression) && expression.operatorToken.kind === SyntaxKind.CommaToken) return resolveBundledAliasImport(expression.right);
 	};
-	sourceFile.getVariableDeclarations().forEach((declaration) => {
-		if (!Node.isIdentifier(declaration.getNameNode())) return;
-		if (bundledNamed.has(declaration.getName())) return;
-		const bundledAlias = resolveBundledAliasImport(declaration.getInitializer());
+	getVariableDeclarations(sourceFile).forEach((declaration) => {
+		if (!Node.isIdentifier(nameNodeOf(declaration))) return;
+		if (bundledNamed.has(getName(declaration) ?? "")) return;
+		const bundledAlias = resolveBundledAliasImport(childOf(declaration, "initializer"));
 		if (!bundledAlias) return;
-		bundledNamed.set(declaration.getName(), bundledAlias);
+		bundledNamed.set(getName(declaration) ?? "", bundledAlias);
 	});
 	return {
 		named,
@@ -1668,7 +1668,7 @@ const normalizeTagName = (text) => {
 const getTagName = (node) => {
 	if (!node) return;
 	const expression = unwrapExpression(node);
-	if (Node.isStringLiteral(expression) || Node.isNoSubstitutionTemplateLiteral(expression)) return expression.getLiteralValue();
+	if (Node.isStringLiteral(expression) || Node.isNoSubstitutionTemplateLiteral(expression)) return literalValueOf(expression);
 	if (Node.isIdentifier(expression) || Node.isPropertyAccessExpression(expression) || Node.isElementAccessExpression(expression)) return normalizeTagName(expression.getText());
 };
 const isQwikMod = (mod) => mod.includes("qwik");
@@ -1748,11 +1748,11 @@ const runtimeProfiles = [
 */
 const findLocalDeclaration = (identifier) => {
 	const name = identifier.getText();
-	for (let scope = identifier.getParent(); scope; scope = scope.getParent()) {
-		if (!Node.isStatemented(scope)) continue;
-		const variable = scope.getVariableDeclaration(name);
+	for (let scope = identifier.parent; scope; scope = scope.parent) {
+		if (!Node.isStatement(scope)) continue;
+		const variable = getVariableDeclaration(scope, name);
 		if (variable) return variable;
-		const fn = scope.getFunction(name);
+		const fn = (childOf(scope, "statements") ?? []).find((statement) => is.isFunctionDeclaration(statement) && getName(statement) === name);
 		if (fn) return fn;
 	}
 };
@@ -1760,7 +1760,7 @@ const createCompiledJsxContext = (sourceFile) => {
 	const imports = collectImports(sourceFile);
 	const normalizeCallee = (node) => {
 		const expression = unwrapExpression(node);
-		if (Node.isBinaryExpression(expression) && expression.getOperatorToken().getKind() === SyntaxKind.CommaToken) return normalizeCallee(expression.getRight());
+		if (Node.isBinaryExpression(expression) && expression.operatorToken.kind === SyntaxKind.CommaToken) return normalizeCallee(expression.right);
 		return expression;
 	};
 	const localDefinitionCache = /* @__PURE__ */ new Map();
@@ -1779,13 +1779,13 @@ const createCompiledJsxContext = (sourceFile) => {
 				};
 				return resolveIdentifierDefinition(expression);
 			}
-			if (Node.isConditionalExpression(expression)) return resolveLocalAlias(expression.getWhenTrue()) ?? resolveLocalAlias(expression.getWhenFalse());
-			if (Node.isBinaryExpression(expression) && expression.getOperatorToken().getKind() === SyntaxKind.CommaToken) return resolveLocalAlias(expression.getRight());
+			if (Node.isConditionalExpression(expression)) return resolveLocalAlias(expression.whenTrue) ?? resolveLocalAlias(expression.whenFalse);
+			if (Node.isBinaryExpression(expression) && expression.operatorToken.kind === SyntaxKind.CommaToken) return resolveLocalAlias(expression.right);
 		};
 		const declaration = findLocalDeclaration(identifier);
 		if (!declaration) return;
 		if (Node.isFunctionDeclaration(declaration)) {
-			const imported = resolveBundledHelperImport(declaration.getName() ?? name, declaration);
+			const imported = resolveBundledHelperImport(getName(declaration) ?? name, declaration);
 			if (!imported) return;
 			const resolved = {
 				mod: imported.mod,
@@ -1794,11 +1794,11 @@ const createCompiledJsxContext = (sourceFile) => {
 			localDefinitionCache.set(name, resolved);
 			return resolved;
 		}
-		const directImport = resolveBundledHelperImport(declaration.getName(), declaration.getInitializer());
+		const directImport = resolveBundledHelperImport(getName(declaration) ?? "", childOf(declaration, "initializer"));
 		const aliasImport = directImport ? {
 			mod: directImport.mod,
 			importedName: directImport.importedName
-		} : resolveLocalAlias(declaration.getInitializer());
+		} : resolveLocalAlias(childOf(declaration, "initializer"));
 		if (!aliasImport) return;
 		localDefinitionCache.set(name, aliasImport);
 		return aliasImport;
@@ -1814,36 +1814,40 @@ const createCompiledJsxContext = (sourceFile) => {
 			return resolveIdentifierDefinition(expression);
 		}
 		if (Node.isPropertyAccessExpression(expression)) {
-			const target = normalizeCallee(expression.getExpression());
+			const target = normalizeCallee(expression.expression);
 			if (!Node.isIdentifier(target)) return;
 			const targetName = target.getText();
 			const mod = imports.default.get(targetName) ?? imports.namespace.get(targetName) ?? imports.bundledNamespace.get(targetName);
 			if (!mod) return;
 			return {
 				mod,
-				importedName: expression.getName()
+				importedName: getName(expression)
 			};
 		}
 	};
 	const isMergePropsCall = (node) => {
 		if (!Node.isCallExpression(node)) return false;
-		const resolved = resolveCallee(node.getExpression());
+		const resolved = resolveCallee(node.expression);
 		if (!resolved) return false;
 		return resolved.importedName === "mergeProps" && (solidMods.has(resolved.mod) || vueMods.has(resolved.mod));
 	};
 	const getCallInfo = (node) => {
-		const resolved = resolveCallee(node.getExpression());
+		const resolved = resolveCallee(node.expression);
 		if (!resolved) return;
-		const args = node.getArguments().map((arg) => unwrapExpression(arg));
+		const args = node.arguments.map((arg) => unwrapExpression(arg));
 		const tagName = getTagName(args[0]);
 		if (!tagName) return;
 		const baseInfo = {
 			tagName,
-			isFactory: tagName.includes(".")
+			isFactory: String(tagName).includes(".")
 		};
-		for (const profile of runtimeProfiles) if (profile.matches(resolved)) return {
+		for (const profile of runtimeProfiles) if (profile.matches({
+			...resolved,
+			importedName: resolved.importedName ?? ""
+		})) return {
 			framework: profile.framework,
 			...baseInfo,
+			tagName: String(baseInfo.tagName),
 			propNodes: profile.getPropNodes(args)
 		};
 	};
@@ -1855,18 +1859,18 @@ const createCompiledJsxContext = (sourceFile) => {
 //#endregion
 //#region src/jsx-attribute.ts
 const extractJsxAttribute = (jsxAttribute, ctx) => {
-	const initializer = jsxAttribute.getInitializer();
+	const initializer = jsxAttribute.initializer;
 	const stack = [jsxAttribute, initializer];
 	if (!initializer) {
-		const nameNode = jsxAttribute.getNameNode();
+		const nameNode = jsxAttribute.name;
 		return box.emptyInitializer(nameNode, stack);
 	}
 	if (Node.isStringLiteral(initializer)) {
-		const literalText = initializer.getLiteralText();
+		const literalText = getLiteralText(initializer);
 		return box.literal(trimWhitespace(literalText), initializer, stack);
 	}
 	if (Node.isJsxExpression(initializer)) {
-		const expr = initializer.getExpression();
+		const expr = initializer.expression;
 		if (!expr) return;
 		const expression = unwrapExpression(expr);
 		if (!expression) return;
@@ -1878,7 +1882,7 @@ const extractJsxAttribute = (jsxAttribute, ctx) => {
 //#endregion
 //#region src/jsx-spread-attribute.ts
 const extractJsxSpreadAttributeValues = (node, ctx, matchProp) => {
-	return maybeBoxNode(unwrapExpression(node.getExpression()), [], ctx, matchProp);
+	return maybeBoxNode(unwrapExpression(node.expression), [], ctx, matchProp);
 };
 //#endregion
 //#region src/object-like-to-map.ts
@@ -1952,7 +1956,7 @@ const extract = ({ ast, ...ctx }) => {
 			return;
 		}
 		if (Node.isCallExpression(expression) && compiledJsx.isMergePropsCall(expression)) {
-			expression.getArguments().forEach((arg) => {
+			expression.arguments.forEach((arg) => {
 				processCompiledPropSource(componentNode, component, boxByProp, arg, matchProp);
 			});
 			return;
@@ -1961,11 +1965,8 @@ const extract = ({ ast, ...ctx }) => {
 		if (!maybeValue) return;
 		processComponentBoxNode(component, boxByProp, expression, maybeValue, matchProp, true);
 	};
-	ast.forEachDescendant((node, traversal) => {
-		if (isImportOrExport(node)) {
-			traversal.skip();
-			return;
-		}
+	forEachDescendant(ast, (node) => {
+		if (isImportOrExport(node)) return SKIP;
 		if (components) {
 			if (Node.isJsxOpeningElement(node) || Node.isJsxSelfClosingElement(node)) {
 				const componentNode = node;
@@ -1979,7 +1980,7 @@ const extract = ({ ast, ...ctx }) => {
 				ensureComponent(componentNode, componentName);
 			}
 			if (Node.isJsxSpreadAttribute(node)) {
-				const componentNode = node.getFirstAncestor(isJsxElement);
+				const componentNode = getFirstAncestor(node, isJsxElement);
 				const component = componentByNode.get(componentNode);
 				if (!componentNode || !component) return;
 				const componentName = getComponentName(componentNode);
@@ -1996,12 +1997,12 @@ const extract = ({ ast, ...ctx }) => {
 				return;
 			}
 			if (Node.isJsxAttribute(node)) {
-				const componentNode = node.getFirstAncestor(isJsxElement);
+				const componentNode = getFirstAncestor(node, isJsxElement);
 				const component = componentByNode.get(componentNode);
 				if (!componentNode || !component) return;
 				const componentName = getComponentName(componentNode);
 				const boxByProp = byName.get(componentName).nodesByProp;
-				const propName = node.getNameNode().getText();
+				const propName = node.name.getText();
 				if (!components.matchProp({
 					tagNode: componentNode,
 					tagName: componentName,
@@ -2035,8 +2036,8 @@ const extract = ({ ast, ...ctx }) => {
 			}
 		}
 		if (functions && Node.isCallExpression(node)) {
-			const expr = node.getExpression();
-			const fnName = Node.isCallExpression(expr) ? expr.getExpression().getText() : expr.getText();
+			const expr = node.expression;
+			const fnName = Node.isCallExpression(expr) ? expr.expression.getText() : expr.getText();
 			if (!functions.matchFn({
 				fnNode: node,
 				fnName
@@ -2100,12 +2101,12 @@ const extract = ({ ast, ...ctx }) => {
 //#region src/jsx-element-props.ts
 const isObjectLike = (node) => box.isObject(node) || box.isMap(node);
 const extractJsxElementProps = (node, ctx) => {
-	const tagName = node.getTagNameNode().getText();
-	const jsxAttributes = node.getAttributes();
+	const tagName = node.tagName.getText();
+	const jsxAttributes = childOf(node, "attributes")?.properties ?? [];
 	const props = /* @__PURE__ */ new Map();
 	jsxAttributes.forEach((attrNode) => {
 		if (Node.isJsxAttribute(attrNode)) {
-			const nameNode = attrNode.getNameNode();
+			const nameNode = attrNode.name;
 			const maybeValue = extractJsxAttribute(attrNode, ctx);
 			if (!maybeValue) return;
 			props.set(nameNode.getText(), maybeValue);