@bamboocss/vite 1.48.5 → 1.50.0

package/dist/fold-module.cjs

@@ -6,7 +6,7 @@ let magic_string = require("magic-string");
 magic_string = require_chunk.__toESM(magic_string);
 let _bamboocss_config_ts_path = require("@bamboocss/config/ts-path");
 let _bamboocss_extractor = require("@bamboocss/extractor");
-let ts_morph = require("ts-morph");
+let _bamboocss_ts_ast = require("@bamboocss/ts-ast");
 //#region src/fold-analysis.ts
 /**
 * Nodes that *compose* a value out of their children rather than computing one.
@@ -21,7 +21,7 @@ let ts_morph = require("ts-morph");
 * own literal argument is syntactically inside a default, so an unbounded walk calls it one.
 * That is correct code, and rejecting it fails the build.
 */
-const composesValue = (node) => ts_morph.Node.isObjectLiteralExpression(node) || ts_morph.Node.isArrayLiteralExpression(node) || ts_morph.Node.isPropertyAssignment(node) || ts_morph.Node.isShorthandPropertyAssignment(node) || ts_morph.Node.isSpreadAssignment(node) || ts_morph.Node.isSpreadElement(node) || ts_morph.Node.isAsExpression(node) || ts_morph.Node.isParenthesizedExpression(node) || ts_morph.Node.isNonNullExpression(node) || ts_morph.Node.isTypeAssertion(node) || ts_morph.Node.isSatisfiesExpression(node);
+const composesValue = (node) => _bamboocss_ts_ast.Node.isObjectLiteralExpression(node) || _bamboocss_ts_ast.Node.isArrayLiteralExpression(node) || _bamboocss_ts_ast.Node.isPropertyAssignment(node) || _bamboocss_ts_ast.Node.isShorthandPropertyAssignment(node) || _bamboocss_ts_ast.Node.isSpreadAssignment(node) || _bamboocss_ts_ast.Node.isSpreadElement(node) || _bamboocss_ts_ast.Node.isAsExpression(node) || _bamboocss_ts_ast.Node.isParenthesizedExpression(node) || _bamboocss_ts_ast.Node.isNonNullExpression(node) || _bamboocss_ts_ast.Node.isTypeAssertion(node) || _bamboocss_ts_ast.Node.isSatisfiesExpression(node);
 /** Is `inner` written within `outer`? Positions rather than a walk, so it is O(1). */
 const contains = (outer, inner) => outer.getSourceFile() === inner.getSourceFile() && outer.getStart() <= inner.getStart() && inner.getEnd() <= outer.getEnd();
 /**
@@ -42,12 +42,12 @@ const contains = (outer, inner) => outer.getSourceFile() === inner.getSourceFile
 * `{ tone = X }`'s name node is not mistaken for its default.
 */
 const isBindingElementDefault = (node) => {
-	if (node && ts_morph.Node.isCallExpression(node)) return false;
+	if (node && _bamboocss_ts_ast.Node.isCallExpression(node)) return false;
 	let current = node;
 	while (current) {
-		const parent = current.getParent();
+		const parent = current.parent;
 		if (!parent) return false;
-		if (ts_morph.Node.isBindingElement(parent)) return parent.getInitializer() === current;
+		if (_bamboocss_ts_ast.Node.isBindingElement(parent)) return parent.initializer === current;
 		if (!composesValue(parent)) return false;
 		current = parent;
 	}
@@ -74,7 +74,7 @@ const isFromBindingDefault = (node) => {
 	const own = node.getNode?.();
 	if (isBindingElementDefault(own)) return true;
 	for (const entry of node.getStack?.() ?? []) {
-		if (!ts_morph.Node.isBindingElement(entry) || !entry.getInitializer()) continue;
+		if (!_bamboocss_ts_ast.Node.isBindingElement(entry) || !entry.initializer) continue;
 		if (own && contains(entry, own)) continue;
 		return true;
 	}
@@ -97,7 +97,7 @@ const isStaticBox = (node, seen = /* @__PURE__ */ new Set()) => {
 	if (isFromBindingDefault(node)) return false;
 	if (_bamboocss_extractor.box.isLiteral(node) && node.value === void 0) {
 		const source = node.getNode?.();
-		return Boolean(source && ts_morph.Node.isIdentifier(source) && source.getText() === "undefined");
+		return Boolean(source && _bamboocss_ts_ast.Node.isIdentifier(source) && source.getText() === "undefined");
 	}
 	if (_bamboocss_extractor.box.isMap(node)) {
 		for (const child of node.value.values()) if (!isStaticBox(child, seen)) return false;
@@ -117,7 +117,7 @@ const isStaticBox = (node, seen = /* @__PURE__ */ new Set()) => {
 * surface. Recognising fewer wrappers than it does is not a cosmetic difference: an
 * unrecognised one leaves an object literal wrapped, and the object checks below skip it.
 */
-const unwrapExpression = (node) => ts_morph.Node.isAsExpression(node) || ts_morph.Node.isParenthesizedExpression(node) || ts_morph.Node.isNonNullExpression(node) || ts_morph.Node.isTypeAssertion(node) || ts_morph.Node.isSatisfiesExpression(node) ? unwrapExpression(node.getExpression()) : node;
+const unwrapExpression = (node) => _bamboocss_ts_ast.Node.isAsExpression(node) || _bamboocss_ts_ast.Node.isParenthesizedExpression(node) || _bamboocss_ts_ast.Node.isNonNullExpression(node) || _bamboocss_ts_ast.Node.isTypeAssertion(node) || _bamboocss_ts_ast.Node.isSatisfiesExpression(node) ? unwrapExpression(node.expression) : node;
 /**
 * Mirrors the parser's evaluator environment, so re-boxing an operand here gets the same
 * answer the extraction did. Left to its default, ts-evaluator presets to `NODE` and
@@ -137,7 +137,7 @@ const rebox = (node) => (0, _bamboocss_extractor.maybeBoxNode)(unwrapExpression(
 const resolvesExactly = (node) => {
 	const inner = unwrapExpression(node);
 	if (!rebox(inner)) return false;
-	return ts_morph.Node.isConditionalExpression(inner) || isCollapsedBinary(inner) ? decidedAtBuildTime(inner) : true;
+	return _bamboocss_ts_ast.Node.isConditionalExpression(inner) || isCollapsedBinary(inner) ? decidedAtBuildTime(inner) : true;
 };
 /**
 * Is this operand's value written here, rather than named?
@@ -150,7 +150,7 @@ const resolvesExactly = (node) => {
 */
 const isWrittenHere = (node) => {
 	const inner = unwrapExpression(node);
-	return ts_morph.Node.isStringLiteral(inner) || ts_morph.Node.isNumericLiteral(inner) || ts_morph.Node.isNoSubstitutionTemplateLiteral(inner) || ts_morph.Node.isObjectLiteralExpression(inner) || ts_morph.Node.isArrayLiteralExpression(inner) || ts_morph.Node.isTrueLiteral(inner) || ts_morph.Node.isFalseLiteral(inner) || inner.getKind() === ts_morph.SyntaxKind.NullKeyword || ts_morph.Node.isPrefixUnaryExpression(inner) && ts_morph.Node.isNumericLiteral(inner.getOperand());
+	return _bamboocss_ts_ast.Node.isStringLiteral(inner) || _bamboocss_ts_ast.Node.isNumericLiteral(inner) || _bamboocss_ts_ast.Node.isNoSubstitutionTemplateLiteral(inner) || _bamboocss_ts_ast.Node.isObjectLiteralExpression(inner) || _bamboocss_ts_ast.Node.isArrayLiteralExpression(inner) || _bamboocss_ts_ast.Node.isTrueLiteral(inner) || _bamboocss_ts_ast.Node.isFalseLiteral(inner) || inner.kind === _bamboocss_ts_ast.SyntaxKind.NullKeyword || _bamboocss_ts_ast.Node.isPrefixUnaryExpression(inner) && _bamboocss_ts_ast.Node.isNumericLiteral(inner.operand);
 };
 /** An inline value's truthiness, which its box carries directly. */
 const isTruthy = (boxNode) => _bamboocss_extractor.box.isLiteral(boxNode) ? Boolean(boxNode.value) : _bamboocss_extractor.box.isMap(boxNode) || _bamboocss_extractor.box.isArray(boxNode) || _bamboocss_extractor.box.isObject(boxNode);
@@ -168,20 +168,20 @@ const isTruthy = (boxNode) => _bamboocss_extractor.box.isLiteral(boxNode) ? Bool
 * be established is that the left is the side that wins.
 */
 const decidedAtBuildTime = (node) => {
-	if (ts_morph.Node.isConditionalExpression(node)) return resolvesExactly(node.getWhenTrue()) && resolvesExactly(node.getWhenFalse());
-	const operator = node.getOperatorToken().getKind();
+	if (_bamboocss_ts_ast.Node.isConditionalExpression(node)) return resolvesExactly(node.whenTrue) && resolvesExactly(node.whenFalse);
+	const operator = node.operatorToken.kind;
 	if (!SHORT_CIRCUIT.includes(operator)) return false;
-	if (!isWrittenHere(node.getLeft())) return false;
-	const left = rebox(node.getLeft());
+	if (!isWrittenHere(node.left)) return false;
+	const left = rebox(node.left);
 	if (!left) return false;
-	if (operator === ts_morph.SyntaxKind.BarBarToken) return isTruthy(left);
-	if (operator === ts_morph.SyntaxKind.QuestionQuestionToken) return !_bamboocss_extractor.box.isLiteral(left) || left.value != null;
-	return isTruthy(left) ? resolvesExactly(node.getRight()) : true;
+	if (operator === _bamboocss_ts_ast.SyntaxKind.BarBarToken) return isTruthy(left);
+	if (operator === _bamboocss_ts_ast.SyntaxKind.QuestionQuestionToken) return !_bamboocss_extractor.box.isLiteral(left) || left.value != null;
+	return isTruthy(left) ? resolvesExactly(node.right) : true;
 };
 const SHORT_CIRCUIT = [
-	ts_morph.SyntaxKind.AmpersandAmpersandToken,
-	ts_morph.SyntaxKind.BarBarToken,
-	ts_morph.SyntaxKind.QuestionQuestionToken
+	_bamboocss_ts_ast.SyntaxKind.AmpersandAmpersandToken,
+	_bamboocss_ts_ast.SyntaxKind.BarBarToken,
+	_bamboocss_ts_ast.SyntaxKind.QuestionQuestionToken
 ];
 /**
 * Every binary form the extractor collapses to one operand — the short-circuits plus the
@@ -193,18 +193,18 @@ const SHORT_CIRCUIT = [
 */
 const COLLAPSED_BINARY = new Set([
 	...SHORT_CIRCUIT,
-	ts_morph.SyntaxKind.EqualsEqualsToken,
-	ts_morph.SyntaxKind.EqualsEqualsEqualsToken,
-	ts_morph.SyntaxKind.ExclamationEqualsToken,
-	ts_morph.SyntaxKind.ExclamationEqualsEqualsToken,
-	ts_morph.SyntaxKind.GreaterThanToken,
-	ts_morph.SyntaxKind.GreaterThanEqualsToken,
-	ts_morph.SyntaxKind.LessThanToken,
-	ts_morph.SyntaxKind.LessThanEqualsToken,
-	ts_morph.SyntaxKind.InKeyword,
-	ts_morph.SyntaxKind.InstanceOfKeyword
+	_bamboocss_ts_ast.SyntaxKind.EqualsEqualsToken,
+	_bamboocss_ts_ast.SyntaxKind.EqualsEqualsEqualsToken,
+	_bamboocss_ts_ast.SyntaxKind.ExclamationEqualsToken,
+	_bamboocss_ts_ast.SyntaxKind.ExclamationEqualsEqualsToken,
+	_bamboocss_ts_ast.SyntaxKind.GreaterThanToken,
+	_bamboocss_ts_ast.SyntaxKind.GreaterThanEqualsToken,
+	_bamboocss_ts_ast.SyntaxKind.LessThanToken,
+	_bamboocss_ts_ast.SyntaxKind.LessThanEqualsToken,
+	_bamboocss_ts_ast.SyntaxKind.InKeyword,
+	_bamboocss_ts_ast.SyntaxKind.InstanceOfKeyword
 ]);
-const isCollapsedBinary = (node) => ts_morph.Node.isBinaryExpression(node) && COLLAPSED_BINARY.has(node.getOperatorToken().getKind());
+const isCollapsedBinary = (node) => _bamboocss_ts_ast.Node.isBinaryExpression(node) && COLLAPSED_BINARY.has(node.operatorToken.kind);
 /**
 * Does the extracted box account for every property the source declares?
 *
@@ -231,38 +231,38 @@ const isCollapsedBinary = (node) => ts_morph.Node.isBinaryExpression(node) && CO
 * expression — reading an initializer that is not there reports the property as having no
 * source, and everything hidden behind the name goes unchecked.
 */
-const valueOf = (property) => ts_morph.Node.isPropertyAssignment(property) ? property.getInitializer() : ts_morph.Node.isShorthandPropertyAssignment(property) ? property.getNameNode() : void 0;
+const valueOf = (property) => _bamboocss_ts_ast.Node.isPropertyAssignment(property) ? property.initializer : _bamboocss_ts_ast.Node.isShorthandPropertyAssignment(property) ? property.name : void 0;
 const accountsForSource = (node, boxNode) => {
 	if (!node) return true;
 	const unwrapped = unwrapExpression(node);
-	if ((ts_morph.Node.isConditionalExpression(unwrapped) || isCollapsedBinary(unwrapped)) && !_bamboocss_extractor.box.isConditional(boxNode) && !decidedAtBuildTime(unwrapped)) return false;
-	if (ts_morph.Node.isArrayLiteralExpression(unwrapped)) {
+	if ((_bamboocss_ts_ast.Node.isConditionalExpression(unwrapped) || isCollapsedBinary(unwrapped)) && !_bamboocss_extractor.box.isConditional(boxNode) && !decidedAtBuildTime(unwrapped)) return false;
+	if (_bamboocss_ts_ast.Node.isArrayLiteralExpression(unwrapped)) {
 		if (!_bamboocss_extractor.box.isArray(boxNode)) return false;
-		const elements = unwrapped.getElements();
+		const elements = unwrapped.elements;
 		if (elements.length !== boxNode.value.length) return false;
 		return elements.every((element, index) => accountsForSource(element, boxNode.value[index]));
 	}
-	if (!ts_morph.Node.isObjectLiteralExpression(unwrapped)) {
+	if (!_bamboocss_ts_ast.Node.isObjectLiteralExpression(unwrapped)) {
 		const origin = _bamboocss_extractor.box.isMap(boxNode) ? boxNode.getNode() : void 0;
-		return !origin || origin === unwrapped || !ts_morph.Node.isObjectLiteralExpression(origin) ? true : accountsForSource(origin, boxNode);
+		return !origin || origin === unwrapped || !_bamboocss_ts_ast.Node.isObjectLiteralExpression(origin) ? true : accountsForSource(origin, boxNode);
 	}
 	if (!_bamboocss_extractor.box.isMap(boxNode)) return false;
-	for (const property of unwrapped.getProperties()) {
-		if (ts_morph.Node.isSpreadAssignment(property)) {
-			const expression = unwrapExpression(property.getExpression());
-			if (ts_morph.Node.isObjectLiteralExpression(expression)) continue;
+	for (const property of unwrapped.properties) {
+		if (_bamboocss_ts_ast.Node.isSpreadAssignment(property)) {
+			const expression = unwrapExpression(property.expression);
+			if (_bamboocss_ts_ast.Node.isObjectLiteralExpression(expression)) continue;
 			const walked = boxNode.resolvedSpreads?.find((entry) => entry.node === expression);
 			if (!walked) return false;
 			if (!accountsForSource(walked.box.getNode(), walked.box)) return false;
 			continue;
 		}
-		if (ts_morph.Node.isMethodDeclaration(property) || ts_morph.Node.isGetAccessorDeclaration(property) || ts_morph.Node.isSetAccessorDeclaration(property)) return false;
-		if (!ts_morph.Node.isPropertyAssignment(property) && !ts_morph.Node.isShorthandPropertyAssignment(property)) return false;
-		const nameNode = property.getNameNode();
-		if (ts_morph.Node.isComputedPropertyName(nameNode)) return false;
-		const key = ts_morph.Node.isStringLiteral(nameNode) || ts_morph.Node.isNumericLiteral(nameNode) ? String(nameNode.getLiteralValue()) : nameNode.getText();
+		if (_bamboocss_ts_ast.Node.isMethodDeclaration(property) || _bamboocss_ts_ast.Node.isGetAccessorDeclaration(property) || _bamboocss_ts_ast.Node.isSetAccessorDeclaration(property)) return false;
+		if (!_bamboocss_ts_ast.Node.isPropertyAssignment(property) && !_bamboocss_ts_ast.Node.isShorthandPropertyAssignment(property)) return false;
+		const nameNode = property.name;
+		if (_bamboocss_ts_ast.Node.isComputedPropertyName(nameNode)) return false;
+		const key = _bamboocss_ts_ast.Node.isStringLiteral(nameNode) || _bamboocss_ts_ast.Node.isNumericLiteral(nameNode) ? String((0, _bamboocss_ts_ast.literalValueOf)(nameNode)) : nameNode.getText();
 		const value = valueOf(property);
-		if (value && ts_morph.Node.isIdentifier(value) && value.getText() === "undefined") continue;
+		if (value && _bamboocss_ts_ast.Node.isIdentifier(value) && value.getText() === "undefined") continue;
 		if (!boxNode.value.has(key)) return false;
 		if (!accountsForSource(value, boxNode.value.get(key))) return false;
 	}
@@ -310,20 +310,20 @@ const collectModuleScopeNames = (sourceFile) => {
 	const names = /* @__PURE__ */ new Set();
 	const addBinding = (node) => {
 		if (!node) return;
-		if (ts_morph.Node.isObjectBindingPattern(node) || ts_morph.Node.isArrayBindingPattern(node)) {
-			for (const element of node.getElements()) if (ts_morph.Node.isBindingElement(element)) addBinding(element.getNameNode());
+		if (_bamboocss_ts_ast.Node.isObjectBindingPattern(node) || _bamboocss_ts_ast.Node.isArrayBindingPattern(node)) {
+			for (const element of node.elements) if (_bamboocss_ts_ast.Node.isBindingElement(element)) addBinding(element.name);
 			return;
 		}
-		if (ts_morph.Node.isIdentifier(node)) names.add(node.getText());
+		if (_bamboocss_ts_ast.Node.isIdentifier(node)) names.add(node.getText());
 	};
 	const addDeclarations = (list) => {
-		if (ts_morph.Node.isVariableStatement(list)) {
-			for (const declaration of list.getDeclarations()) addBinding(declaration.getNameNode());
+		if (_bamboocss_ts_ast.Node.isVariableStatement(list)) {
+			for (const declaration of list.declarationList.declarations) addBinding(declaration.name);
 			return;
 		}
-		if (ts_morph.Node.isVariableDeclarationList(list)) for (const declaration of list.getDeclarations()) addBinding(declaration.getNameNode());
+		if (_bamboocss_ts_ast.Node.isVariableDeclarationList(list)) for (const declaration of list.declarations) addBinding(declaration.name);
 	};
-	const isVar = (node) => (ts_morph.Node.isVariableStatement(node) || ts_morph.Node.isVariableDeclarationList(node)) && node.getDeclarationKind() === ts_morph.VariableDeclarationKind.Var;
+	const isVar = (node) => (_bamboocss_ts_ast.Node.isVariableStatement(node) || _bamboocss_ts_ast.Node.isVariableDeclarationList(node)) && ((0, _bamboocss_ts_ast.childOf)(node, "declarationList")?.flags ?? 0) === 0;
 	/**
 	* `var` is scoped to the enclosing *function*, not the enclosing block, so one written
 	* inside any statement at the top level still binds at module scope. Walking only the
@@ -337,62 +337,62 @@ const collectModuleScopeNames = (sourceFile) => {
 			addDeclarations(node);
 			return;
 		}
-		if (ts_morph.Node.isBlock(node)) {
-			for (const statement of node.getStatements()) addHoistedVars(statement);
+		if (_bamboocss_ts_ast.Node.isBlock(node)) {
+			for (const statement of node.statements) addHoistedVars(statement);
 			return;
 		}
-		if (ts_morph.Node.isIfStatement(node)) {
-			addHoistedVars(node.getThenStatement());
-			const otherwise = node.getElseStatement();
+		if (_bamboocss_ts_ast.Node.isIfStatement(node)) {
+			addHoistedVars(node.thenStatement);
+			const otherwise = node.elseStatement;
 			if (otherwise) addHoistedVars(otherwise);
 			return;
 		}
-		if (ts_morph.Node.isForStatement(node)) {
-			const initializer = node.getInitializer();
+		if (_bamboocss_ts_ast.Node.isForStatement(node)) {
+			const initializer = node.initializer;
 			if (initializer) addHoistedVars(initializer);
-			addHoistedVars(node.getStatement());
+			addHoistedVars(node.statement);
 			return;
 		}
-		if (ts_morph.Node.isForInStatement(node) || ts_morph.Node.isForOfStatement(node)) {
-			addHoistedVars(node.getInitializer());
-			addHoistedVars(node.getStatement());
+		if (_bamboocss_ts_ast.Node.isForInStatement(node) || _bamboocss_ts_ast.Node.isForOfStatement(node)) {
+			addHoistedVars(node.initializer);
+			addHoistedVars(node.statement);
 			return;
 		}
-		if (ts_morph.Node.isWhileStatement(node) || ts_morph.Node.isDoStatement(node) || ts_morph.Node.isWithStatement(node)) {
-			addHoistedVars(node.getStatement());
+		if (_bamboocss_ts_ast.Node.isWhileStatement(node) || _bamboocss_ts_ast.Node.isDoStatement(node) || _bamboocss_ts_ast.Node.isWithStatement(node)) {
+			addHoistedVars(node.statement);
 			return;
 		}
-		if (ts_morph.Node.isLabeledStatement(node)) {
-			addHoistedVars(node.getStatement());
+		if (_bamboocss_ts_ast.Node.isLabeledStatement(node)) {
+			addHoistedVars(node.statement);
 			return;
 		}
-		if (ts_morph.Node.isTryStatement(node)) {
-			addHoistedVars(node.getTryBlock());
-			const caught = node.getCatchClause();
-			if (caught) addHoistedVars(caught.getBlock());
-			const finally_ = node.getFinallyBlock();
+		if (_bamboocss_ts_ast.Node.isTryStatement(node)) {
+			addHoistedVars(node.tryBlock);
+			const caught = (0, _bamboocss_ts_ast.childOf)(node, "catchClause");
+			if (caught) addHoistedVars((0, _bamboocss_ts_ast.childOf)(caught, "block"));
+			const finally_ = (0, _bamboocss_ts_ast.childOf)(node, "finallyBlock");
 			if (finally_) addHoistedVars(finally_);
 			return;
 		}
-		if (ts_morph.Node.isSwitchStatement(node)) for (const clause of node.getCaseBlock().getClauses()) for (const statement of clause.getStatements()) addHoistedVars(statement);
+		if (_bamboocss_ts_ast.Node.isSwitchStatement(node)) for (const clause of (0, _bamboocss_ts_ast.childOf)(node, "caseBlock")?.clauses ?? []) for (const statement of (0, _bamboocss_ts_ast.childOf)(clause, "statements") ?? []) addHoistedVars(statement);
 	};
-	for (const statement of sourceFile.getStatements()) {
-		if (ts_morph.Node.isVariableStatement(statement)) {
+	for (const statement of sourceFile.statements) {
+		if (_bamboocss_ts_ast.Node.isVariableStatement(statement)) {
 			addDeclarations(statement);
 			continue;
 		}
-		if (ts_morph.Node.isImportDeclaration(statement)) {
-			addBinding(statement.getDefaultImport());
-			addBinding(statement.getNamespaceImport());
-			for (const named of statement.getNamedImports()) addBinding(named.getAliasNode() ?? named.getNameNode());
+		if (_bamboocss_ts_ast.Node.isImportDeclaration(statement)) {
+			addBinding((0, _bamboocss_ts_ast.getDefaultImport)(statement));
+			addBinding((0, _bamboocss_ts_ast.getNamespaceImport)(statement));
+			for (const named of (0, _bamboocss_ts_ast.getNamedImports)(statement)) addBinding((0, _bamboocss_ts_ast.getAliasNode)(named) ?? (0, _bamboocss_ts_ast.nameNodeOf)(named));
 			continue;
 		}
-		if (ts_morph.Node.isImportEqualsDeclaration(statement)) {
-			addBinding(statement.getNameNode());
+		if (_bamboocss_ts_ast.Node.isImportEqualsDeclaration(statement)) {
+			addBinding(statement.name);
 			continue;
 		}
-		if (ts_morph.Node.isFunctionDeclaration(statement) || ts_morph.Node.isClassDeclaration(statement) || ts_morph.Node.isEnumDeclaration(statement) || ts_morph.Node.isModuleDeclaration(statement) || ts_morph.Node.isTypeAliasDeclaration(statement) || ts_morph.Node.isInterfaceDeclaration(statement)) {
-			addBinding(statement.getNameNode());
+		if (_bamboocss_ts_ast.Node.isFunctionDeclaration(statement) || _bamboocss_ts_ast.Node.isClassDeclaration(statement) || _bamboocss_ts_ast.Node.isEnumDeclaration(statement) || _bamboocss_ts_ast.Node.isModuleDeclaration(statement) || _bamboocss_ts_ast.Node.isTypeAliasDeclaration(statement) || _bamboocss_ts_ast.Node.isInterfaceDeclaration(statement)) {
+			addBinding(statement.name);
 			continue;
 		}
 		addHoistedVars(statement);
@@ -410,70 +410,61 @@ const collectModuleScopeNames = (sourceFile) => {
 *
 * `SyntaxKind.Identifier` sorts *below* `SyntaxKind.FirstNode`, which is what ts-morph tests to
 * decide whether it may search the parse tree. For a kind below that line it falls back to
-* materialising the whole **token** tree — every brace, comma and keyword becomes a ts-morph node
+* materialising the whole **token** tree — every brace, comma and keyword became a ts-morph node
 * on the way to collecting the identifiers. On 55 KB of real tsx that measured 22ms against
-* 0.22ms for the same collection over compiler nodes, and the node cache does not help: a second
+* 0.22ms for the same collection over compiler nodes, and the node cache did not help: a second
 * call cost the same 22ms.
 *
-* Wrapping is what costs, so only the buckets a caller actually reads are wrapped, on the first
-* read and cached after. Nothing enumerates this index — both callers ask for one name — so the
-* rest is never built. `_getNodeFromCompilerNode` is ts-morph's own memoized wrapper factory, so
-* a node handed back here is the very object `getDescendantsOfKind` would have returned, which
-* `localReferencesTo` depends on: it compares against the declaration by identity.
+* That cost was ts-morph's wrapper objects, and TypeScript 7 has none — the walk below yields
+* the compiler's own nodes, which is exactly what `getDescendantsOfKind` would return. So the
+* lazy per-bucket wrapping this used to do has nothing left to defer, and the buckets are handed
+* back as collected. `localReferencesTo` still depends on the identity of what comes out, since
+* it compares each reference against the declaration.
 *
 * JSDoc is walked explicitly. `ts.forEachChild` does not descend into it, while the token path
 * this replaces does, so a name mentioned only in a `@type` annotation was previously found and
 * would otherwise stop being — a silent narrowing of what counts as a surviving reference.
-* Keyed on `escapedText` because that is what ts-morph's `Identifier.getText()` returns: the name
-* as the compiler resolves it, so `\u0062adge` and `badge` share a bucket exactly as before.
+* Keyed on the identifier's `text` because that is the name as the compiler resolves it, so
+* `\u0062adge` and `badge` share a bucket exactly as before.
 *
 * Deliberately *not* memoized across passes, unlike the module-scope names beside it. That
-* cache holds strings, which outlive anything; this one holds nodes, and a node does not
-* survive its source file being replaced — `addSourceFile` overwrites, which forgets every
-* node previously taken from it. Keying on the source text does not help, because identical
-* text re-parsed is a fresh tree: the cache hits and returns nodes that throw
-* `Attempted to get information from a node that was removed or forgotten` on the next read.
+* cache holds strings, which outlive anything; this one holds nodes, and a node belongs to the
+* tree it was taken from. Keying on the source text does not help, because identical text
+* re-parsed is a fresh tree: the cache would hit and hand back nodes from a previous snapshot,
+* which no longer match anything the current pass compares them against.
 */
 const identifierIndex = (sourceFile) => {
 	const compilerNodes = /* @__PURE__ */ new Map();
 	const collect = (node) => {
-		if (node.kind === ts_morph.ts.SyntaxKind.Identifier) {
-			const name = String(node.escapedText);
+		if (node.kind === _bamboocss_ts_ast.ts.SyntaxKind.Identifier) {
+			const name = String(node.text);
 			const known = compilerNodes.get(name);
 			if (known) known.push(node);
 			else compilerNodes.set(name, [node]);
 		}
 		const jsDoc = node.jsDoc;
 		if (jsDoc) for (const doc of jsDoc) collect(doc);
-		ts_morph.ts.forEachChild(node, collect);
+		_bamboocss_ts_ast.ts.forEachChild(node, collect);
 	};
-	ts_morph.ts.forEachChild(sourceFile.compilerNode, collect);
-	const wrapped = /* @__PURE__ */ new Map();
-	const wrap = sourceFile;
-	return { get: (name) => {
-		const known = wrapped.get(name);
-		if (known) return known;
-		const nodes = (compilerNodes.get(name) ?? []).map((node) => wrap._getNodeFromCompilerNode(node));
-		wrapped.set(name, nodes);
-		return nodes;
-	} };
+	_bamboocss_ts_ast.ts.forEachChild(sourceFile, collect);
+	return { get: (name) => compilerNodes.get(name) ?? [] };
 };
 const localReferencesTo = (index, name, declaration) => {
 	const references = [];
 	for (const identifier of index.get(name)) {
 		if (identifier === declaration) continue;
-		const parent = identifier.getParent();
+		const parent = identifier.parent;
 		if (!parent) continue;
-		if (ts_morph.Node.isPropertyAccessExpression(parent) && parent.getNameNode() === identifier) continue;
-		if (ts_morph.Node.isPropertyAssignment(parent) && parent.getNameNode() === identifier) continue;
-		if (ts_morph.Node.isBindingElement(parent) && parent.getPropertyNameNode() === identifier) continue;
-		if ((ts_morph.Node.isJsxOpeningElement(parent) || ts_morph.Node.isJsxSelfClosingElement(parent) || ts_morph.Node.isJsxClosingElement(parent)) && parent.getTagNameNode() === identifier) continue;
-		if (ts_morph.Node.isJsxAttribute(parent) && parent.getNameNode() === identifier) continue;
-		if ((ts_morph.Node.isMethodDeclaration(parent) || ts_morph.Node.isPropertyDeclaration(parent) || ts_morph.Node.isGetAccessorDeclaration(parent) || ts_morph.Node.isSetAccessorDeclaration(parent) || ts_morph.Node.isMethodSignature(parent) || ts_morph.Node.isPropertySignature(parent) || ts_morph.Node.isEnumMember(parent)) && parent.getNameNode() === identifier) continue;
-		if ((ts_morph.Node.isVariableDeclaration(parent) || ts_morph.Node.isParameterDeclaration(parent) || ts_morph.Node.isFunctionDeclaration(parent) || ts_morph.Node.isClassDeclaration(parent) || ts_morph.Node.isBindingElement(parent)) && parent.getNameNode() === identifier) continue;
-		if (ts_morph.Node.isImportSpecifier(parent) || ts_morph.Node.isExportSpecifier(parent)) {
-			if (parent.getNameNode() !== identifier) continue;
-			if (ts_morph.Node.isExportSpecifier(parent)) {
+		if (_bamboocss_ts_ast.Node.isPropertyAccessExpression(parent) && parent.name === identifier) continue;
+		if (_bamboocss_ts_ast.Node.isPropertyAssignment(parent) && parent.name === identifier) continue;
+		if (_bamboocss_ts_ast.Node.isBindingElement(parent) && parent.propertyName === identifier) continue;
+		if ((_bamboocss_ts_ast.Node.isJsxOpeningElement(parent) || _bamboocss_ts_ast.Node.isJsxSelfClosingElement(parent) || _bamboocss_ts_ast.Node.isJsxClosingElement(parent)) && parent.tagName === identifier) continue;
+		if (_bamboocss_ts_ast.Node.isJsxAttribute(parent) && parent.name === identifier) continue;
+		if ((_bamboocss_ts_ast.Node.isMethodDeclaration(parent) || _bamboocss_ts_ast.Node.isPropertyDeclaration(parent) || _bamboocss_ts_ast.Node.isGetAccessorDeclaration(parent) || _bamboocss_ts_ast.Node.isSetAccessorDeclaration(parent) || _bamboocss_ts_ast.Node.isMethodSignatureDeclaration(parent) || _bamboocss_ts_ast.Node.isPropertySignatureDeclaration(parent) || _bamboocss_ts_ast.Node.isEnumMember(parent)) && (0, _bamboocss_ts_ast.nameNodeOf)(parent) === identifier) continue;
+		if ((_bamboocss_ts_ast.Node.isVariableDeclaration(parent) || _bamboocss_ts_ast.Node.isParameterDeclaration(parent) || _bamboocss_ts_ast.Node.isFunctionDeclaration(parent) || _bamboocss_ts_ast.Node.isClassDeclaration(parent) || _bamboocss_ts_ast.Node.isBindingElement(parent)) && parent.name === identifier) continue;
+		if (_bamboocss_ts_ast.Node.isImportSpecifier(parent) || _bamboocss_ts_ast.Node.isExportSpecifier(parent)) {
+			if (parent.name !== identifier) continue;
+			if (_bamboocss_ts_ast.Node.isExportSpecifier(parent)) {
 				references.push(identifier);
 				continue;
 			}
@@ -500,8 +491,10 @@ const collectRecipeConfigs = (parserResult) => {
 	for (const definition of definitions) {
 		const node = definition.box?.getNode?.();
 		if (!node) continue;
-		const nameNode = ((ts_morph.Node.isCallExpression(node) ? node : node.getFirstAncestorByKind(ts_morph.SyntaxKind.CallExpression))?.getFirstAncestorByKind(ts_morph.SyntaxKind.VariableDeclaration))?.getNameNode();
-		if (!nameNode || !ts_morph.Node.isIdentifier(nameNode)) continue;
+		const call = _bamboocss_ts_ast.Node.isCallExpression(node) ? node : (0, _bamboocss_ts_ast.getFirstAncestorByKind)(node, _bamboocss_ts_ast.SyntaxKind.CallExpression);
+		const declaration = call && (0, _bamboocss_ts_ast.getFirstAncestorByKind)(call, _bamboocss_ts_ast.SyntaxKind.VariableDeclaration);
+		const nameNode = declaration && (0, _bamboocss_ts_ast.nameNodeOf)(declaration);
+		if (!nameNode || !_bamboocss_ts_ast.Node.isIdentifier(nameNode)) continue;
 		if (definition.data?.length !== 1) {
 			configs.set(nameNode.getText(), AMBIGUOUS);
 			continue;
@@ -534,11 +527,11 @@ const AMBIGUOUS = Object.freeze({
 const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
 const propertyAccess = (key) => IDENTIFIER.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
 const LITERAL_KINDS = new Set([
-	ts_morph.SyntaxKind.StringLiteral,
-	ts_morph.SyntaxKind.NoSubstitutionTemplateLiteral,
-	ts_morph.SyntaxKind.NumericLiteral,
-	ts_morph.SyntaxKind.TrueKeyword,
-	ts_morph.SyntaxKind.FalseKeyword
+	_bamboocss_ts_ast.SyntaxKind.StringLiteral,
+	_bamboocss_ts_ast.SyntaxKind.NoSubstitutionTemplateLiteral,
+	_bamboocss_ts_ast.SyntaxKind.NumericLiteral,
+	_bamboocss_ts_ast.SyntaxKind.TrueKeyword,
+	_bamboocss_ts_ast.SyntaxKind.FalseKeyword
 ]);
 /**
 * The value a literal node denotes, or `undefined` for anything else.
@@ -549,11 +542,11 @@ const LITERAL_KINDS = new Set([
 * string missing the variant — the element renders, wrongly, with no report.
 */
 const literalValue = (node) => {
-	if (!node || !LITERAL_KINDS.has(node.getKind())) return void 0;
-	if (ts_morph.Node.isStringLiteral(node) || ts_morph.Node.isNoSubstitutionTemplateLiteral(node)) return node.getLiteralValue();
-	if (ts_morph.Node.isNumericLiteral(node)) return node.getLiteralValue();
-	if (node.getKind() === ts_morph.SyntaxKind.TrueKeyword) return true;
-	if (node.getKind() === ts_morph.SyntaxKind.FalseKeyword) return false;
+	if (!node || !LITERAL_KINDS.has(node.kind)) return void 0;
+	if (_bamboocss_ts_ast.Node.isStringLiteral(node) || _bamboocss_ts_ast.Node.isNoSubstitutionTemplateLiteral(node)) return (0, _bamboocss_ts_ast.literalValueOf)(node);
+	if (_bamboocss_ts_ast.Node.isNumericLiteral(node)) return (0, _bamboocss_ts_ast.literalValueOf)(node);
+	if (node.kind === _bamboocss_ts_ast.SyntaxKind.TrueKeyword) return true;
+	if (node.kind === _bamboocss_ts_ast.SyntaxKind.FalseKeyword) return false;
 };
 /**
 * The property name a key node denotes.
@@ -564,9 +557,9 @@ const literalValue = (node) => {
 * numeric key normalises the same way: `{ 0x10: 'a' }` is the key `16`.
 */
 const propertyKey = (nameNode) => {
-	if (ts_morph.Node.isIdentifier(nameNode)) return nameNode.getText();
-	if (ts_morph.Node.isStringLiteral(nameNode) || ts_morph.Node.isNoSubstitutionTemplateLiteral(nameNode)) return nameNode.getLiteralValue();
-	if (ts_morph.Node.isNumericLiteral(nameNode)) return String(nameNode.getLiteralValue());
+	if (_bamboocss_ts_ast.Node.isIdentifier(nameNode)) return nameNode.getText();
+	if (_bamboocss_ts_ast.Node.isStringLiteral(nameNode) || _bamboocss_ts_ast.Node.isNoSubstitutionTemplateLiteral(nameNode)) return (0, _bamboocss_ts_ast.stringLiteralValue)(nameNode);
+	if (_bamboocss_ts_ast.Node.isNumericLiteral(nameNode)) return String((0, _bamboocss_ts_ast.literalValueOf)(nameNode));
 };
 /**
 * Make a generated compile helper callable at this call site, by whatever name the file gives it.
@@ -579,26 +572,26 @@ const ensureRecipeHelperImport = (imported, call, isBambooCssModule, isGenerated
 	const sourceFile = call.getSourceFile();
 	let host;
 	let subpathModule;
-	for (const declaration of sourceFile.getImportDeclarations()) {
-		const mod = declaration.getModuleSpecifierValue();
-		if (declaration.isTypeOnly()) continue;
-		for (const named of declaration.getNamedImports()) {
-			if (named.isTypeOnly()) continue;
-			if (named.getNameNode().getText() === imported) {
-				if (!isBambooCssModule(mod)) return void 0;
-				const local = (named.getAliasNode() ?? named.getNameNode()).getText();
+	for (const declaration of (0, _bamboocss_ts_ast.getImportDeclarations)(sourceFile)) {
+		const mod = (0, _bamboocss_ts_ast.getModuleSpecifierValue)(declaration);
+		if ((0, _bamboocss_ts_ast.isTypeOnly)(declaration)) continue;
+		for (const named of (0, _bamboocss_ts_ast.getNamedImports)(declaration)) {
+			if ((0, _bamboocss_ts_ast.isTypeOnly)(named)) continue;
+			if ((0, _bamboocss_ts_ast.nameNodeOf)(named)?.getText() === imported) {
+				if (!isBambooCssModule(mod ?? "")) return void 0;
+				const local = ((0, _bamboocss_ts_ast.getAliasNode)(named) ?? (0, _bamboocss_ts_ast.nameNodeOf)(named))?.getText() ?? "";
 				return isShadowed(call, local) ? void 0 : { name: local };
 			}
 		}
-		if (!host && isGeneratedCssModule(mod) && declaration.getNamedImports().length > 0) host = declaration;
-		if (!subpathModule) subpathModule = helperModuleFromSubpath?.(mod);
+		if (!host && isGeneratedCssModule(mod ?? "") && (0, _bamboocss_ts_ast.getNamedImports)(declaration).length > 0) host = declaration;
+		if (!subpathModule) subpathModule = helperModuleFromSubpath?.(mod ?? "");
 	}
 	const fallbackModule = newImportModule ?? subpathModule;
 	if (!host && !fallbackModule) return void 0;
 	if (declaredAtModuleScope(sourceFile).has(imported)) return void 0;
 	if (isShadowed(call, imported)) return void 0;
 	if (!host) {
-		const anchor = sourceFile.getImportDeclarations().at(-1);
+		const anchor = (0, _bamboocss_ts_ast.getImportDeclarations)(sourceFile).at(-1);
 		if (!anchor) return void 0;
 		return {
 			name: imported,
@@ -609,7 +602,7 @@ const ensureRecipeHelperImport = (imported, call, isBambooCssModule, isGenerated
 			}
 		};
 	}
-	const last = host.getNamedImports().at(-1);
+	const last = (0, _bamboocss_ts_ast.getNamedImports)(host).at(-1);
 	if (!last) return void 0;
 	return {
 		name: imported,
@@ -645,11 +638,11 @@ const lowerRecipeCall = (call, entry, styleCompiler, isInert, resolvedSelection,
 		kind: "decline",
 		reason: "unknown-recipe"
 	};
-	if (!ts_morph.Node.isCallExpression(call)) return {
+	if (!_bamboocss_ts_ast.Node.isCallExpression(call)) return {
 		kind: "decline",
 		reason: "unsupported-shape"
 	};
-	const args = call.getArguments();
+	const args = call.arguments;
 	if (args.length > 1) return {
 		kind: "decline",
 		reason: "unsupported-shape"
@@ -684,29 +677,29 @@ const lowerRecipeCall = (call, entry, styleCompiler, isInert, resolvedSelection,
 		* An identifier only. Each variant reads the binding again, and re-reading anything else —
 		* a call, a property access — would evaluate it once per axis instead of once.
 		*/
-		if (ts_morph.Node.isIdentifier(arg)) {
+		if (_bamboocss_ts_ast.Node.isIdentifier(arg)) {
 			const binding = arg.getText();
 			for (const key of Object.keys(config.variants ?? {})) dynamicAxes.set(key, `${binding}${propertyAccess(key)}`);
-		} else if (!ts_morph.Node.isObjectLiteralExpression(arg)) return {
+		} else if (!_bamboocss_ts_ast.Node.isObjectLiteralExpression(arg)) return {
 			kind: "decline",
 			reason: "dynamic"
 		};
-		else for (const property of arg.getProperties()) {
-			if (ts_morph.Node.isSpreadAssignment(property)) return {
+		else for (const property of arg.properties) {
+			if (_bamboocss_ts_ast.Node.isSpreadAssignment(property)) return {
 				kind: "decline",
 				reason: "dynamic"
 			};
-			if (ts_morph.Node.isShorthandPropertyAssignment(property)) {
-				dynamicAxes.set(property.getName(), property.getName());
-				delete selection[property.getName()];
+			if (_bamboocss_ts_ast.Node.isShorthandPropertyAssignment(property)) {
+				dynamicAxes.set((0, _bamboocss_ts_ast.getName)(property) ?? "", (0, _bamboocss_ts_ast.getName)(property) ?? "");
+				delete selection[(0, _bamboocss_ts_ast.getName)(property) ?? ""];
 				continue;
 			}
-			if (!ts_morph.Node.isPropertyAssignment(property)) return {
+			if (!_bamboocss_ts_ast.Node.isPropertyAssignment(property)) return {
 				kind: "decline",
 				reason: "dynamic"
 			};
-			const nameNode = property.getNameNode();
-			if (ts_morph.Node.isComputedPropertyName(nameNode)) return {
+			const nameNode = property.name;
+			if (_bamboocss_ts_ast.Node.isComputedPropertyName(nameNode)) return {
 				kind: "decline",
 				reason: "dynamic"
 			};
@@ -715,7 +708,7 @@ const lowerRecipeCall = (call, entry, styleCompiler, isInert, resolvedSelection,
 				kind: "decline",
 				reason: "dynamic"
 			};
-			const initializer = property.getInitializer();
+			const initializer = property.initializer;
 			if (initializer && !isInert(initializer)) {
 				if (!Object.hasOwn(config.variants ?? {}, key)) return {
 					kind: "decline",
@@ -1153,24 +1146,24 @@ const RECIPE_CALL_TYPE = "cva-call";
 * A type position is excluded for a different reason: it is erased, and with it the import.
 */
 const isValueReference = (identifier) => {
-	const parent = identifier.getParent();
+	const parent = identifier.parent;
 	if (!parent) return false;
-	if (ts_morph.Node.isImportSpecifier(parent) || ts_morph.Node.isExportSpecifier(parent)) return false;
-	if (ts_morph.Node.isImportClause(parent) || ts_morph.Node.isNamespaceImport(parent)) return false;
-	if (ts_morph.Node.isPropertyAccessExpression(parent) && parent.getNameNode() === identifier) return false;
-	if (ts_morph.Node.isQualifiedName(parent) && parent.getRight() === identifier) return false;
-	if (ts_morph.Node.isPropertyAssignment(parent) && parent.getNameNode() === identifier) return false;
-	if (ts_morph.Node.isMethodDeclaration(parent) || ts_morph.Node.isPropertyDeclaration(parent) || ts_morph.Node.isGetAccessorDeclaration(parent) || ts_morph.Node.isSetAccessorDeclaration(parent) || ts_morph.Node.isMethodSignature(parent) || ts_morph.Node.isPropertySignature(parent) || ts_morph.Node.isEnumMember(parent)) {
-		if (parent.getNameNode() === identifier) return false;
+	if (_bamboocss_ts_ast.Node.isImportSpecifier(parent) || _bamboocss_ts_ast.Node.isExportSpecifier(parent)) return false;
+	if (_bamboocss_ts_ast.Node.isImportClause(parent) || _bamboocss_ts_ast.Node.isNamespaceImport(parent)) return false;
+	if (_bamboocss_ts_ast.Node.isPropertyAccessExpression(parent) && parent.name === identifier) return false;
+	if (_bamboocss_ts_ast.Node.isQualifiedName(parent) && parent.right === identifier) return false;
+	if (_bamboocss_ts_ast.Node.isPropertyAssignment(parent) && parent.name === identifier) return false;
+	if (_bamboocss_ts_ast.Node.isMethodDeclaration(parent) || _bamboocss_ts_ast.Node.isPropertyDeclaration(parent) || _bamboocss_ts_ast.Node.isGetAccessorDeclaration(parent) || _bamboocss_ts_ast.Node.isSetAccessorDeclaration(parent) || _bamboocss_ts_ast.Node.isMethodSignatureDeclaration(parent) || _bamboocss_ts_ast.Node.isPropertySignatureDeclaration(parent) || _bamboocss_ts_ast.Node.isEnumMember(parent)) {
+		if ((0, _bamboocss_ts_ast.nameNodeOf)(parent) === identifier) return false;
 	}
-	if (ts_morph.Node.isLabeledStatement(parent) || ts_morph.Node.isBreakStatement(parent) || ts_morph.Node.isContinueStatement(parent)) return false;
-	if (ts_morph.Node.isJsxOpeningElement(parent) || ts_morph.Node.isJsxSelfClosingElement(parent) || ts_morph.Node.isJsxClosingElement(parent)) {
-		if (parent.getTagNameNode() === identifier) return identifier.getText()[0] === identifier.getText()[0]?.toUpperCase();
+	if (_bamboocss_ts_ast.Node.isLabeledStatement(parent) || _bamboocss_ts_ast.Node.isBreakStatement(parent) || _bamboocss_ts_ast.Node.isContinueStatement(parent)) return false;
+	if (_bamboocss_ts_ast.Node.isJsxOpeningElement(parent) || _bamboocss_ts_ast.Node.isJsxSelfClosingElement(parent) || _bamboocss_ts_ast.Node.isJsxClosingElement(parent)) {
+		if (parent.tagName === identifier) return identifier.getText()[0] === identifier.getText()[0]?.toUpperCase();
 	}
-	if (ts_morph.Node.isJsxAttribute(parent)) return false;
-	if (ts_morph.Node.isBindingElement(parent) && parent.getPropertyNameNode() === identifier) return false;
-	if ((ts_morph.Node.isVariableDeclaration(parent) || ts_morph.Node.isParameterDeclaration(parent) || ts_morph.Node.isBindingElement(parent) || ts_morph.Node.isFunctionDeclaration(parent) || ts_morph.Node.isClassDeclaration(parent)) && parent.getNameNode() === identifier) return false;
-	return !identifier.getFirstAncestor((ancestor) => ts_morph.Node.isTypeNode(ancestor) || ts_morph.Node.isTypeAliasDeclaration(ancestor) || ts_morph.Node.isInterfaceDeclaration(ancestor));
+	if (_bamboocss_ts_ast.Node.isJsxAttribute(parent)) return false;
+	if (_bamboocss_ts_ast.Node.isBindingElement(parent) && parent.propertyName === identifier) return false;
+	if ((_bamboocss_ts_ast.Node.isVariableDeclaration(parent) || _bamboocss_ts_ast.Node.isParameterDeclaration(parent) || _bamboocss_ts_ast.Node.isBindingElement(parent) || _bamboocss_ts_ast.Node.isFunctionDeclaration(parent) || _bamboocss_ts_ast.Node.isClassDeclaration(parent)) && parent.name === identifier) return false;
+	return !(0, _bamboocss_ts_ast.getFirstAncestor)(identifier, (ancestor) => _bamboocss_ts_ast.Node.isTypeNode(ancestor) || _bamboocss_ts_ast.Node.isTypeAliasDeclaration(ancestor) || _bamboocss_ts_ast.Node.isInterfaceDeclaration(ancestor));
 };
 /**
 * Imports a surviving reference to is not a failure.
@@ -1211,7 +1204,7 @@ const TRAILING_INDEX = /\/index$/;
 * contract is behaviour preservation regardless: a literal is the cheap way to prove it, since
 * it means no call, no property read, no getter.
 */
-const isInertArgument = (node) => ts_morph.Node.isStringLiteral(node) || ts_morph.Node.isNumericLiteral(node) || ts_morph.Node.isNoSubstitutionTemplateLiteral(node) || node.getKind() === ts_morph.SyntaxKind.TrueKeyword || node.getKind() === ts_morph.SyntaxKind.FalseKeyword || node.getKind() === ts_morph.SyntaxKind.NullKeyword || ts_morph.Node.isIdentifier(node) && node.getText() === "undefined";
+const isInertArgument = (node) => _bamboocss_ts_ast.Node.isStringLiteral(node) || _bamboocss_ts_ast.Node.isNumericLiteral(node) || _bamboocss_ts_ast.Node.isNoSubstitutionTemplateLiteral(node) || node.kind === _bamboocss_ts_ast.SyntaxKind.TrueKeyword || node.kind === _bamboocss_ts_ast.SyntaxKind.FalseKeyword || node.kind === _bamboocss_ts_ast.SyntaxKind.NullKeyword || _bamboocss_ts_ast.Node.isIdentifier(node) && node.getText() === "undefined";
 /**
 * An expression whose evaluation cannot do anything observable, so deleting it preserves
 * behaviour.
@@ -1223,26 +1216,26 @@ const isInertArgument = (node) => ts_morph.Node.isStringLiteral(node) || ts_morp
 */
 const isInertExpression = (node) => {
 	if (isInertArgument(node)) return true;
-	if (ts_morph.Node.isIdentifier(node)) return true;
-	if (ts_morph.Node.isAsExpression(node) || ts_morph.Node.isSatisfiesExpression(node) || ts_morph.Node.isNonNullExpression(node) || ts_morph.Node.isTypeAssertion(node) || ts_morph.Node.isParenthesizedExpression(node)) return isInertExpression(node.getExpression());
-	if (ts_morph.Node.isArrowFunction(node) || ts_morph.Node.isFunctionExpression(node)) return true;
-	if (ts_morph.Node.isRegularExpressionLiteral(node) || ts_morph.Node.isBigIntLiteral(node)) return true;
-	if (ts_morph.Node.isPrefixUnaryExpression(node)) {
-		const operator = node.getOperatorToken();
-		return (operator === ts_morph.SyntaxKind.MinusToken || operator === ts_morph.SyntaxKind.PlusToken || operator === ts_morph.SyntaxKind.ExclamationToken || operator === ts_morph.SyntaxKind.TildeToken) && isInertExpression(node.getOperand());
+	if (_bamboocss_ts_ast.Node.isIdentifier(node)) return true;
+	if (_bamboocss_ts_ast.Node.isAsExpression(node) || _bamboocss_ts_ast.Node.isSatisfiesExpression(node) || _bamboocss_ts_ast.Node.isNonNullExpression(node) || _bamboocss_ts_ast.Node.isTypeAssertion(node) || _bamboocss_ts_ast.Node.isParenthesizedExpression(node)) return isInertExpression(node.expression);
+	if (_bamboocss_ts_ast.Node.isArrowFunction(node) || _bamboocss_ts_ast.Node.isFunctionExpression(node)) return true;
+	if (_bamboocss_ts_ast.Node.isRegularExpressionLiteral(node) || _bamboocss_ts_ast.Node.isBigIntLiteral(node)) return true;
+	if (_bamboocss_ts_ast.Node.isPrefixUnaryExpression(node)) {
+		const operator = node.operator;
+		return (operator === _bamboocss_ts_ast.SyntaxKind.MinusToken || operator === _bamboocss_ts_ast.SyntaxKind.PlusToken || operator === _bamboocss_ts_ast.SyntaxKind.ExclamationToken || operator === _bamboocss_ts_ast.SyntaxKind.TildeToken) && isInertExpression(node.operand);
 	}
-	if (ts_morph.Node.isBinaryExpression(node)) {
-		const operator = node.getOperatorToken().getKind();
-		return (operator === ts_morph.SyntaxKind.QuestionQuestionToken || operator === ts_morph.SyntaxKind.BarBarToken || operator === ts_morph.SyntaxKind.AmpersandAmpersandToken) && isInertExpression(node.getLeft()) && isInertExpression(node.getRight());
+	if (_bamboocss_ts_ast.Node.isBinaryExpression(node)) {
+		const operator = node.operatorToken.kind;
+		return (operator === _bamboocss_ts_ast.SyntaxKind.QuestionQuestionToken || operator === _bamboocss_ts_ast.SyntaxKind.BarBarToken || operator === _bamboocss_ts_ast.SyntaxKind.AmpersandAmpersandToken) && isInertExpression(node.left) && isInertExpression(node.right);
 	}
-	if (ts_morph.Node.isObjectLiteralExpression(node)) return node.getProperties().every((property) => {
-		if (ts_morph.Node.isShorthandPropertyAssignment(property)) return true;
-		if (!ts_morph.Node.isPropertyAssignment(property)) return false;
-		if (ts_morph.Node.isComputedPropertyName(property.getNameNode())) return false;
-		const initializer = property.getInitializer();
+	if (_bamboocss_ts_ast.Node.isObjectLiteralExpression(node)) return node.properties.every((property) => {
+		if (_bamboocss_ts_ast.Node.isShorthandPropertyAssignment(property)) return true;
+		if (!_bamboocss_ts_ast.Node.isPropertyAssignment(property)) return false;
+		if (_bamboocss_ts_ast.Node.isComputedPropertyName(property.name)) return false;
+		const initializer = property.initializer;
 		return initializer !== void 0 && isInertExpression(initializer);
 	});
-	if (ts_morph.Node.isArrayLiteralExpression(node)) return node.getElements().every(isInertExpression);
+	if (_bamboocss_ts_ast.Node.isArrayLiteralExpression(node)) return node.elements.every(isInertExpression);
 	return false;
 };
 /**
@@ -1274,7 +1267,7 @@ const createDependencyScan = (ownFile) => {
 			if (sourceFile === ownFile) return;
 			let path = paths.get(sourceFile);
 			if (path === void 0) {
-				path = sourceFile.getFilePath();
+				path = (0, _bamboocss_ts_ast.pathOf)(sourceFile);
 				paths.set(sourceFile, path);
 			}
 			if (path) results.add(path);
@@ -1291,13 +1284,13 @@ const createDependencyScan = (ownFile) => {
 */
 const findCallExpression = (node) => {
 	const own = node.getNode?.();
-	if (own && ts_morph.Node.isCallExpression(own)) return own;
+	if (own && _bamboocss_ts_ast.Node.isCallExpression(own)) return own;
 	const stack = node.getStack?.() ?? [];
-	for (const entry of stack) if (ts_morph.Node.isCallExpression(entry)) return entry;
+	for (const entry of stack) if (_bamboocss_ts_ast.Node.isCallExpression(entry)) return entry;
 	let current = own;
 	for (let depth = 0; current && depth < 3; depth++) {
-		if (ts_morph.Node.isCallExpression(current)) return current;
-		current = current.getParent();
+		if (_bamboocss_ts_ast.Node.isCallExpression(current)) return current;
+		current = current.parent;
 	}
 };
 /**
@@ -1306,16 +1299,16 @@ const findCallExpression = (node) => {
 * normalizes function names, so the parser result cannot tell us; the callee text can.
 */
 const isRawCall = (call) => {
-	if (!ts_morph.Node.isCallExpression(call)) return false;
-	const callee = call.getExpression().getText();
+	if (!_bamboocss_ts_ast.Node.isCallExpression(call)) return false;
+	const callee = call.expression.getText();
 	return callee === "raw" || callee.endsWith(".raw");
 };
 /** The identifier a callee is rooted at: `css` for `css(…)`, `panda` for `panda.css(…)`. */
 const calleeRootName = (call) => {
-	if (!ts_morph.Node.isCallExpression(call)) return void 0;
-	let current = call.getExpression();
-	while (ts_morph.Node.isPropertyAccessExpression(current)) current = current.getExpression();
-	return ts_morph.Node.isIdentifier(current) ? current.getText() : void 0;
+	if (!_bamboocss_ts_ast.Node.isCallExpression(call)) return void 0;
+	let current = call.expression;
+	while (_bamboocss_ts_ast.Node.isPropertyAccessExpression(current)) current = current.expression;
+	return _bamboocss_ts_ast.Node.isIdentifier(current) ? current.getText() : void 0;
 };
 /**
 * Local names a module binds to an import of bamboo's own generated system.
@@ -1334,26 +1327,26 @@ const calleeRootName = (call) => {
 */
 const bambooImportedNames = (sourceFile, ctx) => {
 	const names = /* @__PURE__ */ new Set();
-	for (const declaration of sourceFile.getImportDeclarations()) {
-		const mod = declaration.getModuleSpecifierValue();
-		for (const named of declaration.getNamedImports()) {
-			const name = named.getNameNode().getText();
-			const alias = named.getAliasNode()?.getText() ?? name;
+	for (const declaration of (0, _bamboocss_ts_ast.getImportDeclarations)(sourceFile)) {
+		const mod = (0, _bamboocss_ts_ast.getModuleSpecifierValue)(declaration);
+		for (const named of (0, _bamboocss_ts_ast.getNamedImports)(declaration)) {
+			const name = (0, _bamboocss_ts_ast.nameNodeOf)(named)?.getText();
+			const alias = (0, _bamboocss_ts_ast.getAliasNode)(named)?.getText() ?? name;
 			if (ctx.imports.match({
-				mod,
-				name,
-				alias
-			})) names.add(alias);
+				mod: mod ?? "",
+				name: name ?? "",
+				alias: alias ?? ""
+			})) names.add(alias ?? "");
 		}
-		const namespace = declaration.getNamespaceImport();
+		const namespace = (0, _bamboocss_ts_ast.getNamespaceImport)(declaration);
 		if (namespace) {
 			const alias = namespace.getText();
 			if (ctx.imports.match({
-				mod,
-				name: alias,
-				alias,
+				mod: mod ?? "",
+				name: alias ?? "",
+				alias: alias ?? "",
 				kind: "namespace"
-			})) names.add(alias);
+			})) names.add(alias ?? "");
 		}
 	}
 	return names;
@@ -1368,8 +1361,8 @@ const bambooImportedNames = (sourceFile, ctx) => {
 * attributes, which match neither and cost nothing.
 */
 const isShadowed = (call, name) => {
-	for (let node = call.getParent(); node; node = node.getParent()) {
-		if (ts_morph.Node.isSourceFile(node)) return false;
+	for (let node = call.parent; node; node = node.parent) {
+		if (_bamboocss_ts_ast.Node.isSourceFile(node)) return false;
 		if (bindsName(node, name)) return true;
 	}
 	return false;
@@ -1384,21 +1377,21 @@ const isShadowed = (call, name) => {
 */
 const bindingIntroduces = (nameNode, name) => {
 	if (!nameNode) return false;
-	if (ts_morph.Node.isIdentifier(nameNode)) return nameNode.getText() === name;
-	if (ts_morph.Node.isObjectBindingPattern(nameNode) || ts_morph.Node.isArrayBindingPattern(nameNode)) return nameNode.getElements().some((element) => ts_morph.Node.isBindingElement(element) && bindingIntroduces(element.getNameNode(), name));
+	if (_bamboocss_ts_ast.Node.isIdentifier(nameNode)) return nameNode.getText() === name;
+	if (_bamboocss_ts_ast.Node.isObjectBindingPattern(nameNode) || _bamboocss_ts_ast.Node.isArrayBindingPattern(nameNode)) return nameNode.elements.some((element) => _bamboocss_ts_ast.Node.isBindingElement(element) && bindingIntroduces(element.name, name));
 	return false;
 };
-const declarationsBind = (list, name) => ts_morph.Node.isVariableDeclarationList(list) && list.getDeclarations().some((declaration) => bindingIntroduces(declaration.getNameNode(), name));
+const declarationsBind = (list, name) => list !== void 0 && _bamboocss_ts_ast.Node.isVariableDeclarationList(list) && list.declarations.some((declaration) => bindingIntroduces(declaration.name, name));
 const bindsName = (scope, name) => {
-	if (ts_morph.Node.isBlock(scope)) return scope.getStatements().some((statement) => statementBinds(statement, name));
-	if (ts_morph.Node.isFunctionDeclaration(scope) || ts_morph.Node.isArrowFunction(scope) || ts_morph.Node.isFunctionExpression(scope) || ts_morph.Node.isMethodDeclaration(scope)) return scope.getParameters().some((parameter) => bindingIntroduces(parameter.getNameNode(), name));
-	if (ts_morph.Node.isCatchClause(scope)) return bindingIntroduces(scope.getVariableDeclaration()?.getNameNode(), name);
-	if (ts_morph.Node.isForStatement(scope) || ts_morph.Node.isForOfStatement(scope) || ts_morph.Node.isForInStatement(scope)) return declarationsBind(scope.getInitializer(), name);
+	if (_bamboocss_ts_ast.Node.isBlock(scope)) return scope.statements.some((statement) => statementBinds(statement, name));
+	if (_bamboocss_ts_ast.Node.isFunctionDeclaration(scope) || _bamboocss_ts_ast.Node.isArrowFunction(scope) || _bamboocss_ts_ast.Node.isFunctionExpression(scope) || _bamboocss_ts_ast.Node.isMethodDeclaration(scope)) return scope.parameters.some((parameter) => bindingIntroduces(parameter.name, name));
+	if (_bamboocss_ts_ast.Node.isCatchClause(scope)) return bindingIntroduces(scope.variableDeclaration?.name, name);
+	if (_bamboocss_ts_ast.Node.isForStatement(scope) || _bamboocss_ts_ast.Node.isForOfStatement(scope) || _bamboocss_ts_ast.Node.isForInStatement(scope)) return declarationsBind(scope.initializer, name);
 	return false;
 };
 const statementBinds = (statement, name) => {
-	if (ts_morph.Node.isVariableStatement(statement)) return statement.getDeclarations().some((declaration) => bindingIntroduces(declaration.getNameNode(), name));
-	if (ts_morph.Node.isFunctionDeclaration(statement) || ts_morph.Node.isClassDeclaration(statement)) return statement.getNameNode()?.getText() === name;
+	if (_bamboocss_ts_ast.Node.isVariableStatement(statement)) return statement.declarationList.declarations.some((declaration) => bindingIntroduces(declaration.name, name));
+	if (_bamboocss_ts_ast.Node.isFunctionDeclaration(statement) || _bamboocss_ts_ast.Node.isClassDeclaration(statement)) return statement.name?.getText() === name;
 	return false;
 };
 const hasStyles = (data) => data.length > 0 && data.every((entry) => entry != null && typeof entry === "object");
@@ -1408,8 +1401,8 @@ const hasStyles = (data) => data.length > 0 && data.every((entry) => entry != nu
 * (multi-arg calls) or just the first argument's map (single-arg calls).
 */
 const argumentsAccountedFor = (call, boxNode) => {
-	if (!ts_morph.Node.isCallExpression(call)) return false;
-	const args = call.getArguments();
+	if (!_bamboocss_ts_ast.Node.isCallExpression(call)) return false;
+	const args = call.arguments;
 	if (args.length === 0) return true;
 	if (_bamboocss_extractor.box.isArray(boxNode) && boxNode.getNode() === call) {
 		if (boxNode.value.length !== args.length) return false;
@@ -1515,13 +1508,13 @@ const foldSource = (options) => {
 	* its `/recipes` suffix; falling back to the configured generated entry covers bare imports.
 	*/
 	const configRecipeCssSpecifier = (call, binding) => {
-		for (const declaration of call.getSourceFile().getImportDeclarations()) {
-			if (declaration.isTypeOnly()) continue;
-			if (!declaration.getNamedImports().some((named) => {
-				if (named.isTypeOnly()) return false;
-				return (named.getAliasNode() ?? named.getNameNode()).getText() === binding;
+		for (const declaration of (0, _bamboocss_ts_ast.getImportDeclarations)(call.getSourceFile())) {
+			if ((0, _bamboocss_ts_ast.isTypeOnly)(declaration)) continue;
+			if (!(0, _bamboocss_ts_ast.getNamedImports)(declaration).some((named) => {
+				if ((0, _bamboocss_ts_ast.isTypeOnly)(named)) return false;
+				return ((0, _bamboocss_ts_ast.getAliasNode)(named) ?? (0, _bamboocss_ts_ast.nameNodeOf)(named))?.getText() === binding;
 			})) continue;
-			const mod = declaration.getModuleSpecifierValue().replaceAll("\\", "/");
+			const mod = ((0, _bamboocss_ts_ast.getModuleSpecifierValue)(declaration) ?? "").replaceAll("\\", "/");
 			const at = mod.lastIndexOf("/recipes");
 			if (at >= 0) return `${mod.slice(0, at)}/css`;
 		}
@@ -1539,10 +1532,10 @@ const foldSource = (options) => {
 	* expressed from the module being folded.
 	*/
 	const cssModuleSpecifierFrom = (declaring) => {
-		for (const declaration of declaring.getImportDeclarations()) {
-			if (declaration.isTypeOnly()) continue;
-			const mod = declaration.getModuleSpecifierValue();
-			if (isGeneratedCssModule(mod)) return mod;
+		for (const declaration of (0, _bamboocss_ts_ast.getImportDeclarations)(declaring)) {
+			if ((0, _bamboocss_ts_ast.isTypeOnly)(declaration)) continue;
+			const mod = (0, _bamboocss_ts_ast.getModuleSpecifierValue)(declaration);
+			if (isGeneratedCssModule(mod ?? "")) return mod;
 		}
 	};
 	/**
@@ -1593,7 +1586,7 @@ const foldSource = (options) => {
 		const resolve = () => {
 			if (!parseModule) return void 0;
 			const consuming = call.getSourceFile();
-			if (origin.filePath === consuming.getFilePath()) return void 0;
+			if (origin.filePath === (0, _bamboocss_ts_ast.pathOf)(consuming)) return void 0;
 			let foreign = configsByModule.get(origin.filePath);
 			if (!foreign) {
 				const result = parseModule(origin.filePath);
@@ -1620,7 +1613,7 @@ const foldSource = (options) => {
 				name: origin.name,
 				digest: digestRecipeConfig(entry)
 			});
-			helperModules.set(name, foreign.cssSpecifier ? rebaseSpecifier(foreign.cssSpecifier, origin.filePath, consuming.getFilePath()) : void 0);
+			helperModules.set(name, foreign.cssSpecifier ? rebaseSpecifier(foreign.cssSpecifier, origin.filePath, (0, _bamboocss_ts_ast.pathOf)(consuming)) : void 0);
 			return entry;
 		};
 		const resolved = resolve();
@@ -1637,7 +1630,7 @@ const foldSource = (options) => {
 		if (entry === AMBIGUOUS) continue;
 		const definition = entry.box?.getNode?.();
 		if (!definition) continue;
-		const call = ts_morph.Node.isCallExpression(definition) ? definition : definition.getFirstAncestorByKind(ts_morph.SyntaxKind.CallExpression);
+		const call = _bamboocss_ts_ast.Node.isCallExpression(definition) ? definition : (0, _bamboocss_ts_ast.getFirstAncestorByKind)(definition, _bamboocss_ts_ast.SyntaxKind.CallExpression);
 		if (!call || code.slice(call.getStart(), call.getEnd()) !== call.getText()) continue;
 		recipeDefinitions.push({
 			name,
@@ -1694,8 +1687,8 @@ const foldSource = (options) => {
 				});
 				continue;
 			}
-			const callee = ts_morph.Node.isCallExpression(call) ? call.getExpression() : void 0;
-			const propertyName = ts_morph.Node.isPropertyAccessExpression(callee) ? callee.getNameNode().getText() : void 0;
+			const callee = _bamboocss_ts_ast.Node.isCallExpression(call) ? call.expression : void 0;
+			const propertyName = callee !== void 0 && _bamboocss_ts_ast.Node.isPropertyAccessExpression(callee) ? (0, _bamboocss_ts_ast.nameNodeOf)(callee)?.getText() ?? "" : void 0;
 			const wantsValue = type === "tokenValue";
 			if (wantsValue !== (propertyName === "value")) {
 				skipped.push({
@@ -1734,7 +1727,7 @@ const foldSource = (options) => {
 				});
 				continue;
 			}
-			if (!(ts_morph.Node.isCallExpression(call) ? call.getArguments().slice(1) : []).every(isInertArgument)) {
+			if (!(_bamboocss_ts_ast.Node.isCallExpression(call) ? call.arguments.slice(1) : []).every(isInertArgument)) {
 				skipped.push({
 					name,
 					reason: "dynamic",
@@ -1808,16 +1801,16 @@ const foldSource = (options) => {
 					let inlineSlot;
 					let inlineEnd = end;
 					if (Array.isArray(entry?.config.slots)) {
-						const parent = call.getParent();
-						if (ts_morph.Node.isPropertyAccessExpression(parent) && parent.getExpression() === call) {
-							const accessed = parent.getName();
+						const parent = call.parent;
+						if (_bamboocss_ts_ast.Node.isPropertyAccessExpression(parent) && parent.expression === call) {
+							const accessed = (0, _bamboocss_ts_ast.getName)(parent);
 							if (entry.config.slots.includes(accessed)) {
 								inlineSlot = accessed;
 								inlineEnd = parent.getEnd();
 							}
-						} else if (ts_morph.Node.isElementAccessExpression(parent) && parent.getExpression() === call) {
-							const argument = parent.getArgumentExpression();
-							const accessed = argument && (ts_morph.Node.isStringLiteral(argument) || ts_morph.Node.isNoSubstitutionTemplateLiteral(argument)) ? argument.getLiteralValue() : void 0;
+						} else if (_bamboocss_ts_ast.Node.isElementAccessExpression(parent) && parent.expression === call) {
+							const argument = parent.argumentExpression;
+							const accessed = argument && (_bamboocss_ts_ast.Node.isStringLiteral(argument) || _bamboocss_ts_ast.Node.isNoSubstitutionTemplateLiteral(argument)) ? (0, _bamboocss_ts_ast.literalValueOf)(argument) : void 0;
 							if (typeof accessed === "string" && entry.config.slots.includes(accessed)) {
 								inlineSlot = accessed;
 								inlineEnd = parent.getEnd();
@@ -1915,9 +1908,9 @@ const foldSource = (options) => {
 		}
 		const start = call.getStart();
 		const end = call.getEnd();
-		const memberParent = call.getParent();
-		const accessed = type === "recipe" && ts_morph.Node.isPropertyAccessExpression(memberParent) && memberParent.getExpression() === call ? memberParent : void 0;
-		const accessedName = accessed?.getNameNode().getText();
+		const memberParent = call.parent;
+		const accessed = type === "recipe" && _bamboocss_ts_ast.Node.isPropertyAccessExpression(memberParent) && memberParent.expression === call ? memberParent : void 0;
+		const accessedName = accessed?.name.getText();
 		const declaredSlots = accessed ? ctx.recipes.getConfig(name)?.slots ?? [] : [];
 		const memberAccess = accessedName && declaredSlots.includes(accessedName) ? accessed : void 0;
 		const slot = memberAccess ? accessedName : void 0;
@@ -1953,7 +1946,7 @@ const foldSource = (options) => {
 			});
 			continue;
 		}
-		if (!(ts_morph.Node.isCallExpression(call) && call.getArguments().length === 0 && item.data.length === 1) && !isStaticBox(item.box) || !hasStyles(item.data) || !argumentsAccountedFor(call, item.box)) {
+		if (!(_bamboocss_ts_ast.Node.isCallExpression(call) && call.arguments.length === 0 && item.data.length === 1) && !isStaticBox(item.box) || !hasStyles(item.data) || !argumentsAccountedFor(call, item.box)) {
 			skipped.push({
 				name,
 				reason: "dynamic",
@@ -2001,17 +1994,17 @@ const foldSource = (options) => {
 		const sourceFile = ownSourceFile ?? candidates[0]?.node.getSourceFile();
 		if (sourceFile) {
 			const cxBindings = /* @__PURE__ */ new Set();
-			for (const declaration of sourceFile.getImportDeclarations()) {
-				if (declaration.isTypeOnly() || !isBambooCssModule(declaration.getModuleSpecifierValue())) continue;
-				for (const named of declaration.getNamedImports()) {
-					if (named.isTypeOnly() || named.getNameNode().getText() !== "cx") continue;
-					cxBindings.add((named.getAliasNode() ?? named.getNameNode()).getText());
+			for (const declaration of (0, _bamboocss_ts_ast.getImportDeclarations)(sourceFile)) {
+				if ((0, _bamboocss_ts_ast.isTypeOnly)(declaration) || !isBambooCssModule((0, _bamboocss_ts_ast.getModuleSpecifierValue)(declaration) ?? "")) continue;
+				for (const named of (0, _bamboocss_ts_ast.getNamedImports)(declaration)) {
+					if ((0, _bamboocss_ts_ast.isTypeOnly)(named) || (0, _bamboocss_ts_ast.nameNodeOf)(named)?.getText() !== "cx") continue;
+					cxBindings.add(((0, _bamboocss_ts_ast.getAliasNode)(named) ?? (0, _bamboocss_ts_ast.nameNodeOf)(named))?.getText() ?? "");
 				}
 			}
 			const byRange = new Map(candidates.map((candidate) => [`${candidate.start}:${candidate.end}`, candidate]));
-			for (const call of cxBindings.size ? sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.CallExpression) : []) {
-				const callee = call.getExpression();
-				if (!ts_morph.Node.isIdentifier(callee) || !cxBindings.has(callee.getText()) || isShadowed(call, callee.getText())) continue;
+			for (const call of cxBindings.size ? (0, _bamboocss_ts_ast.getDescendantsOfKind)(sourceFile, _bamboocss_ts_ast.SyntaxKind.CallExpression) : []) {
+				const callee = (0, _bamboocss_ts_ast.childOf)(call, "expression");
+				if (callee === void 0 || !_bamboocss_ts_ast.Node.isIdentifier(callee) || !cxBindings.has(callee.getText()) || isShadowed(call, callee.getText())) continue;
 				const matched = [];
 				const parts = [];
 				const dynamic = [];
@@ -2044,21 +2037,21 @@ const foldSource = (options) => {
 						});
 						return true;
 					}
-					if (ts_morph.Node.isStringLiteral(arg) || ts_morph.Node.isNoSubstitutionTemplateLiteral(arg)) {
+					if (_bamboocss_ts_ast.Node.isStringLiteral(arg) || _bamboocss_ts_ast.Node.isNoSubstitutionTemplateLiteral(arg)) {
 						parts.push({
 							kind: "class",
-							value: arg.getLiteralValue()
+							value: (0, _bamboocss_ts_ast.stringLiteralValue)(arg)
 						});
 						return true;
 					}
-					if (ts_morph.Node.isArrayLiteralExpression(arg)) {
-						for (const element of arg.getElements()) if (ts_morph.Node.isSpreadElement(element) || !take(element)) return false;
+					if (_bamboocss_ts_ast.Node.isArrayLiteralExpression(arg)) {
+						for (const element of arg.elements) if (_bamboocss_ts_ast.Node.isSpreadElement(element) || !take(element)) return false;
 						return true;
 					}
-					if (arg.getKind() === ts_morph.SyntaxKind.FalseKeyword || arg.getKind() === ts_morph.SyntaxKind.TrueKeyword || ts_morph.Node.isNumericLiteral(arg) || arg.getKind() === ts_morph.SyntaxKind.NullKeyword || ts_morph.Node.isIdentifier(arg) && arg.getText() === "undefined") return true;
+					if (arg.kind === _bamboocss_ts_ast.SyntaxKind.FalseKeyword || arg.kind === _bamboocss_ts_ast.SyntaxKind.TrueKeyword || _bamboocss_ts_ast.Node.isNumericLiteral(arg) || arg.kind === _bamboocss_ts_ast.SyntaxKind.NullKeyword || _bamboocss_ts_ast.Node.isIdentifier(arg) && arg.getText() === "undefined") return true;
 					return false;
 				};
-				for (const arg of call.getArguments()) {
+				for (const arg of (0, _bamboocss_ts_ast.childOf)(call, "arguments") ?? []) {
 					if (take(arg)) continue;
 					supported = false;
 					break;
@@ -2288,10 +2281,10 @@ const foldSource = (options) => {
 		collectSourceFiles(item.box, dependencyScan);
 	}
 	const recipeSourceFile = candidates[0]?.node.getSourceFile();
-	if (recipeSourceFile && mayNameSplitVariantProps(recipeSourceFile.getFullText())) for (const access of recipeSourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.PropertyAccessExpression)) {
-		if (access.getName() !== "splitVariantProps") continue;
-		const target = access.getExpression();
-		if (!ts_morph.Node.isIdentifier(target)) continue;
+	if (recipeSourceFile && mayNameSplitVariantProps(recipeSourceFile.getFullText())) for (const access of (0, _bamboocss_ts_ast.getDescendantsOfKind)(recipeSourceFile, _bamboocss_ts_ast.SyntaxKind.PropertyAccessExpression)) {
+		if ((0, _bamboocss_ts_ast.getName)(access) !== "splitVariantProps") continue;
+		const target = (0, _bamboocss_ts_ast.childOf)(access, "expression");
+		if (target === void 0 || !_bamboocss_ts_ast.Node.isIdentifier(target)) continue;
 		if (isShadowed(access, target.getText())) continue;
 		const local = recipeConfigs?.get(target.getText());
 		const importedConfig = !local && importsFor(recipeSourceFile).has(target.getText()) ? ctx.recipes.getConfig(target.getText()) : void 0;
@@ -2300,9 +2293,9 @@ const foldSource = (options) => {
 			box: void 0
 		} : void 0;
 		if (!entry) continue;
-		const call = access.getParent();
-		if (!ts_morph.Node.isCallExpression(call) || call.getExpression() !== access) continue;
-		const args = call.getArguments();
+		const call = access.parent;
+		if (!_bamboocss_ts_ast.Node.isCallExpression(call) || call.expression !== access) continue;
+		const args = call.arguments;
 		if (args.length !== 1) continue;
 		const start = call.getStart();
 		const end = call.getEnd();
@@ -2344,11 +2337,11 @@ const foldSource = (options) => {
 	*/
 	/** The specifier this module imported `binding` through, if it did. */
 	function importSpecifierFor(sourceFile, binding) {
-		for (const declaration of sourceFile.getImportDeclarations()) {
-			if (declaration.isTypeOnly()) continue;
-			for (const named of declaration.getNamedImports()) {
-				if (named.isTypeOnly()) continue;
-				if ((named.getAliasNode() ?? named.getNameNode()).getText() === binding) return named.getAliasNode() ?? named.getNameNode();
+		for (const declaration of (0, _bamboocss_ts_ast.getImportDeclarations)(sourceFile)) {
+			if ((0, _bamboocss_ts_ast.isTypeOnly)(declaration)) continue;
+			for (const named of (0, _bamboocss_ts_ast.getNamedImports)(declaration)) {
+				if ((0, _bamboocss_ts_ast.isTypeOnly)(named)) continue;
+				if (((0, _bamboocss_ts_ast.getAliasNode)(named) ?? (0, _bamboocss_ts_ast.nameNodeOf)(named))?.getText() === binding) return (0, _bamboocss_ts_ast.getAliasNode)(named) ?? (0, _bamboocss_ts_ast.nameNodeOf)(named);
 			}
 		}
 	}
@@ -2376,9 +2369,9 @@ const foldSource = (options) => {
 			if (entry === AMBIGUOUS) continue;
 			if (!entry && !importedRecipeBindings.has(binding)) continue;
 			const definition = entry?.box?.getNode?.();
-			const nameNode = definition?.getSourceFile() === sourceFile ? definition?.getFirstAncestorByKind(ts_morph.SyntaxKind.VariableDeclaration)?.getNameNode() : importSpecifierFor(sourceFile, binding);
-			if (!nameNode || !ts_morph.Node.isIdentifier(nameNode)) continue;
-			const references = localReferencesTo(identifiersByName(), binding, nameNode).filter((reference) => !reference.getFirstAncestorByKind(ts_morph.SyntaxKind.TypeQuery));
+			const nameNode = definition?.getSourceFile() === sourceFile ? (0, _bamboocss_ts_ast.nameNodeOf)((0, _bamboocss_ts_ast.getFirstAncestorByKind)(definition, _bamboocss_ts_ast.SyntaxKind.VariableDeclaration)) : importSpecifierFor(sourceFile, binding);
+			if (!nameNode || !_bamboocss_ts_ast.Node.isIdentifier(nameNode)) continue;
+			const references = localReferencesTo(identifiersByName(), binding, nameNode).filter((reference) => !(0, _bamboocss_ts_ast.getFirstAncestorByKind)(reference, _bamboocss_ts_ast.SyntaxKind.TypeQuery));
 			if (skipped.filter((item) => SURVIVES_TO_RUNTIME.has(item.reason) && item.end > item.start).some((item) => references.some((ref) => ref.getStart() >= item.start && ref.getStart() < item.end))) continue;
 			const survivor = references.find((ref) => !applied.some(([from, to]) => ref.getStart() >= from && ref.getStart() < to));
 			if (!survivor) continue;
@@ -2397,17 +2390,17 @@ const foldSource = (options) => {
 		];
 		const runtimeCalls = [];
 		const importEquals = [];
-		sourceFile.forEachDescendant((node) => {
-			if (ts_morph.Node.isCallExpression(node)) runtimeCalls.push(node);
-			else if (ts_morph.Node.isImportEqualsDeclaration(node)) importEquals.push(node);
+		(0, _bamboocss_ts_ast.forEachDescendant)(sourceFile, (node) => {
+			if (_bamboocss_ts_ast.Node.isCallExpression(node)) runtimeCalls.push(node);
+			else if (_bamboocss_ts_ast.Node.isImportEqualsDeclaration(node)) importEquals.push(node);
 		});
 		for (const call of runtimeCalls) {
-			const callee = call.getExpression();
-			const argument = call.getArguments()[0];
-			if (!argument || !ts_morph.Node.isStringLiteral(argument) && !ts_morph.Node.isNoSubstitutionTemplateLiteral(argument)) continue;
-			if (!matchesModule(argument.getLiteralValue(), bambooModules)) continue;
-			const isDynamicImport = callee.getKind() === ts_morph.SyntaxKind.ImportKeyword;
-			const isRequire = ts_morph.Node.isIdentifier(callee) && callee.getText() === "require" && !isShadowed(call, "require");
+			const callee = call.expression;
+			const argument = call.arguments[0];
+			if (!argument || !_bamboocss_ts_ast.Node.isStringLiteral(argument) && !_bamboocss_ts_ast.Node.isNoSubstitutionTemplateLiteral(argument)) continue;
+			if (!matchesModule((0, _bamboocss_ts_ast.stringLiteralValue)(argument), bambooModules)) continue;
+			const isDynamicImport = callee.kind === _bamboocss_ts_ast.SyntaxKind.ImportKeyword;
+			const isRequire = _bamboocss_ts_ast.Node.isIdentifier(callee) && callee.getText() === "require" && !isShadowed(call, "require");
 			if (!isDynamicImport && !isRequire) continue;
 			skipped.push({
 				name: isDynamicImport ? "import" : "require",
@@ -2417,13 +2410,13 @@ const foldSource = (options) => {
 			});
 		}
 		for (const declaration of importEquals) {
-			if (declaration.isTypeOnly()) continue;
-			const reference = declaration.getModuleReference();
-			if (!ts_morph.Node.isExternalModuleReference(reference)) continue;
-			const expression = reference.getExpression();
-			if (!expression || !ts_morph.Node.isStringLiteral(expression) || !matchesModule(expression.getLiteralValue(), bambooModules)) continue;
+			if ((0, _bamboocss_ts_ast.isTypeOnly)(declaration)) continue;
+			const reference = declaration.moduleReference;
+			if (!_bamboocss_ts_ast.Node.isExternalModuleReference(reference)) continue;
+			const expression = reference.expression;
+			if (!expression || !_bamboocss_ts_ast.Node.isStringLiteral(expression) || !matchesModule((0, _bamboocss_ts_ast.stringLiteralValue)(expression), bambooModules)) continue;
 			skipped.push({
-				name: declaration.getName(),
+				name: (0, _bamboocss_ts_ast.getName)(declaration) ?? "",
 				reason: "runtime-binding",
 				start: declaration.getStart(),
 				end: declaration.getEnd()
@@ -2431,52 +2424,53 @@ const foldSource = (options) => {
 		}
 		/** Local name -> what to call it in the report. */
 		const watched = /* @__PURE__ */ new Map();
-		for (const declaration of sourceFile.getImportDeclarations()) {
-			if (declaration.isTypeOnly()) continue;
-			if (!matchesModule(declaration.getModuleSpecifierValue(), bambooModules)) continue;
-			for (const named of declaration.getNamedImports()) {
-				if (named.isTypeOnly()) continue;
-				const imported = named.getNameNode().getText();
-				if (PERMITTED_BINDINGS.has(imported)) continue;
-				watched.set((named.getAliasNode() ?? named.getNameNode()).getText(), imported);
+		for (const declaration of (0, _bamboocss_ts_ast.getImportDeclarations)(sourceFile)) {
+			if ((0, _bamboocss_ts_ast.isTypeOnly)(declaration)) continue;
+			if (!matchesModule((0, _bamboocss_ts_ast.getModuleSpecifierValue)(declaration) ?? "", bambooModules)) continue;
+			for (const named of (0, _bamboocss_ts_ast.getNamedImports)(declaration)) {
+				if ((0, _bamboocss_ts_ast.isTypeOnly)(named)) continue;
+				const imported = (0, _bamboocss_ts_ast.nameNodeOf)(named)?.getText();
+				if (PERMITTED_BINDINGS.has(imported ?? "")) continue;
+				watched.set(((0, _bamboocss_ts_ast.getAliasNode)(named) ?? (0, _bamboocss_ts_ast.nameNodeOf)(named))?.getText() ?? "", imported ?? "");
 			}
-			const namespace = declaration.getNamespaceImport();
+			const namespace = (0, _bamboocss_ts_ast.getNamespaceImport)(declaration);
 			if (namespace) watched.set(namespace.getText(), `${namespace.getText()}.*`);
-			const defaultImport = declaration.getDefaultImport();
+			const defaultImport = (0, _bamboocss_ts_ast.getDefaultImport)(declaration);
 			if (defaultImport) watched.set(defaultImport.getText(), defaultImport.getText());
 		}
-		for (const declaration of sourceFile.getExportDeclarations()) {
-			if (declaration.isTypeOnly()) continue;
-			if (!matchesModule(declaration.getModuleSpecifierValue() ?? "", bambooModules)) continue;
-			if (declaration.isNamespaceExport()) {
+		for (const declaration of (0, _bamboocss_ts_ast.getExportDeclarations)(sourceFile)) {
+			if ((0, _bamboocss_ts_ast.isTypeOnly)(declaration)) continue;
+			if (!matchesModule((0, _bamboocss_ts_ast.getModuleSpecifierValue)(declaration) ?? "", bambooModules)) continue;
+			if ((0, _bamboocss_ts_ast.isStarExport)(declaration)) {
+				const namespace = (0, _bamboocss_ts_ast.getNamespaceExport)(declaration);
 				skipped.push({
-					name: declaration.getNamespaceExport()?.getName() ?? "*",
+					name: (namespace && (0, _bamboocss_ts_ast.getName)(namespace)) ?? "*",
 					reason: "runtime-binding",
 					start: declaration.getStart(),
 					end: declaration.getEnd()
 				});
 				continue;
 			}
-			for (const named of declaration.getNamedExports()) {
-				if (named.isTypeOnly()) continue;
-				const imported = named.getNameNode().getText();
-				if (PERMITTED_BINDINGS.has(imported)) continue;
+			for (const named of (0, _bamboocss_ts_ast.getNamedExports)(declaration)) {
+				if ((0, _bamboocss_ts_ast.isTypeOnly)(named)) continue;
+				const imported = (0, _bamboocss_ts_ast.nameNodeOf)(named)?.getText();
+				if (PERMITTED_BINDINGS.has(imported ?? "")) continue;
 				skipped.push({
-					name: imported,
+					name: imported ?? "",
 					reason: "runtime-binding",
 					start: named.getStart(),
 					end: named.getEnd()
 				});
 			}
 		}
-		for (const declaration of sourceFile.getExportDeclarations()) {
-			if (declaration.isTypeOnly() || declaration.getModuleSpecifier()) continue;
-			for (const named of declaration.getNamedExports()) {
-				if (named.isTypeOnly()) continue;
-				const imported = watched.get(named.getNameNode().getText());
+		for (const declaration of (0, _bamboocss_ts_ast.getExportDeclarations)(sourceFile)) {
+			if ((0, _bamboocss_ts_ast.isTypeOnly)(declaration) || (0, _bamboocss_ts_ast.childOf)(declaration, "moduleSpecifier")) continue;
+			for (const named of (0, _bamboocss_ts_ast.getNamedExports)(declaration)) {
+				if ((0, _bamboocss_ts_ast.isTypeOnly)(named)) continue;
+				const imported = watched.get((0, _bamboocss_ts_ast.nameNodeOf)(named)?.getText() ?? "");
 				if (imported === void 0) continue;
 				skipped.push({
-					name: imported,
+					name: imported ?? "",
 					reason: "runtime-binding",
 					start: named.getStart(),
 					end: named.getEnd()
@@ -2488,7 +2482,7 @@ const foldSource = (options) => {
 		const survivors = [];
 		for (const [local, imported] of watched) for (const identifier of identifiersByName().get(local)) {
 			const start = identifier.getStart();
-			if (identifier.getFirstAncestorByKind(ts_morph.SyntaxKind.ImportDeclaration)) continue;
+			if ((0, _bamboocss_ts_ast.getFirstAncestorByKind)(identifier, _bamboocss_ts_ast.SyntaxKind.ImportDeclaration)) continue;
 			if (applied.some(([from, to]) => start >= from && start < to)) continue;
 			if (declined.some(([from, to]) => start >= from && start < to)) continue;
 			if (!isValueReference(identifier)) continue;