@vue-jsx-vapor/macros 2.3.6 → 2.4.0

package/dist/api.cjs

@@ -1,7 +1,6 @@
-const require_core = require('./core-C740HxiF.cjs');
+const require_core = require('./core-Bcy1Ov-P.cjs');
 
-exports.getMacroExpression = require_core.getMacroExpression
-exports.getParamsStart = require_core.getParamsStart
-exports.isFunctionalNode = require_core.isFunctionalNode
-exports.restructure = require_core.restructure
-exports.transformJsxMacros = require_core.transformJsxMacros
+exports.getMacroExpression = require_core.getMacroExpression;
+exports.isFunctionalNode = require_core.isFunctionalNode;
+exports.restructure = require_core.restructure;
+exports.transformJsxMacros = require_core.transformJsxMacros;

package/dist/api.d.cts

@@ -1,47 +1,48 @@
-import { OptionsResolved } from "./options.d-CXMsJZSo.cjs";
+import { OptionsResolved } from "./options-BxlJkUDe.cjs";
 import { CodeTransform, MagicStringAST } from "@vue-macros/common";
 import { ArrowFunctionExpression, CallExpression, FunctionDeclaration, FunctionExpression, LVal, Node } from "@babel/types";
 
+//#region src/core/babel-utils.d.ts
+
+type FunctionalNode = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+declare function isFunctionalNode(node?: Node | null): node is FunctionalNode; //#endregion
 //#region src/core/restructure.d.ts
 type Options = {
-    withDefaultsFrom?: string;
-    skipDefaultProps?: boolean;
-    generateRestProps?: (restPropsName: string, index: number, list: Prop[]) => string | undefined;
+  withDefaultsFrom?: string;
+  skipDefaultProps?: boolean;
+  generateRestProps?: (restPropsName: string, index: number, list: Prop[]) => string | undefined;
 };
 type Prop = {
-    path: string;
-    name: string;
-    value: string;
-    defaultValue?: string;
-    isRest?: boolean;
+  path: string;
+  name: string;
+  value: string;
+  defaultValue?: string;
+  isRest?: boolean;
 };
 declare function restructure(s: MagicStringAST, node: FunctionalNode, options?: Options): Prop[];
 
 //#endregion
 //#region src/core/index.d.ts
-type FunctionalNode = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
 type DefineStyle = {
-    expression: CallExpression;
-    isCssModules: boolean;
-    lang: string;
+  expression: CallExpression;
+  isCssModules: boolean;
+  lang: string;
 };
 type Macros = {
-    defineComponent?: CallExpression;
-    defineModel?: {
-        expression: CallExpression;
-        isRequired: boolean;
-    }[];
-    defineSlots?: {
-        expression: CallExpression;
-        id?: LVal;
-    };
-    defineExpose?: CallExpression;
-    defineStyle?: DefineStyle[];
+  defineComponent?: CallExpression;
+  defineModel?: {
+    expression: CallExpression;
+    isRequired: boolean;
+  }[];
+  defineSlots?: {
+    expression: CallExpression;
+    id?: LVal;
+  };
+  defineExpose?: CallExpression;
+  defineStyle?: DefineStyle[];
 };
 declare function transformJsxMacros(code: string, id: string, importMap: Map<string, string>, options: OptionsResolved): CodeTransform | undefined;
-declare function isFunctionalNode(node?: Node | null): node is FunctionalNode;
 declare function getMacroExpression(node: Node, options: OptionsResolved): CallExpression | undefined;
-declare function getParamsStart(node: FunctionalNode, code: string): number;
 
 //#endregion
-export { DefineStyle, FunctionalNode, Macros, getMacroExpression, getParamsStart, isFunctionalNode, restructure, transformJsxMacros };
+export { DefineStyle, Macros, getMacroExpression, isFunctionalNode, restructure, transformJsxMacros };

package/dist/api.d.ts

@@ -1,47 +1,48 @@
-import { OptionsResolved } from "./options.d-DNWXuL_g.js";
+import { OptionsResolved } from "./options-QKLCzlvG.js";
 import { CodeTransform, MagicStringAST } from "@vue-macros/common";
 import { ArrowFunctionExpression, CallExpression, FunctionDeclaration, FunctionExpression, LVal, Node } from "@babel/types";
 
+//#region src/core/babel-utils.d.ts
+
+type FunctionalNode = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+declare function isFunctionalNode(node?: Node | null): node is FunctionalNode; //#endregion
 //#region src/core/restructure.d.ts
 type Options = {
-    withDefaultsFrom?: string;
-    skipDefaultProps?: boolean;
-    generateRestProps?: (restPropsName: string, index: number, list: Prop[]) => string | undefined;
+  withDefaultsFrom?: string;
+  skipDefaultProps?: boolean;
+  generateRestProps?: (restPropsName: string, index: number, list: Prop[]) => string | undefined;
 };
 type Prop = {
-    path: string;
-    name: string;
-    value: string;
-    defaultValue?: string;
-    isRest?: boolean;
+  path: string;
+  name: string;
+  value: string;
+  defaultValue?: string;
+  isRest?: boolean;
 };
 declare function restructure(s: MagicStringAST, node: FunctionalNode, options?: Options): Prop[];
 
 //#endregion
 //#region src/core/index.d.ts
-type FunctionalNode = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
 type DefineStyle = {
-    expression: CallExpression;
-    isCssModules: boolean;
-    lang: string;
+  expression: CallExpression;
+  isCssModules: boolean;
+  lang: string;
 };
 type Macros = {
-    defineComponent?: CallExpression;
-    defineModel?: {
-        expression: CallExpression;
-        isRequired: boolean;
-    }[];
-    defineSlots?: {
-        expression: CallExpression;
-        id?: LVal;
-    };
-    defineExpose?: CallExpression;
-    defineStyle?: DefineStyle[];
+  defineComponent?: CallExpression;
+  defineModel?: {
+    expression: CallExpression;
+    isRequired: boolean;
+  }[];
+  defineSlots?: {
+    expression: CallExpression;
+    id?: LVal;
+  };
+  defineExpose?: CallExpression;
+  defineStyle?: DefineStyle[];
 };
 declare function transformJsxMacros(code: string, id: string, importMap: Map<string, string>, options: OptionsResolved): CodeTransform | undefined;
-declare function isFunctionalNode(node?: Node | null): node is FunctionalNode;
 declare function getMacroExpression(node: Node, options: OptionsResolved): CallExpression | undefined;
-declare function getParamsStart(node: FunctionalNode, code: string): number;
 
 //#endregion
-export { DefineStyle, FunctionalNode, Macros, getMacroExpression, getParamsStart, isFunctionalNode, restructure, transformJsxMacros };
+export { DefineStyle, Macros, getMacroExpression, isFunctionalNode, restructure, transformJsxMacros };

package/dist/api.js

@@ -1,3 +1,3 @@
-import { getMacroExpression, getParamsStart, isFunctionalNode, restructure, transformJsxMacros } from "./core-CHBxRAvb.js";
+import { getMacroExpression, isFunctionalNode, restructure, transformJsxMacros } from "./core-CVDOxdBq.js";
 
-export { getMacroExpression, getParamsStart, isFunctionalNode, restructure, transformJsxMacros };
+export { getMacroExpression, isFunctionalNode, restructure, transformJsxMacros };

package/dist/astro.cjs

@@ -1,9 +1,8 @@
-"use strict";
 Object.defineProperty(exports, '__esModule', { value: true });
-require('./core-C740HxiF.cjs');
-require('./raw-BXpT71mV.cjs');
-require('./options-BSX_vMxh.cjs');
-const require_src = require('./src-2EUAmvRo.cjs');
+require('./core-Bcy1Ov-P.cjs');
+require('./raw-CWSp77B1.cjs');
+require('./options-BejTnOdM.cjs');
+const require_src = require('./src-B6eLwniY.cjs');
 
 //#region src/astro.ts
 var astro_default = (options) => ({
@@ -15,4 +14,4 @@ var astro_default = (options) => ({
 });
 
 //#endregion
-exports.default = astro_default
+exports.default = astro_default;

package/dist/astro.d.cts

@@ -1,12 +1,10 @@
-import { Options } from "./options.d-CXMsJZSo.cjs";
+import { Options } from "./options-BxlJkUDe.cjs";
 
 //#region src/astro.d.ts
 declare const _default: (options: Options) => {
-    name: string;
-    hooks: {
-        'astro:config:setup': (astro: any) => void;
-    };
-};
-
-//#endregion
+  name: string;
+  hooks: {
+    'astro:config:setup': (astro: any) => void;
+  };
+}; //#endregion
 export { _default as default };

package/dist/astro.d.ts

@@ -1,12 +1,10 @@
-import { Options } from "./options.d-DNWXuL_g.js";
+import { Options } from "./options-QKLCzlvG.js";
 
 //#region src/astro.d.ts
 declare const _default: (options: Options) => {
-    name: string;
-    hooks: {
-        'astro:config:setup': (astro: any) => void;
-    };
-};
-
-//#endregion
+  name: string;
+  hooks: {
+    'astro:config:setup': (astro: any) => void;
+  };
+}; //#endregion
 export { _default as default };

package/dist/astro.js

@@ -1,7 +1,7 @@
-import "./core-CHBxRAvb.js";
-import "./raw-Hr7QYA0U.js";
+import "./core-CVDOxdBq.js";
+import "./raw-BYuezyBg.js";
 import "./options-BWRkHmm5.js";
-import { src_default } from "./src-BDMVJUXS.js";
+import { src_default } from "./src-CLt7j2eU.js";
 
 //#region src/astro.ts
 var astro_default = (options) => ({

package/dist/{chunk-BCwAaXi7.cjs → chunk-CUT6urMc.cjs}

@@ -1,4 +1,3 @@
-"use strict";
 //#region rolldown:runtime
 var __create = Object.create;
 var __defProp = Object.defineProperty;

package/dist/{core-C740HxiF.cjs → core-Bcy1Ov-P.cjs}

@@ -1,9 +1,220 @@
-"use strict";
-const require_chunk = require('./chunk-BCwAaXi7.cjs');
+const require_chunk = require('./chunk-CUT6urMc.cjs');
 const __vue_macros_common = require_chunk.__toESM(require("@vue-macros/common"));
-const __vue_compiler_sfc = require_chunk.__toESM(require("@vue/compiler-sfc"));
 const hash_sum = require_chunk.__toESM(require("hash-sum"));
 
+//#region src/core/babel-utils.ts
+/**
+* Return value indicates whether the AST walked can be a constant
+*/
+function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = Object.create(null)) {
+	const rootExp = root.type === "Program" ? root.body[0].type === "ExpressionStatement" && root.body[0].expression : root;
+	(0, __vue_macros_common.walkAST)(root, {
+		enter(node, parent) {
+			parent && parentStack.push(parent);
+			if (parent && parent.type.startsWith("TS") && !TS_NODE_TYPES.includes(parent.type)) return this.skip();
+			if (node.type === "Identifier" || node.type === "JSXIdentifier") {
+				const isLocal = !!knownIds[node.name];
+				const isRefed = isReferencedIdentifier(node, parent, parentStack);
+				if (includeAll || isRefed && !isLocal) onIdentifier(node, parent, parentStack, isRefed, isLocal);
+			} else if (node.type === "ObjectProperty" && parent?.type === "ObjectPattern") node.inPattern = true;
+			else if (isFunctionType$1(node)) if (node.scopeIds) node.scopeIds.forEach((id) => markKnownIds(id, knownIds));
+			else walkFunctionParams(node, (id) => markScopeIdentifier(node, id, knownIds));
+			else if (node.type === "BlockStatement") if (node.scopeIds) node.scopeIds.forEach((id) => markKnownIds(id, knownIds));
+			else walkBlockDeclarations(node, (id) => markScopeIdentifier(node, id, knownIds));
+			else if (node.type === "CatchClause" && node.param) for (const id of extractIdentifiers(node.param)) markScopeIdentifier(node, id, knownIds);
+			else if (isForStatement(node)) walkForStatement(node, false, (id) => markScopeIdentifier(node, id, knownIds));
+		},
+		leave(node, parent) {
+			parent && parentStack.pop();
+			if (node !== rootExp && node.scopeIds) for (const id of node.scopeIds) {
+				knownIds[id]--;
+				if (knownIds[id] === 0) delete knownIds[id];
+			}
+		}
+	});
+}
+function isReferencedIdentifier(id, parent, parentStack) {
+	if (!parent) return true;
+	if (id.name === "arguments") return false;
+	if (isReferenced(id, parent)) return true;
+	switch (parent.type) {
+		case "AssignmentExpression":
+		case "AssignmentPattern": return true;
+		case "ObjectPattern":
+		case "ArrayPattern": return isInDestructureAssignment(parent, parentStack);
+	}
+	return false;
+}
+function isInDestructureAssignment(parent, parentStack) {
+	if (parent && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern")) {
+		let i = parentStack.length;
+		while (i--) {
+			const p = parentStack[i];
+			if (p.type === "AssignmentExpression") return true;
+			else if (p.type !== "ObjectProperty" && !p.type.endsWith("Pattern")) break;
+		}
+	}
+	return false;
+}
+function walkFunctionParams(node, onIdent) {
+	for (const p of node.params) for (const id of extractIdentifiers(p)) onIdent(id);
+}
+function walkBlockDeclarations(block, onIdent) {
+	for (const stmt of block.body) if (stmt.type === "VariableDeclaration") {
+		if (stmt.declare) continue;
+		for (const decl of stmt.declarations) for (const id of extractIdentifiers(decl.id)) onIdent(id);
+	} else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
+		if (stmt.declare || !stmt.id) continue;
+		onIdent(stmt.id);
+	} else if (isForStatement(stmt)) walkForStatement(stmt, true, onIdent);
+}
+function isForStatement(stmt) {
+	return stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement";
+}
+function walkForStatement(stmt, isVar, onIdent) {
+	const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left;
+	if (variable && variable.type === "VariableDeclaration" && (variable.kind === "var" ? isVar : !isVar)) for (const decl of variable.declarations) for (const id of extractIdentifiers(decl.id)) onIdent(id);
+}
+function extractIdentifiers(param, nodes = []) {
+	switch (param.type) {
+		case "Identifier":
+			nodes.push(param);
+			break;
+		case "MemberExpression": {
+			let object = param;
+			while (object.type === "MemberExpression") object = object.object;
+			nodes.push(object);
+			break;
+		}
+		case "JSXMemberExpression": {
+			let object = param;
+			while (object.type === "JSXMemberExpression") object = object.object;
+			nodes.push(object);
+			break;
+		}
+		case "ObjectPattern":
+			for (const prop of param.properties) if (prop.type === "RestElement") extractIdentifiers(prop.argument, nodes);
+			else extractIdentifiers(prop.value, nodes);
+			break;
+		case "ArrayPattern":
+			param.elements.forEach((element) => {
+				if (element) extractIdentifiers(element, nodes);
+			});
+			break;
+		case "RestElement":
+			extractIdentifiers(param.argument, nodes);
+			break;
+		case "AssignmentPattern":
+			extractIdentifiers(param.left, nodes);
+			break;
+	}
+	return nodes;
+}
+function markKnownIds(name, knownIds) {
+	if (name in knownIds) knownIds[name]++;
+	else knownIds[name] = 1;
+}
+function markScopeIdentifier(node, child, knownIds) {
+	const { name } = child;
+	if (node.scopeIds && node.scopeIds.has(name)) return;
+	markKnownIds(name, knownIds);
+	(node.scopeIds || (node.scopeIds = new Set())).add(name);
+}
+const isFunctionType$1 = (node) => {
+	return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
+};
+/**
+* Copied from https://github.com/babel/babel/blob/main/packages/babel-types/src/validators/isReferenced.ts
+* To avoid runtime dependency on @babel/types (which includes process references)
+* This file should not change very often in babel but we may need to keep it
+* up-to-date from time to time.
+*
+* https://github.com/babel/babel/blob/main/LICENSE
+*
+*/
+function isReferenced(node, parent, grandparent) {
+	switch (parent.type) {
+		case "MemberExpression":
+		case "OptionalMemberExpression":
+			if (parent.property === node) return !!parent.computed;
+			return parent.object === node;
+		case "JSXMemberExpression": return parent.object === node;
+		case "VariableDeclarator": return parent.init === node;
+		case "ArrowFunctionExpression": return parent.body === node;
+		case "PrivateName": return false;
+		case "ClassMethod":
+		case "ClassPrivateMethod":
+		case "ObjectMethod":
+			if (parent.key === node) return !!parent.computed;
+			return false;
+		case "ObjectProperty":
+			if (parent.key === node) return !!parent.computed;
+			return !grandparent || grandparent.type !== "ObjectPattern";
+		case "ClassProperty":
+			if (parent.key === node) return !!parent.computed;
+			return true;
+		case "ClassPrivateProperty": return parent.key !== node;
+		case "ClassDeclaration":
+		case "ClassExpression": return parent.superClass === node;
+		case "AssignmentExpression": return parent.right === node;
+		case "AssignmentPattern": return parent.right === node;
+		case "LabeledStatement": return false;
+		case "CatchClause": return false;
+		case "RestElement": return false;
+		case "BreakStatement":
+		case "ContinueStatement": return false;
+		case "FunctionDeclaration":
+		case "FunctionExpression": return false;
+		case "ExportNamespaceSpecifier":
+		case "ExportDefaultSpecifier": return false;
+		case "ExportSpecifier":
+			if (grandparent?.source) return false;
+			return parent.local === node;
+		case "ImportDefaultSpecifier":
+		case "ImportNamespaceSpecifier":
+		case "ImportSpecifier": return false;
+		case "ImportAttribute": return false;
+		case "JSXAttribute": return false;
+		case "ObjectPattern":
+		case "ArrayPattern": return false;
+		case "MetaProperty": return false;
+		case "ObjectTypeProperty": return parent.key !== node;
+		case "TSEnumMember": return parent.id !== node;
+		case "TSPropertySignature":
+			if (parent.key === node) return !!parent.computed;
+			return true;
+	}
+	return true;
+}
+const TS_NODE_TYPES = [
+	"TSAsExpression",
+	"TSTypeAssertion",
+	"TSNonNullExpression",
+	"TSInstantiationExpression",
+	"TSSatisfiesExpression"
+];
+function prependFunctionalNode(node, s, result) {
+	const isBlockStatement = node.body.type === "BlockStatement";
+	const start = node.body.extra?.parenthesized ? node.body.extra.parenStart : node.body.start;
+	s.appendRight(start + (isBlockStatement ? 1 : 0), `${result};${!isBlockStatement ? "return " : ""}`);
+	if (!isBlockStatement) {
+		s.appendLeft(start, "{");
+		s.appendRight(node.end, "}");
+	}
+}
+function isFunctionalNode(node) {
+	return !!(node && (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression"));
+}
+function getParamsStart(node, code) {
+	return node.params[0] ? node.params[0].start : node.start + (code.slice(node.start, node.body.start).match(/\(\s*\)/)?.index || 0) + 1;
+}
+function getDefaultValue(node) {
+	if (node.type === "TSNonNullExpression") return getDefaultValue(node.expression);
+	if (node.type === "TSAsExpression") return getDefaultValue(node.expression);
+	return node;
+}
+
+//#endregion
 //#region src/core/helper/use-model.ts?raw
 var use_model_default = "import { customRef, watchSyncEffect } from \"vue\";\nexport function useModel(props, name, options = {}) {\n  const res = customRef((track, trigger) => {\n    let localValue = options && options.default;\n    let prevEmittedValue;\n    watchSyncEffect(() => {\n      const propValue = props[name];\n      if (!Object.is(prevEmittedValue, propValue)) {\n        localValue = propValue;\n        trigger();\n      }\n    });\n    return {\n      get() {\n        track();\n        return options.get ? options.get(localValue) : localValue;\n      },\n      set(value) {\n        if (Object.is(value, localValue)) return;\n        localValue = value;\n        trigger();\n        const emittedValue = prevEmittedValue = options.set ? options.set(value) : value;\n        for (const emit of [props[`onUpdate:${name}`]].flat()) {\n          if (typeof emit === \"function\") emit(emittedValue);\n        }\n      }\n    };\n  });\n  res[Symbol.iterator] = () => {\n    let i = 0;\n    return {\n      next() {\n        if (i < 2) {\n          return {\n            value: i++ ? props[`${name}Modifiers`] || {} : res,\n            done: false\n          };\n        } else {\n          return { done: true };\n        }\n      }\n    };\n  };\n  return res;\n}\n";
 
@@ -46,7 +257,7 @@ function restructure(s, node, options = {}) {
 			const resolvedValues = values.map((i) => `'${i.path.replace(path, "")}${i.value}': ${i.defaultValue}`).join(", ");
 			prependFunctionalNode(node, s, `\n${path} = ${createPropsDefaultProxy}(${path}, {${resolvedValues}})`);
 		}
-		(0, __vue_compiler_sfc.walkIdentifiers)(node.body, (id, parent) => {
+		walkIdentifiers(node.body, (id, parent) => {
 			const prop = propList.find((i) => i.name === id.name);
 			if (prop && !prop.isRest) s.overwrite(id.start, id.end, `${parent?.type === "ObjectProperty" && parent.shorthand ? `${id.name}: ` : ""}${prop.path}${prop.value}`);
 		}, false);
@@ -100,26 +311,9 @@ function getProps(s, options, node, path = "", props = []) {
 	});
 	return props.length ? props : void 0;
 }
-function getDefaultValue(node) {
-	if (node.type === "TSNonNullExpression") return getDefaultValue(node.expression);
-	if (node.type === "TSAsExpression") return getDefaultValue(node.expression);
-	return node;
-}
-function prependFunctionalNode(node, s, result) {
-	const isBlockStatement = node.body.type === "BlockStatement";
-	const start = node.body.extra?.parenthesized ? node.body.extra.parenStart : node.body.start;
-	s.appendRight(start + (isBlockStatement ? 1 : 0), `${result};${!isBlockStatement ? "return " : ""}`);
-	if (!isBlockStatement) {
-		s.appendLeft(start, "{");
-		s.appendRight(node.end, "}");
-	}
-}
 
 //#endregion
 //#region src/core/define-component/await.ts
-const isFunctionType = (node) => {
-	return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
-};
 function transformAwait(root, s) {
 	if (root.body.type !== "BlockStatement") return;
 	let hasAwait = false;
@@ -127,7 +321,7 @@ function transformAwait(root, s) {
 		const scope = [root.body.body];
 		(0, __vue_macros_common.walkAST)(node, {
 			enter(child, parent) {
-				if (isFunctionType(child)) this.skip();
+				if ((0, __vue_macros_common.isFunctionType)(child)) this.skip();
 				if (child.type === "BlockStatement") scope.push(child.body);
 				if (child.type === "AwaitExpression") {
 					hasAwait = true;
@@ -170,8 +364,11 @@ function transformDefineComponent(root, propsName, macros, s, autoReturnFunction
 	let hasRestProp = false;
 	const props = {};
 	if (root.params[0]) {
-		if (root.params[0].type === "Identifier") getWalkedIds(root, propsName).forEach((id) => props[id] = null);
-		else if (root.params[0].type === "ObjectPattern") {
+		if (root.params[0].type === "Identifier") {
+			getWalkedIds(root, propsName).forEach((id) => props[id] = null);
+			prependFunctionalNode(root, s, `const ${propsName} = ${(0, __vue_macros_common.importHelperFn)(s, 0, "useFullProps", void 0, "vue-jsx-vapor")}()`);
+			s.overwrite(root.params[0].start, root.params[0].end, `${__vue_macros_common.HELPER_PREFIX}props`);
+		} else if (root.params[0].type === "ObjectPattern") {
 			const restructuredProps = root.params[0];
 			for (const prop of restructuredProps.properties) {
 				if (prop.type !== "ObjectProperty" || prop.key.type !== "Identifier") continue;
@@ -211,7 +408,12 @@ function transformDefineComponent(root, propsName, macros, s, autoReturnFunction
 		const argument = macros.defineComponent.arguments[1];
 		if (!argument) s.appendRight(root.end, `, {${hasRestProp ? "inheritAttrs: false," : ""} props: {\n${propsString}\n} }`);
 		else if (argument.type === "ObjectExpression") {
-			prependObjectExpression(argument, "props", `{\n${propsString}\n}`, s);
+			const resolvedPropsString = `{\n${propsString}\n}`;
+			const prop = prependObjectExpression(argument, "props", resolvedPropsString, s);
+			if (prop && prop.type === "ObjectProperty" && prop.value.type === "ObjectExpression") {
+				s.appendLeft(prop.value.start, `{...${resolvedPropsString}, ...`);
+				s.appendRight(prop.value.end, "}");
+			}
 			if (hasRestProp) prependObjectExpression(argument, "inheritAttrs", "false", s);
 		}
 	}
@@ -219,13 +421,15 @@ function transformDefineComponent(root, propsName, macros, s, autoReturnFunction
 	if (autoReturnFunction) transformReturn(root, s);
 }
 function prependObjectExpression(argument, name, value, s) {
-	if (!argument.properties?.find((prop) => prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === name)) s.appendRight(argument.start + 1, `${name}: ${value},`);
+	const prop = argument.properties?.find((prop$1) => prop$1.type === "ObjectProperty" && prop$1.key.type === "Identifier" && prop$1.key.name === name);
+	if (!prop) s.appendRight(argument.start + 1, `${name}: ${value},`);
+	return prop;
 }
 function getWalkedIds(root, propsName) {
 	const walkedIds = new Set();
-	(0, __vue_compiler_sfc.walkIdentifiers)(root.body, (id, parent) => {
-		if (id.name === propsName && (parent?.type === "MemberExpression" || parent?.type === "OptionalMemberExpression")) {
-			const prop = parent.property.type === "Identifier" ? parent.property.name : parent.property.type === "StringLiteral" ? parent.property.value : "";
+	walkIdentifiers(root.body, (id, parent) => {
+		if (id.name === propsName && (parent?.type === "MemberExpression" || parent?.type === "JSXMemberExpression" || parent?.type === "OptionalMemberExpression")) {
+			const prop = parent.property.type === "Identifier" || parent.property.type === "JSXIdentifier" ? parent.property.name : parent.property.type === "StringLiteral" ? parent.property.value : "";
 			if (prop) walkedIds.add(prop);
 		}
 	});
@@ -295,9 +499,9 @@ function getTypeAndValue(s, node) {
 
 //#endregion
 //#region src/core/define-expose.ts
-function transformDefineExpose(node, s, version) {
+function transformDefineExpose(node, s) {
 	s.overwriteNode(node.callee, ";");
-	s.appendRight(node.arguments[0]?.start || node.end - 1, version >= 3.6 ? `${(0, __vue_macros_common.importHelperFn)(s, 0, "currentInstance")}.exposed = ` : `${(0, __vue_macros_common.importHelperFn)(s, 0, "getCurrentInstance")}().exposed = `);
+	s.appendRight(node.arguments[0]?.start || node.end - 1, `${(0, __vue_macros_common.importHelperFn)(s, 0, "getCurrentInstance", void 0, "vue-jsx-vapor")}().exposed = `);
 }
 
 //#endregion
@@ -398,7 +602,7 @@ function transformJsxMacros(code, id, importMap, options) {
 			transformDefineModel(expression, propsName, s);
 		});
 		if (macros.defineSlots) transformDefineSlots(macros.defineSlots.expression, s);
-		if (macros.defineExpose) transformDefineExpose(macros.defineExpose, s, options.version);
+		if (macros.defineExpose) transformDefineExpose(macros.defineExpose, s);
 	}
 	return (0, __vue_macros_common.generateTransform)(s, id);
 }
@@ -444,9 +648,6 @@ function getRootMap(ast, s, options) {
 	});
 	return rootMap;
 }
-function isFunctionalNode(node) {
-	return !!(node && (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression"));
-}
 function getMacroExpression(node, options) {
 	if (node.type === "TSNonNullExpression") node = node.expression;
 	if (node.type === "CallExpression") {
@@ -460,9 +661,6 @@ function getMacroExpression(node, options) {
 		].includes(node.callee.name)) return node;
 	}
 }
-function getParamsStart(node, code) {
-	return node.params[0] ? node.params[0].start : node.start + (code.slice(node.start, node.body.start).match(/\(\s*\)/)?.index || 0) + 1;
-}
 
 //#endregion
 Object.defineProperty(exports, 'getMacroExpression', {
@@ -471,12 +669,6 @@ Object.defineProperty(exports, 'getMacroExpression', {
     return getMacroExpression;
   }
 });
-Object.defineProperty(exports, 'getParamsStart', {
-  enumerable: true,
-  get: function () {
-    return getParamsStart;
-  }
-});
 Object.defineProperty(exports, 'helperPrefix', {
   enumerable: true,
   get: function () {