@bamboocss/extractor 1.11.1 → 1.11.2

package/dist/index.cjs

@@ -0,0 +1,1832 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _bamboocss_shared = require("@bamboocss/shared");
+let ts_morph = require("ts-morph");
+let ts_evaluator = require("ts-evaluator");
+//#region src/get-typeof-literal.ts
+const getTypeOfLiteral = (value) => {
+	if (Array.isArray(value)) return "array";
+	if (typeof value === "string") return "string";
+	if (typeof value === "number") return "number";
+	if (typeof value === "boolean") return "boolean";
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	throw new _bamboocss_shared.BambooError("UNKNOWN_LITERAL_TYPE", `Unexpected literal type: ${value}. Expected: string, number, boolean, null, undefined, or array`);
+};
+//#endregion
+//#region src/utils.ts
+const isNotNullish = (element) => element != null;
+const isNullish = (element) => element == null;
+const isTruthyOrZero = (element) => !!element || element === 0;
+/** Returns true if typeof value is object && not null */
+const isObject = (value) => value != null && typeof value === "object";
+const isArray = (value) => Array.isArray(value);
+const isPrimitiveType = (value) => {
+	const type = typeof 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());
+	return node;
+};
+const getComponentName = (node) => {
+	return node.getTagNameNode().getText();
+};
+const whitespaceRegex = /\s+/g;
+const trimWhitespace = (str) => {
+	return str.replaceAll(whitespaceRegex, " ");
+};
+//#endregion
+//#region src/get-node-range.ts
+const getNodeRange = (node) => {
+	const src = node.getSourceFile();
+	const [startPosition, endPosition] = [node.getStart(), node.getEnd()];
+	const startInfo = src.getLineAndColumnAtPos(startPosition);
+	const endInfo = src.getLineAndColumnAtPos(endPosition);
+	return {
+		startPosition,
+		startLineNumber: startInfo.line,
+		startColumn: startInfo.column,
+		endPosition,
+		endLineNumber: endInfo.line,
+		endColumn: endInfo.column
+	};
+};
+//#endregion
+//#region src/box-factory.ts
+var BoxNodeType = class {
+	type;
+	stack = [];
+	node;
+	constructor(definition) {
+		this.type = definition.type;
+		this.node = definition.node;
+		this.stack = [...definition.stack ?? []];
+	}
+	getNode() {
+		return this.node;
+	}
+	getStack() {
+		return this.stack;
+	}
+	getRange = () => getNodeRange(this.node);
+	toJSON() {
+		const range = this.getRange();
+		return {
+			type: this.type,
+			value: this.value,
+			node: this.node.getKindName(),
+			line: range.startLineNumber,
+			column: range.startColumn,
+			endLineNumber: range.endLineNumber,
+			endColumn: range.endColumn
+		};
+	}
+	toString() {
+		return JSON.stringify(this.toJSON(), null, 2);
+	}
+};
+var BoxNodeObject = class extends BoxNodeType {
+	value;
+	isEmpty;
+	constructor(definition) {
+		super(definition);
+		this.value = definition.value;
+		this.isEmpty = definition.isEmpty;
+	}
+};
+var BoxNodeLiteral = class extends BoxNodeType {
+	value;
+	kind;
+	constructor(definition) {
+		super(definition);
+		this.value = definition.value;
+		this.kind = definition.kind;
+	}
+};
+const recipeProps = [
+	"compoundVariants",
+	"defaultVariants",
+	"variants",
+	"base"
+];
+var BoxNodeMap = class extends BoxNodeType {
+	value;
+	spreadConditions;
+	constructor(definition) {
+		super(definition);
+		this.value = definition.value;
+	}
+	isRecipe = () => {
+		return recipeProps.some((prop) => this.value.has(prop));
+	};
+};
+var BoxNodeArray = class extends BoxNodeType {
+	value;
+	constructor(definition) {
+		super(definition);
+		this.value = definition.value;
+	}
+};
+var BoxNodeUnresolvable = class extends BoxNodeType {};
+var BoxNodeConditional = class extends BoxNodeType {
+	whenTrue;
+	whenFalse;
+	constructor(definition) {
+		super(definition);
+		this.whenTrue = definition.whenTrue;
+		this.whenFalse = definition.whenFalse;
+	}
+};
+var BoxNodeEmptyInitializer = class extends BoxNodeType {};
+const isBoxNode = (value) => value instanceof BoxNodeType;
+//#endregion
+//#region src/to-box-node.ts
+function toBoxNode(value, node, stack) {
+	if (isNullish(value)) return;
+	if (isBoxNode(value)) return value;
+	if (isObject(value)) return box.object(value, node, stack);
+	if (isArray(value)) {
+		if (value.length === 1) return toBoxNode(value[0], node, stack);
+		return value.map((item) => toBoxNode(item, node, stack));
+	}
+	if (isPrimitiveType(value)) return box.literal(value, node, stack);
+}
+//#endregion
+//#region src/box.ts
+const box = {
+	object(value, node, stack) {
+		return new BoxNodeObject({
+			type: "object",
+			value,
+			node,
+			stack
+		});
+	},
+	literal(value, node, stack) {
+		return new BoxNodeLiteral({
+			type: "literal",
+			value,
+			kind: getTypeOfLiteral(value),
+			node,
+			stack
+		});
+	},
+	map(value, node, stack) {
+		return new BoxNodeMap({
+			type: "map",
+			value,
+			node,
+			stack
+		});
+	},
+	array(value, node, stack) {
+		return new BoxNodeArray({
+			type: "array",
+			value,
+			node,
+			stack
+		});
+	},
+	conditional(whenTrue, whenFalse, node, stack) {
+		return new BoxNodeConditional({
+			type: "conditional",
+			whenTrue,
+			whenFalse,
+			node,
+			stack
+		});
+	},
+	from: toBoxNode,
+	objectToMap: (value, node, stack) => {
+		return new BoxNodeMap({
+			type: "map",
+			value: new Map(Object.entries(value).map(([k, v]) => {
+				return [k, box.from(v, node, stack) || null];
+			})),
+			node,
+			stack
+		});
+	},
+	emptyObject: (node, stack) => {
+		return new BoxNodeObject({
+			type: "object",
+			value: {},
+			isEmpty: true,
+			node,
+			stack
+		});
+	},
+	emptyInitializer: (node, stack) => {
+		return new BoxNodeEmptyInitializer({
+			type: "empty-initializer",
+			node,
+			stack
+		});
+	},
+	unresolvable: (node, stack) => {
+		return new BoxNodeUnresolvable({
+			type: "unresolvable",
+			node,
+			stack
+		});
+	},
+	fallback(node) {
+		return {
+			value: void 0,
+			getNode: () => node.getNode(),
+			getStack: () => node.getStack(),
+			getRange: () => node.getRange()
+		};
+	},
+	/**
+	* box.type === “object” -> object that was resolved using ts-evaluator, most likely from a
+	* complex condition OR a simple CallExpression eval result, we don’t have access to individual
+	* AST nodes here so we need the distinction
+	*/
+	isObject(value) {
+		return value?.type === "object";
+	},
+	isLiteral(value) {
+		return value?.type === "literal";
+	},
+	/**
+	* box.type === “map” -> basically any object that was statically analyzable, we store each
+	* prop + value in a Map
+	*/
+	isMap(value) {
+		return value?.type === "map";
+	},
+	isRecipe(value) {
+		return box.isMap(value) && value.isRecipe();
+	},
+	isArray(value) {
+		return value?.type === "array";
+	},
+	isUnresolvable(value) {
+		return value?.type === "unresolvable";
+	},
+	isConditional(value) {
+		return value?.type === "conditional";
+	},
+	isEmptyInitializer(value) {
+		return value?.type === "empty-initializer";
+	},
+	isNumberLiteral(node) {
+		return box.isLiteral(node) && node.kind === "number";
+	},
+	hasValue: (node) => {
+		return box.isObject(node) || box.isLiteral(node) || box.isMap(node) || box.isArray(node);
+	}
+};
+//#endregion
+//#region src/evaluate-node.ts
+const TsEvalError = Symbol("EvalError");
+const cacheMap$2 = /* @__PURE__ */ new WeakMap();
+/**
+* Evaluates a node with strict policies restrictions
+* @see https://github.com/wessberg/ts-evaluator#setting-up-policies
+*/
+const evaluateNode = (node, stack, ctx) => {
+	if (ctx.flags?.skipEvaluate) return;
+	if (ctx.canEval && !ctx.canEval?.(node, stack)) return;
+	if (cacheMap$2.has(node)) return cacheMap$2.get(node);
+	const result = (0, ts_evaluator.evaluate)({
+		policy: {
+			deterministic: true,
+			network: false,
+			console: false,
+			maxOps: Number.POSITIVE_INFINITY,
+			maxOpDuration: 1e3,
+			io: {
+				read: true,
+				write: false
+			},
+			process: {
+				exit: false,
+				spawnChild: false
+			}
+		},
+		...ctx.getEvaluateOptions?.(node, stack),
+		node: node.compilerNode,
+		typescript: ts_morph.ts
+	});
+	const expr = result.success ? result.value : TsEvalError;
+	cacheMap$2.set(node, expr);
+	return expr;
+};
+const safeEvaluateNode = (node, stack, ctx) => {
+	const result = evaluateNode(node, stack, ctx);
+	if (result === TsEvalError) return;
+	return result;
+};
+//#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);
+}
+function getDeclarationFor(node, stack, ctx) {
+	const parent = node.getParent();
+	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) {
+		declarationStack.push(parent);
+		declaration = parent;
+	} else if (ts_morph.Node.isImportSpecifier(parent) && parent.getNameNode() == node) {
+		if (ctx.flags?.skipTraverseFiles) return;
+		const sourceFile = getModuleSpecifierSourceFile(parent.getImportDeclaration());
+		if (sourceFile) {
+			const exportStack = [parent, sourceFile];
+			const maybeVar = getExportedVarDeclarationWithName(node.getText(), sourceFile, exportStack, ctx);
+			if (maybeVar) {
+				declarationStack.push(...exportStack.concat(maybeVar));
+				declaration = maybeVar;
+			}
+		}
+	}
+	if (declaration) stack.push(...declarationStack);
+	return declaration;
+}
+const getInnermostScope = (from) => {
+	let scope = from.getParent();
+	while (scope && !isScope(scope)) scope = scope.getParent();
+	return scope;
+};
+function findIdentifierValueDeclaration(identifier, stack, ctx, visitedsWithStack = /* @__PURE__ */ new Map()) {
+	let scope = identifier;
+	let foundNode;
+	let isUnresolvable = false;
+	let count = 0;
+	const innerStack = [];
+	do {
+		scope = getInnermostScope(scope);
+		count++;
+		if (!scope) return;
+		const refName = identifier.getText();
+		scope.forEachDescendant((node, traversal) => {
+			if (visitedsWithStack.has(node)) {
+				traversal.skip();
+				innerStack.push(...visitedsWithStack.get(node));
+				return;
+			}
+			if (node == identifier) return;
+			visitedsWithStack.set(node, innerStack);
+			if (ts_morph.Node.isIdentifier(node) && node.getText() == refName) {
+				const declarationStack = [node];
+				const maybeDeclaration = getDeclarationFor(node, declarationStack, ctx);
+				if (maybeDeclaration) {
+					if (ts_morph.Node.isParameterDeclaration(maybeDeclaration)) {
+						const initializer = maybeDeclaration.getInitializer();
+						const typeNode = maybeDeclaration.getTypeNode();
+						if (initializer) {
+							innerStack.push(...declarationStack.concat(initializer));
+							foundNode = maybeDeclaration;
+						} else if (typeNode && ts_morph.Node.isTypeLiteral(typeNode)) {
+							innerStack.push(...declarationStack.concat(typeNode));
+							foundNode = maybeDeclaration;
+						} else isUnresolvable = true;
+						traversal.stop();
+						return;
+					}
+					innerStack.push(...declarationStack);
+					foundNode = maybeDeclaration;
+					traversal.stop();
+				}
+			}
+		});
+		if (foundNode || isUnresolvable) {
+			if (foundNode) stack.push(...innerStack);
+			return foundNode;
+		}
+	} while (scope && !ts_morph.Node.isSourceFile(scope) && !foundNode && !isUnresolvable && 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();
+			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 (ts_morph.Node.isShorthandPropertyAssignment(property)) {
+		const name = property.getName();
+		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();
+			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);
+	}
+};
+//#endregion
+//#region src/get-object-literal-expression-prop-pairs.ts
+const getObjectLiteralExpressionPropPairs = (expression, expressionStack, ctx, matchProp) => {
+	const properties = expression.getProperties();
+	if (properties.length === 0) return box.emptyObject(expression, expressionStack);
+	const extractedPropValues = [];
+	const spreadConditions = [];
+	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)) {
+			const propNameBox = getPropertyName(property, stack, ctx);
+			if (!propNameBox) return;
+			const propName = propNameBox.value;
+			if (isNullish(propName)) return;
+			if (matchProp && !matchProp?.({
+				propName,
+				propNode: property
+			})) return;
+			if (ts_morph.Node.isShorthandPropertyAssignment(property)) {
+				const initializer = property.getNameNode();
+				stack.push(initializer);
+				const maybeValue = maybeBoxNode(initializer, stack, ctx);
+				if (maybeValue) {
+					extractedPropValues.push([propName.toString(), maybeValue]);
+					return;
+				}
+			}
+			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 (!init) return;
+			const initializer = unwrapExpression((ts_morph.Node.isReturnStatement(init) ? init.getExpression() : void 0) ?? init);
+			stack.push(initializer);
+			const maybeValue = maybeBoxNode(initializer, stack, ctx);
+			if (maybeValue) {
+				extractedPropValues.push([propName.toString(), maybeValue]);
+				return;
+			}
+		}
+		if (ts_morph.Node.isSpreadAssignment(property)) {
+			const initializer = unwrapExpression(property.getExpression());
+			stack.push(initializer);
+			const maybeObject = maybeBoxNode(initializer, stack, ctx, matchProp);
+			if (!maybeObject) return;
+			if (box.isObject(maybeObject)) {
+				Object.entries(maybeObject.value).forEach(([propName, value]) => {
+					const boxNode = box.from(value, initializer, stack);
+					if (!boxNode) return;
+					extractedPropValues.push([propName, boxNode]);
+				});
+				return;
+			}
+			if (box.isMap(maybeObject)) {
+				maybeObject.value.forEach((nested, propName) => {
+					extractedPropValues.push([propName, nested]);
+				});
+				return;
+			}
+			if (box.isConditional(maybeObject)) spreadConditions.push(maybeObject);
+		}
+	});
+	const orderedMapValue = /* @__PURE__ */ new Map();
+	extractedPropValues.forEach(([propName, value]) => {
+		if (orderedMapValue.has(propName)) orderedMapValue.delete(propName);
+		orderedMapValue.set(propName, value);
+	});
+	const map = box.map(orderedMapValue, expression, expressionStack);
+	if (spreadConditions.length > 0) map.spreadConditions = spreadConditions;
+	return map;
+};
+//#endregion
+//#region src/maybe-box-node.ts
+const cacheMap$1 = /* @__PURE__ */ new WeakMap();
+const isCached = (node) => cacheMap$1.has(node);
+const getCached = (node) => cacheMap$1.get(node);
+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 canReturnWhenTrueInLogicalExpression = (op) => {
+	return op === ts_morph.ts.SyntaxKind.BarBarToken || op === ts_morph.ts.SyntaxKind.QuestionQuestionToken;
+};
+function maybeBoxNode(node, stack, ctx, matchProp) {
+	const cache = (value) => {
+		cacheMap$1.set(node, value);
+		return value;
+	};
+	if (isCached(node)) return getCached(node);
+	if (ts_morph.Node.isStringLiteral(node) || ts_morph.Node.isNoSubstitutionTemplateLiteral(node)) {
+		const value = trimWhitespace(node.getLiteralValue());
+		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();
+		return cache(box.literal(value, node, stack));
+	}
+	if (ts_morph.Node.isNumericLiteral(node)) {
+		const value = node.getLiteralValue();
+		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();
+		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);
+	}
+	if (ts_morph.Node.isArrayLiteralExpression(node)) {
+		const boxNodes = node.getElements().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 (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)) {
+		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 (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 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));
+		if (box.isUnresolvable(condValue) || box.isConditional(condValue) || isFromDefaultBinding) return cache(maybeResolveConditionalExpression({
+			whenTrueExpr: unwrapExpression(node.getWhenTrue()),
+			whenFalseExpr: unwrapExpression(node.getWhenFalse()),
+			node,
+			stack
+		}, ctx));
+		if (condValue.value) {
+			const whenTrueExpr = unwrapExpression(node.getWhenTrue());
+			return cache(maybeBoxNode(whenTrueExpr, [...stack], ctx) ?? box.unresolvable(whenTrueExpr, stack));
+		}
+		return cache(maybeBoxNode(unwrapExpression(node.getWhenFalse()), [...stack], ctx) ?? box.unresolvable(node, stack));
+	}
+	if (ts_morph.Node.isCallExpression(node)) {
+		if (ctx.tokens) {
+			const expr = node.getExpression();
+			let fnName = "";
+			let isVarMethod = false;
+			if (ts_morph.Node.isIdentifier(expr)) fnName = expr.getText();
+			else if (ts_morph.Node.isPropertyAccessExpression(expr)) {
+				const exprName = expr.getExpression();
+				const propertyName = expr.getName();
+				if (ts_morph.Node.isIdentifier(exprName)) {
+					fnName = exprName.getText();
+					isVarMethod = propertyName === "var";
+				}
+			}
+			if (ctx.tokens.isTokenFn ? ctx.tokens.isTokenFn(fnName) : fnName === "token") {
+				const args = node.getArguments();
+				const tokenPathArg = args[0];
+				if (tokenPathArg && ts_morph.Node.isStringLiteral(tokenPathArg)) {
+					const tokenPath = tokenPathArg.getLiteralValue();
+					const fallbackArg = args[1];
+					const fallbackValue = fallbackArg && ts_morph.Node.isStringLiteral(fallbackArg) ? fallbackArg.getLiteralValue() : void 0;
+					const resolvedValue = isVarMethod ? ctx.tokens.view.getVar(tokenPath, fallbackValue) : ctx.tokens.view.get(tokenPath, fallbackValue);
+					if (resolvedValue) return cache(box.literal(resolvedValue, node, stack));
+				}
+			}
+		}
+		const value = safeEvaluateNode(node, stack, ctx);
+		if (!value) return;
+		return cache(box.from(value, node, stack));
+	}
+	if (ts_morph.Node.isBinaryExpression(node)) {
+		const operatorKind = node.getOperatorToken().getKind();
+		if (isPlusSyntax(operatorKind)) {
+			const value = tryComputingPlusTokenBinaryExpressionToString(node, stack, ctx) ?? safeEvaluateNode(node, stack, ctx);
+			if (!value) return;
+			return cache(box.from(value, node, stack));
+		}
+		if (isLogicalSyntax(operatorKind)) return cache(maybeResolveConditionalExpression({
+			whenTrueExpr: unwrapExpression(node.getLeft()),
+			whenFalseExpr: unwrapExpression(node.getRight()),
+			node,
+			stack,
+			canReturnWhenTrue: canReturnWhenTrueInLogicalExpression(operatorKind)
+		}, ctx));
+		if (isOperationSyntax(operatorKind)) return cache(box.literal(safeEvaluateNode(node, stack, ctx), node, stack));
+	}
+}
+const onlyStringLiteral = (boxNode) => {
+	if (!boxNode) return;
+	if (isBoxNode(boxNode) && box.isLiteral(boxNode) && typeof boxNode.value === "string") return boxNode;
+};
+const onlyNumberLiteral = (boxNode) => {
+	if (!boxNode) return;
+	if (isBoxNode(boxNode) && box.isLiteral(boxNode) && typeof boxNode.value === "number") return boxNode;
+};
+const maybeStringLiteral = (node, stack, ctx) => onlyStringLiteral(maybeBoxNode(node, stack, ctx));
+const maybePropName = (node, stack, ctx) => {
+	const boxed = maybeBoxNode(node, stack, ctx);
+	const strBox = onlyStringLiteral(boxed);
+	if (strBox) return strBox;
+	const numberBox = onlyNumberLiteral(boxed);
+	if (numberBox) return numberBox;
+};
+const maybeResolveConditionalExpression = ({ whenTrueExpr, whenFalseExpr, node, stack, canReturnWhenTrue }, ctx) => {
+	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 (!whenTrueValue && !whenFalseValue) return;
+	if (whenTrueValue && !whenFalseValue) return whenTrueValue;
+	if (!whenTrueValue && whenFalseValue) return whenFalseValue;
+	const whenTrue = whenTrueValue;
+	const whenFalse = whenFalseValue;
+	if (box.isLiteral(whenTrue) && box.isLiteral(whenFalse) && whenTrue.value === whenFalse.value) return whenTrue;
+	return box.conditional(whenTrue, whenFalse, node, stack);
+};
+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) {
+			stack.push(name);
+			return node;
+		}
+		if (ts_morph.Node.isStringLiteral(name) && name.getLiteralText() === propName) {
+			stack.push(name);
+			return name.getLiteralText();
+		}
+		if (ts_morph.Node.isComputedPropertyName(name)) {
+			const expression = unwrapExpression(name.getExpression());
+			const computedPropNameBox = maybePropName(expression, stack, ctx);
+			if (!computedPropNameBox) return;
+			if (String(computedPropNameBox.value) === propName) {
+				stack.push(name, expression);
+				return node;
+			}
+		}
+	}
+	if (ts_morph.Node.isShorthandPropertyAssignment(node)) {
+		const name = node.getNameNode();
+		if (ts_morph.Node.isIdentifier(name) && name.getText() === propName) {
+			stack.push(name);
+			return node;
+		}
+	}
+};
+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));
+	if (!property) return;
+	stack.push(property);
+	if (ts_morph.Node.isPropertyAssignment(property)) {
+		const propInit = property.getInitializer();
+		if (!propInit) return;
+		if (ts_morph.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 (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 headValue = maybeStringLiteral(head, stack, ctx);
+	if (!headValue) return;
+	const tailValues = tail.map((t) => {
+		const propBox = maybePropName(t.getExpression(), stack, ctx);
+		if (!propBox) return;
+		const literal = t.getLiteral();
+		return propBox.value + literal.getLiteralText();
+	});
+	if (tailValues.every(isNotNullish)) return headValue.value + tailValues.join("");
+};
+const maybeBindingElementValue = (def, stack, propName, ctx) => {
+	const parent = def.getParent();
+	if (!parent) return;
+	const grandParent = parent.getParent();
+	if (!grandParent) return;
+	if (ts_morph.Node.isArrayBindingPattern(parent)) {
+		const index = parent.getChildIndex();
+		if (Number.isNaN(index)) return;
+		if (ts_morph.Node.isVariableDeclaration(grandParent)) {
+			const init = grandParent.getInitializer();
+			if (!init) return;
+			const initializer = unwrapExpression(init);
+			if (!ts_morph.Node.isArrayLiteralExpression(initializer)) return;
+			const element = initializer.getElements()[index + 1];
+			if (!element) return;
+			const innerStack = [
+				...stack,
+				initializer,
+				element
+			];
+			const maybeObject = maybeBoxNode(element, innerStack, ctx);
+			if (!maybeObject) return;
+			if (box.isObject(maybeObject)) {
+				const propValue = maybeObject.value[propName];
+				return box.from(propValue, element, innerStack);
+			}
+			if (!box.isMap(maybeObject)) return maybeObject;
+			const propValue = maybeObject.value.get(propName);
+			if (!propValue) return;
+			return propValue;
+		}
+	}
+	if (ts_morph.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 (!init) {
+			const type = def.getTypeNode();
+			if (!type) return;
+			if (ts_morph.Node.isTypeLiteral(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)) {
+						stack.push(typeProp, typeLiteral);
+						propName = accessList.pop();
+						typeProp = typeLiteral.getProperty(propName);
+						typeLiteral = typeProp?.getTypeNode();
+					}
+					if (!typeLiteral) return;
+					const typeValue = getTypeNodeValue(typeLiteral, stack, ctx);
+					return box.from(typeValue, typeLiteral, stack);
+				}
+				const propValue = getTypeLiteralNodePropValue(type, propName, _stack, ctx);
+				_stack.push(type);
+				return box.from(propValue, type, _stack);
+			}
+			return;
+		}
+		const initializer = unwrapExpression(init);
+		if (ts_morph.Node.isObjectLiteralExpression(initializer)) {
+			const propValue = getObjectLiteralPropValue(initializer, accessList, _stack, ctx);
+			if (!propValue) return;
+			_stack.push(initializer);
+			return propValue;
+		}
+		if (ts_morph.Node.isArrayLiteralExpression(initializer)) {
+			const index = Number(propName);
+			if (Number.isNaN(index)) return;
+			const element = initializer.getElements()[index];
+			if (!element) return;
+			_stack.push(initializer);
+			const boxed = maybeBoxNode(element, _stack, ctx);
+			if (boxed && isBoxNode(boxed) && box.isLiteral(boxed)) return boxed;
+		}
+		const maybeValue = maybeBoxNode(initializer, [..._stack, initializer], ctx);
+		if (maybeValue) return maybeValue;
+	}
+	if (ts_morph.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 (!member) return;
+		const initializer = member.getInitializer();
+		if (!initializer) return;
+		const maybeValue = maybeBoxNode(initializer, [..._stack, initializer], ctx);
+		if (maybeValue) return maybeValue;
+	}
+}
+const maybePropIdentifierValue = (identifier, accessList, _stack, ctx) => {
+	const maybeValueDeclaration = findIdentifierValueDeclaration(identifier, _stack, ctx);
+	if (!maybeValueDeclaration) return box.unresolvable(identifier, _stack);
+	const maybeValue = maybePropDefinitionValue(maybeValueDeclaration, accessList, _stack, ctx);
+	if (maybeValue) return maybeValue;
+	return box.unresolvable(identifier, _stack);
+};
+const typeLiteralCache = /* @__PURE__ */ new WeakMap();
+const getTypeLiteralNodePropValue = (type, propName, stack, ctx) => {
+	if (typeLiteralCache.has(type)) {
+		const map = typeLiteralCache.get(type);
+		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();
+		if (!propType) {
+			typeLiteralCache.set(type, null);
+			return;
+		}
+		const propValue = getTypeNodeValue(propType, stack, ctx);
+		if (isNotNullish(propValue)) {
+			if (!typeLiteralCache.has(type)) typeLiteralCache.set(type, /* @__PURE__ */ new Map());
+			typeLiteralCache.get(type).set(propName, propValue);
+			return propValue;
+		}
+	}
+	typeLiteralCache.set(type, null);
+};
+function getNameLiteral(wrapper) {
+	if (ts_morph.Node.isStringLiteral(wrapper)) return wrapper.getLiteralText();
+	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();
+			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())) {
+			const entries = members.map((member) => {
+				const nameNode = member.getNameNode();
+				const nameText = nameNode.getText();
+				const name = getNameLiteral(nameNode);
+				if (!name) return;
+				return [name, getTypeLiteralNodePropValue(type, nameText, stack, ctx)];
+			}).filter(isNotNullish);
+			const result = Object.fromEntries(entries);
+			typeNodeCache.set(type, result);
+			return result;
+		}
+	}
+	typeNodeCache.set(type, void 0);
+};
+const maybeDefinitionValue = (def, stack, ctx) => {
+	if (ts_morph.Node.isShorthandPropertyAssignment(def)) {
+		const propNameNode = def.getNameNode();
+		return maybePropIdentifierValue(propNameNode, [propNameNode.getText()], stack, ctx);
+	}
+	if (ts_morph.Node.isVariableDeclaration(def)) {
+		const init = def.getInitializer();
+		if (!init) {
+			const type = def.getTypeNode();
+			if (!type) return;
+			if (ts_morph.Node.isTypeLiteral(type)) {
+				stack.push(type);
+				const maybeTypeValue = getTypeNodeValue(type, stack, ctx);
+				if (isNotNullish(maybeTypeValue)) return box.from(maybeTypeValue, def, stack);
+			}
+			return box.unresolvable(def, stack);
+		}
+		const initializer = unwrapExpression(init);
+		const maybeValue = maybeBoxNode(initializer, [...stack, initializer], ctx);
+		if (maybeValue) return maybeValue;
+	}
+	if (ts_morph.Node.isBindingElement(def)) {
+		const init = def.getInitializer();
+		if (!init) {
+			const nameNode = def.getPropertyNameNode() ?? def.getNameNode();
+			const propName = nameNode.getText();
+			const value = maybeBindingElementValue(def, [...stack, nameNode], propName, ctx);
+			if (value) return value;
+			return box.unresolvable(def, stack);
+		}
+		const initializer = unwrapExpression(init);
+		const maybeValue = maybeBoxNode(initializer, [...stack, initializer], ctx);
+		if (maybeValue) return maybeValue;
+	}
+};
+const getExportedVarDeclarationWithName = (varName, sourceFile, stack, ctx) => {
+	const maybeVar = sourceFile.getVariableDeclaration(varName);
+	if (maybeVar) return maybeVar;
+	const exportDeclaration = resolveVarDeclarationFromExportWithName(varName, sourceFile, stack, ctx);
+	if (!exportDeclaration) return;
+	return exportDeclaration;
+};
+const hasNamedExportWithName = (name, exportDeclaration) => {
+	const namedExports = exportDeclaration.getNamedExports();
+	if (namedExports.length === 0) return true;
+	for (const namedExport of namedExports) if (namedExport.getNameNode().getText() === name) return true;
+};
+/**
+* Faster than declaration.getModuleSpecifierSourceFile()
+*
+* since it does NOT require a call to `initializeTypeChecker`
+* > getModuleSpecifierSourceFile > getSymbol > getTypechecker > createTypeChecker > initializeTypeChecker
+*
+* which costs a minimum of around 90ms (and scales up with the file/project, could be hundreds of ms)
+* @see https://github.com/dsherret/ts-morph/blob/42d811ed9a5177fc678a5bfec4923a2048124fe0/packages/ts-morph/src/compiler/ast/module/ExportDeclaration.ts#L160
+*/
+const getModuleSpecifierSourceFile = (declaration) => {
+	const project = declaration.getProject();
+	const moduleName = declaration.getModuleSpecifierValue();
+	if (!moduleName) return;
+	const containingFile = declaration.getSourceFile().getFilePath();
+	const resolved = ts_morph.ts.resolveModuleName(moduleName, containingFile, project.getCompilerOptions(), project.getModuleResolutionHost());
+	if (!resolved.resolvedModule) return;
+	return project.addSourceFileAtPath(resolved.resolvedModule.resolvedFileName);
+};
+function resolveVarDeclarationFromExportWithName(symbolName, sourceFile, stack, ctx) {
+	for (const exportDeclaration of sourceFile.getExportDeclarations()) {
+		const exportStack = [exportDeclaration];
+		if (!hasNamedExportWithName(symbolName, exportDeclaration)) continue;
+		const maybeFile = getModuleSpecifierSourceFile(exportDeclaration);
+		if (!maybeFile) continue;
+		exportStack.push(maybeFile);
+		const maybeVar = getExportedVarDeclarationWithName(symbolName, maybeFile, stack, ctx);
+		if (maybeVar) {
+			stack.push(...exportStack.concat(maybeVar));
+			return maybeVar;
+		}
+	}
+}
+const maybeIdentifierValue = (identifier, _stack, ctx) => {
+	const valueDeclaration = findIdentifierValueDeclaration(identifier, _stack, ctx);
+	if (!valueDeclaration) return box.unresolvable(identifier, _stack);
+	const declaration = unwrapExpression(valueDeclaration);
+	const stack = [..._stack];
+	const maybeValue = maybeDefinitionValue(declaration, stack, ctx);
+	if (maybeValue) return maybeValue;
+	return box.unresolvable(identifier, stack);
+};
+const tryComputingPlusTokenBinaryExpressionToString = (node, stack, ctx) => {
+	const left = unwrapExpression(node.getLeft());
+	const right = unwrapExpression(node.getRight());
+	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();
+	if (!argExpr) return;
+	const arg = unwrapExpression(argExpr);
+	const stack = [
+		..._stack,
+		elementAccessed,
+		arg
+	];
+	const argLiteral = maybePropName(arg, stack, ctx);
+	if (ts_morph.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;
+		const propName = tryComputingPlusTokenBinaryExpressionToString(arg, stack, ctx) ?? maybePropName(arg, stack, ctx);
+		if (propName && ts_morph.Node.isIdentifier(elementAccessed)) {
+			if (!isNotNullish(propName.value)) return;
+			return maybePropIdentifierValue(elementAccessed, [propName.value.toString()], stack, ctx);
+		}
+	}
+	if (ts_morph.Node.isTemplateExpression(arg)) {
+		const propName = maybeTemplateStringValue(arg, stack, ctx);
+		if (propName && ts_morph.Node.isIdentifier(elementAccessed)) return maybePropIdentifierValue(elementAccessed, [propName], stack, ctx);
+	}
+	if (ts_morph.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)) {
+		const propRefValue = getPropertyAccessedExpressionValue(elementAccessed, [], stack, ctx);
+		if (!propRefValue) return box.unresolvable(elementAccessed, stack);
+		const propName = argLiteral.value.toString();
+		if (box.isObject(propRefValue)) {
+			const propValue = propRefValue.value[propName];
+			return box.from(propValue, arg, stack);
+		}
+		if (box.isMap(propRefValue)) {
+			const propValue = propRefValue.value.get(propName);
+			return box.from(propValue, arg, stack);
+		}
+		if (box.isArray(propRefValue)) {
+			const propValue = propRefValue.value[Number(propName)];
+			return box.from(propValue, arg, stack);
+		}
+		return box.unresolvable(elementAccessed, stack);
+	}
+	if (ts_morph.Node.isIdentifier(elementAccessed) && ts_morph.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)) {
+		const identifier = getElementAccessedExpressionValue(elementAccessed, stack, ctx);
+		if (isObject(identifier)) {
+			const argValue = argLiteral.value.toString();
+			if (box.isMap(identifier)) return identifier.value.get(argValue);
+			if (box.isObject(identifier)) {
+				const maybeLiteralValue = identifier.value[argValue];
+				if (!maybeLiteralValue) return;
+				return box.from(maybeLiteralValue, expression, stack);
+			}
+		}
+	}
+	if (ts_morph.Node.isArrayLiteralExpression(elementAccessed) && argLiteral) return getArrayElementValueAtIndex(elementAccessed, Number(argLiteral.value), stack, ctx);
+	if (ts_morph.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);
+		}
+		const whenTrueExpr = unwrapExpression(arg.getWhenTrue());
+		const whenFalseExpr = unwrapExpression(arg.getWhenFalse());
+		const whenTrueValue = maybePropName(whenTrueExpr, stack, ctx);
+		const whenFalseValue = maybePropName(whenFalseExpr, stack, ctx);
+		if (ts_morph.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;
+			if (whenTrueResolved && !whenFalseResolved) return whenTrueResolved;
+			if (!whenTrueResolved && whenFalseResolved) return whenFalseResolved;
+			return box.conditional(whenTrueResolved, whenFalseResolved, arg, stack);
+		}
+	}
+};
+const getArrayElementValueAtIndex = (array, index, stack, ctx) => {
+	const element = array.getElements()[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);
+	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)) {
+		const leftElementAccessed = getElementAccessedExpressionValue(elementAccessed, stack, ctx);
+		if (!leftElementAccessed) return;
+		if (box.isObject(leftElementAccessed)) {
+			const propValue = leftElementAccessed.value[propName];
+			return box.from(propValue, expression, stack);
+		}
+		if (box.isMap(leftElementAccessed)) {
+			const propValue = leftElementAccessed.value.get(propName);
+			return box.from(propValue, expression, stack);
+		}
+	}
+};
+//#endregion
+//#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();
+	if (fnArguments.length === 0) return box.array([], node, []);
+	return box.array(fnArguments.map((argument, index) => {
+		const argNode = unwrapExpression(argument);
+		const stack = [node, argNode];
+		if (matchArg({
+			fnNode: node,
+			fnName,
+			argNode,
+			index
+		})) return maybeBoxNode(argNode, stack, ctx, matchProp) ?? box.unresolvable(argNode, stack);
+		return box.unresolvable(argNode, stack);
+	}), node, []);
+};
+//#endregion
+//#region src/compiled-jsx.ts
+const reactRuntimeMods = new Set(["react/jsx-runtime", "react/jsx-dev-runtime"]);
+const preactRuntimeMods = new Set(["preact/jsx-runtime", "preact/jsx-dev-runtime"]);
+const classicReactMods = new Set(["react"]);
+const classicPreactMods = new Set(["preact"]);
+const solidMods = new Set(["solid-js", "solid-js/web"]);
+const vueMods = new Set(["vue"]);
+const resolveBundledHelperImport = (name, node) => {
+	if (!node) return;
+	const text = node.getText();
+	const isVueBundledCreateVNode = text.includes("type, props = null, children = null") && (text.includes("createBaseVNode") && text.includes("guardReactiveProps") || text.includes("patchFlag = -2") && text.includes("__vccOpts") && text.includes("shapeFlag"));
+	const isVueBundledCreateVNodeTransform = name.includes("createVNodeWithArgsTransform") && text.includes("...args") && text.includes("_createVNode");
+	const isVueBundledMergeProps = text.includes("const ret = {}") && text.includes("toMerge = args[i]") && text.includes("ret[key] = toMerge[key]") && text.includes("key !== \"\"");
+	const isSolidBundledCreateComponent = name === "createComponent" && text.includes("Comp(props || {})") && text.includes("untrack");
+	const isSolidBundledMergeProps = name === "mergeProps" && text.includes("...sources") && text.includes("resolveSource") && text.includes("sources.length");
+	const isPreactBundledJsxHelper = text.includes("type:") && text.includes("props:") && text.includes("__v:") && text.includes("defaultProps") && text.includes(".vnode");
+	if (isVueBundledCreateVNode || isVueBundledCreateVNodeTransform) return {
+		importedName: "createVNode",
+		mod: "vue"
+	};
+	if (isVueBundledMergeProps) return {
+		importedName: "mergeProps",
+		mod: "vue"
+	};
+	if (isSolidBundledCreateComponent) return {
+		importedName: "createComponent",
+		mod: "solid-js/web"
+	};
+	if (isSolidBundledMergeProps) return {
+		importedName: "mergeProps",
+		mod: "solid-js"
+	};
+	if (isPreactBundledJsxHelper) return {
+		importedName: "jsx",
+		mod: "preact/jsx-runtime"
+	};
+};
+const collectImports = (sourceFile) => {
+	const named = /* @__PURE__ */ new Map();
+	const defaultImports = /* @__PURE__ */ new Map();
+	const namespace = /* @__PURE__ */ new Map();
+	const bundledNamed = /* @__PURE__ */ new Map();
+	const bundledNamespace = /* @__PURE__ */ new Map();
+	const getBundledRuntimeModFromName = (name) => {
+		const normalized = name.replace(/[^a-z]/gi, "").toLowerCase();
+		if (normalized.includes("jsxdevruntime")) return "react/jsx-dev-runtime";
+		if (normalized.includes("jsxruntime")) return "react/jsx-runtime";
+		if (normalized === "react" || normalized.endsWith("react")) return "react";
+	};
+	const parcelRuntimeModuleIds = /* @__PURE__ */ new Map();
+	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;
+			const calleeName = callee.getText();
+			if (/requirejsxdevruntime/i.test(calleeName)) return "react/jsx-dev-runtime";
+			if (/requirejsxruntime/i.test(calleeName)) return "react/jsx-runtime";
+			if (/requirereact/i.test(calleeName)) return "react";
+		}
+	};
+	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");
+	});
+	sourceFile.getImportDeclarations().forEach((declaration) => {
+		const mod = declaration.getModuleSpecifierValue();
+		if (!mod) return;
+		const defaultImport = declaration.getDefaultImport();
+		if (defaultImport) defaultImports.set(defaultImport.getText(), mod);
+		const namespaceImport = declaration.getNamespaceImport();
+		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,
+				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());
+		}
+		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();
+			}).filter(Boolean));
+			if (propertyNames.has("jsx") && propertyNames.has("Fragment")) mod = "preact/jsx-runtime";
+		}
+		if (!mod) return;
+		bundledNamespace.set(variableName, mod);
+	});
+	sourceFile.getDescendantsOfKind(ts_morph.SyntaxKind.FunctionDeclaration).forEach((declaration) => {
+		const bundledImport = resolveBundledHelperImport(declaration.getName() ?? "", declaration);
+		if (!bundledImport || !declaration.getName()) return;
+		bundledNamed.set(declaration.getName(), 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());
+	};
+	sourceFile.getVariableDeclarations().forEach((declaration) => {
+		if (!ts_morph.Node.isIdentifier(declaration.getNameNode())) return;
+		if (bundledNamed.has(declaration.getName())) return;
+		const bundledAlias = resolveBundledAliasImport(declaration.getInitializer());
+		if (!bundledAlias) return;
+		bundledNamed.set(declaration.getName(), bundledAlias);
+	});
+	return {
+		named,
+		default: defaultImports,
+		namespace,
+		bundledNamed,
+		bundledNamespace
+	};
+};
+const normalizeTagName = (text) => {
+	const parcelVarMatch = text.match(/\$[^$]+\$var\$(.+)$/);
+	if (parcelVarMatch?.[1]) return parcelVarMatch[1];
+	return 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());
+};
+const isQwikMod = (mod) => mod.includes("qwik");
+const getArgsAt = (...indices) => (args) => indices.map((index) => args[index]).filter(Boolean);
+const runtimeProfiles = [
+	{
+		framework: "react",
+		matches: ({ mod, importedName }) => reactRuntimeMods.has(mod) && [
+			"jsx",
+			"jsxs",
+			"jsxDEV"
+		].includes(importedName),
+		getPropNodes: getArgsAt(1)
+	},
+	{
+		framework: "preact",
+		matches: ({ mod, importedName }) => preactRuntimeMods.has(mod) && [
+			"jsx",
+			"jsxs",
+			"jsxDEV"
+		].includes(importedName),
+		getPropNodes: getArgsAt(1)
+	},
+	{
+		framework: "react",
+		matches: ({ mod, importedName }) => classicReactMods.has(mod) && importedName === "createElement",
+		getPropNodes: getArgsAt(1)
+	},
+	{
+		framework: "preact",
+		matches: ({ mod, importedName }) => classicPreactMods.has(mod) && ["createElement", "h"].includes(importedName),
+		getPropNodes: getArgsAt(1)
+	},
+	{
+		framework: "vue",
+		matches: ({ mod, importedName }) => vueMods.has(mod) && ["createVNode", "h"].includes(importedName),
+		getPropNodes: getArgsAt(1)
+	},
+	{
+		framework: "solid",
+		matches: ({ mod, importedName }) => solidMods.has(mod) && importedName === "createComponent",
+		getPropNodes: getArgsAt(1)
+	},
+	{
+		framework: "qwik",
+		matches: ({ mod, importedName }) => isQwikMod(mod) && ["_jsxQ", "_jsxS"].includes(importedName),
+		getPropNodes: getArgsAt(1, 2)
+	},
+	{
+		framework: "qwik",
+		matches: ({ mod, importedName }) => isQwikMod(mod) && [
+			"_jsxC",
+			"jsx",
+			"jsxs",
+			"jsxDEV"
+		].includes(importedName),
+		getPropNodes: getArgsAt(1)
+	}
+];
+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());
+		return expression;
+	};
+	const localDefinitionCache = /* @__PURE__ */ new Map();
+	const resolveIdentifierDefinition = (identifier) => {
+		const name = identifier.getText();
+		if (localDefinitionCache.has(name)) return localDefinitionCache.get(name) ?? void 0;
+		localDefinitionCache.set(name, null);
+		const resolveLocalAlias = (aliasNode) => {
+			if (!aliasNode) return;
+			const expression = unwrapExpression(aliasNode);
+			if (ts_morph.Node.isIdentifier(expression)) {
+				const imported = imports.bundledNamed.get(expression.getText());
+				if (imported) return {
+					mod: imported.mod,
+					importedName: imported.importedName
+				};
+				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());
+		};
+		for (const definition of identifier.getDefinitions()) {
+			const declaration = definition.getDeclarationNode();
+			if (!declaration) continue;
+			if (ts_morph.Node.isFunctionDeclaration(declaration)) {
+				const imported = resolveBundledHelperImport(declaration.getName() ?? name, declaration);
+				if (!imported) continue;
+				const resolved = {
+					mod: imported.mod,
+					importedName: imported.importedName
+				};
+				localDefinitionCache.set(name, resolved);
+				return resolved;
+			}
+			if (ts_morph.Node.isVariableDeclaration(declaration)) {
+				const directImport = resolveBundledHelperImport(declaration.getName(), declaration.getInitializer());
+				const aliasImport = directImport ? {
+					mod: directImport.mod,
+					importedName: directImport.importedName
+				} : resolveLocalAlias(declaration.getInitializer());
+				if (!aliasImport) continue;
+				localDefinitionCache.set(name, aliasImport);
+				return aliasImport;
+			}
+		}
+	};
+	const resolveCallee = (node) => {
+		const expression = normalizeCallee(node);
+		if (ts_morph.Node.isIdentifier(expression)) {
+			const imported = imports.named.get(expression.getText()) ?? imports.bundledNamed.get(expression.getText());
+			if (imported) return {
+				mod: imported.mod,
+				importedName: imported.importedName
+			};
+			return resolveIdentifierDefinition(expression);
+		}
+		if (ts_morph.Node.isPropertyAccessExpression(expression)) {
+			const target = normalizeCallee(expression.getExpression());
+			if (!ts_morph.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()
+			};
+		}
+	};
+	const isMergePropsCall = (node) => {
+		if (!ts_morph.Node.isCallExpression(node)) return false;
+		const resolved = resolveCallee(node.getExpression());
+		if (!resolved) return false;
+		return resolved.importedName === "mergeProps" && (solidMods.has(resolved.mod) || vueMods.has(resolved.mod));
+	};
+	const getCallInfo = (node) => {
+		const resolved = resolveCallee(node.getExpression());
+		if (!resolved) return;
+		const args = node.getArguments().map((arg) => unwrapExpression(arg));
+		const tagName = getTagName(args[0]);
+		if (!tagName) return;
+		const baseInfo = {
+			tagName,
+			isFactory: tagName.includes(".")
+		};
+		for (const profile of runtimeProfiles) if (profile.matches(resolved)) return {
+			framework: profile.framework,
+			...baseInfo,
+			propNodes: profile.getPropNodes(args)
+		};
+	};
+	return {
+		getCallInfo,
+		isMergePropsCall
+	};
+};
+//#endregion
+//#region src/jsx-attribute.ts
+const extractJsxAttribute = (jsxAttribute, ctx) => {
+	const initializer = jsxAttribute.getInitializer();
+	const stack = [jsxAttribute, initializer];
+	if (!initializer) {
+		const nameNode = jsxAttribute.getNameNode();
+		return box.emptyInitializer(nameNode, stack);
+	}
+	if (ts_morph.Node.isStringLiteral(initializer)) {
+		const literalText = initializer.getLiteralText();
+		return box.literal(trimWhitespace(literalText), initializer, stack);
+	}
+	if (ts_morph.Node.isJsxExpression(initializer)) {
+		const expr = initializer.getExpression();
+		if (!expr) return;
+		const expression = unwrapExpression(expr);
+		if (!expression) return;
+		stack.push(expression);
+		const maybeValue = maybeBoxNode(expression, stack, ctx);
+		if (maybeValue) return maybeValue;
+	}
+};
+//#endregion
+//#region src/jsx-spread-attribute.ts
+const extractJsxSpreadAttributeValues = (node, ctx, matchProp) => {
+	return maybeBoxNode(unwrapExpression(node.getExpression()), [], ctx, matchProp);
+};
+//#endregion
+//#region src/object-like-to-map.ts
+const objectLikeToMap = (maybeObject, node) => {
+	if (!maybeObject) return /* @__PURE__ */ new Map();
+	if (!isBoxNode(maybeObject)) return new Map(Object.entries(maybeObject));
+	if (box.isUnresolvable(maybeObject) || box.isConditional(maybeObject)) return /* @__PURE__ */ new Map();
+	if (box.isMap(maybeObject)) return maybeObject.value;
+	return new Map(Object.entries(maybeObject.value).map(([key, value]) => {
+		return [key, box.from(value, maybeObject.getNode() ?? node, maybeObject.getStack() ?? []) || null];
+	}).filter(([, value]) => value !== null));
+};
+//#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 extract = ({ ast, ...ctx }) => {
+	const { components, functions, taggedTemplates } = ctx;
+	const compiledJsx = createCompiledJsxContext(ast);
+	/** contains all the extracted nodes from this ast parsing */
+	const byName = /* @__PURE__ */ new Map();
+	/**
+	* associate a component node with its props and (spread) conditionals
+	* since js es6 map preserve insertion order, we can use it to keep the order of the props
+	* so we can keep the last one
+	* ex: <ColorBox padding="4" {...{ color: "blue.100" }} color="red" margin={2} />
+	* => color: "red"
+	*/
+	const componentByNode = /* @__PURE__ */ new Map();
+	const ensureComponent = (componentNode, componentName) => {
+		if (!byName.has(componentName)) byName.set(componentName, {
+			kind: "component",
+			nodesByProp: /* @__PURE__ */ new Map(),
+			queryList: []
+		});
+		if (!componentByNode.has(componentNode)) componentByNode.set(componentNode, {
+			name: componentName,
+			props: /* @__PURE__ */ new Map(),
+			conditionals: []
+		});
+		return {
+			component: componentByNode.get(componentNode),
+			boxByProp: byName.get(componentName).nodesByProp
+		};
+	};
+	const addComponentProp = (component, boxByProp, propName, propValue) => {
+		component.props.set(propName, propValue);
+		boxByProp.set(propName, (boxByProp.get(propName) ?? []).concat(propValue));
+	};
+	const processComponentObjectLike = (component, boxByProp, propNode, objLike, matchProp, trackSpreadConditions = false) => {
+		if (trackSpreadConditions && box.isMap(objLike) && objLike.spreadConditions?.length) component.conditionals.push(...objLike.spreadConditions);
+		objectLikeToMap(objLike, propNode).forEach((propValue, propName) => {
+			if (matchProp({
+				propName,
+				propNode
+			})) addComponentProp(component, boxByProp, propName, propValue);
+		});
+	};
+	const processComponentBoxNode = (component, boxByProp, propNode, boxNode, matchProp, trackSpreadConditions = false) => {
+		if (box.isConditional(boxNode)) {
+			component.conditionals.push(boxNode);
+			return;
+		}
+		if (box.isObject(boxNode) || box.isMap(boxNode)) processComponentObjectLike(component, boxByProp, propNode, boxNode, matchProp, trackSpreadConditions);
+	};
+	const processCompiledPropSource = (componentNode, component, boxByProp, propNode, matchProp) => {
+		const expression = unwrapExpression(propNode);
+		const stack = [componentNode, expression];
+		if (ts_morph.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) => {
+				processCompiledPropSource(componentNode, component, boxByProp, arg, matchProp);
+			});
+			return;
+		}
+		const maybeValue = maybeBoxNode(expression, stack, ctx, matchProp);
+		if (!maybeValue) return;
+		processComponentBoxNode(component, boxByProp, expression, maybeValue, matchProp, true);
+	};
+	ast.forEachDescendant((node, traversal) => {
+		if (isImportOrExport(node)) {
+			traversal.skip();
+			return;
+		}
+		if (components) {
+			if (ts_morph.Node.isJsxOpeningElement(node) || ts_morph.Node.isJsxSelfClosingElement(node)) {
+				const componentNode = node;
+				const componentName = getComponentName(componentNode);
+				const isFactory = componentName.includes(".");
+				if (!components.matchTag({
+					tagNode: componentNode,
+					tagName: componentName,
+					isFactory
+				})) return;
+				ensureComponent(componentNode, componentName);
+			}
+			if (ts_morph.Node.isJsxSpreadAttribute(node)) {
+				const componentNode = node.getFirstAncestor(isJsxElement);
+				const component = componentByNode.get(componentNode);
+				if (!componentNode || !component) return;
+				const componentName = getComponentName(componentNode);
+				const boxByProp = byName.get(componentName).nodesByProp;
+				const matchProp = ({ propName, propNode }) => components.matchProp({
+					tagNode: componentNode,
+					tagName: componentName,
+					propName,
+					propNode
+				});
+				const spreadNode = extractJsxSpreadAttributeValues(node, ctx, matchProp);
+				if (!spreadNode) return;
+				processComponentBoxNode(component, boxByProp, node, spreadNode, matchProp);
+				return;
+			}
+			if (ts_morph.Node.isJsxAttribute(node)) {
+				const componentNode = node.getFirstAncestor(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();
+				if (!components.matchProp({
+					tagNode: componentNode,
+					tagName: componentName,
+					propName,
+					propNode: node
+				})) return;
+				const maybeBox = extractJsxAttribute(node, ctx);
+				if (!maybeBox) return;
+				addComponentProp(component, boxByProp, propName, maybeBox);
+			}
+			if (ts_morph.Node.isCallExpression(node)) {
+				const compiledCall = compiledJsx.getCallInfo(node);
+				if (compiledCall) {
+					const { tagName, isFactory, propNodes } = compiledCall;
+					if (!components.matchTag({
+						tagNode: node,
+						tagName,
+						isFactory
+					})) return;
+					const { component, boxByProp } = ensureComponent(node, tagName);
+					const matchProp = ({ propName, propNode }) => components.matchProp({
+						tagNode: node,
+						tagName,
+						propName,
+						propNode
+					});
+					propNodes.forEach((propNode) => {
+						processCompiledPropSource(node, component, boxByProp, propNode, matchProp);
+					});
+				}
+			}
+		}
+		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.matchFn({
+				fnNode: node,
+				fnName
+			})) return;
+			const matchProp = ({ propName, propNode }) => functions.matchProp({
+				fnNode: node,
+				fnName,
+				propName,
+				propNode
+			});
+			if (!byName.has(fnName)) byName.set(fnName, {
+				kind: "function",
+				nodesByProp: /* @__PURE__ */ new Map(),
+				queryList: []
+			});
+			const fnResultMap = byName.get(fnName);
+			const boxByProp = fnResultMap.nodesByProp;
+			const nodeList = extractCallExpressionArguments(node, ctx, matchProp, functions.matchArg).value.map((boxNode) => {
+				if (box.isObject(boxNode) || box.isMap(boxNode)) {
+					const mapValue = objectLikeToMap(boxNode, node);
+					const isMap = box.isMap(boxNode);
+					mapValue.forEach((propValue, propName) => {
+						if (isMap ? true : matchProp({
+							propName,
+							propNode: node
+						})) boxByProp.set(propName, (boxByProp.get(propName) ?? []).concat(propValue));
+					});
+					const boxMap = box.map(mapValue, node, boxNode.getStack());
+					if (box.isMap(boxNode) && boxNode.spreadConditions?.length) boxMap.spreadConditions = boxNode.spreadConditions;
+					return boxMap;
+				}
+				return boxNode;
+			});
+			const query = {
+				kind: "call-expression",
+				name: fnName,
+				box: box.array(nodeList, node, [])
+			};
+			fnResultMap.queryList.push(query);
+		}
+		if (taggedTemplates && ts_morph.Node.isTaggedTemplateExpression(node)) {
+			const tag = node.getTag();
+			const fnName = ts_morph.Node.isCallExpression(tag) ? tag.getExpression().getText() : tag.getText();
+			if (!taggedTemplates.matchTaggedTemplate({
+				taggedTemplateNode: node,
+				fnName
+			})) return;
+			if (!byName.has(fnName)) byName.set(fnName, {
+				kind: "function",
+				nodesByProp: /* @__PURE__ */ new Map(),
+				queryList: []
+			});
+			const fnResultMap = byName.get(fnName);
+			const query = {
+				kind: "tagged-template",
+				name: fnName,
+				box: maybeBoxNode(node, [], ctx)
+			};
+			fnResultMap.queryList.push(query);
+		}
+	});
+	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;
+		const query = {
+			name: parentRef.name,
+			box: box.map(component.props, componentNode, [])
+		};
+		if (component.conditionals?.length) query.box.spreadConditions = component.conditionals;
+		const componentName = parentRef.name;
+		byName.get(componentName).queryList.push(query);
+	});
+	byName.forEach((result, name) => {
+		if (result.kind === "component" && result.queryList.length === 0) byName.delete(name);
+	});
+	return byName;
+};
+//#endregion
+//#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 props = /* @__PURE__ */ new Map();
+	jsxAttributes.forEach((attrNode) => {
+		if (ts_morph.Node.isJsxAttribute(attrNode)) {
+			const nameNode = attrNode.getNameNode();
+			const maybeValue = extractJsxAttribute(attrNode, ctx);
+			if (!maybeValue) return;
+			props.set(nameNode.getText(), maybeValue);
+			return;
+		}
+		if (ts_morph.Node.isJsxSpreadAttribute(attrNode)) {
+			const maybeValue = extractJsxSpreadAttributeValues(attrNode, ctx, () => true);
+			if (!isObjectLike(maybeValue)) return;
+			if (box.isMap(maybeValue)) maybeValue.value.forEach((value, propName) => {
+				props.set(propName, value);
+			});
+			if (box.isObject(maybeValue)) Object.entries(maybeValue.value).forEach(([propName, value]) => {
+				props.set(propName, box.literal(value, node, []));
+			});
+		}
+	});
+	return {
+		name: tagName,
+		props
+	};
+};
+//#endregion
+//#region src/unbox.ts
+const makeObjAt = (path, value) => {
+	if (!path.length) return value;
+	const obj = {};
+	path.reduce((acc, key, i) => {
+		const isLast = i === path.length - 1;
+		acc[key] = isLast ? value : {};
+		return isLast ? obj : acc[key];
+	}, obj);
+	return obj;
+};
+const makeArrayWithValueAt = (index, value) => {
+	if (index < 0) return [];
+	const arr = [];
+	for (let i = 0; i <= index; i++) arr[i] = i === index ? value : void 0;
+	return arr;
+};
+const getLiteralValue = (node, ctx) => {
+	if (!node) return;
+	if (box.isConditional(node)) {
+		const path = ctx.path;
+		const whenTrue = getLiteralValue(node.whenTrue, Object.assign({}, ctx, {
+			path,
+			parent: node
+		}));
+		const whenFalse = getLiteralValue(node.whenFalse, Object.assign({}, ctx, {
+			path,
+			parent: node
+		}));
+		const last = node.getStack().at(-1);
+		const maybeIndex = Number(path[path.length - 1]);
+		if (last && ts_morph.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)));
+			return;
+		}
+		if (isTruthyOrZero(whenTrue)) ctx.conditions.push(makeObjAt(path, whenTrue));
+		if (isTruthyOrZero(whenFalse)) ctx.conditions.push(makeObjAt(path, whenFalse));
+		return;
+	}
+	if (box.isLiteral(node) || box.isObject(node)) return node.value;
+	if (box.isEmptyInitializer(node)) return true;
+	if (box.isMap(node)) {
+		if (node.spreadConditions) {
+			const path = ctx.path;
+			node.spreadConditions.forEach((spread) => {
+				const whenTrue = getLiteralValue(spread.whenTrue, Object.assign({}, ctx, {
+					path,
+					parent: node
+				}));
+				const whenFalse = getLiteralValue(spread.whenFalse, Object.assign({}, ctx, {
+					path,
+					parent: node
+				}));
+				if (whenTrue) ctx.spreadConditions.push(makeObjAt(path, whenTrue));
+				if (whenFalse) ctx.spreadConditions.push(makeObjAt(path, whenFalse));
+			});
+		}
+		const obj = {};
+		node.value.forEach((propNode, key) => {
+			const value = getLiteralValue(propNode, Object.assign({}, ctx, {
+				path: ctx.path.concat(key),
+				parent: node
+			}));
+			if (isNotNullish(value)) obj[key] = value;
+		});
+		return obj;
+	}
+	if (box.isArray(node)) return node.value.flatMap((elementNode, index) => getLiteralValue(elementNode, Object.assign({}, ctx, {
+		path: ctx.path.concat(String(index)),
+		parent: node
+	})));
+};
+const cacheMap = /* @__PURE__ */ new WeakMap();
+const createCache = (map) => ({
+	value: map,
+	has: (node) => map.has(node),
+	get: (node) => map.get(node),
+	set: (node, value) => map.set(node, value)
+});
+const unbox = (node, ctx) => {
+	const _ctx = {
+		cache: ctx?.cache ?? cacheMap,
+		...ctx,
+		path: [],
+		parent: void 0,
+		conditions: [],
+		spreadConditions: []
+	};
+	const cache = createCache(_ctx.cache);
+	if (cache.has(node)) return cache.get(node);
+	let raw;
+	if (Array.isArray(node)) raw = node.map((boxNode) => getLiteralValue(boxNode, _ctx)).filter(isNotNullish)[0];
+	else raw = getLiteralValue(node, _ctx);
+	const result = {
+		raw: raw ?? {},
+		conditions: _ctx.conditions,
+		spreadConditions: _ctx.spreadConditions
+	};
+	if (raw) cache.set(node, result);
+	return result;
+};
+//#endregion
+exports.BoxNodeArray = BoxNodeArray;
+exports.BoxNodeConditional = BoxNodeConditional;
+exports.BoxNodeEmptyInitializer = BoxNodeEmptyInitializer;
+exports.BoxNodeLiteral = BoxNodeLiteral;
+exports.BoxNodeMap = BoxNodeMap;
+exports.BoxNodeObject = BoxNodeObject;
+exports.BoxNodeUnresolvable = BoxNodeUnresolvable;
+exports.box = box;
+exports.extract = extract;
+exports.extractCallExpressionArguments = extractCallExpressionArguments;
+exports.extractJsxAttribute = extractJsxAttribute;
+exports.extractJsxElementProps = extractJsxElementProps;
+exports.extractJsxSpreadAttributeValues = extractJsxSpreadAttributeValues;
+exports.findIdentifierValueDeclaration = findIdentifierValueDeclaration;
+exports.isBoxNode = isBoxNode;
+exports.maybeBoxNode = maybeBoxNode;
+exports.maybeIdentifierValue = maybeIdentifierValue;
+exports.unbox = unbox;