@bamboocss/extractor 1.48.5 → 1.50.0

package/dist/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let _bamboocss_shared = require("@bamboocss/shared");
-let ts_morph = require("ts-morph");
+let _bamboocss_ts_ast = require("@bamboocss/ts-ast");
 let ts_evaluator = require("ts-evaluator");
 //#region src/get-typeof-literal.ts
 const getTypeOfLiteral = (value) => {
@@ -25,15 +25,15 @@ const isPrimitiveType = (value) => {
 	return type === "string" || type === "number" || type === "boolean" || value === null || value === void 0;
 };
 const unwrapExpression = (node) => {
-	if (ts_morph.Node.isAsExpression(node)) return unwrapExpression(node.getExpression());
-	if (ts_morph.Node.isParenthesizedExpression(node)) return unwrapExpression(node.getExpression());
-	if (ts_morph.Node.isNonNullExpression(node)) return unwrapExpression(node.getExpression());
-	if (ts_morph.Node.isTypeAssertion(node)) return unwrapExpression(node.getExpression());
-	if (ts_morph.Node.isSatisfiesExpression(node)) return unwrapExpression(node.getExpression());
+	if (_bamboocss_ts_ast.Node.isAsExpression(node)) return unwrapExpression(node.expression);
+	if (_bamboocss_ts_ast.Node.isParenthesizedExpression(node)) return unwrapExpression(node.expression);
+	if (_bamboocss_ts_ast.Node.isNonNullExpression(node)) return unwrapExpression(node.expression);
+	if (_bamboocss_ts_ast.Node.isTypeAssertion(node)) return unwrapExpression(node.expression);
+	if (_bamboocss_ts_ast.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) => {
@@ -44,8 +44,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 = (0, _bamboocss_ts_ast.getLineAndColumnAtPos)(src, startPosition);
+	const endInfo = (0, _bamboocss_ts_ast.getLineAndColumnAtPos)(src, endPosition);
 	return {
 		startPosition,
 		startLineNumber: startInfo.line,
@@ -78,7 +78,7 @@ var BoxNodeType = class {
 		return {
 			type: this.type,
 			value: this.value,
-			node: this.node.getKindName(),
+			node: (0, _bamboocss_ts_ast.kindNameOf)(this.node.kind),
 			line: range.startLineNumber,
 			column: range.startColumn,
 			endLineNumber: range.endLineNumber,
@@ -446,15 +446,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 (0, _bamboocss_ts_ast.getImportDeclarations)(sourceFile)) {
+		for (const specifier of (0, _bamboocss_ts_ast.getNamedImports)(declaration)) {
+			const local = ((0, _bamboocss_ts_ast.getAliasNode)(specifier) ?? (0, _bamboocss_ts_ast.nameNodeOf)(specifier))?.getText();
+			bindings.set(local ?? "", {
 				declaration,
-				exportedName: specifier.getNameNode().getText()
+				exportedName: (0, _bamboocss_ts_ast.nameNodeOf)(specifier)?.getText() ?? ""
 			});
 		}
-		const defaultImport = declaration.getDefaultImport();
+		const defaultImport = (0, _bamboocss_ts_ast.getDefaultImport)(declaration);
 		if (defaultImport) bindings.set(defaultImport.getText(), {
 			declaration,
 			exportedName: "default"
@@ -466,7 +466,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 ((0, _bamboocss_ts_ast.isInNodeModules)(sourceFile)) return;
 	const declaration = getExportedVarDeclarationWithName(binding.exportedName, sourceFile, stack, ctx);
 	if (!declaration) return;
 	const cached = evaluatedValues.get(declaration);
@@ -474,7 +474,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;
@@ -500,8 +500,8 @@ 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(ts_morph.SyntaxKind.Identifier);
-	if (ts_morph.Node.isIdentifier(node)) references.unshift(node);
+	const references = (0, _bamboocss_ts_ast.getDescendantsOfKind)(node, _bamboocss_ts_ast.SyntaxKind.Identifier);
+	if (_bamboocss_ts_ast.Node.isIdentifier(node)) references.unshift(node);
 	if (!references.length) return;
 	let environment;
 	for (const reference of references) {
@@ -572,8 +572,8 @@ const evaluateNodeUncached = (node, stack, ctx, depth, dependencyEntry) => {
 	let options = {
 		policy: { ...POLICY },
 		...ctx.getEvaluateOptions?.(node, stack),
-		node: node.compilerNode,
-		typescript: ts_morph.ts
+		node,
+		typescript: _bamboocss_ts_ast.ts
 	};
 	let imported = depth > 0 ? importedEnvironmentFor(node, ctx, stack, depth, safeEvaluateNode) : void 0;
 	if (imported) {
@@ -630,22 +630,22 @@ const safeEvaluateNode = (node, stack, ctx, depth = 0) => {
 //#endregion
 //#region src/find-identifier-value-declaration.ts
 function isScope(node) {
-	return ts_morph.Node.isFunctionDeclaration(node) || ts_morph.Node.isFunctionExpression(node) || ts_morph.Node.isArrowFunction(node) || ts_morph.Node.isSourceFile(node);
+	return _bamboocss_ts_ast.Node.isFunctionDeclaration(node) || _bamboocss_ts_ast.Node.isFunctionExpression(node) || _bamboocss_ts_ast.Node.isArrowFunction(node) || _bamboocss_ts_ast.Node.isSourceFile(node);
 }
 function getDeclarationFor(node, stack, ctx) {
-	const parent = node.getParent();
+	const parent = node.parent;
 	if (!parent) return;
 	const declarationStack = [];
 	let declaration;
-	if ((ts_morph.Node.isVariableDeclaration(parent) || ts_morph.Node.isParameterDeclaration(parent) || ts_morph.Node.isFunctionDeclaration(parent) || ts_morph.Node.isEnumDeclaration(parent) || ts_morph.Node.isBindingElement(parent)) && parent.getNameNode() == node) {
+	if ((_bamboocss_ts_ast.Node.isVariableDeclaration(parent) || _bamboocss_ts_ast.Node.isParameterDeclaration(parent) || _bamboocss_ts_ast.Node.isFunctionDeclaration(parent) || _bamboocss_ts_ast.Node.isEnumDeclaration(parent) || _bamboocss_ts_ast.Node.isBindingElement(parent)) && parent.name == node) {
 		declarationStack.push(parent);
 		declaration = parent;
-	} else if (ts_morph.Node.isImportSpecifier(parent) && (parent.getNameNode() == node || parent.getAliasNode() == node)) {
+	} else if (_bamboocss_ts_ast.Node.isImportSpecifier(parent) && ((0, _bamboocss_ts_ast.nameNodeOf)(parent) == node || (0, _bamboocss_ts_ast.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((0, _bamboocss_ts_ast.nameNodeOf)(parent)?.getText() ?? "", sourceFile, exportStack, ctx);
 			if (maybeVar) {
 				declarationStack.push(...exportStack.concat(maybeVar));
 				declaration = maybeVar;
@@ -656,8 +656,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;
 };
 /**
@@ -671,8 +671,8 @@ const getInnermostScope = (from) => {
 */
 const declarationIndexes = /* @__PURE__ */ new WeakMap();
 const isDeclarationName = (node, parent) => {
-	if (ts_morph.Node.isVariableDeclaration(parent) || ts_morph.Node.isParameterDeclaration(parent) || ts_morph.Node.isFunctionDeclaration(parent) || ts_morph.Node.isEnumDeclaration(parent) || ts_morph.Node.isBindingElement(parent)) return parent.getNameNode() == node;
-	return ts_morph.Node.isImportSpecifier(parent) && (parent.getNameNode() == node || parent.getAliasNode() == node);
+	if (_bamboocss_ts_ast.Node.isVariableDeclaration(parent) || _bamboocss_ts_ast.Node.isParameterDeclaration(parent) || _bamboocss_ts_ast.Node.isFunctionDeclaration(parent) || _bamboocss_ts_ast.Node.isEnumDeclaration(parent) || _bamboocss_ts_ast.Node.isBindingElement(parent)) return parent.name == node;
+	return _bamboocss_ts_ast.Node.isImportSpecifier(parent) && ((0, _bamboocss_ts_ast.nameNodeOf)(parent) == node || (0, _bamboocss_ts_ast.getAliasNode)(parent) == node);
 };
 /**
 * Walk a scope once, so that every later lookup inside it is a map read.
@@ -683,19 +683,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) => {
-		if (!ts_morph.Node.isIdentifier(node)) return;
-		const parent = node.getParent();
+	(0, _bamboocss_ts_ast.forEachDescendant)(scope, (node) => {
+		if (!_bamboocss_ts_ast.Node.isIdentifier(node)) return;
+		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,11 +714,11 @@ function findIdentifierValueDeclaration(identifier, stack, ctx, visitedsWithStac
 			const declarationStack = [candidate];
 			const maybeDeclaration = getDeclarationFor(candidate, declarationStack, ctx);
 			if (!maybeDeclaration) continue;
-			if (ts_morph.Node.isParameterDeclaration(maybeDeclaration)) {
-				const initializer = maybeDeclaration.getInitializer();
-				const typeNode = maybeDeclaration.getTypeNode();
+			if (_bamboocss_ts_ast.Node.isParameterDeclaration(maybeDeclaration)) {
+				const initializer = maybeDeclaration.initializer;
+				const typeNode = maybeDeclaration.type;
 				if (initializer) innerStack.push(...declarationStack.concat(initializer));
-				else if (typeNode && ts_morph.Node.isTypeLiteral(typeNode)) innerStack.push(...declarationStack.concat(typeNode));
+				else if (typeNode && _bamboocss_ts_ast.Node.isTypeLiteralNode(typeNode)) innerStack.push(...declarationStack.concat(typeNode));
 				else return;
 				stack.push(...innerStack);
 				return maybeDeclaration;
@@ -727,41 +727,41 @@ function findIdentifierValueDeclaration(identifier, stack, ctx, visitedsWithStac
 			stack.push(...innerStack);
 			return maybeDeclaration;
 		}
-	} while (scope && !ts_morph.Node.isSourceFile(scope) && count < 100);
+	} while (scope && !_bamboocss_ts_ast.Node.isSourceFile(scope) && count < 100);
 }
 //#endregion
 //#region src/get-property-name.ts
 const getPropertyName = (property, stack, ctx) => {
 	if (!property) return;
-	if (ts_morph.Node.isPropertyAssignment(property)) {
-		const node = unwrapExpression(property.getNameNode());
-		if (ts_morph.Node.isIdentifier(node)) return box.from(node.getText(), node, stack);
-		if (ts_morph.Node.isComputedPropertyName(node)) {
-			const expression = node.getExpression();
+	if (_bamboocss_ts_ast.Node.isPropertyAssignment(property)) {
+		const node = unwrapExpression(property.name);
+		if (_bamboocss_ts_ast.Node.isIdentifier(node)) return box.from(node.getText(), node, stack);
+		if (_bamboocss_ts_ast.Node.isComputedPropertyName(node)) {
+			const expression = node.expression;
 			stack.push(expression);
 			return maybePropName(expression, stack, ctx);
 		}
-		if (ts_morph.Node.isStringLiteral(node) || ts_morph.Node.isNumericLiteral(node)) return box.from(node.getLiteralText(), node, stack);
+		if (_bamboocss_ts_ast.Node.isStringLiteral(node) || _bamboocss_ts_ast.Node.isNumericLiteral(node)) return box.from((0, _bamboocss_ts_ast.getLiteralText)(node), node, stack);
 	}
-	if (ts_morph.Node.isShorthandPropertyAssignment(property)) {
-		const name = property.getName();
+	if (_bamboocss_ts_ast.Node.isShorthandPropertyAssignment(property)) {
+		const name = (0, _bamboocss_ts_ast.getName)(property);
 		if (name != null) return box.from(name, property, stack);
 	}
-	if (ts_morph.Node.isGetAccessorDeclaration(property)) {
-		const node = unwrapExpression(property.getNameNode());
-		if (ts_morph.Node.isIdentifier(node)) return box.from(node.getText(), node, stack);
-		if (ts_morph.Node.isComputedPropertyName(node)) {
-			const expression = node.getExpression();
+	if (_bamboocss_ts_ast.Node.isGetAccessorDeclaration(property)) {
+		const node = unwrapExpression(property.name);
+		if (_bamboocss_ts_ast.Node.isIdentifier(node)) return box.from(node.getText(), node, stack);
+		if (_bamboocss_ts_ast.Node.isComputedPropertyName(node)) {
+			const expression = node.expression;
 			stack.push(expression);
 			return maybePropName(expression, stack, ctx);
 		}
-		if (ts_morph.Node.isStringLiteral(node) || ts_morph.Node.isNumericLiteral(node)) return box.from(node.getLiteralText(), node, stack);
+		if (_bamboocss_ts_ast.Node.isStringLiteral(node) || _bamboocss_ts_ast.Node.isNumericLiteral(node)) return box.from((0, _bamboocss_ts_ast.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 = [];
@@ -770,7 +770,7 @@ const getObjectLiteralExpressionPropPairs = (expression, expressionStack, ctx, m
 	properties.forEach((property) => {
 		const stack = [...expressionStack];
 		stack.push(property);
-		if (ts_morph.Node.isPropertyAssignment(property) || ts_morph.Node.isShorthandPropertyAssignment(property) || ts_morph.Node.isGetAccessorDeclaration(property)) {
+		if (_bamboocss_ts_ast.Node.isPropertyAssignment(property) || _bamboocss_ts_ast.Node.isShorthandPropertyAssignment(property) || _bamboocss_ts_ast.Node.isGetAccessorDeclaration(property)) {
 			const propNameBox = getPropertyName(property, stack, ctx);
 			if (!propNameBox) return;
 			const propName = propNameBox.value;
@@ -779,8 +779,8 @@ const getObjectLiteralExpressionPropPairs = (expression, expressionStack, ctx, m
 				propName,
 				propNode: property
 			})) return;
-			if (ts_morph.Node.isShorthandPropertyAssignment(property)) {
-				const initializer = property.getNameNode();
+			if (_bamboocss_ts_ast.Node.isShorthandPropertyAssignment(property)) {
+				const initializer = property.name;
 				stack.push(initializer);
 				const maybeValue = maybeBoxNode(initializer, stack, ctx);
 				if (maybeValue) {
@@ -789,12 +789,12 @@ const getObjectLiteralExpressionPropPairs = (expression, expressionStack, ctx, m
 				}
 			}
 			let init;
-			if (ts_morph.Node.isGetAccessorDeclaration(property)) {
-				const body = property.getBody();
-				init = ts_morph.Node.isBlock(body) ? body.getStatements().at(-1) : void 0;
-			} else init = property.getInitializer();
+			if (_bamboocss_ts_ast.Node.isGetAccessorDeclaration(property)) {
+				const body = property.body;
+				init = body !== void 0 && _bamboocss_ts_ast.Node.isBlock(body) ? body.statements.at(-1) : void 0;
+			} else init = (0, _bamboocss_ts_ast.childOf)(property, "initializer");
 			if (!init) return;
-			const initializer = unwrapExpression((ts_morph.Node.isReturnStatement(init) ? init.getExpression() : void 0) ?? init);
+			const initializer = unwrapExpression((_bamboocss_ts_ast.Node.isReturnStatement(init) ? init.expression : void 0) ?? init);
 			stack.push(initializer);
 			const maybeValue = maybeBoxNode(initializer, stack, ctx);
 			if (maybeValue) {
@@ -802,8 +802,8 @@ const getObjectLiteralExpressionPropPairs = (expression, expressionStack, ctx, m
 				return;
 			}
 		}
-		if (ts_morph.Node.isSpreadAssignment(property)) {
-			const initializer = unwrapExpression(property.getExpression());
+		if (_bamboocss_ts_ast.Node.isSpreadAssignment(property)) {
+			const initializer = unwrapExpression(property.expression);
 			stack.push(initializer);
 			const maybeObject = maybeBoxNode(initializer, stack, ctx, matchProp);
 			if (!maybeObject) return;
@@ -858,11 +858,11 @@ const clearBoxNodeCache = () => {
 	hasCachedEntries = false;
 };
 let hasCachedEntries = false;
-const isPlusSyntax = (op) => op === ts_morph.ts.SyntaxKind.PlusToken;
-const isLogicalSyntax = (op) => op === ts_morph.ts.SyntaxKind.BarBarToken || op === ts_morph.ts.SyntaxKind.QuestionQuestionToken || op === ts_morph.ts.SyntaxKind.AmpersandAmpersandToken || op === ts_morph.ts.SyntaxKind.EqualsEqualsEqualsToken || op === ts_morph.ts.SyntaxKind.EqualsEqualsToken || op === ts_morph.ts.SyntaxKind.ExclamationEqualsEqualsToken || op === ts_morph.ts.SyntaxKind.ExclamationEqualsToken || op === ts_morph.ts.SyntaxKind.GreaterThanEqualsToken || op === ts_morph.ts.SyntaxKind.GreaterThanToken || op === ts_morph.ts.SyntaxKind.LessThanEqualsToken || op === ts_morph.ts.SyntaxKind.LessThanToken || op === ts_morph.ts.SyntaxKind.InstanceOfKeyword || op === ts_morph.ts.SyntaxKind.InKeyword;
-const isOperationSyntax = (op) => op === ts_morph.ts.SyntaxKind.AsteriskToken || op === ts_morph.ts.SyntaxKind.SlashToken || op === ts_morph.ts.SyntaxKind.PercentToken || op === ts_morph.ts.SyntaxKind.AsteriskAsteriskToken || op === ts_morph.ts.SyntaxKind.MinusToken;
+const isPlusSyntax = (op) => op === _bamboocss_ts_ast.ts.SyntaxKind.PlusToken;
+const isLogicalSyntax = (op) => op === _bamboocss_ts_ast.ts.SyntaxKind.BarBarToken || op === _bamboocss_ts_ast.ts.SyntaxKind.QuestionQuestionToken || op === _bamboocss_ts_ast.ts.SyntaxKind.AmpersandAmpersandToken || op === _bamboocss_ts_ast.ts.SyntaxKind.EqualsEqualsEqualsToken || op === _bamboocss_ts_ast.ts.SyntaxKind.EqualsEqualsToken || op === _bamboocss_ts_ast.ts.SyntaxKind.ExclamationEqualsEqualsToken || op === _bamboocss_ts_ast.ts.SyntaxKind.ExclamationEqualsToken || op === _bamboocss_ts_ast.ts.SyntaxKind.GreaterThanEqualsToken || op === _bamboocss_ts_ast.ts.SyntaxKind.GreaterThanToken || op === _bamboocss_ts_ast.ts.SyntaxKind.LessThanEqualsToken || op === _bamboocss_ts_ast.ts.SyntaxKind.LessThanToken || op === _bamboocss_ts_ast.ts.SyntaxKind.InstanceOfKeyword || op === _bamboocss_ts_ast.ts.SyntaxKind.InKeyword;
+const isOperationSyntax = (op) => op === _bamboocss_ts_ast.ts.SyntaxKind.AsteriskToken || op === _bamboocss_ts_ast.ts.SyntaxKind.SlashToken || op === _bamboocss_ts_ast.ts.SyntaxKind.PercentToken || op === _bamboocss_ts_ast.ts.SyntaxKind.AsteriskAsteriskToken || op === _bamboocss_ts_ast.ts.SyntaxKind.MinusToken;
 const canReturnWhenTrueInLogicalExpression = (op) => {
-	return op === ts_morph.ts.SyntaxKind.BarBarToken || op === ts_morph.ts.SyntaxKind.QuestionQuestionToken;
+	return op === _bamboocss_ts_ast.ts.SyntaxKind.BarBarToken || op === _bamboocss_ts_ast.ts.SyntaxKind.QuestionQuestionToken;
 };
 function maybeBoxNode(node, stack, ctx, matchProp) {
 	const cached = getCached(node);
@@ -883,76 +883,76 @@ function maybeBoxNodeUncached(node, stack, ctx, matchProp, dependencyEntry) {
 		hasCachedEntries = true;
 		return value;
 	};
-	if (ts_morph.Node.isStringLiteral(node) || ts_morph.Node.isNoSubstitutionTemplateLiteral(node)) {
-		const value = trimWhitespace(node.getLiteralValue());
+	if (_bamboocss_ts_ast.Node.isStringLiteral(node) || _bamboocss_ts_ast.Node.isNoSubstitutionTemplateLiteral(node)) {
+		const value = trimWhitespace((0, _bamboocss_ts_ast.stringLiteralValue)(node));
 		return cache(box.literal(value, node, stack));
 	}
-	if (ts_morph.Node.isObjectLiteralExpression(node)) return cache(getObjectLiteralExpressionPropPairs(node, stack, ctx, matchProp));
-	if (ts_morph.Node.isTrueLiteral(node) || ts_morph.Node.isFalseLiteral(node)) {
-		const value = node.getLiteralValue();
+	if (_bamboocss_ts_ast.Node.isObjectLiteralExpression(node)) return cache(getObjectLiteralExpressionPropPairs(node, stack, ctx, matchProp));
+	if (_bamboocss_ts_ast.Node.isTrueLiteral(node) || _bamboocss_ts_ast.Node.isFalseLiteral(node)) {
+		const value = (0, _bamboocss_ts_ast.literalValueOf)(node);
 		return cache(box.literal(value, node, stack));
 	}
-	if (ts_morph.Node.isNumericLiteral(node)) {
-		const value = node.getLiteralValue();
+	if (_bamboocss_ts_ast.Node.isNumericLiteral(node)) {
+		const value = (0, _bamboocss_ts_ast.literalValueOf)(node);
 		return cache(box.literal(value, node, stack));
 	}
-	if (ts_morph.Node.isNullLiteral(node)) return cache(box.literal(null, node, stack));
-	if (ts_morph.Node.isPrefixUnaryExpression(node)) {
-		const operand = node.getOperand();
-		const operator = node.getOperatorToken();
+	if (_bamboocss_ts_ast.Node.isNullLiteral(node)) return cache(box.literal(null, node, stack));
+	if (_bamboocss_ts_ast.Node.isPrefixUnaryExpression(node)) {
+		const operand = node.operand;
+		const operator = node.operator;
 		const boxNode = maybeBoxNode(operand, stack, ctx);
 		if (!box.isNumberLiteral(boxNode)) return;
-		return cache(operator === ts_morph.ts.SyntaxKind.MinusToken ? box.literal(-Number(boxNode.value), node, stack) : boxNode);
+		return cache(operator === _bamboocss_ts_ast.ts.SyntaxKind.MinusToken ? box.literal(-Number(boxNode.value), node, stack) : boxNode);
 	}
-	if (ts_morph.Node.isArrayLiteralExpression(node)) {
-		const boxNodes = node.getElements().map((element) => {
+	if (_bamboocss_ts_ast.Node.isArrayLiteralExpression(node)) {
+		const boxNodes = node.elements.map((element) => {
 			return maybeBoxNode(element, stack, ctx) ?? cache(box.unresolvable(element, stack));
 		});
 		return cache(box.array(boxNodes, node, stack));
 	}
-	if (ts_morph.Node.isIdentifier(node)) {
+	if (_bamboocss_ts_ast.Node.isIdentifier(node)) {
 		if (node.getText() === "undefined") return cache(box.literal(void 0, node, stack));
 		return cache(maybeIdentifierValue(node, stack, ctx));
 	}
-	if (ts_morph.Node.isTemplateHead(node)) return cache(box.literal(node.getLiteralText(), node, stack));
-	if (ts_morph.Node.isTemplateExpression(node)) {
+	if (_bamboocss_ts_ast.Node.isTemplateHead(node)) return cache(box.literal((0, _bamboocss_ts_ast.getLiteralText)(node), node, stack));
+	if (_bamboocss_ts_ast.Node.isTemplateExpression(node)) {
 		const value = maybeTemplateStringValue(node, stack, ctx);
 		return cache(box.literal(value, node, stack));
 	}
-	if (ts_morph.Node.isTaggedTemplateExpression(node)) return cache(maybeBoxNode(node.getTemplate(), stack, ctx));
-	if (ts_morph.Node.isElementAccessExpression(node)) return cache(getElementAccessedExpressionValue(node, stack, ctx));
-	if (ts_morph.Node.isPropertyAccessExpression(node)) return cache(getPropertyAccessedExpressionValue(node, [], stack, ctx));
-	if (ts_morph.Node.isConditionalExpression(node)) {
+	if (_bamboocss_ts_ast.Node.isTaggedTemplateExpression(node)) return cache(maybeBoxNode(node.template, stack, ctx));
+	if (_bamboocss_ts_ast.Node.isElementAccessExpression(node)) return cache(getElementAccessedExpressionValue(node, stack, ctx));
+	if (_bamboocss_ts_ast.Node.isPropertyAccessExpression(node)) return cache(getPropertyAccessedExpressionValue(node, [], stack, ctx));
+	if (_bamboocss_ts_ast.Node.isConditionalExpression(node)) {
 		if (ctx.flags?.skipConditions) return cache(box.unresolvable(node, stack));
-		const condExpr = unwrapExpression(node.getCondition());
-		const condBoxNode = (ts_morph.Node.isIdentifier(condExpr) ? maybeBoxNode(condExpr, [], ctx) : safeEvaluateNode(condExpr, stack, ctx)) ?? box.unresolvable(condExpr, stack);
+		const condExpr = unwrapExpression(node.condition);
+		const condBoxNode = (_bamboocss_ts_ast.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) => ts_morph.Node.isBindingElement(node));
+		const isFromDefaultBinding = condValue.getStack().some((node) => _bamboocss_ts_ast.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 (ts_morph.Node.isCallExpression(node)) {
+	if (_bamboocss_ts_ast.Node.isCallExpression(node)) {
 		if (ctx.tokens) {
-			const expr = node.getExpression();
+			const expr = node.expression;
 			let fnName = "";
 			let isValueMethod = false;
-			if (ts_morph.Node.isIdentifier(expr)) fnName = expr.getText();
-			else if (ts_morph.Node.isPropertyAccessExpression(expr)) if (expr.getName() === "value") {
+			if (_bamboocss_ts_ast.Node.isIdentifier(expr)) fnName = expr.getText();
+			else if (_bamboocss_ts_ast.Node.isPropertyAccessExpression(expr)) if ((0, _bamboocss_ts_ast.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,8 +964,8 @@ function maybeBoxNodeUncached(node, stack, ctx, matchProp, dependencyEntry) {
 		if (!value) return;
 		return cache(box.from(value, node, stack));
 	}
-	if (ts_morph.Node.isBinaryExpression(node)) {
-		const operatorKind = node.getOperatorToken().getKind();
+	if (_bamboocss_ts_ast.Node.isBinaryExpression(node)) {
+		const operatorKind = node.operatorToken.kind;
 		if (isPlusSyntax(operatorKind)) {
 			const value = tryComputingPlusTokenBinaryExpressionToString(node, stack, ctx) ?? safeEvaluateNode(node, stack, ctx);
 			if (!value) return;
@@ -973,8 +973,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)
@@ -991,7 +991,7 @@ function maybeBoxNodeUncached(node, stack, ctx, matchProp, dependencyEntry) {
 * Returning `undefined` leaves the call unresolved, exactly as before.
 */
 function literalStringOf(node, stack, ctx) {
-	if (ts_morph.Node.isStringLiteral(node)) return node.getLiteralValue();
+	if (_bamboocss_ts_ast.Node.isStringLiteral(node)) return (0, _bamboocss_ts_ast.stringLiteralValue)(node);
 	const resolved = onlyStringLiteral(maybeBoxNode(node, stack, ctx));
 	return resolved && typeof resolved.value === "string" ? resolved.value : void 0;
 }
@@ -1015,7 +1015,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 (ts_morph.Node.isBinaryExpression(node) && node.getOperatorToken().getKind() === ts_morph.ts.SyntaxKind.AmpersandAmpersandToken && whenTrueValue && whenFalseValue && box.isLiteral(whenTrueValue) && whenTrueValue.value === true) return whenFalseValue;
+	if (_bamboocss_ts_ast.Node.isBinaryExpression(node) && node.operatorToken.kind === _bamboocss_ts_ast.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,18 +1026,18 @@ const maybeResolveConditionalExpression = ({ whenTrueExpr, whenFalseExpr, node,
 };
 const findProperty = (node, propName, _stack, ctx) => {
 	const stack = [..._stack];
-	if (ts_morph.Node.isPropertyAssignment(node)) {
-		const name = node.getNameNode();
-		if (ts_morph.Node.isIdentifier(name) && name.getText() === propName) {
+	if (_bamboocss_ts_ast.Node.isPropertyAssignment(node)) {
+		const name = node.name;
+		if (_bamboocss_ts_ast.Node.isIdentifier(name) && name.getText() === propName) {
 			stack.push(name);
 			return node;
 		}
-		if (ts_morph.Node.isStringLiteral(name) && name.getLiteralText() === propName) {
+		if (_bamboocss_ts_ast.Node.isStringLiteral(name) && (0, _bamboocss_ts_ast.getLiteralText)(name) === propName) {
 			stack.push(name);
-			return name.getLiteralText();
+			return (0, _bamboocss_ts_ast.getLiteralText)(name);
 		}
-		if (ts_morph.Node.isComputedPropertyName(name)) {
-			const expression = unwrapExpression(name.getExpression());
+		if (_bamboocss_ts_ast.Node.isComputedPropertyName(name)) {
+			const expression = unwrapExpression(name.expression);
 			const computedPropNameBox = maybePropName(expression, stack, ctx);
 			if (!computedPropNameBox) return;
 			if (String(computedPropNameBox.value) === propName) {
@@ -1046,9 +1046,9 @@ const findProperty = (node, propName, _stack, ctx) => {
 			}
 		}
 	}
-	if (ts_morph.Node.isShorthandPropertyAssignment(node)) {
-		const name = node.getNameNode();
-		if (ts_morph.Node.isIdentifier(name) && name.getText() === propName) {
+	if (_bamboocss_ts_ast.Node.isShorthandPropertyAssignment(node)) {
+		const name = node.name;
+		if (_bamboocss_ts_ast.Node.isIdentifier(name) && name.getText() === propName) {
 			stack.push(name);
 			return node;
 		}
@@ -1057,53 +1057,54 @@ 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 = (0, _bamboocss_ts_ast.getProperty)(initializer, propName) ?? initializer.properties.find((p) => findProperty(p, propName, stack, ctx));
 	if (!property) return;
 	stack.push(property);
-	if (ts_morph.Node.isPropertyAssignment(property)) {
-		const propInit = property.getInitializer();
+	if (_bamboocss_ts_ast.Node.isPropertyAssignment(property)) {
+		const propInit = property.initializer;
 		if (!propInit) return;
-		if (ts_morph.Node.isObjectLiteralExpression(propInit)) {
+		if (_bamboocss_ts_ast.Node.isObjectLiteralExpression(propInit)) {
 			if (accessList.length > 0) return getObjectLiteralPropValue(propInit, accessList, stack, ctx);
 			return maybeBoxNode(propInit, stack, ctx);
 		}
 		const maybePropValue = maybeBoxNode(propInit, stack, ctx);
 		if (maybePropValue) return maybePropValue;
 	}
-	if (ts_morph.Node.isShorthandPropertyAssignment(property)) {
-		const identifier = property.getNameNode();
+	if (_bamboocss_ts_ast.Node.isShorthandPropertyAssignment(property)) {
+		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 + (0, _bamboocss_ts_ast.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 (ts_morph.Node.isArrayBindingPattern(parent)) {
-		const index = parent.getChildIndex();
+	if (_bamboocss_ts_ast.Node.isArrayBindingPattern(parent)) {
+		const index = (0, _bamboocss_ts_ast.getChildIndex)(parent);
 		if (Number.isNaN(index)) return;
-		if (ts_morph.Node.isVariableDeclaration(grandParent)) {
-			const init = grandParent.getInitializer();
+		if (_bamboocss_ts_ast.Node.isVariableDeclaration(grandParent)) {
+			const init = grandParent.initializer;
 			if (!init) return;
 			const initializer = unwrapExpression(init);
-			if (!ts_morph.Node.isArrayLiteralExpression(initializer)) return;
-			const element = initializer.getElements()[index + 1];
+			if (!_bamboocss_ts_ast.Node.isArrayLiteralExpression(initializer)) return;
+			const element = initializer.elements[index + 1];
 			if (!element) return;
 			const innerStack = [
 				...stack,
@@ -1122,27 +1123,27 @@ const maybeBindingElementValue = (def, stack, propName, ctx) => {
 			return propValue;
 		}
 	}
-	if (ts_morph.Node.isObjectBindingPattern(parent)) {}
+	if (_bamboocss_ts_ast.Node.isObjectBindingPattern(parent)) {}
 };
 function maybePropDefinitionValue(def, accessList, _stack, ctx) {
 	const propName = accessList.at(-1);
-	if (ts_morph.Node.isVariableDeclaration(def)) {
-		const init = def.getInitializer();
+	if (_bamboocss_ts_ast.Node.isVariableDeclaration(def)) {
+		const init = def.initializer;
 		if (!init) {
-			const type = def.getTypeNode();
+			const type = def.type;
 			if (!type) return;
-			if (ts_morph.Node.isTypeLiteral(type)) {
+			if (_bamboocss_ts_ast.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 && ts_morph.Node.isTypeLiteral(typeLiteral)) {
+					let typeProp = (0, _bamboocss_ts_ast.getProperty)(type, propName);
+					let typeLiteral = typeProp && (0, _bamboocss_ts_ast.childOf)(typeProp, "type");
+					while (typeProp && accessList.length > 0 && typeLiteral && _bamboocss_ts_ast.Node.isTypeLiteralNode(typeLiteral)) {
 						stack.push(typeProp, typeLiteral);
 						propName = accessList.pop();
-						typeProp = typeLiteral.getProperty(propName);
-						typeLiteral = typeProp?.getTypeNode();
+						typeProp = (0, _bamboocss_ts_ast.getProperty)(typeLiteral, propName);
+						typeLiteral = typeProp && (0, _bamboocss_ts_ast.childOf)(typeProp, "type");
 					}
 					if (!typeLiteral) return;
 					const typeValue = getTypeNodeValue(typeLiteral, stack, ctx);
@@ -1155,16 +1156,16 @@ function maybePropDefinitionValue(def, accessList, _stack, ctx) {
 			return;
 		}
 		const initializer = unwrapExpression(init);
-		if (ts_morph.Node.isObjectLiteralExpression(initializer)) {
+		if (_bamboocss_ts_ast.Node.isObjectLiteralExpression(initializer)) {
 			const propValue = getObjectLiteralPropValue(initializer, accessList, _stack, ctx);
 			if (!propValue) return;
 			_stack.push(initializer);
 			return propValue;
 		}
-		if (ts_morph.Node.isArrayLiteralExpression(initializer)) {
+		if (_bamboocss_ts_ast.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);
@@ -1173,14 +1174,14 @@ function maybePropDefinitionValue(def, accessList, _stack, ctx) {
 		const maybeValue = maybeBoxNode(initializer, [..._stack, initializer], ctx);
 		if (maybeValue) return maybeValue;
 	}
-	if (ts_morph.Node.isBindingElement(def)) {
+	if (_bamboocss_ts_ast.Node.isBindingElement(def)) {
 		const value = maybeBindingElementValue(def, _stack, propName, ctx);
 		if (value) return value;
 	}
-	if (ts_morph.Node.isEnumDeclaration(def)) {
-		const member = def.getMember(propName);
+	if (_bamboocss_ts_ast.Node.isEnumDeclaration(def)) {
+		const member = (0, _bamboocss_ts_ast.getMember)(def, propName);
 		if (!member) return;
-		const initializer = member.getInitializer();
+		const initializer = (0, _bamboocss_ts_ast.childOf)(member, "initializer");
 		if (!initializer) return;
 		const maybeValue = maybeBoxNode(initializer, [..._stack, initializer], ctx);
 		if (maybeValue) return maybeValue;
@@ -1200,9 +1201,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) => ts_morph.Node.isPropertySignature(member) && member.getName() === propName);
-	if (ts_morph.Node.isPropertySignature(prop) && prop.isReadonly()) {
-		const propType = prop.getTypeNode();
+	const prop = type.members.find((member) => _bamboocss_ts_ast.Node.isPropertySignatureDeclaration(member) && (0, _bamboocss_ts_ast.getName)(member) === propName);
+	if (prop !== void 0 && _bamboocss_ts_ast.Node.isPropertySignatureDeclaration(prop) && (0, _bamboocss_ts_ast.isReadonly)(prop)) {
+		const propType = prop.type;
 		if (!propType) {
 			typeLiteralCache.set(type, null);
 			return;
@@ -1217,29 +1218,28 @@ const getTypeLiteralNodePropValue = (type, propName, stack, ctx) => {
 	typeLiteralCache.set(type, null);
 };
 function getNameLiteral(wrapper) {
-	if (ts_morph.Node.isStringLiteral(wrapper)) return wrapper.getLiteralText();
+	if (_bamboocss_ts_ast.Node.isStringLiteral(wrapper)) return (0, _bamboocss_ts_ast.getLiteralText)(wrapper);
 	return wrapper.getText();
 }
 const typeNodeCache = /* @__PURE__ */ new WeakMap();
 const getTypeNodeValue = (type, stack, ctx) => {
 	if (typeNodeCache.has(type)) return typeNodeCache.get(type);
-	if (ts_morph.Node.isLiteralTypeNode(type)) {
-		const literal = type.getLiteral();
-		if (ts_morph.Node.isStringLiteral(literal)) {
-			const result = literal.getLiteralText();
+	if (_bamboocss_ts_ast.Node.isLiteralTypeNode(type)) {
+		const literal = type.literal;
+		if (_bamboocss_ts_ast.Node.isStringLiteral(literal)) {
+			const result = (0, _bamboocss_ts_ast.getLiteralText)(literal);
 			typeNodeCache.set(type, result);
 			return result;
 		}
 	}
-	if (ts_morph.Node.isTypeLiteral(type)) {
-		const members = type.getMembers();
-		if (!members.some((member) => !ts_morph.Node.isPropertySignature(member) || !member.isReadonly())) {
+	if (_bamboocss_ts_ast.Node.isTypeLiteralNode(type)) {
+		const members = type.members;
+		if (!members.some((member) => !_bamboocss_ts_ast.Node.isPropertySignatureDeclaration(member) || !(0, _bamboocss_ts_ast.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,16 +1249,16 @@ const getTypeNodeValue = (type, stack, ctx) => {
 	typeNodeCache.set(type, void 0);
 };
 const maybeDefinitionValue = (def, stack, ctx) => {
-	if (ts_morph.Node.isShorthandPropertyAssignment(def)) {
-		const propNameNode = def.getNameNode();
+	if (_bamboocss_ts_ast.Node.isShorthandPropertyAssignment(def)) {
+		const propNameNode = def.name;
 		return maybePropIdentifierValue(propNameNode, [propNameNode.getText()], stack, ctx);
 	}
-	if (ts_morph.Node.isVariableDeclaration(def)) {
-		const init = def.getInitializer();
+	if (_bamboocss_ts_ast.Node.isVariableDeclaration(def)) {
+		const init = def.initializer;
 		if (!init) {
-			const type = def.getTypeNode();
+			const type = def.type;
 			if (!type) return;
-			if (ts_morph.Node.isTypeLiteral(type)) {
+			if (_bamboocss_ts_ast.Node.isTypeLiteralNode(type)) {
 				stack.push(type);
 				const maybeTypeValue = getTypeNodeValue(type, stack, ctx);
 				if (isNotNullish(maybeTypeValue)) return box.from(maybeTypeValue, def, stack);
@@ -1269,12 +1269,12 @@ const maybeDefinitionValue = (def, stack, ctx) => {
 		const maybeValue = maybeBoxNode(initializer, [...stack, initializer], ctx);
 		if (maybeValue) return maybeValue;
 	}
-	if (ts_morph.Node.isBindingElement(def)) {
-		const init = def.getInitializer();
+	if (_bamboocss_ts_ast.Node.isBindingElement(def)) {
+		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);
 		}
@@ -1284,11 +1284,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?.((0, _bamboocss_ts_ast.pathOf)(sourceFile), varName);
+	const key = `${(0, _bamboocss_ts_ast.pathOf)(sourceFile)}:${varName}`;
 	if (visited.has(key)) return;
 	visited.add(key);
-	const maybeVar = sourceFile.getVariableDeclaration(varName);
+	const maybeVar = (0, _bamboocss_ts_ast.getVariableDeclaration)(sourceFile, varName);
 	if (maybeVar) return maybeVar;
 	const exportDeclaration = resolveVarDeclarationFromExportWithName(varName, sourceFile, stack, ctx, visited);
 	if (!exportDeclaration) return;
@@ -1304,9 +1304,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 = (0, _bamboocss_ts_ast.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 ((((0, _bamboocss_ts_ast.getAliasNode)(namedExport) ?? (0, _bamboocss_ts_ast.nameNodeOf)(namedExport))?.getText() ?? "") === name) return (0, _bamboocss_ts_ast.nameNodeOf)(namedExport)?.getText();
 };
 /**
 * Faster than declaration.getModuleSpecifierSourceFile()
@@ -1318,20 +1318,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 = (0, _bamboocss_ts_ast.getModuleSpecifierValue)(declaration);
 	if (!moduleName) return;
 	const sourceFile = ctx.resolveModule?.(moduleName, declaration.getSourceFile());
-	if (sourceFile) recordModuleDependency(ctx, sourceFile.getFilePath());
+	if (sourceFile) recordModuleDependency(ctx, (0, _bamboocss_ts_ast.pathOf)(sourceFile));
 	return sourceFile;
 };
 function resolveVarDeclarationFromExportWithName(symbolName, sourceFile, stack, ctx, visited) {
-	for (const exportDeclaration of sourceFile.getExportDeclarations()) {
+	for (const exportDeclaration of (0, _bamboocss_ts_ast.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 = (0, _bamboocss_ts_ast.getVariableDeclaration)(sourceFile, sourceName);
 			if (localVar) {
 				stack.push(...exportStack.concat(localVar));
 				return localVar;
@@ -1356,16 +1356,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 = [
@@ -1374,28 +1374,28 @@ const getElementAccessedExpressionValue = (expression, _stack, ctx) => {
 		arg
 	];
 	const argLiteral = maybePropName(arg, stack, ctx);
-	if (ts_morph.Node.isIdentifier(elementAccessed) && argLiteral) {
+	if (_bamboocss_ts_ast.Node.isIdentifier(elementAccessed) && argLiteral) {
 		if (!isNotNullish(argLiteral.value)) return;
 		return maybePropIdentifierValue(elementAccessed, [argLiteral.value.toString()], stack, ctx);
 	}
-	if (ts_morph.Node.isBinaryExpression(arg)) {
-		if (arg.getOperatorToken().getKind() !== ts_morph.ts.SyntaxKind.PlusToken) return;
+	if (_bamboocss_ts_ast.Node.isBinaryExpression(arg)) {
+		if (arg.operatorToken.kind !== _bamboocss_ts_ast.ts.SyntaxKind.PlusToken) return;
 		const propName = tryComputingPlusTokenBinaryExpressionToString(arg, stack, ctx) ?? maybePropName(arg, stack, ctx);
-		if (propName && ts_morph.Node.isIdentifier(elementAccessed)) {
+		if (propName && _bamboocss_ts_ast.Node.isIdentifier(elementAccessed)) {
 			if (!isNotNullish(propName.value)) return;
 			return maybePropIdentifierValue(elementAccessed, [propName.value.toString()], stack, ctx);
 		}
 	}
-	if (ts_morph.Node.isTemplateExpression(arg)) {
+	if (_bamboocss_ts_ast.Node.isTemplateExpression(arg)) {
 		const propName = maybeTemplateStringValue(arg, stack, ctx);
-		if (propName && ts_morph.Node.isIdentifier(elementAccessed)) return maybePropIdentifierValue(elementAccessed, [propName], stack, ctx);
+		if (propName && _bamboocss_ts_ast.Node.isIdentifier(elementAccessed)) return maybePropIdentifierValue(elementAccessed, [propName], stack, ctx);
 	}
-	if (ts_morph.Node.isObjectLiteralExpression(elementAccessed) && argLiteral) {
+	if (_bamboocss_ts_ast.Node.isObjectLiteralExpression(elementAccessed) && argLiteral) {
 		if (!isNotNullish(argLiteral.value)) return;
 		return getObjectLiteralPropValue(elementAccessed, [argLiteral.value.toString()], stack, ctx);
 	}
-	if (ts_morph.Node.isPropertyAccessExpression(arg)) return getPropertyAccessedExpressionValue(arg, [], stack, ctx);
-	if (ts_morph.Node.isPropertyAccessExpression(elementAccessed) && argLiteral && isNotNullish(argLiteral.value)) {
+	if (_bamboocss_ts_ast.Node.isPropertyAccessExpression(arg)) return getPropertyAccessedExpressionValue(arg, [], stack, ctx);
+	if (_bamboocss_ts_ast.Node.isPropertyAccessExpression(elementAccessed) && argLiteral && isNotNullish(argLiteral.value)) {
 		const propRefValue = getPropertyAccessedExpressionValue(elementAccessed, [], stack, ctx);
 		if (!propRefValue) return box.unresolvable(elementAccessed, stack);
 		const propName = argLiteral.value.toString();
@@ -1413,11 +1413,11 @@ const getElementAccessedExpressionValue = (expression, _stack, ctx) => {
 		}
 		return box.unresolvable(elementAccessed, stack);
 	}
-	if (ts_morph.Node.isIdentifier(elementAccessed) && ts_morph.Node.isElementAccessExpression(arg)) {
+	if (_bamboocss_ts_ast.Node.isIdentifier(elementAccessed) && _bamboocss_ts_ast.Node.isElementAccessExpression(arg)) {
 		const propName = getElementAccessedExpressionValue(arg, stack, ctx);
 		if (typeof propName === "string" && isNotNullish(propName)) return maybePropIdentifierValue(elementAccessed, [propName], stack, ctx);
 	}
-	if (ts_morph.Node.isElementAccessExpression(elementAccessed) && argLiteral && isNotNullish(argLiteral.value)) {
+	if (_bamboocss_ts_ast.Node.isElementAccessExpression(elementAccessed) && argLiteral && isNotNullish(argLiteral.value)) {
 		const identifier = getElementAccessedExpressionValue(elementAccessed, stack, ctx);
 		if (isObject(identifier)) {
 			const argValue = argLiteral.value.toString();
@@ -1429,18 +1429,18 @@ const getElementAccessedExpressionValue = (expression, _stack, ctx) => {
 			}
 		}
 	}
-	if (ts_morph.Node.isArrayLiteralExpression(elementAccessed) && argLiteral) return getArrayElementValueAtIndex(elementAccessed, Number(argLiteral.value), stack, ctx);
-	if (ts_morph.Node.isConditionalExpression(arg)) {
+	if (_bamboocss_ts_ast.Node.isArrayLiteralExpression(elementAccessed) && argLiteral) return getArrayElementValueAtIndex(elementAccessed, Number(argLiteral.value), stack, ctx);
+	if (_bamboocss_ts_ast.Node.isConditionalExpression(arg)) {
 		if (ctx.flags?.skipConditions) return box.unresolvable(arg, stack);
 		const propName = maybePropName(arg, stack, ctx);
 		if (isNotNullish(propName) && isNotNullish(propName.value)) {
-			if (ts_morph.Node.isIdentifier(elementAccessed)) return maybePropIdentifierValue(elementAccessed, [propName.value.toString()], stack, ctx);
+			if (_bamboocss_ts_ast.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 (ts_morph.Node.isIdentifier(elementAccessed)) {
+		if (_bamboocss_ts_ast.Node.isIdentifier(elementAccessed)) {
 			const whenTrueResolved = whenTrueValue && isNotNullish(whenTrueValue.value) ? maybePropIdentifierValue(elementAccessed, [whenTrueValue.value.toString()], stack, ctx) : void 0;
 			const whenFalseResolved = whenFalseValue && isNotNullish(whenFalseValue.value) ? maybePropIdentifierValue(elementAccessed, [whenFalseValue.value.toString()], stack, ctx) : void 0;
 			if (!whenTrueResolved && !whenFalseResolved) return;
@@ -1451,27 +1451,27 @@ 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 = (0, _bamboocss_ts_ast.getName)(expression);
+	const elementAccessed = unwrapExpression(expression.expression);
+	const accessList = _accessList.concat(String(propName));
 	stack.push(elementAccessed);
-	if (ts_morph.Node.isIdentifier(elementAccessed)) return maybePropIdentifierValue(elementAccessed, accessList, stack, ctx);
-	if (ts_morph.Node.isPropertyAccessExpression(elementAccessed)) return getPropertyAccessedExpressionValue(elementAccessed, accessList, stack, ctx);
-	if (ts_morph.Node.isElementAccessExpression(elementAccessed)) {
+	if (_bamboocss_ts_ast.Node.isIdentifier(elementAccessed)) return maybePropIdentifierValue(elementAccessed, accessList, stack, ctx);
+	if (_bamboocss_ts_ast.Node.isPropertyAccessExpression(elementAccessed)) return getPropertyAccessedExpressionValue(elementAccessed, accessList, stack, ctx);
+	if (_bamboocss_ts_ast.Node.isElementAccessExpression(elementAccessed)) {
 		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);
 		}
 	}
@@ -1480,8 +1480,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,9 +1578,9 @@ const collectImports = (sourceFile) => {
 	const resolveBundledNamespaceMod = (node) => {
 		if (!node) return;
 		const expression = unwrapExpression(node);
-		if (ts_morph.Node.isCallExpression(expression)) {
-			const callee = unwrapExpression(expression.getExpression());
-			if (!ts_morph.Node.isIdentifier(callee)) return;
+		if (_bamboocss_ts_ast.Node.isCallExpression(expression)) {
+			const callee = unwrapExpression(expression.expression);
+			if (!_bamboocss_ts_ast.Node.isIdentifier(callee)) return;
 			const calleeName = callee.getText();
 			if (/requirejsxdevruntime/i.test(calleeName)) return "react/jsx-dev-runtime";
 			if (/requirejsxruntime/i.test(calleeName)) return "react/jsx-runtime";
@@ -1588,70 +1588,70 @@ const collectImports = (sourceFile) => {
 		}
 	};
 	const bundledCandidates = mayHoldBundledOutput(sourceFile.getFullText());
-	(bundledCandidates ? sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.CallExpression) : []).forEach((callExpression) => {
-		const callee = unwrapExpression(callExpression.getExpression());
-		if (!ts_morph.Node.isIdentifier(callee) || callee.getText() !== "parcelRegister") return;
-		const [idArg, factoryArg] = callExpression.getArguments();
-		if (!ts_morph.Node.isStringLiteral(idArg)) return;
-		if (!ts_morph.Node.isArrowFunction(factoryArg) && !ts_morph.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");
+	(bundledCandidates ? (0, _bamboocss_ts_ast.getDescendantsOfKind)(sourceFile, _bamboocss_ts_ast.SyntaxKind.CallExpression) : []).forEach((callExpression) => {
+		const callee = unwrapExpression((0, _bamboocss_ts_ast.childOf)(callExpression, "expression"));
+		if (!_bamboocss_ts_ast.Node.isIdentifier(callee) || callee.getText() !== "parcelRegister") return;
+		const [idArg, factoryArg] = (0, _bamboocss_ts_ast.childOf)(callExpression, "arguments") ?? [];
+		if (!_bamboocss_ts_ast.Node.isStringLiteral(idArg)) return;
+		if (!_bamboocss_ts_ast.Node.isArrowFunction(factoryArg) && !_bamboocss_ts_ast.Node.isFunctionExpression(factoryArg)) return;
+		const factoryText = factoryArg.body.getText();
+		if (factoryText.includes("\"Fragment\"") && factoryText.includes("\"jsx\"") && factoryText.includes("\"jsxs\"") && factoryText.includes("module.exports")) parcelRuntimeModuleIds.set((0, _bamboocss_ts_ast.stringLiteralValue)(idArg), "react/jsx-runtime");
 	});
-	sourceFile.getImportDeclarations().forEach((declaration) => {
-		const mod = declaration.getModuleSpecifierValue();
+	(0, _bamboocss_ts_ast.getImportDeclarations)(sourceFile).forEach((declaration) => {
+		const mod = (0, _bamboocss_ts_ast.getModuleSpecifierValue)(declaration);
 		if (!mod) return;
-		const defaultImport = declaration.getDefaultImport();
+		const defaultImport = (0, _bamboocss_ts_ast.getDefaultImport)(declaration);
 		if (defaultImport) defaultImports.set(defaultImport.getText(), mod);
-		const namespaceImport = declaration.getNamespaceImport();
+		const namespaceImport = (0, _bamboocss_ts_ast.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,
+		(0, _bamboocss_ts_ast.getNamedImports)(declaration).forEach((specifier) => {
+			const importedName = (0, _bamboocss_ts_ast.nameNodeOf)(specifier)?.getText();
+			const alias = (0, _bamboocss_ts_ast.getAliasNode)(specifier)?.getText() || importedName;
+			named.set(alias ?? "", {
+				importedName: importedName ?? "",
 				mod
 			});
 		});
 	});
-	sourceFile.getVariableDeclarations().forEach((declaration) => {
-		if (!ts_morph.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);
-		if (!mod && initializer && ts_morph.Node.isCallExpression(initializer)) {
-			const callee = unwrapExpression(initializer.getExpression());
-			const [firstArg] = initializer.getArguments();
-			if (ts_morph.Node.isIdentifier(callee) && callee.getText() === "parcelRequire" && ts_morph.Node.isStringLiteral(firstArg)) mod = parcelRuntimeModuleIds.get(firstArg.getLiteralValue());
+	(0, _bamboocss_ts_ast.getVariableDeclarations)(sourceFile).forEach((declaration) => {
+		if (!_bamboocss_ts_ast.Node.isIdentifier((0, _bamboocss_ts_ast.nameNodeOf)(declaration))) return;
+		const variableName = (0, _bamboocss_ts_ast.getName)(declaration);
+		const initializer = (0, _bamboocss_ts_ast.childOf)(declaration, "initializer");
+		const bundledImport = resolveBundledHelperImport(variableName ?? "", initializer);
+		if (bundledImport) bundledNamed.set(variableName ?? "", bundledImport);
+		let mod = getBundledRuntimeModFromName(variableName ?? "") ?? resolveBundledNamespaceMod(initializer);
+		if (!mod && initializer && _bamboocss_ts_ast.Node.isCallExpression(initializer)) {
+			const callee = unwrapExpression(initializer.expression);
+			const [firstArg] = initializer.arguments;
+			if (_bamboocss_ts_ast.Node.isIdentifier(callee) && callee.getText() === "parcelRequire" && _bamboocss_ts_ast.Node.isStringLiteral(firstArg)) mod = parcelRuntimeModuleIds.get((0, _bamboocss_ts_ast.stringLiteralValue)(firstArg));
 		}
-		if (!mod && initializer && ts_morph.Node.isObjectLiteralExpression(initializer)) {
-			const propertyNames = new Set(initializer.getProperties().map((property) => {
-				if (ts_morph.Node.isPropertyAssignment(property)) return property.getName();
+		if (!mod && initializer && _bamboocss_ts_ast.Node.isObjectLiteralExpression(initializer)) {
+			const propertyNames = new Set(initializer.properties.map((property) => {
+				if (_bamboocss_ts_ast.Node.isPropertyAssignment(property)) return (0, _bamboocss_ts_ast.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(ts_morph.SyntaxKind.FunctionDeclaration) : []).forEach((declaration) => {
-		const bundledImport = resolveBundledHelperImport(declaration.getName() ?? "", declaration);
-		if (!bundledImport || !declaration.getName()) return;
-		bundledNamed.set(declaration.getName(), bundledImport);
+	(bundledCandidates ? (0, _bamboocss_ts_ast.getDescendantsOfKind)(sourceFile, _bamboocss_ts_ast.SyntaxKind.FunctionDeclaration) : []).forEach((declaration) => {
+		const bundledImport = resolveBundledHelperImport((0, _bamboocss_ts_ast.getName)(declaration) ?? "", declaration);
+		if (!bundledImport || !(0, _bamboocss_ts_ast.getName)(declaration)) return;
+		bundledNamed.set((0, _bamboocss_ts_ast.getName)(declaration), bundledImport);
 	});
 	const resolveBundledAliasImport = (node) => {
 		if (!node) return;
 		const expression = unwrapExpression(node);
-		if (ts_morph.Node.isIdentifier(expression)) return bundledNamed.get(expression.getText());
-		if (ts_morph.Node.isConditionalExpression(expression)) return resolveBundledAliasImport(expression.getWhenTrue()) ?? resolveBundledAliasImport(expression.getWhenFalse());
-		if (ts_morph.Node.isBinaryExpression(expression) && expression.getOperatorToken().getKind() === ts_morph.SyntaxKind.CommaToken) return resolveBundledAliasImport(expression.getRight());
+		if (_bamboocss_ts_ast.Node.isIdentifier(expression)) return bundledNamed.get(expression.getText());
+		if (_bamboocss_ts_ast.Node.isConditionalExpression(expression)) return resolveBundledAliasImport(expression.whenTrue) ?? resolveBundledAliasImport(expression.whenFalse);
+		if (_bamboocss_ts_ast.Node.isBinaryExpression(expression) && expression.operatorToken.kind === _bamboocss_ts_ast.SyntaxKind.CommaToken) return resolveBundledAliasImport(expression.right);
 	};
-	sourceFile.getVariableDeclarations().forEach((declaration) => {
-		if (!ts_morph.Node.isIdentifier(declaration.getNameNode())) return;
-		if (bundledNamed.has(declaration.getName())) return;
-		const bundledAlias = resolveBundledAliasImport(declaration.getInitializer());
+	(0, _bamboocss_ts_ast.getVariableDeclarations)(sourceFile).forEach((declaration) => {
+		if (!_bamboocss_ts_ast.Node.isIdentifier((0, _bamboocss_ts_ast.nameNodeOf)(declaration))) return;
+		if (bundledNamed.has((0, _bamboocss_ts_ast.getName)(declaration) ?? "")) return;
+		const bundledAlias = resolveBundledAliasImport((0, _bamboocss_ts_ast.childOf)(declaration, "initializer"));
 		if (!bundledAlias) return;
-		bundledNamed.set(declaration.getName(), bundledAlias);
+		bundledNamed.set((0, _bamboocss_ts_ast.getName)(declaration) ?? "", bundledAlias);
 	});
 	return {
 		named,
@@ -1669,8 +1669,8 @@ const normalizeTagName = (text) => {
 const getTagName = (node) => {
 	if (!node) return;
 	const expression = unwrapExpression(node);
-	if (ts_morph.Node.isStringLiteral(expression) || ts_morph.Node.isNoSubstitutionTemplateLiteral(expression)) return expression.getLiteralValue();
-	if (ts_morph.Node.isIdentifier(expression) || ts_morph.Node.isPropertyAccessExpression(expression) || ts_morph.Node.isElementAccessExpression(expression)) return normalizeTagName(expression.getText());
+	if (_bamboocss_ts_ast.Node.isStringLiteral(expression) || _bamboocss_ts_ast.Node.isNoSubstitutionTemplateLiteral(expression)) return (0, _bamboocss_ts_ast.literalValueOf)(expression);
+	if (_bamboocss_ts_ast.Node.isIdentifier(expression) || _bamboocss_ts_ast.Node.isPropertyAccessExpression(expression) || _bamboocss_ts_ast.Node.isElementAccessExpression(expression)) return normalizeTagName(expression.getText());
 };
 const isQwikMod = (mod) => mod.includes("qwik");
 const getArgsAt = (...indices) => (args) => indices.map((index) => args[index]).filter(Boolean);
@@ -1749,11 +1749,11 @@ const runtimeProfiles = [
 */
 const findLocalDeclaration = (identifier) => {
 	const name = identifier.getText();
-	for (let scope = identifier.getParent(); scope; scope = scope.getParent()) {
-		if (!ts_morph.Node.isStatemented(scope)) continue;
-		const variable = scope.getVariableDeclaration(name);
+	for (let scope = identifier.parent; scope; scope = scope.parent) {
+		if (!_bamboocss_ts_ast.Node.isStatement(scope)) continue;
+		const variable = (0, _bamboocss_ts_ast.getVariableDeclaration)(scope, name);
 		if (variable) return variable;
-		const fn = scope.getFunction(name);
+		const fn = ((0, _bamboocss_ts_ast.childOf)(scope, "statements") ?? []).find((statement) => _bamboocss_ts_ast.is.isFunctionDeclaration(statement) && (0, _bamboocss_ts_ast.getName)(statement) === name);
 		if (fn) return fn;
 	}
 };
@@ -1761,7 +1761,7 @@ const createCompiledJsxContext = (sourceFile) => {
 	const imports = collectImports(sourceFile);
 	const normalizeCallee = (node) => {
 		const expression = unwrapExpression(node);
-		if (ts_morph.Node.isBinaryExpression(expression) && expression.getOperatorToken().getKind() === ts_morph.SyntaxKind.CommaToken) return normalizeCallee(expression.getRight());
+		if (_bamboocss_ts_ast.Node.isBinaryExpression(expression) && expression.operatorToken.kind === _bamboocss_ts_ast.SyntaxKind.CommaToken) return normalizeCallee(expression.right);
 		return expression;
 	};
 	const localDefinitionCache = /* @__PURE__ */ new Map();
@@ -1772,7 +1772,7 @@ const createCompiledJsxContext = (sourceFile) => {
 		const resolveLocalAlias = (aliasNode) => {
 			if (!aliasNode) return;
 			const expression = unwrapExpression(aliasNode);
-			if (ts_morph.Node.isIdentifier(expression)) {
+			if (_bamboocss_ts_ast.Node.isIdentifier(expression)) {
 				const imported = imports.bundledNamed.get(expression.getText());
 				if (imported) return {
 					mod: imported.mod,
@@ -1780,13 +1780,13 @@ const createCompiledJsxContext = (sourceFile) => {
 				};
 				return resolveIdentifierDefinition(expression);
 			}
-			if (ts_morph.Node.isConditionalExpression(expression)) return resolveLocalAlias(expression.getWhenTrue()) ?? resolveLocalAlias(expression.getWhenFalse());
-			if (ts_morph.Node.isBinaryExpression(expression) && expression.getOperatorToken().getKind() === ts_morph.SyntaxKind.CommaToken) return resolveLocalAlias(expression.getRight());
+			if (_bamboocss_ts_ast.Node.isConditionalExpression(expression)) return resolveLocalAlias(expression.whenTrue) ?? resolveLocalAlias(expression.whenFalse);
+			if (_bamboocss_ts_ast.Node.isBinaryExpression(expression) && expression.operatorToken.kind === _bamboocss_ts_ast.SyntaxKind.CommaToken) return resolveLocalAlias(expression.right);
 		};
 		const declaration = findLocalDeclaration(identifier);
 		if (!declaration) return;
-		if (ts_morph.Node.isFunctionDeclaration(declaration)) {
-			const imported = resolveBundledHelperImport(declaration.getName() ?? name, declaration);
+		if (_bamboocss_ts_ast.Node.isFunctionDeclaration(declaration)) {
+			const imported = resolveBundledHelperImport((0, _bamboocss_ts_ast.getName)(declaration) ?? name, declaration);
 			if (!imported) return;
 			const resolved = {
 				mod: imported.mod,
@@ -1795,18 +1795,18 @@ const createCompiledJsxContext = (sourceFile) => {
 			localDefinitionCache.set(name, resolved);
 			return resolved;
 		}
-		const directImport = resolveBundledHelperImport(declaration.getName(), declaration.getInitializer());
+		const directImport = resolveBundledHelperImport((0, _bamboocss_ts_ast.getName)(declaration) ?? "", (0, _bamboocss_ts_ast.childOf)(declaration, "initializer"));
 		const aliasImport = directImport ? {
 			mod: directImport.mod,
 			importedName: directImport.importedName
-		} : resolveLocalAlias(declaration.getInitializer());
+		} : resolveLocalAlias((0, _bamboocss_ts_ast.childOf)(declaration, "initializer"));
 		if (!aliasImport) return;
 		localDefinitionCache.set(name, aliasImport);
 		return aliasImport;
 	};
 	const resolveCallee = (node) => {
 		const expression = normalizeCallee(node);
-		if (ts_morph.Node.isIdentifier(expression)) {
+		if (_bamboocss_ts_ast.Node.isIdentifier(expression)) {
 			const imported = imports.named.get(expression.getText()) ?? imports.bundledNamed.get(expression.getText());
 			if (imported) return {
 				mod: imported.mod,
@@ -1814,37 +1814,41 @@ const createCompiledJsxContext = (sourceFile) => {
 			};
 			return resolveIdentifierDefinition(expression);
 		}
-		if (ts_morph.Node.isPropertyAccessExpression(expression)) {
-			const target = normalizeCallee(expression.getExpression());
-			if (!ts_morph.Node.isIdentifier(target)) return;
+		if (_bamboocss_ts_ast.Node.isPropertyAccessExpression(expression)) {
+			const target = normalizeCallee(expression.expression);
+			if (!_bamboocss_ts_ast.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: (0, _bamboocss_ts_ast.getName)(expression)
 			};
 		}
 	};
 	const isMergePropsCall = (node) => {
-		if (!ts_morph.Node.isCallExpression(node)) return false;
-		const resolved = resolveCallee(node.getExpression());
+		if (!_bamboocss_ts_ast.Node.isCallExpression(node)) return false;
+		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)
 		};
 	};
@@ -1856,18 +1860,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 (ts_morph.Node.isStringLiteral(initializer)) {
-		const literalText = initializer.getLiteralText();
+	if (_bamboocss_ts_ast.Node.isStringLiteral(initializer)) {
+		const literalText = (0, _bamboocss_ts_ast.getLiteralText)(initializer);
 		return box.literal(trimWhitespace(literalText), initializer, stack);
 	}
-	if (ts_morph.Node.isJsxExpression(initializer)) {
-		const expr = initializer.getExpression();
+	if (_bamboocss_ts_ast.Node.isJsxExpression(initializer)) {
+		const expr = initializer.expression;
 		if (!expr) return;
 		const expression = unwrapExpression(expr);
 		if (!expression) return;
@@ -1879,7 +1883,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
@@ -1894,8 +1898,8 @@ const objectLikeToMap = (maybeObject, node) => {
 };
 //#endregion
 //#region src/extract.ts
-const isImportOrExport = (node) => ts_morph.Node.isImportDeclaration(node) || ts_morph.Node.isExportDeclaration(node);
-const isJsxElement = (node) => ts_morph.Node.isJsxOpeningElement(node) || ts_morph.Node.isJsxSelfClosingElement(node);
+const isImportOrExport = (node) => _bamboocss_ts_ast.Node.isImportDeclaration(node) || _bamboocss_ts_ast.Node.isExportDeclaration(node);
+const isJsxElement = (node) => _bamboocss_ts_ast.Node.isJsxOpeningElement(node) || _bamboocss_ts_ast.Node.isJsxSelfClosingElement(node);
 const extract = ({ ast, ...ctx }) => {
 	const { components, functions } = ctx;
 	const compiledJsx = createCompiledJsxContext(ast);
@@ -1948,12 +1952,12 @@ const extract = ({ ast, ...ctx }) => {
 	const processCompiledPropSource = (componentNode, component, boxByProp, propNode, matchProp) => {
 		const expression = unwrapExpression(propNode);
 		const stack = [componentNode, expression];
-		if (ts_morph.Node.isObjectLiteralExpression(expression)) {
+		if (_bamboocss_ts_ast.Node.isObjectLiteralExpression(expression)) {
 			processComponentBoxNode(component, boxByProp, expression, getObjectLiteralExpressionPropPairs(expression, stack, ctx, matchProp), matchProp, true);
 			return;
 		}
-		if (ts_morph.Node.isCallExpression(expression) && compiledJsx.isMergePropsCall(expression)) {
-			expression.getArguments().forEach((arg) => {
+		if (_bamboocss_ts_ast.Node.isCallExpression(expression) && compiledJsx.isMergePropsCall(expression)) {
+			expression.arguments.forEach((arg) => {
 				processCompiledPropSource(componentNode, component, boxByProp, arg, matchProp);
 			});
 			return;
@@ -1962,13 +1966,10 @@ const extract = ({ ast, ...ctx }) => {
 		if (!maybeValue) return;
 		processComponentBoxNode(component, boxByProp, expression, maybeValue, matchProp, true);
 	};
-	ast.forEachDescendant((node, traversal) => {
-		if (isImportOrExport(node)) {
-			traversal.skip();
-			return;
-		}
+	(0, _bamboocss_ts_ast.forEachDescendant)(ast, (node) => {
+		if (isImportOrExport(node)) return _bamboocss_ts_ast.SKIP;
 		if (components) {
-			if (ts_morph.Node.isJsxOpeningElement(node) || ts_morph.Node.isJsxSelfClosingElement(node)) {
+			if (_bamboocss_ts_ast.Node.isJsxOpeningElement(node) || _bamboocss_ts_ast.Node.isJsxSelfClosingElement(node)) {
 				const componentNode = node;
 				const componentName = getComponentName(componentNode);
 				const isFactory = componentName.includes(".");
@@ -1979,8 +1980,8 @@ const extract = ({ ast, ...ctx }) => {
 				})) return;
 				ensureComponent(componentNode, componentName);
 			}
-			if (ts_morph.Node.isJsxSpreadAttribute(node)) {
-				const componentNode = node.getFirstAncestor(isJsxElement);
+			if (_bamboocss_ts_ast.Node.isJsxSpreadAttribute(node)) {
+				const componentNode = (0, _bamboocss_ts_ast.getFirstAncestor)(node, isJsxElement);
 				const component = componentByNode.get(componentNode);
 				if (!componentNode || !component) return;
 				const componentName = getComponentName(componentNode);
@@ -1996,13 +1997,13 @@ const extract = ({ ast, ...ctx }) => {
 				processComponentBoxNode(component, boxByProp, node, spreadNode, matchProp);
 				return;
 			}
-			if (ts_morph.Node.isJsxAttribute(node)) {
-				const componentNode = node.getFirstAncestor(isJsxElement);
+			if (_bamboocss_ts_ast.Node.isJsxAttribute(node)) {
+				const componentNode = (0, _bamboocss_ts_ast.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,
@@ -2013,7 +2014,7 @@ const extract = ({ ast, ...ctx }) => {
 				if (!maybeBox) return;
 				addComponentProp(component, boxByProp, propName, maybeBox);
 			}
-			if (ts_morph.Node.isCallExpression(node)) {
+			if (_bamboocss_ts_ast.Node.isCallExpression(node)) {
 				const compiledCall = compiledJsx.getCallInfo(node);
 				if (compiledCall) {
 					const { tagName, isFactory, propNodes } = compiledCall;
@@ -2035,9 +2036,9 @@ const extract = ({ ast, ...ctx }) => {
 				}
 			}
 		}
-		if (functions && ts_morph.Node.isCallExpression(node)) {
-			const expr = node.getExpression();
-			const fnName = ts_morph.Node.isCallExpression(expr) ? expr.getExpression().getText() : expr.getText();
+		if (functions && _bamboocss_ts_ast.Node.isCallExpression(node)) {
+			const expr = node.expression;
+			const fnName = _bamboocss_ts_ast.Node.isCallExpression(expr) ? expr.expression.getText() : expr.getText();
 			if (!functions.matchFn({
 				fnNode: node,
 				fnName
@@ -2083,7 +2084,7 @@ const extract = ({ ast, ...ctx }) => {
 	componentByNode.forEach((parentRef, componentNode) => {
 		const component = componentByNode.get(componentNode);
 		if (!component) return;
-		if (ts_morph.Node.isCallExpression(componentNode) && component.props.size === 0 && component.conditionals.length === 0) return;
+		if (_bamboocss_ts_ast.Node.isCallExpression(componentNode) && component.props.size === 0 && component.conditionals.length === 0) return;
 		const query = {
 			name: parentRef.name,
 			box: box.map(component.props, componentNode, [])
@@ -2101,18 +2102,18 @@ 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 = (0, _bamboocss_ts_ast.childOf)(node, "attributes")?.properties ?? [];
 	const props = /* @__PURE__ */ new Map();
 	jsxAttributes.forEach((attrNode) => {
-		if (ts_morph.Node.isJsxAttribute(attrNode)) {
-			const nameNode = attrNode.getNameNode();
+		if (_bamboocss_ts_ast.Node.isJsxAttribute(attrNode)) {
+			const nameNode = attrNode.name;
 			const maybeValue = extractJsxAttribute(attrNode, ctx);
 			if (!maybeValue) return;
 			props.set(nameNode.getText(), maybeValue);
 			return;
 		}
-		if (ts_morph.Node.isJsxSpreadAttribute(attrNode)) {
+		if (_bamboocss_ts_ast.Node.isJsxSpreadAttribute(attrNode)) {
 			const maybeValue = extractJsxSpreadAttributeValues(attrNode, ctx, () => true);
 			if (!isObjectLike(maybeValue)) return;
 			if (box.isMap(maybeValue)) maybeValue.value.forEach((value, propName) => {
@@ -2160,7 +2161,7 @@ const getLiteralValue = (node, ctx) => {
 		}));
 		const last = node.getStack().at(-1);
 		const maybeIndex = Number(path[path.length - 1]);
-		if (last && ts_morph.Node.isArrayLiteralExpression(last) && !Number.isNaN(maybeIndex)) {
+		if (last && _bamboocss_ts_ast.Node.isArrayLiteralExpression(last) && !Number.isNaN(maybeIndex)) {
 			const sliced = path.slice(0, -1);
 			if (whenTrue) ctx.conditions.push(makeObjAt(sliced, makeArrayWithValueAt(maybeIndex, whenTrue)));
 			if (whenFalse) ctx.conditions.push(makeObjAt(sliced, makeArrayWithValueAt(maybeIndex, whenFalse)));