@vue-jsx-vapor/macros 2.3.6 → 2.4.1

package/dist/{core-CHBxRAvb.js → core-Bo9gAeWA.js}

@@ -1,7 +1,219 @@
-import { HELPER_PREFIX, MagicStringAST, babelParse, generateTransform, getLang, importHelperFn, walkAST } from "@vue-macros/common";
-import { walkIdentifiers } from "@vue/compiler-sfc";
+import { HELPER_PREFIX, MagicStringAST, babelParse, generateTransform, getLang, importHelperFn, isFunctionType, walkAST } from "@vue-macros/common";
 import hash from "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;
+	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";
 
@@ -98,26 +310,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;
@@ -168,8 +363,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} = ${importHelperFn(s, 0, "useFullProps", void 0, "vue-jsx-vapor")}()`);
+			s.overwrite(root.params[0].start, root.params[0].end, `${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;
@@ -209,7 +407,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);
 		}
 	}
@@ -217,13 +420,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();
 	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 : "";
+		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);
 		}
 	});
@@ -293,9 +498,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 ? `${importHelperFn(s, 0, "currentInstance")}.exposed = ` : `${importHelperFn(s, 0, "getCurrentInstance")}().exposed = `);
+	s.appendRight(node.arguments[0]?.start || node.end - 1, `${importHelperFn(s, 0, "getCurrentInstance", void 0, "vue-jsx-vapor/runtime")}().exposed = `);
 }
 
 //#endregion
@@ -396,7 +601,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 generateTransform(s, id);
 }
@@ -442,9 +647,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") {
@@ -458,9 +660,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
-export { getMacroExpression, getParamsStart, helperPrefix, isFunctionalNode, restructure, transformJsxMacros, useModelHelperId, use_model_default, withDefaultsHelperId, with_defaults_default };
+export { getMacroExpression, helperPrefix, isFunctionalNode, restructure, transformJsxMacros, useModelHelperId, use_model_default, withDefaultsHelperId, with_defaults_default };

package/dist/esbuild.cjs

@@ -1,12 +1,11 @@
-"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-BP7HnDkZ.cjs');
+require('./raw-DrrIS86r.cjs');
+require('./options-BejTnOdM.cjs');
+const require_src = require('./src-HPKL-RKa.cjs');
 
 //#region src/esbuild.ts
 var esbuild_default = require_src.src_default.esbuild;
 
 //#endregion
-exports.default = esbuild_default
+exports.default = esbuild_default;

package/dist/esbuild.d.cts

@@ -1,8 +1,8 @@
-import { Options } from "./options.d-CXMsJZSo.cjs";
-import { Plugin } from "esbuild";
+import { Options } from "./options-BxlJkUDe.cjs";
+import * as esbuild1 from "esbuild";
 
 //#region src/esbuild.d.ts
-declare const _default: (options?: Options | undefined) => Plugin;
+declare const _default: (options?: Options | undefined) => esbuild1.Plugin;
 
 //#endregion
 export { _default as default };

package/dist/esbuild.d.ts

@@ -1,8 +1,8 @@
-import { Options } from "./options.d-DNWXuL_g.js";
-import { Plugin } from "esbuild";
+import { Options } from "./options-QKLCzlvG.js";
+import * as esbuild1 from "esbuild";
 
 //#region src/esbuild.d.ts
-declare const _default: (options?: Options | undefined) => Plugin;
+declare const _default: (options?: Options | undefined) => esbuild1.Plugin;
 
 //#endregion
 export { _default as default };

package/dist/esbuild.js

@@ -1,7 +1,7 @@
-import "./core-CHBxRAvb.js";
-import "./raw-Hr7QYA0U.js";
+import "./core-Bo9gAeWA.js";
+import "./raw-BLYamp8z.js";
 import "./options-BWRkHmm5.js";
-import { src_default } from "./src-BDMVJUXS.js";
+import { src_default } from "./src-DyWBtz6W.js";
 
 //#region src/esbuild.ts
 var esbuild_default = src_default.esbuild;

package/dist/index.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
-require('./core-C740HxiF.cjs');
-require('./raw-BXpT71mV.cjs');
-const require_options = require('./options-BSX_vMxh.cjs');
-const require_src = require('./src-2EUAmvRo.cjs');
+require('./core-BP7HnDkZ.cjs');
+require('./raw-DrrIS86r.cjs');
+const require_options = require('./options-BejTnOdM.cjs');
+const require_src = require('./src-HPKL-RKa.cjs');
 
-exports.default = require_src.src_default
-exports.resolveOptions = require_options.resolveOptions
+exports.default = require_src.src_default;
+exports.resolveOptions = require_options.resolveOptions;

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { Options, OptionsResolved, resolveOptions } from "./options.d-CXMsJZSo.cjs";
+import { Options, OptionsResolved, resolveOptions } from "./options-BxlJkUDe.cjs";
 import { UnpluginInstance } from "unplugin";
 
 //#region src/index.d.ts

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Options, OptionsResolved, resolveOptions$1 as resolveOptions } from "./options.d-DNWXuL_g.js";
+import { Options, OptionsResolved, resolveOptions$1 as resolveOptions } from "./options-QKLCzlvG.js";
 import { UnpluginInstance } from "unplugin";
 
 //#region src/index.d.ts

package/dist/index.js

@@ -1,6 +1,6 @@
-import "./core-CHBxRAvb.js";
-import "./raw-Hr7QYA0U.js";
+import "./core-Bo9gAeWA.js";
+import "./raw-BLYamp8z.js";
 import { resolveOptions } from "./options-BWRkHmm5.js";
-import { src_default } from "./src-BDMVJUXS.js";
+import { src_default } from "./src-DyWBtz6W.js";
 
 export { src_default as default, resolveOptions };

package/dist/nuxt.cjs

@@ -1,12 +1,11 @@
-"use strict";
 Object.defineProperty(exports, '__esModule', { value: true });
-const require_chunk = require('./chunk-BCwAaXi7.cjs');
-require('./core-C740HxiF.cjs');
-require('./raw-BXpT71mV.cjs');
-require('./options-BSX_vMxh.cjs');
-require('./src-2EUAmvRo.cjs');
-const require_vite = require('./vite-DP98E6od.cjs');
-const require_webpack = require('./webpack-qmJC3FBB.cjs');
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+require('./core-BP7HnDkZ.cjs');
+require('./raw-DrrIS86r.cjs');
+require('./options-BejTnOdM.cjs');
+require('./src-HPKL-RKa.cjs');
+const require_vite = require('./vite-Dh79M9Hy.cjs');
+const require_webpack = require('./webpack-D9QKBbTH.cjs');
 const __nuxt_kit = require_chunk.__toESM(require("@nuxt/kit"));
 require("@nuxt/schema");
 
@@ -23,4 +22,4 @@ var nuxt_default = (0, __nuxt_kit.defineNuxtModule)({
 });
 
 //#endregion
-exports.default = nuxt_default
+exports.default = nuxt_default;

package/dist/nuxt.d.cts

@@ -1,10 +1,9 @@
-import { Options } from "./options.d-CXMsJZSo.cjs";
-import { NuxtModule } from "@nuxt/schema";
+import { Options } from "./options-BxlJkUDe.cjs";
+import * as _nuxt_schema14 from "@nuxt/schema";
 
 //#region src/nuxt.d.ts
-interface ModuleOptions extends Options {
-}
-declare const _default: NuxtModule<ModuleOptions, ModuleOptions, false>;
+interface ModuleOptions extends Options {}
+declare const _default: _nuxt_schema14.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
 //#endregion
 export { ModuleOptions, _default as default };

package/dist/nuxt.d.ts

@@ -1,10 +1,9 @@
-import { Options } from "./options.d-DNWXuL_g.js";
-import { NuxtModule } from "@nuxt/schema";
+import { Options } from "./options-QKLCzlvG.js";
+import * as _nuxt_schema2 from "@nuxt/schema";
 
 //#region src/nuxt.d.ts
-interface ModuleOptions extends Options {
-}
-declare const _default: NuxtModule<ModuleOptions, ModuleOptions, false>;
+interface ModuleOptions extends Options {}
+declare const _default: _nuxt_schema2.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
 //#endregion
 export { ModuleOptions, _default as default };

package/dist/nuxt.js

@@ -1,9 +1,9 @@
-import "./core-CHBxRAvb.js";
-import "./raw-Hr7QYA0U.js";
+import "./core-Bo9gAeWA.js";
+import "./raw-BLYamp8z.js";
 import "./options-BWRkHmm5.js";
-import "./src-BDMVJUXS.js";
-import { vite_default } from "./vite-CS2vynmi.js";
-import { webpack_default } from "./webpack-C78RZrII.js";
+import "./src-DyWBtz6W.js";
+import { vite_default } from "./vite-C3qfPxM8.js";
+import { webpack_default } from "./webpack-DJtxInME.js";
 import { addVitePlugin, addWebpackPlugin, defineNuxtModule } from "@nuxt/kit";
 import "@nuxt/schema";
 

package/dist/{options-BSX_vMxh.cjs → options-BejTnOdM.cjs}

@@ -1,5 +1,4 @@
-"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"));
 
 //#region src/options.ts

package/dist/options-BxlJkUDe.d.cts

@@ -0,0 +1,37 @@
+import { BaseOptions, MarkRequired } from "@vue-macros/common";
+
+//#region src/options.d.ts
+type DefineComponentOptions = {
+  alias?: string[];
+  autoReturnFunction?: boolean;
+};
+type DefineModelOptions = {
+  alias?: string[];
+};
+type DefineExposeOptions = {
+  alias?: string[];
+};
+type DefineSlotsOptions = {
+  alias?: string[];
+};
+type DefineStyleOptions = {
+  alias?: string[];
+};
+type Options = BaseOptions & {
+  defineComponent?: DefineComponentOptions;
+  defineModel?: DefineModelOptions;
+  defineExpose?: DefineExposeOptions;
+  defineSlots?: DefineSlotsOptions;
+  defineStyle?: DefineStyleOptions;
+};
+type OptionsResolved = MarkRequired<Options, 'include' | 'version'> & {
+  defineComponent: MarkRequired<DefineComponentOptions, 'alias'>;
+  defineModel: MarkRequired<DefineModelOptions, 'alias'>;
+  defineExpose: MarkRequired<DefineExposeOptions, 'alias'>;
+  defineSlots: MarkRequired<DefineSlotsOptions, 'alias'>;
+  defineStyle: MarkRequired<DefineStyleOptions, 'alias'>;
+};
+declare function resolveOptions(options: Options): OptionsResolved;
+
+//#endregion
+export { Options, OptionsResolved, resolveOptions };

package/dist/options-QKLCzlvG.d.ts

@@ -0,0 +1,37 @@
+import { BaseOptions, MarkRequired } from "@vue-macros/common";
+
+//#region src/options.d.ts
+type DefineComponentOptions = {
+  alias?: string[];
+  autoReturnFunction?: boolean;
+};
+type DefineModelOptions = {
+  alias?: string[];
+};
+type DefineExposeOptions = {
+  alias?: string[];
+};
+type DefineSlotsOptions = {
+  alias?: string[];
+};
+type DefineStyleOptions = {
+  alias?: string[];
+};
+type Options = BaseOptions & {
+  defineComponent?: DefineComponentOptions;
+  defineModel?: DefineModelOptions;
+  defineExpose?: DefineExposeOptions;
+  defineSlots?: DefineSlotsOptions;
+  defineStyle?: DefineStyleOptions;
+};
+type OptionsResolved = MarkRequired<Options, 'include' | 'version'> & {
+  defineComponent: MarkRequired<DefineComponentOptions, 'alias'>;
+  defineModel: MarkRequired<DefineModelOptions, 'alias'>;
+  defineExpose: MarkRequired<DefineExposeOptions, 'alias'>;
+  defineSlots: MarkRequired<DefineSlotsOptions, 'alias'>;
+  defineStyle: MarkRequired<DefineStyleOptions, 'alias'>;
+};
+declare function resolveOptions(options: Options): OptionsResolved;
+
+//#endregion
+export { Options, OptionsResolved, resolveOptions as resolveOptions$1 };

package/dist/options.cjs

@@ -1,3 +1,3 @@
-const require_options = require('./options-BSX_vMxh.cjs');
+const require_options = require('./options-BejTnOdM.cjs');
 
-exports.resolveOptions = require_options.resolveOptions
+exports.resolveOptions = require_options.resolveOptions;

package/dist/options.d.cts

@@ -1,3 +1,2 @@
-import { Options, OptionsResolved, resolveOptions } from "./options.d-CXMsJZSo.cjs";
-
+import { Options, OptionsResolved, resolveOptions } from "./options-BxlJkUDe.cjs";
 export { Options, OptionsResolved, resolveOptions };

package/dist/options.d.ts

@@ -1,3 +1,2 @@
-import { Options, OptionsResolved, resolveOptions$1 as resolveOptions } from "./options.d-DNWXuL_g.js";
-
+import { Options, OptionsResolved, resolveOptions$1 as resolveOptions } from "./options-QKLCzlvG.js";
 export { Options, OptionsResolved, resolveOptions };

package/dist/{raw-Hr7QYA0U.js → raw-BLYamp8z.js}

@@ -1,4 +1,4 @@
-import { helperPrefix, transformJsxMacros, useModelHelperId, use_model_default, withDefaultsHelperId, with_defaults_default } from "./core-CHBxRAvb.js";
+import { helperPrefix, transformJsxMacros, useModelHelperId, use_model_default, withDefaultsHelperId, with_defaults_default } from "./core-Bo9gAeWA.js";
 import { resolveOptions } from "./options-BWRkHmm5.js";
 import { createFilter, normalizePath } from "@vue-macros/common";
 import { compileStyleAsync } from "@vue/compiler-sfc";

package/dist/{raw-BXpT71mV.cjs → raw-DrrIS86r.cjs}

@@ -1,7 +1,6 @@
-"use strict";
-const require_chunk = require('./chunk-BCwAaXi7.cjs');
-const require_core = require('./core-C740HxiF.cjs');
-const require_options = require('./options-BSX_vMxh.cjs');
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_core = require('./core-BP7HnDkZ.cjs');
+const require_options = require('./options-BejTnOdM.cjs');
 const __vue_macros_common = require_chunk.__toESM(require("@vue-macros/common"));
 const __vue_compiler_sfc = require_chunk.__toESM(require("@vue/compiler-sfc"));
 

package/dist/raw.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, '__esModule', { value: true });
-require('./core-C740HxiF.cjs');
-const require_raw = require('./raw-BXpT71mV.cjs');
-require('./options-BSX_vMxh.cjs');
+require('./core-BP7HnDkZ.cjs');
+const require_raw = require('./raw-DrrIS86r.cjs');
+require('./options-BejTnOdM.cjs');
 
-exports.default = require_raw.raw_default
+exports.default = require_raw.raw_default;

package/dist/raw.d.cts

@@ -1,4 +1,4 @@
-import { Options } from "./options.d-CXMsJZSo.cjs";
+import { Options } from "./options-BxlJkUDe.cjs";
 import { UnpluginOptions } from "unplugin";
 
 //#region src/raw.d.ts