@bamboocss/extractor 1.11.1 → 1.11.3

package/dist/index.mjs

@@ -1,1947 +1,1814 @@
-// src/get-typeof-literal.ts
 import { BambooError } from "@bamboocss/shared";
-var 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 BambooError(
-    "UNKNOWN_LITERAL_TYPE",
-    `Unexpected literal type: ${value}. Expected: string, number, boolean, null, undefined, or array`
-  );
+import { Node, SyntaxKind, ts } from "ts-morph";
+import { evaluate } from "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 BambooError("UNKNOWN_LITERAL_TYPE", `Unexpected literal type: ${value}. Expected: string, number, boolean, null, undefined, or array`);
 };
-
-// src/utils.ts
-import { Node } from "ts-morph";
-var isNotNullish = (element) => element != null;
-var isNullish = (element) => element == null;
-var isTruthyOrZero = (element) => !!element || element === 0;
-var isObject = (value) => value != null && typeof value === "object";
-var isArray = (value) => Array.isArray(value);
-var isPrimitiveType = (value) => {
-  const type = typeof value;
-  return type === "string" || type === "number" || type === "boolean" || value === null || value === void 0;
+//#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;
 };
-var unwrapExpression = (node) => {
-  if (Node.isAsExpression(node)) {
-    return unwrapExpression(node.getExpression());
-  }
-  if (Node.isParenthesizedExpression(node)) {
-    return unwrapExpression(node.getExpression());
-  }
-  if (Node.isNonNullExpression(node)) {
-    return unwrapExpression(node.getExpression());
-  }
-  if (Node.isTypeAssertion(node)) {
-    return unwrapExpression(node.getExpression());
-  }
-  if (Node.isSatisfiesExpression(node)) {
-    return unwrapExpression(node.getExpression());
-  }
-  return node;
+const unwrapExpression = (node) => {
+	if (Node.isAsExpression(node)) return unwrapExpression(node.getExpression());
+	if (Node.isParenthesizedExpression(node)) return unwrapExpression(node.getExpression());
+	if (Node.isNonNullExpression(node)) return unwrapExpression(node.getExpression());
+	if (Node.isTypeAssertion(node)) return unwrapExpression(node.getExpression());
+	if (Node.isSatisfiesExpression(node)) return unwrapExpression(node.getExpression());
+	return node;
 };
-var getComponentName = (node) => {
-  return node.getTagNameNode().getText();
+const getComponentName = (node) => {
+	return node.getTagNameNode().getText();
 };
-var whitespaceRegex = /\s+/g;
-var trimWhitespace = (str) => {
-  return str.replaceAll(whitespaceRegex, " ");
+const whitespaceRegex = /\s+/g;
+const trimWhitespace = (str) => {
+	return str.replaceAll(whitespaceRegex, " ");
 };
-
-// src/get-node-range.ts
-var 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/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
+	};
 };
-
-// src/box-factory.ts
+//#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,
-      // @ts-expect-error
-      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);
-  }
+	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;
-  }
+	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;
-  }
+	value;
+	kind;
+	constructor(definition) {
+		super(definition);
+		this.value = definition.value;
+		this.kind = definition.kind;
+	}
 };
-var recipeProps = ["compoundVariants", "defaultVariants", "variants", "base"];
+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));
-  };
+	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 {
+	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;
-  }
+	whenTrue;
+	whenFalse;
+	constructor(definition) {
+		super(definition);
+		this.whenTrue = definition.whenTrue;
+		this.whenFalse = definition.whenFalse;
+	}
 };
-var BoxNodeEmptyInitializer = class extends BoxNodeType {
-};
-var isBoxNode = (value) => value instanceof BoxNodeType;
-
-// src/to-box-node.ts
+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);
+	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);
 }
-
-// src/box.ts
-var 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) => {
-    const map = new Map(
-      Object.entries(value).map(([k, v]) => {
-        const boxed = box.from(v, node, stack);
-        return [k, boxed || null];
-      })
-    );
-    return new BoxNodeMap({ type: "map", value: map, 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/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);
+	}
 };
-
-// src/maybe-box-node.ts
-import { Node as Node5, ts as ts2 } from "ts-morph";
-
-// src/evaluate-node.ts
-import { evaluate } from "ts-evaluator";
-import { ts } from "ts-morph";
-var TsEvalError = Symbol("EvalError");
-var cacheMap = /* @__PURE__ */ new WeakMap();
-var evaluateNode = (node, stack, ctx) => {
-  if (ctx.flags?.skipEvaluate) return;
-  if (ctx.canEval && !ctx.canEval?.(node, stack)) return;
-  if (cacheMap.has(node)) {
-    return cacheMap.get(node);
-  }
-  const result = 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
-  });
-  const expr = result.success ? result.value : TsEvalError;
-  cacheMap.set(node, expr);
-  return expr;
+//#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 = 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
+	});
+	const expr = result.success ? result.value : TsEvalError;
+	cacheMap$2.set(node, expr);
+	return expr;
 };
-var safeEvaluateNode = (node, stack, ctx) => {
-  const result = evaluateNode(node, stack, ctx);
-  if (result === TsEvalError) return;
-  return result;
+const safeEvaluateNode = (node, stack, ctx) => {
+	const result = evaluateNode(node, stack, ctx);
+	if (result === TsEvalError) return;
+	return result;
 };
-
-// src/find-identifier-value-declaration.ts
-import {
-  Node as Node2
-} from "ts-morph";
+//#endregion
+//#region src/find-identifier-value-declaration.ts
 function isScope(node) {
-  return Node2.isFunctionDeclaration(node) || Node2.isFunctionExpression(node) || Node2.isArrowFunction(node) || Node2.isSourceFile(node);
+	return Node.isFunctionDeclaration(node) || Node.isFunctionExpression(node) || Node.isArrowFunction(node) || Node.isSourceFile(node);
 }
 function getDeclarationFor(node, stack, ctx) {
-  const parent = node.getParent();
-  if (!parent) return;
-  const declarationStack = [];
-  let declaration;
-  if ((Node2.isVariableDeclaration(parent) || Node2.isParameterDeclaration(parent) || Node2.isFunctionDeclaration(parent) || Node2.isEnumDeclaration(parent) || Node2.isBindingElement(parent)) && parent.getNameNode() == node) {
-    declarationStack.push(parent);
-    declaration = parent;
-  } else if (Node2.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 parent = node.getParent();
+	if (!parent) return;
+	const declarationStack = [];
+	let declaration;
+	if ((Node.isVariableDeclaration(parent) || Node.isParameterDeclaration(parent) || Node.isFunctionDeclaration(parent) || Node.isEnumDeclaration(parent) || Node.isBindingElement(parent)) && parent.getNameNode() == node) {
+		declarationStack.push(parent);
+		declaration = parent;
+	} else if (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;
 }
-var getInnermostScope = (from) => {
-  let scope = from.getParent();
-  while (scope && !isScope(scope)) {
-    scope = scope.getParent();
-  }
-  return scope;
+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 (Node2.isIdentifier(node) && node.getText() == refName) {
-        const declarationStack = [node];
-        const maybeDeclaration = getDeclarationFor(node, declarationStack, ctx);
-        if (maybeDeclaration) {
-          if (Node2.isParameterDeclaration(maybeDeclaration)) {
-            const initializer = maybeDeclaration.getInitializer();
-            const typeNode = maybeDeclaration.getTypeNode();
-            if (initializer) {
-              innerStack.push(...declarationStack.concat(initializer));
-              foundNode = maybeDeclaration;
-            } else if (typeNode && Node2.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 && !Node2.isSourceFile(scope) && !foundNode && !isUnresolvable && count < 100);
+	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 (Node.isIdentifier(node) && node.getText() == refName) {
+				const declarationStack = [node];
+				const maybeDeclaration = getDeclarationFor(node, declarationStack, ctx);
+				if (maybeDeclaration) {
+					if (Node.isParameterDeclaration(maybeDeclaration)) {
+						const initializer = maybeDeclaration.getInitializer();
+						const typeNode = maybeDeclaration.getTypeNode();
+						if (initializer) {
+							innerStack.push(...declarationStack.concat(initializer));
+							foundNode = maybeDeclaration;
+						} else if (typeNode && 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 && !Node.isSourceFile(scope) && !foundNode && !isUnresolvable && count < 100);
 }
-
-// src/get-object-literal-expression-prop-pairs.ts
-import { Node as Node4 } from "ts-morph";
-
-// src/get-property-name.ts
-import { Node as Node3 } from "ts-morph";
-var getPropertyName = (property, stack, ctx) => {
-  if (!property) return;
-  if (Node3.isPropertyAssignment(property)) {
-    const node = unwrapExpression(property.getNameNode());
-    if (Node3.isIdentifier(node)) return box.from(node.getText(), node, stack);
-    if (Node3.isComputedPropertyName(node)) {
-      const expression = node.getExpression();
-      stack.push(expression);
-      return maybePropName(expression, stack, ctx);
-    }
-    if (Node3.isStringLiteral(node) || Node3.isNumericLiteral(node)) return box.from(node.getLiteralText(), node, stack);
-  }
-  if (Node3.isShorthandPropertyAssignment(property)) {
-    const name = property.getName();
-    if (name != null) return box.from(name, property, stack);
-  }
-  if (Node3.isGetAccessorDeclaration(property)) {
-    const node = unwrapExpression(property.getNameNode());
-    if (Node3.isIdentifier(node)) return box.from(node.getText(), node, stack);
-    if (Node3.isComputedPropertyName(node)) {
-      const expression = node.getExpression();
-      stack.push(expression);
-      return maybePropName(expression, stack, ctx);
-    }
-    if (Node3.isStringLiteral(node) || Node3.isNumericLiteral(node)) return box.from(node.getLiteralText(), node, stack);
-  }
+//#endregion
+//#region src/get-property-name.ts
+const getPropertyName = (property, stack, ctx) => {
+	if (!property) return;
+	if (Node.isPropertyAssignment(property)) {
+		const node = unwrapExpression(property.getNameNode());
+		if (Node.isIdentifier(node)) return box.from(node.getText(), node, stack);
+		if (Node.isComputedPropertyName(node)) {
+			const expression = node.getExpression();
+			stack.push(expression);
+			return maybePropName(expression, stack, ctx);
+		}
+		if (Node.isStringLiteral(node) || Node.isNumericLiteral(node)) return box.from(node.getLiteralText(), node, stack);
+	}
+	if (Node.isShorthandPropertyAssignment(property)) {
+		const name = property.getName();
+		if (name != null) return box.from(name, property, stack);
+	}
+	if (Node.isGetAccessorDeclaration(property)) {
+		const node = unwrapExpression(property.getNameNode());
+		if (Node.isIdentifier(node)) return box.from(node.getText(), node, stack);
+		if (Node.isComputedPropertyName(node)) {
+			const expression = node.getExpression();
+			stack.push(expression);
+			return maybePropName(expression, stack, ctx);
+		}
+		if (Node.isStringLiteral(node) || Node.isNumericLiteral(node)) return box.from(node.getLiteralText(), node, stack);
+	}
 };
-
-// src/get-object-literal-expression-prop-pairs.ts
-var 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 (Node4.isPropertyAssignment(property) || Node4.isShorthandPropertyAssignment(property) || Node4.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 (Node4.isShorthandPropertyAssignment(property)) {
-        const initializer2 = property.getNameNode();
-        stack.push(initializer2);
-        const maybeValue2 = maybeBoxNode(initializer2, stack, ctx);
-        if (maybeValue2) {
-          extractedPropValues.push([propName.toString(), maybeValue2]);
-          return;
-        }
-      }
-      let init;
-      if (Node4.isGetAccessorDeclaration(property)) {
-        const body = property.getBody();
-        init = Node4.isBlock(body) ? body.getStatements().at(-1) : void 0;
-      } else {
-        init = property.getInitializer();
-      }
-      if (!init) return;
-      const returnExpression = Node4.isReturnStatement(init) ? init.getExpression() : void 0;
-      const initializer = unwrapExpression(returnExpression ?? init);
-      stack.push(initializer);
-      const maybeValue = maybeBoxNode(initializer, stack, ctx);
-      if (maybeValue) {
-        extractedPropValues.push([propName.toString(), maybeValue]);
-        return;
-      }
-    }
-    if (Node4.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/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 (Node.isPropertyAssignment(property) || Node.isShorthandPropertyAssignment(property) || 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 (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 (Node.isGetAccessorDeclaration(property)) {
+				const body = property.getBody();
+				init = Node.isBlock(body) ? body.getStatements().at(-1) : void 0;
+			} else init = property.getInitializer();
+			if (!init) return;
+			const initializer = unwrapExpression((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 (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;
 };
-
-// src/maybe-box-node.ts
-var cacheMap2 = /* @__PURE__ */ new WeakMap();
-var isCached = (node) => cacheMap2.has(node);
-var getCached = (node) => cacheMap2.get(node);
-var isPlusSyntax = (op) => op === ts2.SyntaxKind.PlusToken;
-var isLogicalSyntax = (op) => op === ts2.SyntaxKind.BarBarToken || op === ts2.SyntaxKind.QuestionQuestionToken || op === ts2.SyntaxKind.AmpersandAmpersandToken || op === ts2.SyntaxKind.EqualsEqualsEqualsToken || op === ts2.SyntaxKind.EqualsEqualsToken || op === ts2.SyntaxKind.ExclamationEqualsEqualsToken || op === ts2.SyntaxKind.ExclamationEqualsToken || op === ts2.SyntaxKind.GreaterThanEqualsToken || op === ts2.SyntaxKind.GreaterThanToken || op === ts2.SyntaxKind.LessThanEqualsToken || op === ts2.SyntaxKind.LessThanToken || op === ts2.SyntaxKind.InstanceOfKeyword || op === ts2.SyntaxKind.InKeyword;
-var isOperationSyntax = (op) => op === ts2.SyntaxKind.AsteriskToken || op === ts2.SyntaxKind.SlashToken || op === ts2.SyntaxKind.PercentToken || op === ts2.SyntaxKind.AsteriskAsteriskToken || op === ts2.SyntaxKind.MinusToken;
-var canReturnWhenTrueInLogicalExpression = (op) => {
-  return op === ts2.SyntaxKind.BarBarToken || op === ts2.SyntaxKind.QuestionQuestionToken;
+//#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.SyntaxKind.PlusToken;
+const isLogicalSyntax = (op) => op === ts.SyntaxKind.BarBarToken || op === ts.SyntaxKind.QuestionQuestionToken || op === ts.SyntaxKind.AmpersandAmpersandToken || op === ts.SyntaxKind.EqualsEqualsEqualsToken || op === ts.SyntaxKind.EqualsEqualsToken || op === ts.SyntaxKind.ExclamationEqualsEqualsToken || op === ts.SyntaxKind.ExclamationEqualsToken || op === ts.SyntaxKind.GreaterThanEqualsToken || op === ts.SyntaxKind.GreaterThanToken || op === ts.SyntaxKind.LessThanEqualsToken || op === ts.SyntaxKind.LessThanToken || op === ts.SyntaxKind.InstanceOfKeyword || op === ts.SyntaxKind.InKeyword;
+const isOperationSyntax = (op) => op === ts.SyntaxKind.AsteriskToken || op === ts.SyntaxKind.SlashToken || op === ts.SyntaxKind.PercentToken || op === ts.SyntaxKind.AsteriskAsteriskToken || op === ts.SyntaxKind.MinusToken;
+const canReturnWhenTrueInLogicalExpression = (op) => {
+	return op === ts.SyntaxKind.BarBarToken || op === ts.SyntaxKind.QuestionQuestionToken;
 };
 function maybeBoxNode(node, stack, ctx, matchProp) {
-  const cache = (value) => {
-    cacheMap2.set(node, value);
-    return value;
-  };
-  if (isCached(node)) {
-    return getCached(node);
-  }
-  if (Node5.isStringLiteral(node) || Node5.isNoSubstitutionTemplateLiteral(node)) {
-    const value = trimWhitespace(node.getLiteralValue());
-    return cache(box.literal(value, node, stack));
-  }
-  if (Node5.isObjectLiteralExpression(node)) {
-    return cache(getObjectLiteralExpressionPropPairs(node, stack, ctx, matchProp));
-  }
-  if (Node5.isTrueLiteral(node) || Node5.isFalseLiteral(node)) {
-    const value = node.getLiteralValue();
-    return cache(box.literal(value, node, stack));
-  }
-  if (Node5.isNumericLiteral(node)) {
-    const value = node.getLiteralValue();
-    return cache(box.literal(value, node, stack));
-  }
-  if (Node5.isNullLiteral(node)) {
-    return cache(box.literal(null, node, stack));
-  }
-  if (Node5.isPrefixUnaryExpression(node)) {
-    const operand = node.getOperand();
-    const operator = node.getOperatorToken();
-    const boxNode = maybeBoxNode(operand, stack, ctx);
-    if (!box.isNumberLiteral(boxNode)) return;
-    return cache(operator === ts2.SyntaxKind.MinusToken ? box.literal(-Number(boxNode.value), node, stack) : boxNode);
-  }
-  if (Node5.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 (Node5.isIdentifier(node)) {
-    const value = node.getText();
-    if (value === "undefined") return cache(box.literal(void 0, node, stack));
-    return cache(maybeIdentifierValue(node, stack, ctx));
-  }
-  if (Node5.isTemplateHead(node)) {
-    return cache(box.literal(node.getLiteralText(), node, stack));
-  }
-  if (Node5.isTemplateExpression(node)) {
-    const value = maybeTemplateStringValue(node, stack, ctx);
-    return cache(box.literal(value, node, stack));
-  }
-  if (Node5.isTaggedTemplateExpression(node)) {
-    return cache(maybeBoxNode(node.getTemplate(), stack, ctx));
-  }
-  if (Node5.isElementAccessExpression(node)) {
-    return cache(getElementAccessedExpressionValue(node, stack, ctx));
-  }
-  if (Node5.isPropertyAccessExpression(node)) {
-    return cache(getPropertyAccessedExpressionValue(node, [], stack, ctx));
-  }
-  if (Node5.isConditionalExpression(node)) {
-    if (ctx.flags?.skipConditions) {
-      return cache(box.unresolvable(node, stack));
-    }
-    const condExpr = unwrapExpression(node.getCondition());
-    const condBoxNode = (Node5.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((node2) => Node5.isBindingElement(node2));
-    if (box.isUnresolvable(condValue) || box.isConditional(condValue) || isFromDefaultBinding) {
-      const whenTrueExpr = unwrapExpression(node.getWhenTrue());
-      const whenFalseExpr2 = unwrapExpression(node.getWhenFalse());
-      return cache(maybeResolveConditionalExpression({ whenTrueExpr, whenFalseExpr: whenFalseExpr2, node, stack }, ctx));
-    }
-    if (condValue.value) {
-      const whenTrueExpr = unwrapExpression(node.getWhenTrue());
-      const innerStack2 = [...stack];
-      const maybeValue2 = maybeBoxNode(whenTrueExpr, innerStack2, ctx);
-      return cache(maybeValue2 ?? box.unresolvable(whenTrueExpr, stack));
-    }
-    const whenFalseExpr = unwrapExpression(node.getWhenFalse());
-    const innerStack = [...stack];
-    const maybeValue = maybeBoxNode(whenFalseExpr, innerStack, ctx);
-    return cache(maybeValue ?? box.unresolvable(node, stack));
-  }
-  if (Node5.isCallExpression(node)) {
-    if (ctx.tokens) {
-      const expr = node.getExpression();
-      let fnName = "";
-      let isVarMethod = false;
-      if (Node5.isIdentifier(expr)) {
-        fnName = expr.getText();
-      } else if (Node5.isPropertyAccessExpression(expr)) {
-        const exprName = expr.getExpression();
-        const propertyName = expr.getName();
-        if (Node5.isIdentifier(exprName)) {
-          fnName = exprName.getText();
-          isVarMethod = propertyName === "var";
-        }
-      }
-      const isTokenFunction = ctx.tokens.isTokenFn ? ctx.tokens.isTokenFn(fnName) : fnName === "token";
-      if (isTokenFunction) {
-        const args = node.getArguments();
-        const tokenPathArg = args[0];
-        if (tokenPathArg && Node5.isStringLiteral(tokenPathArg)) {
-          const tokenPath = tokenPathArg.getLiteralValue();
-          const fallbackArg = args[1];
-          const fallbackValue = fallbackArg && Node5.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 (Node5.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)) {
-      const whenTrueExpr = unwrapExpression(node.getLeft());
-      const whenFalseExpr = unwrapExpression(node.getRight());
-      const exprObject = {
-        whenTrueExpr,
-        whenFalseExpr,
-        node,
-        stack,
-        canReturnWhenTrue: canReturnWhenTrueInLogicalExpression(operatorKind)
-      };
-      return cache(maybeResolveConditionalExpression(exprObject, ctx));
-    }
-    if (isOperationSyntax(operatorKind)) {
-      return cache(box.literal(safeEvaluateNode(node, stack, ctx), node, stack));
-    }
-  }
+	const cache = (value) => {
+		cacheMap$1.set(node, value);
+		return value;
+	};
+	if (isCached(node)) return getCached(node);
+	if (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node)) {
+		const value = trimWhitespace(node.getLiteralValue());
+		return cache(box.literal(value, node, stack));
+	}
+	if (Node.isObjectLiteralExpression(node)) return cache(getObjectLiteralExpressionPropPairs(node, stack, ctx, matchProp));
+	if (Node.isTrueLiteral(node) || Node.isFalseLiteral(node)) {
+		const value = node.getLiteralValue();
+		return cache(box.literal(value, node, stack));
+	}
+	if (Node.isNumericLiteral(node)) {
+		const value = node.getLiteralValue();
+		return cache(box.literal(value, node, stack));
+	}
+	if (Node.isNullLiteral(node)) return cache(box.literal(null, node, stack));
+	if (Node.isPrefixUnaryExpression(node)) {
+		const operand = node.getOperand();
+		const operator = node.getOperatorToken();
+		const boxNode = maybeBoxNode(operand, stack, ctx);
+		if (!box.isNumberLiteral(boxNode)) return;
+		return cache(operator === ts.SyntaxKind.MinusToken ? box.literal(-Number(boxNode.value), node, stack) : boxNode);
+	}
+	if (Node.isArrayLiteralExpression(node)) {
+		const boxNodes = node.getElements().map((element) => {
+			return maybeBoxNode(element, stack, ctx) ?? cache(box.unresolvable(element, stack));
+		});
+		return cache(box.array(boxNodes, node, stack));
+	}
+	if (Node.isIdentifier(node)) {
+		if (node.getText() === "undefined") return cache(box.literal(void 0, node, stack));
+		return cache(maybeIdentifierValue(node, stack, ctx));
+	}
+	if (Node.isTemplateHead(node)) return cache(box.literal(node.getLiteralText(), node, stack));
+	if (Node.isTemplateExpression(node)) {
+		const value = maybeTemplateStringValue(node, stack, ctx);
+		return cache(box.literal(value, node, stack));
+	}
+	if (Node.isTaggedTemplateExpression(node)) return cache(maybeBoxNode(node.getTemplate(), stack, ctx));
+	if (Node.isElementAccessExpression(node)) return cache(getElementAccessedExpressionValue(node, stack, ctx));
+	if (Node.isPropertyAccessExpression(node)) return cache(getPropertyAccessedExpressionValue(node, [], stack, ctx));
+	if (Node.isConditionalExpression(node)) {
+		if (ctx.flags?.skipConditions) return cache(box.unresolvable(node, stack));
+		const condExpr = unwrapExpression(node.getCondition());
+		const condBoxNode = (Node.isIdentifier(condExpr) ? maybeBoxNode(condExpr, [], ctx) : safeEvaluateNode(condExpr, stack, ctx)) ?? box.unresolvable(condExpr, stack);
+		const condValue = isBoxNode(condBoxNode) ? condBoxNode : box.from(condBoxNode, node, stack);
+		if (box.isEmptyInitializer(condValue)) return;
+		const isFromDefaultBinding = condValue.getStack().some((node) => Node.isBindingElement(node));
+		if (box.isUnresolvable(condValue) || box.isConditional(condValue) || isFromDefaultBinding) return cache(maybeResolveConditionalExpression({
+			whenTrueExpr: unwrapExpression(node.getWhenTrue()),
+			whenFalseExpr: unwrapExpression(node.getWhenFalse()),
+			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 (Node.isCallExpression(node)) {
+		if (ctx.tokens) {
+			const expr = node.getExpression();
+			let fnName = "";
+			let isVarMethod = false;
+			if (Node.isIdentifier(expr)) fnName = expr.getText();
+			else if (Node.isPropertyAccessExpression(expr)) {
+				const exprName = expr.getExpression();
+				const propertyName = expr.getName();
+				if (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 && Node.isStringLiteral(tokenPathArg)) {
+					const tokenPath = tokenPathArg.getLiteralValue();
+					const fallbackArg = args[1];
+					const fallbackValue = fallbackArg && 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 (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));
+	}
 }
-var onlyStringLiteral = (boxNode) => {
-  if (!boxNode) return;
-  if (isBoxNode(boxNode) && box.isLiteral(boxNode) && typeof boxNode.value === "string") {
-    return boxNode;
-  }
+const onlyStringLiteral = (boxNode) => {
+	if (!boxNode) return;
+	if (isBoxNode(boxNode) && box.isLiteral(boxNode) && typeof boxNode.value === "string") return boxNode;
 };
-var onlyNumberLiteral = (boxNode) => {
-  if (!boxNode) return;
-  if (isBoxNode(boxNode) && box.isLiteral(boxNode) && typeof boxNode.value === "number") {
-    return boxNode;
-  }
+const onlyNumberLiteral = (boxNode) => {
+	if (!boxNode) return;
+	if (isBoxNode(boxNode) && box.isLiteral(boxNode) && typeof boxNode.value === "number") return boxNode;
 };
-var maybeStringLiteral = (node, stack, ctx) => onlyStringLiteral(maybeBoxNode(node, stack, ctx));
-var 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 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;
 };
-var 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 (Node5.isBinaryExpression(node) && node.getOperatorToken().getKind() === ts2.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 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 (Node.isBinaryExpression(node) && node.getOperatorToken().getKind() === 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);
 };
-var findProperty = (node, propName, _stack, ctx) => {
-  const stack = [..._stack];
-  if (Node5.isPropertyAssignment(node)) {
-    const name = node.getNameNode();
-    if (Node5.isIdentifier(name) && name.getText() === propName) {
-      stack.push(name);
-      return node;
-    }
-    if (Node5.isStringLiteral(name) && name.getLiteralText() === propName) {
-      stack.push(name);
-      return name.getLiteralText();
-    }
-    if (Node5.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 (Node5.isShorthandPropertyAssignment(node)) {
-    const name = node.getNameNode();
-    if (Node5.isIdentifier(name) && name.getText() === propName) {
-      stack.push(name);
-      return node;
-    }
-  }
+const findProperty = (node, propName, _stack, ctx) => {
+	const stack = [..._stack];
+	if (Node.isPropertyAssignment(node)) {
+		const name = node.getNameNode();
+		if (Node.isIdentifier(name) && name.getText() === propName) {
+			stack.push(name);
+			return node;
+		}
+		if (Node.isStringLiteral(name) && name.getLiteralText() === propName) {
+			stack.push(name);
+			return name.getLiteralText();
+		}
+		if (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 (Node.isShorthandPropertyAssignment(node)) {
+		const name = node.getNameNode();
+		if (Node.isIdentifier(name) && name.getText() === propName) {
+			stack.push(name);
+			return node;
+		}
+	}
 };
-var 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 (Node5.isPropertyAssignment(property)) {
-    const propInit = property.getInitializer();
-    if (!propInit) return;
-    if (Node5.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 (Node5.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 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 (Node.isPropertyAssignment(property)) {
+		const propInit = property.getInitializer();
+		if (!propInit) return;
+		if (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 (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;
+	}
 };
-var 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 expression = t.getExpression();
-    const propBox = maybePropName(expression, stack, ctx);
-    if (!propBox) return;
-    const literal = t.getLiteral();
-    return propBox.value + literal.getLiteralText();
-  });
-  if (tailValues.every(isNotNullish)) {
-    return headValue.value + tailValues.join("");
-  }
+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("");
 };
-var maybeBindingElementValue = (def, stack, propName, ctx) => {
-  const parent = def.getParent();
-  if (!parent) return;
-  const grandParent = parent.getParent();
-  if (!grandParent) return;
-  if (Node5.isArrayBindingPattern(parent)) {
-    const index = parent.getChildIndex();
-    if (Number.isNaN(index)) return;
-    if (Node5.isVariableDeclaration(grandParent)) {
-      const init = grandParent.getInitializer();
-      if (!init) return;
-      const initializer = unwrapExpression(init);
-      if (!Node5.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 propValue2 = maybeObject.value[propName];
-        return box.from(propValue2, element, innerStack);
-      }
-      if (!box.isMap(maybeObject)) {
-        return maybeObject;
-      }
-      const propValue = maybeObject.value.get(propName);
-      if (!propValue) return;
-      return propValue;
-    }
-  }
-  if (Node5.isObjectBindingPattern(parent)) {
-  }
+const maybeBindingElementValue = (def, stack, propName, ctx) => {
+	const parent = def.getParent();
+	if (!parent) return;
+	const grandParent = parent.getParent();
+	if (!grandParent) return;
+	if (Node.isArrayBindingPattern(parent)) {
+		const index = parent.getChildIndex();
+		if (Number.isNaN(index)) return;
+		if (Node.isVariableDeclaration(grandParent)) {
+			const init = grandParent.getInitializer();
+			if (!init) return;
+			const initializer = unwrapExpression(init);
+			if (!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 (Node.isObjectBindingPattern(parent)) {}
 };
 function maybePropDefinitionValue(def, accessList, _stack, ctx) {
-  const propName = accessList.at(-1);
-  if (Node5.isVariableDeclaration(def)) {
-    const init = def.getInitializer();
-    if (!init) {
-      const type = def.getTypeNode();
-      if (!type) return;
-      if (Node5.isTypeLiteral(type)) {
-        if (accessList.length > 0) {
-          const stack = [..._stack];
-          stack.push(type);
-          let propName2 = accessList.pop();
-          let typeProp = type.getProperty(propName2);
-          let typeLiteral = typeProp?.getTypeNode();
-          while (typeProp && accessList.length > 0 && typeLiteral && Node5.isTypeLiteral(typeLiteral)) {
-            stack.push(typeProp, typeLiteral);
-            propName2 = accessList.pop();
-            typeProp = typeLiteral.getProperty(propName2);
-            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 (Node5.isObjectLiteralExpression(initializer)) {
-      const propValue = getObjectLiteralPropValue(initializer, accessList, _stack, ctx);
-      if (!propValue) return;
-      _stack.push(initializer);
-      return propValue;
-    }
-    if (Node5.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 innerStack = [..._stack, initializer];
-    const maybeValue = maybeBoxNode(initializer, innerStack, ctx);
-    if (maybeValue) return maybeValue;
-  }
-  if (Node5.isBindingElement(def)) {
-    const value = maybeBindingElementValue(def, _stack, propName, ctx);
-    if (value) return value;
-  }
-  if (Node5.isEnumDeclaration(def)) {
-    const member = def.getMember(propName);
-    if (!member) return;
-    const initializer = member.getInitializer();
-    if (!initializer) return;
-    const innerStack = [..._stack, initializer];
-    const maybeValue = maybeBoxNode(initializer, innerStack, ctx);
-    if (maybeValue) return maybeValue;
-  }
+	const propName = accessList.at(-1);
+	if (Node.isVariableDeclaration(def)) {
+		const init = def.getInitializer();
+		if (!init) {
+			const type = def.getTypeNode();
+			if (!type) return;
+			if (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 && 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 (Node.isObjectLiteralExpression(initializer)) {
+			const propValue = getObjectLiteralPropValue(initializer, accessList, _stack, ctx);
+			if (!propValue) return;
+			_stack.push(initializer);
+			return propValue;
+		}
+		if (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 (Node.isBindingElement(def)) {
+		const value = maybeBindingElementValue(def, _stack, propName, ctx);
+		if (value) return value;
+	}
+	if (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;
+	}
 }
-var 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 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);
 };
-var typeLiteralCache = /* @__PURE__ */ new WeakMap();
-var 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 members = type.getMembers();
-  const prop = members.find((member) => Node5.isPropertySignature(member) && member.getName() === propName);
-  if (Node5.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());
-      }
-      const map = typeLiteralCache.get(type);
-      map.set(propName, propValue);
-      return propValue;
-    }
-  }
-  typeLiteralCache.set(type, null);
+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) => Node.isPropertySignature(member) && member.getName() === propName);
+	if (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 (Node5.isStringLiteral(wrapper)) return wrapper.getLiteralText();
-  return wrapper.getText();
+	if (Node.isStringLiteral(wrapper)) return wrapper.getLiteralText();
+	return wrapper.getText();
 }
-var typeNodeCache = /* @__PURE__ */ new WeakMap();
-var getTypeNodeValue = (type, stack, ctx) => {
-  if (typeNodeCache.has(type)) {
-    return typeNodeCache.get(type);
-  }
-  if (Node5.isLiteralTypeNode(type)) {
-    const literal = type.getLiteral();
-    if (Node5.isStringLiteral(literal)) {
-      const result = literal.getLiteralText();
-      typeNodeCache.set(type, result);
-      return result;
-    }
-  }
-  if (Node5.isTypeLiteral(type)) {
-    const members = type.getMembers();
-    if (!members.some((member) => !Node5.isPropertySignature(member) || !member.isReadonly())) {
-      const props = members;
-      const entries = props.map((member) => {
-        const nameNode = member.getNameNode();
-        const nameText = nameNode.getText();
-        const name = getNameLiteral(nameNode);
-        if (!name) return;
-        const value = getTypeLiteralNodePropValue(type, nameText, stack, ctx);
-        return [name, value];
-      }).filter(isNotNullish);
-      const result = Object.fromEntries(entries);
-      typeNodeCache.set(type, result);
-      return result;
-    }
-  }
-  typeNodeCache.set(type, void 0);
+const typeNodeCache = /* @__PURE__ */ new WeakMap();
+const getTypeNodeValue = (type, stack, ctx) => {
+	if (typeNodeCache.has(type)) return typeNodeCache.get(type);
+	if (Node.isLiteralTypeNode(type)) {
+		const literal = type.getLiteral();
+		if (Node.isStringLiteral(literal)) {
+			const result = literal.getLiteralText();
+			typeNodeCache.set(type, result);
+			return result;
+		}
+	}
+	if (Node.isTypeLiteral(type)) {
+		const members = type.getMembers();
+		if (!members.some((member) => !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);
 };
-var maybeDefinitionValue = (def, stack, ctx) => {
-  if (Node5.isShorthandPropertyAssignment(def)) {
-    const propNameNode = def.getNameNode();
-    return maybePropIdentifierValue(propNameNode, [propNameNode.getText()], stack, ctx);
-  }
-  if (Node5.isVariableDeclaration(def)) {
-    const init = def.getInitializer();
-    if (!init) {
-      const type = def.getTypeNode();
-      if (!type) return;
-      if (Node5.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 innerStack = [...stack, initializer];
-    const maybeValue = maybeBoxNode(initializer, innerStack, ctx);
-    if (maybeValue) return maybeValue;
-  }
-  if (Node5.isBindingElement(def)) {
-    const init = def.getInitializer();
-    if (!init) {
-      const nameNode = def.getPropertyNameNode() ?? def.getNameNode();
-      const propName = nameNode.getText();
-      const innerStack2 = [...stack, nameNode];
-      const value = maybeBindingElementValue(def, innerStack2, propName, ctx);
-      if (value) return value;
-      return box.unresolvable(def, stack);
-    }
-    const initializer = unwrapExpression(init);
-    const innerStack = [...stack, initializer];
-    const maybeValue = maybeBoxNode(initializer, innerStack, ctx);
-    if (maybeValue) return maybeValue;
-  }
+const maybeDefinitionValue = (def, stack, ctx) => {
+	if (Node.isShorthandPropertyAssignment(def)) {
+		const propNameNode = def.getNameNode();
+		return maybePropIdentifierValue(propNameNode, [propNameNode.getText()], stack, ctx);
+	}
+	if (Node.isVariableDeclaration(def)) {
+		const init = def.getInitializer();
+		if (!init) {
+			const type = def.getTypeNode();
+			if (!type) return;
+			if (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 (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;
+	}
 };
-var 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 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;
 };
-var hasNamedExportWithName = (name, exportDeclaration) => {
-  const namedExports = exportDeclaration.getNamedExports();
-  if (namedExports.length === 0) return true;
-  for (const namedExport of namedExports) {
-    const exportedName = namedExport.getNameNode().getText();
-    if (exportedName === name) {
-      return true;
-    }
-  }
+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;
 };
-var getModuleSpecifierSourceFile = (declaration) => {
-  const project = declaration.getProject();
-  const moduleName = declaration.getModuleSpecifierValue();
-  if (!moduleName) return;
-  const containingFile = declaration.getSourceFile().getFilePath();
-  const resolved = ts2.resolveModuleName(
-    moduleName,
-    containingFile,
-    project.getCompilerOptions(),
-    project.getModuleResolutionHost()
-  );
-  if (!resolved.resolvedModule) return;
-  const sourceFile = project.addSourceFileAtPath(resolved.resolvedModule.resolvedFileName);
-  return sourceFile;
+/**
+* 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.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;
-    }
-  }
+	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;
+		}
+	}
 }
-var 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 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);
 };
-var 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 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);
 };
-var 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 (Node5.isIdentifier(elementAccessed) && argLiteral) {
-    if (!isNotNullish(argLiteral.value)) return;
-    return maybePropIdentifierValue(elementAccessed, [argLiteral.value.toString()], stack, ctx);
-  }
-  if (Node5.isBinaryExpression(arg)) {
-    if (arg.getOperatorToken().getKind() !== ts2.SyntaxKind.PlusToken) return;
-    const propName = tryComputingPlusTokenBinaryExpressionToString(arg, stack, ctx) ?? maybePropName(arg, stack, ctx);
-    if (propName && Node5.isIdentifier(elementAccessed)) {
-      if (!isNotNullish(propName.value)) return;
-      return maybePropIdentifierValue(elementAccessed, [propName.value.toString()], stack, ctx);
-    }
-  }
-  if (Node5.isTemplateExpression(arg)) {
-    const propName = maybeTemplateStringValue(arg, stack, ctx);
-    if (propName && Node5.isIdentifier(elementAccessed)) {
-      return maybePropIdentifierValue(elementAccessed, [propName], stack, ctx);
-    }
-  }
-  if (Node5.isObjectLiteralExpression(elementAccessed) && argLiteral) {
-    if (!isNotNullish(argLiteral.value)) return;
-    return getObjectLiteralPropValue(elementAccessed, [argLiteral.value.toString()], stack, ctx);
-  }
-  if (Node5.isPropertyAccessExpression(arg)) {
-    return getPropertyAccessedExpressionValue(arg, [], stack, ctx);
-  }
-  if (Node5.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 (Node5.isIdentifier(elementAccessed) && Node5.isElementAccessExpression(arg)) {
-    const propName = getElementAccessedExpressionValue(arg, stack, ctx);
-    if (typeof propName === "string" && isNotNullish(propName)) {
-      return maybePropIdentifierValue(elementAccessed, [propName], stack, ctx);
-    }
-  }
-  if (Node5.isElementAccessExpression(elementAccessed) && argLiteral && isNotNullish(argLiteral.value)) {
-    const identifier = getElementAccessedExpressionValue(elementAccessed, stack, ctx);
-    if (isObject(identifier)) {
-      const argValue = argLiteral.value.toString();
-      if (box.isMap(identifier)) {
-        const maybeValue = identifier.value.get(argValue);
-        return maybeValue;
-      }
-      if (box.isObject(identifier)) {
-        const maybeLiteralValue = identifier.value[argValue];
-        if (!maybeLiteralValue) return;
-        return box.from(maybeLiteralValue, expression, stack);
-      }
-    }
-  }
-  if (Node5.isArrayLiteralExpression(elementAccessed) && argLiteral) {
-    return getArrayElementValueAtIndex(elementAccessed, Number(argLiteral.value), stack, ctx);
-  }
-  if (Node5.isConditionalExpression(arg)) {
-    if (ctx.flags?.skipConditions) return box.unresolvable(arg, stack);
-    const propName = maybePropName(arg, stack, ctx);
-    if (isNotNullish(propName) && isNotNullish(propName.value)) {
-      if (Node5.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 (Node5.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 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 (Node.isIdentifier(elementAccessed) && argLiteral) {
+		if (!isNotNullish(argLiteral.value)) return;
+		return maybePropIdentifierValue(elementAccessed, [argLiteral.value.toString()], stack, ctx);
+	}
+	if (Node.isBinaryExpression(arg)) {
+		if (arg.getOperatorToken().getKind() !== ts.SyntaxKind.PlusToken) return;
+		const propName = tryComputingPlusTokenBinaryExpressionToString(arg, stack, ctx) ?? maybePropName(arg, stack, ctx);
+		if (propName && Node.isIdentifier(elementAccessed)) {
+			if (!isNotNullish(propName.value)) return;
+			return maybePropIdentifierValue(elementAccessed, [propName.value.toString()], stack, ctx);
+		}
+	}
+	if (Node.isTemplateExpression(arg)) {
+		const propName = maybeTemplateStringValue(arg, stack, ctx);
+		if (propName && Node.isIdentifier(elementAccessed)) return maybePropIdentifierValue(elementAccessed, [propName], stack, ctx);
+	}
+	if (Node.isObjectLiteralExpression(elementAccessed) && argLiteral) {
+		if (!isNotNullish(argLiteral.value)) return;
+		return getObjectLiteralPropValue(elementAccessed, [argLiteral.value.toString()], stack, ctx);
+	}
+	if (Node.isPropertyAccessExpression(arg)) return getPropertyAccessedExpressionValue(arg, [], stack, ctx);
+	if (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 (Node.isIdentifier(elementAccessed) && Node.isElementAccessExpression(arg)) {
+		const propName = getElementAccessedExpressionValue(arg, stack, ctx);
+		if (typeof propName === "string" && isNotNullish(propName)) return maybePropIdentifierValue(elementAccessed, [propName], stack, ctx);
+	}
+	if (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 (Node.isArrayLiteralExpression(elementAccessed) && argLiteral) return getArrayElementValueAtIndex(elementAccessed, Number(argLiteral.value), stack, ctx);
+	if (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 (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 (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);
+		}
+	}
 };
-var 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 getArrayElementValueAtIndex = (array, index, stack, ctx) => {
+	const element = array.getElements()[index];
+	if (!element) return;
+	const value = maybeBoxNode(element, stack, ctx);
+	if (isNotNullish(value)) return value;
 };
-var getPropertyAccessedExpressionValue = (expression, _accessList, stack, ctx) => {
-  const propName = expression.getName();
-  const elementAccessed = unwrapExpression(expression.getExpression());
-  const accessList = _accessList.concat(propName);
-  stack.push(elementAccessed);
-  if (Node5.isIdentifier(elementAccessed)) {
-    return maybePropIdentifierValue(elementAccessed, accessList, stack, ctx);
-  }
-  if (Node5.isPropertyAccessExpression(elementAccessed)) {
-    const propValue = getPropertyAccessedExpressionValue(elementAccessed, accessList, stack, ctx);
-    return propValue;
-  }
-  if (Node5.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);
-    }
-  }
+const getPropertyAccessedExpressionValue = (expression, _accessList, stack, ctx) => {
+	const propName = expression.getName();
+	const elementAccessed = unwrapExpression(expression.getExpression());
+	const accessList = _accessList.concat(propName);
+	stack.push(elementAccessed);
+	if (Node.isIdentifier(elementAccessed)) return maybePropIdentifierValue(elementAccessed, accessList, stack, ctx);
+	if (Node.isPropertyAccessExpression(elementAccessed)) return getPropertyAccessedExpressionValue(elementAccessed, accessList, stack, ctx);
+	if (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);
+		}
+	}
 };
-
-// src/call-expression.ts
-var trueFn = () => true;
-var 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/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, []);
 };
-
-// src/extract.ts
-import { Node as Node7 } from "ts-morph";
-
-// src/compiled-jsx.ts
-import { Node as MorphNode, SyntaxKind } from "ts-morph";
-var reactRuntimeMods = /* @__PURE__ */ new Set(["react/jsx-runtime", "react/jsx-dev-runtime"]);
-var preactRuntimeMods = /* @__PURE__ */ new Set(["preact/jsx-runtime", "preact/jsx-dev-runtime"]);
-var classicReactMods = /* @__PURE__ */ new Set(["react"]);
-var classicPreactMods = /* @__PURE__ */ new Set(["preact"]);
-var solidMods = /* @__PURE__ */ new Set(["solid-js", "solid-js/web"]);
-var vueMods = /* @__PURE__ */ new Set(["vue"]);
-var 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" };
-  }
-  return;
+//#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"
+	};
 };
-var 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 (MorphNode.isCallExpression(expression)) {
-      const callee = unwrapExpression(expression.getExpression());
-      if (!MorphNode.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";
-      }
-    }
-    return;
-  };
-  sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).forEach((callExpression) => {
-    const callee = unwrapExpression(callExpression.getExpression());
-    if (!MorphNode.isIdentifier(callee) || callee.getText() !== "parcelRegister") return;
-    const [idArg, factoryArg] = callExpression.getArguments();
-    if (!MorphNode.isStringLiteral(idArg)) return;
-    if (!MorphNode.isArrowFunction(factoryArg) && !MorphNode.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 (!MorphNode.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 && MorphNode.isCallExpression(initializer)) {
-      const callee = unwrapExpression(initializer.getExpression());
-      const [firstArg] = initializer.getArguments();
-      if (MorphNode.isIdentifier(callee) && callee.getText() === "parcelRequire" && MorphNode.isStringLiteral(firstArg)) {
-        mod = parcelRuntimeModuleIds.get(firstArg.getLiteralValue());
-      }
-    }
-    if (!mod && initializer && MorphNode.isObjectLiteralExpression(initializer)) {
-      const propertyNames = new Set(
-        initializer.getProperties().map((property) => {
-          if (MorphNode.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(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 (MorphNode.isIdentifier(expression)) {
-      return bundledNamed.get(expression.getText());
-    }
-    if (MorphNode.isConditionalExpression(expression)) {
-      return resolveBundledAliasImport(expression.getWhenTrue()) ?? resolveBundledAliasImport(expression.getWhenFalse());
-    }
-    if (MorphNode.isBinaryExpression(expression) && expression.getOperatorToken().getKind() === SyntaxKind.CommaToken) {
-      return resolveBundledAliasImport(expression.getRight());
-    }
-  };
-  sourceFile.getVariableDeclarations().forEach((declaration) => {
-    if (!MorphNode.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 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 (Node.isCallExpression(expression)) {
+			const callee = unwrapExpression(expression.getExpression());
+			if (!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(SyntaxKind.CallExpression).forEach((callExpression) => {
+		const callee = unwrapExpression(callExpression.getExpression());
+		if (!Node.isIdentifier(callee) || callee.getText() !== "parcelRegister") return;
+		const [idArg, factoryArg] = callExpression.getArguments();
+		if (!Node.isStringLiteral(idArg)) return;
+		if (!Node.isArrowFunction(factoryArg) && !Node.isFunctionExpression(factoryArg)) return;
+		const factoryText = factoryArg.getBody().getText();
+		if (factoryText.includes("\"Fragment\"") && factoryText.includes("\"jsx\"") && factoryText.includes("\"jsxs\"") && factoryText.includes("module.exports")) parcelRuntimeModuleIds.set(idArg.getLiteralValue(), "react/jsx-runtime");
+	});
+	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 (!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 && Node.isCallExpression(initializer)) {
+			const callee = unwrapExpression(initializer.getExpression());
+			const [firstArg] = initializer.getArguments();
+			if (Node.isIdentifier(callee) && callee.getText() === "parcelRequire" && Node.isStringLiteral(firstArg)) mod = parcelRuntimeModuleIds.get(firstArg.getLiteralValue());
+		}
+		if (!mod && initializer && Node.isObjectLiteralExpression(initializer)) {
+			const propertyNames = new Set(initializer.getProperties().map((property) => {
+				if (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(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 (Node.isIdentifier(expression)) return bundledNamed.get(expression.getText());
+		if (Node.isConditionalExpression(expression)) return resolveBundledAliasImport(expression.getWhenTrue()) ?? resolveBundledAliasImport(expression.getWhenFalse());
+		if (Node.isBinaryExpression(expression) && expression.getOperatorToken().getKind() === SyntaxKind.CommaToken) return resolveBundledAliasImport(expression.getRight());
+	};
+	sourceFile.getVariableDeclarations().forEach((declaration) => {
+		if (!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
+	};
 };
-var normalizeTagName = (text) => {
-  const parcelVarMatch = text.match(/\$[^$]+\$var\$(.+)$/);
-  if (parcelVarMatch?.[1]) {
-    return parcelVarMatch[1];
-  }
-  return text;
+const normalizeTagName = (text) => {
+	const parcelVarMatch = text.match(/\$[^$]+\$var\$(.+)$/);
+	if (parcelVarMatch?.[1]) return parcelVarMatch[1];
+	return text;
 };
-var getTagName = (node) => {
-  if (!node) return;
-  const expression = unwrapExpression(node);
-  if (MorphNode.isStringLiteral(expression) || MorphNode.isNoSubstitutionTemplateLiteral(expression)) {
-    return expression.getLiteralValue();
-  }
-  if (MorphNode.isIdentifier(expression) || MorphNode.isPropertyAccessExpression(expression) || MorphNode.isElementAccessExpression(expression)) {
-    return normalizeTagName(expression.getText());
-  }
+const getTagName = (node) => {
+	if (!node) return;
+	const expression = unwrapExpression(node);
+	if (Node.isStringLiteral(expression) || Node.isNoSubstitutionTemplateLiteral(expression)) return expression.getLiteralValue();
+	if (Node.isIdentifier(expression) || Node.isPropertyAccessExpression(expression) || Node.isElementAccessExpression(expression)) return normalizeTagName(expression.getText());
 };
-var isQwikMod = (mod) => mod.includes("qwik");
-var getArgsAt = (...indices) => (args) => indices.map((index) => args[index]).filter(Boolean);
-var 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 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)
+	}
 ];
-var createCompiledJsxContext = (sourceFile) => {
-  const imports = collectImports(sourceFile);
-  const normalizeCallee = (node) => {
-    const expression = unwrapExpression(node);
-    if (MorphNode.isBinaryExpression(expression) && expression.getOperatorToken().getKind() === 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 (MorphNode.isIdentifier(expression)) {
-        const imported = imports.bundledNamed.get(expression.getText());
-        if (imported) {
-          return { mod: imported.mod, importedName: imported.importedName };
-        }
-        return resolveIdentifierDefinition(expression);
-      }
-      if (MorphNode.isConditionalExpression(expression)) {
-        return resolveLocalAlias(expression.getWhenTrue()) ?? resolveLocalAlias(expression.getWhenFalse());
-      }
-      if (MorphNode.isBinaryExpression(expression) && expression.getOperatorToken().getKind() === SyntaxKind.CommaToken) {
-        return resolveLocalAlias(expression.getRight());
-      }
-    };
-    for (const definition of identifier.getDefinitions()) {
-      const declaration = definition.getDeclarationNode();
-      if (!declaration) continue;
-      if (MorphNode.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 (MorphNode.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 (MorphNode.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 (MorphNode.isPropertyAccessExpression(expression)) {
-      const target = normalizeCallee(expression.getExpression());
-      if (!MorphNode.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 (!MorphNode.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
-  };
+const createCompiledJsxContext = (sourceFile) => {
+	const imports = collectImports(sourceFile);
+	const normalizeCallee = (node) => {
+		const expression = unwrapExpression(node);
+		if (Node.isBinaryExpression(expression) && expression.getOperatorToken().getKind() === SyntaxKind.CommaToken) return normalizeCallee(expression.getRight());
+		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 (Node.isIdentifier(expression)) {
+				const imported = imports.bundledNamed.get(expression.getText());
+				if (imported) return {
+					mod: imported.mod,
+					importedName: imported.importedName
+				};
+				return resolveIdentifierDefinition(expression);
+			}
+			if (Node.isConditionalExpression(expression)) return resolveLocalAlias(expression.getWhenTrue()) ?? resolveLocalAlias(expression.getWhenFalse());
+			if (Node.isBinaryExpression(expression) && expression.getOperatorToken().getKind() === SyntaxKind.CommaToken) return resolveLocalAlias(expression.getRight());
+		};
+		for (const definition of identifier.getDefinitions()) {
+			const declaration = definition.getDeclarationNode();
+			if (!declaration) continue;
+			if (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 (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 (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 (Node.isPropertyAccessExpression(expression)) {
+			const target = normalizeCallee(expression.getExpression());
+			if (!Node.isIdentifier(target)) return;
+			const targetName = target.getText();
+			const mod = imports.default.get(targetName) ?? imports.namespace.get(targetName) ?? imports.bundledNamespace.get(targetName);
+			if (!mod) return;
+			return {
+				mod,
+				importedName: expression.getName()
+			};
+		}
+	};
+	const isMergePropsCall = (node) => {
+		if (!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
+	};
 };
-
-// src/jsx-attribute.ts
-import { Node as Node6 } from "ts-morph";
-var extractJsxAttribute = (jsxAttribute, ctx) => {
-  const initializer = jsxAttribute.getInitializer();
-  const stack = [jsxAttribute, initializer];
-  if (!initializer) {
-    const nameNode = jsxAttribute.getNameNode();
-    return box.emptyInitializer(nameNode, stack);
-  }
-  if (Node6.isStringLiteral(initializer)) {
-    const literalText = initializer.getLiteralText();
-    return box.literal(trimWhitespace(literalText), initializer, stack);
-  }
-  if (Node6.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-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 (Node.isStringLiteral(initializer)) {
+		const literalText = initializer.getLiteralText();
+		return box.literal(trimWhitespace(literalText), initializer, stack);
+	}
+	if (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;
+	}
 };
-
-// src/jsx-spread-attribute.ts
-var extractJsxSpreadAttributeValues = (node, ctx, matchProp) => {
-  const expr = unwrapExpression(node.getExpression());
-  const stack = [];
-  return maybeBoxNode(expr, stack, ctx, matchProp);
+//#endregion
+//#region src/jsx-spread-attribute.ts
+const extractJsxSpreadAttributeValues = (node, ctx, matchProp) => {
+	return maybeBoxNode(unwrapExpression(node.getExpression()), [], ctx, matchProp);
 };
-
-// src/object-like-to-map.ts
-var 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]) => {
-      const boxed = box.from(value, maybeObject.getNode() ?? node, maybeObject.getStack() ?? []);
-      return [key, boxed || null];
-    }).filter(([, value]) => value !== null)
-  );
+//#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));
 };
-
-// src/extract.ts
-var isImportOrExport = (node) => Node7.isImportDeclaration(node) || Node7.isExportDeclaration(node);
-var isJsxElement = (node) => Node7.isJsxOpeningElement(node) || Node7.isJsxSelfClosingElement(node);
-var extract = ({ ast, ...ctx }) => {
-  const { components, functions, taggedTemplates } = ctx;
-  const compiledJsx = createCompiledJsxContext(ast);
-  const byName = /* @__PURE__ */ new Map();
-  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);
-    }
-    const mapValue = objectLikeToMap(objLike, propNode);
-    mapValue.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 (Node7.isObjectLiteralExpression(expression)) {
-      const objectMap = getObjectLiteralExpressionPropPairs(expression, stack, ctx, matchProp);
-      processComponentBoxNode(component, boxByProp, expression, objectMap, matchProp, true);
-      return;
-    }
-    if (Node7.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 (Node7.isJsxOpeningElement(node) || Node7.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 (Node7.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 (Node7.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 (Node7.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 && Node7.isCallExpression(node)) {
-      const expr = node.getExpression();
-      const fnName = Node7.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 boxNodeArray = extractCallExpressionArguments(node, ctx, matchProp, functions.matchArg);
-      const nodeList = boxNodeArray.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 && Node7.isTaggedTemplateExpression(node)) {
-      const tag = node.getTag();
-      const fnName = Node7.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 (Node7.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;
-    const queryList = byName.get(componentName).queryList;
-    queryList.push(query);
-  });
-  byName.forEach((result, name) => {
-    if (result.kind === "component" && result.queryList.length === 0) {
-      byName.delete(name);
-    }
-  });
-  return byName;
+//#endregion
+//#region src/extract.ts
+const isImportOrExport = (node) => Node.isImportDeclaration(node) || Node.isExportDeclaration(node);
+const isJsxElement = (node) => Node.isJsxOpeningElement(node) || 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 (Node.isObjectLiteralExpression(expression)) {
+			processComponentBoxNode(component, boxByProp, expression, getObjectLiteralExpressionPropPairs(expression, stack, ctx, matchProp), matchProp, true);
+			return;
+		}
+		if (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 (Node.isJsxOpeningElement(node) || 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 (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 (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 (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 && Node.isCallExpression(node)) {
+			const expr = node.getExpression();
+			const fnName = 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 && Node.isTaggedTemplateExpression(node)) {
+			const tag = node.getTag();
+			const fnName = 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 (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;
 };
-
-// src/jsx-element-props.ts
-import { Node as Node8 } from "ts-morph";
-var isObjectLike = (node) => box.isObject(node) || box.isMap(node);
-var extractJsxElementProps = (node, ctx) => {
-  const tagName = node.getTagNameNode().getText();
-  const jsxAttributes = node.getAttributes();
-  const props = /* @__PURE__ */ new Map();
-  jsxAttributes.forEach((attrNode) => {
-    if (Node8.isJsxAttribute(attrNode)) {
-      const nameNode = attrNode.getNameNode();
-      const maybeValue = extractJsxAttribute(attrNode, ctx);
-      if (!maybeValue) return;
-      props.set(nameNode.getText(), maybeValue);
-      return;
-    }
-    if (Node8.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/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 (Node.isJsxAttribute(attrNode)) {
+			const nameNode = attrNode.getNameNode();
+			const maybeValue = extractJsxAttribute(attrNode, ctx);
+			if (!maybeValue) return;
+			props.set(nameNode.getText(), maybeValue);
+			return;
+		}
+		if (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
+	};
 };
-
-// src/unbox.ts
-import { Node as Node9 } from "ts-morph";
-var 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;
+//#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;
 };
-var 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 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;
 };
-var 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 && Node9.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 void 0;
-    }
-    if (isTruthyOrZero(whenTrue)) {
-      ctx.conditions.push(makeObjAt(path, whenTrue));
-    }
-    if (isTruthyOrZero(whenFalse)) {
-      ctx.conditions.push(makeObjAt(path, whenFalse));
-    }
-    return void 0;
-  }
-  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 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 && 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
+	})));
 };
-var cacheMap3 = /* @__PURE__ */ new WeakMap();
-var createCache = (map) => ({
-  value: map,
-  has: (node) => map.has(node),
-  get: (node) => map.get(node),
-  set: (node, value) => map.set(node, value)
+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)
 });
-var unbox = (node, ctx) => {
-  const _ctx = {
-    cache: ctx?.cache ?? cacheMap3,
-    ...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;
-};
-export {
-  BoxNodeArray,
-  BoxNodeConditional,
-  BoxNodeEmptyInitializer,
-  BoxNodeLiteral,
-  BoxNodeMap,
-  BoxNodeObject,
-  BoxNodeUnresolvable,
-  box,
-  extract,
-  extractCallExpressionArguments,
-  extractJsxAttribute,
-  extractJsxElementProps,
-  extractJsxSpreadAttributeValues,
-  findIdentifierValueDeclaration,
-  isBoxNode,
-  maybeBoxNode,
-  maybeIdentifierValue,
-  unbox
+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
+export { BoxNodeArray, BoxNodeConditional, BoxNodeEmptyInitializer, BoxNodeLiteral, BoxNodeMap, BoxNodeObject, BoxNodeUnresolvable, box, extract, extractCallExpressionArguments, extractJsxAttribute, extractJsxElementProps, extractJsxSpreadAttributeValues, findIdentifierValueDeclaration, isBoxNode, maybeBoxNode, maybeIdentifierValue, unbox };