@vue-jsx-vapor/macros 2.3.0 → 2.3.2

package/dist/volar.cjs

@@ -1,403 +1,252 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-var _chunk53TNKVYDcjs = require('./chunk-53TNKVYD.cjs');
-
-// src/volar.ts
-var _common = require('@vue-macros/common');
-var _tsmacro = require('ts-macro');
-
-// src/volar/index.ts
-
-
-
-
-
-// src/volar/define-component.ts
-
-function transformDefineComponent(node, options) {
-  const { codes, source, ast } = options;
-  _tsmacro.replaceRange.call(void 0, codes, node.arguments[0].end, node.end - 1);
-  const componentOptions = node.arguments[1];
-  _tsmacro.replaceRange.call(void 0, 
-    codes,
-    node.getStart(ast),
-    node.expression.end + 1,
-    "(",
-    [node.expression.getText(ast), source, node.getStart(ast), _tsmacro.allCodeFeatures],
-    "(() => ({}) as any, ",
-    componentOptions ? [
-      componentOptions.getText(ast),
-      source,
-      componentOptions.getStart(ast),
-      _tsmacro.allCodeFeatures
-    ] : "",
-    "), "
-  );
+"use strict";
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_chunk = require('./chunk-BCwAaXi7.cjs');
+const require_options = require('./options-CNIhAQHD.cjs');
+const __vue_macros_common = require_chunk.__toESM(require("@vue-macros/common"));
+const ts_macro = require_chunk.__toESM(require("ts-macro"));
+const __vue_language_core_lib_codegen_style_classProperty_js = require_chunk.__toESM(require("@vue/language-core/lib/codegen/style/classProperty.js"));
+const __vue_language_core_lib_utils_parseCssClassNames_js = require_chunk.__toESM(require("@vue/language-core/lib/utils/parseCssClassNames.js"));
+
+//#region src/volar/define-component.ts
+function transformDefineComponent(node, parent, options) {
+	const { codes, source, ast, ts } = options;
+	(0, ts_macro.replaceRange)(codes, node.arguments[0].end, node.end - 1);
+	const componentOptions = node.arguments[1];
+	(0, ts_macro.replaceRange)(codes, node.getStart(ast), node.expression.end + 1, ts.isExpressionStatement(parent) ? ";" : "", "(", [
+		node.expression.getText(ast),
+		source,
+		node.getStart(ast),
+		ts_macro.allCodeFeatures
+	], "(() => ({}) as any, ", componentOptions ? [
+		componentOptions.getText(ast),
+		source,
+		componentOptions.getStart(ast),
+		ts_macro.allCodeFeatures
+	] : "", "), ");
 }
 
-// src/volar/transform.ts
-
-
-
-// src/volar/define-style.ts
-
-var _classPropertyjs = require('@vue/language-core/lib/codegen/style/classProperty.js');
-var _parseCssClassNamesjs = require('@vue/language-core/lib/utils/parseCssClassNames.js');
-
+//#endregion
+//#region src/volar/define-style.ts
 function transformDefineStyle(defineStyles, options) {
-  if (!_optionalChain([defineStyles, 'optionalAccess', _ => _.length])) return;
-  const { ts, codes, ast } = options;
-  defineStyles.forEach(({ expression, isCssModules }, index) => {
-    if (isCssModules && _optionalChain([expression, 'optionalAccess', _2 => _2.arguments, 'access', _3 => _3[0]]) && !expression.typeArguments && ts.isTemplateLiteral(expression.arguments[0])) {
-      _tsmacro.replaceRange.call(void 0, 
-        codes,
-        expression.arguments.pos - 1,
-        expression.arguments.pos - 1,
-        `<${_common.HELPER_PREFIX}PrettifyLocal<{}`,
-        ...generateCssClassesType(
-          expression.arguments[0].getText(ast).slice(1, -1),
-          expression.arguments[0].getStart(ast) + 1,
-          index
-        ),
-        ">>"
-      );
-    }
-    addEmbeddedCode(expression, index, options);
-  });
+	if (!defineStyles?.length) return;
+	const { ts, codes, ast } = options;
+	defineStyles.forEach(({ expression, isCssModules }, index) => {
+		if (isCssModules && expression?.arguments[0] && !expression.typeArguments && ts.isTemplateLiteral(expression.arguments[0])) (0, ts_macro.replaceRange)(codes, expression.arguments.pos - 1, expression.arguments.pos - 1, `<${__vue_macros_common.HELPER_PREFIX}PrettifyLocal<{}`, ...generateCssClassesType(expression.arguments[0].getText(ast).slice(1, -1), expression.arguments[0].getStart(ast) + 1, index), ">>");
+		addEmbeddedCode(expression, index, options);
+	});
 }
 function* generateCssClassesType(css, offset, index) {
-  for (const className of [..._parseCssClassNamesjs.parseCssClassNames.call(void 0, css)]) {
-    yield* _classPropertyjs.generateClassProperty.call(void 0, 
-      index,
-      className.text,
-      className.offset + offset,
-      "string"
-    );
-  }
+	for (const className of [...(0, __vue_language_core_lib_utils_parseCssClassNames_js.parseCssClassNames)(css)]) yield* (0, __vue_language_core_lib_codegen_style_classProperty_js.generateClassProperty)(index, className.text, className.offset + offset, "string");
 }
 function addEmbeddedCode(expression, index, options) {
-  const { ts, ast } = options;
-  const languageId = ts.isPropertyAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.name) ? expression.expression.name.text : "css";
-  const style = expression.arguments[0];
-  const styleText = style.getText(ast).slice(1, -1).replaceAll(/\$\{.*\}/g, (str) => "_".repeat(str.length));
-  options.embeddedCodes.push({
-    id: `style_${index}`,
-    languageId,
-    snapshot: {
-      getText: (start, end) => styleText.slice(start, end),
-      getLength: () => styleText.length,
-      getChangeRange: () => void 0
-    },
-    mappings: [
-      {
-        sourceOffsets: [style.getStart(ast) + 1],
-        generatedOffsets: [0],
-        lengths: [styleText.length],
-        data: {
-          completion: true,
-          format: true,
-          navigation: true,
-          semantic: true,
-          structure: true,
-          verification: true
-        }
-      }
-    ],
-    embeddedCodes: []
-  });
+	const { ts, ast } = options;
+	const languageId = ts.isPropertyAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.name) ? expression.expression.name.text : "css";
+	const style = expression.arguments[0];
+	const styleText = style.getText(ast).slice(1, -1).replaceAll(/\$\{.*\}/g, (str) => "_".repeat(str.length));
+	options.embeddedCodes.push({
+		id: `style_${index}`,
+		languageId,
+		snapshot: {
+			getText: (start, end) => styleText.slice(start, end),
+			getLength: () => styleText.length,
+			getChangeRange: () => void 0
+		},
+		mappings: [{
+			sourceOffsets: [style.getStart(ast) + 1],
+			generatedOffsets: [0],
+			lengths: [styleText.length],
+			data: {
+				completion: true,
+				format: true,
+				navigation: true,
+				semantic: true,
+				structure: true,
+				verification: true
+			}
+		}],
+		embeddedCodes: []
+	});
 }
 
-// src/volar/transform.ts
+//#endregion
+//#region src/volar/transform.ts
 function transformJsxMacros(rootMap, options) {
-  const { ts, codes, ast } = options;
-  for (const [root, map] of rootMap) {
-    transformDefineStyle(map.defineStyle, options);
-    if (!_optionalChain([root, 'optionalAccess', _4 => _4.body])) continue;
-    const asyncModifier = _optionalChain([root, 'access', _5 => _5.modifiers, 'optionalAccess', _6 => _6.find, 'call', _7 => _7(
-      (modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword
-    )]);
-    if (asyncModifier && map.defineComponent)
-      _tsmacro.replaceRange.call(void 0, codes, asyncModifier.pos, asyncModifier.end);
-    const result = `({}) as __VLS_PickNotAny<typeof ${_common.HELPER_PREFIX}ctx.render, {}> & { __ctx: typeof ${_common.HELPER_PREFIX}ctx }`;
-    const propsType = _optionalChain([root, 'access', _8 => _8.parameters, 'access', _9 => _9[0], 'optionalAccess', _10 => _10.type]) ? String(root.parameters[0].type.getText(ast)) : "{}";
-    _tsmacro.replaceRange.call(void 0, 
-      codes,
-      root.parameters.pos,
-      root.parameters.pos,
-      ts.isArrowFunction(root) && root.parameters.pos === root.pos ? "(" : "",
-      `${_common.HELPER_PREFIX}props: typeof ${_common.HELPER_PREFIX}ctx.props & ${propsType}, `,
-      `${_common.HELPER_PREFIX}placeholder?: {}, `,
-      `${_common.HELPER_PREFIX}ctx = {} as Awaited<ReturnType<typeof ${_common.HELPER_PREFIX}setup>>, `,
-      `${_common.HELPER_PREFIX}setup = (${asyncModifier ? "async" : ""}(`
-    );
-    if (ts.isArrowFunction(root)) {
-      _tsmacro.replaceRange.call(void 0, 
-        codes,
-        root.end,
-        root.end,
-        `))${root.pos === root.parameters.pos ? ")" : ""} => `,
-        result
-      );
-    } else {
-      _tsmacro.replaceRange.call(void 0, 
-        codes,
-        root.body.getStart(ast),
-        root.body.getStart(ast),
-        "=>"
-      );
-      _tsmacro.replaceRange.call(void 0, codes, root.end, root.end, `)){ return `, result, "}");
-    }
-    ts.forEachChild(root.body, (node) => {
-      if (ts.isReturnStatement(node) && node.expression) {
-        const props = [..._nullishCoalesce(map.defineModel, () => ( []))];
-        const elements = root.parameters[0] && !root.parameters[0].type && ts.isObjectBindingPattern(root.parameters[0].name) ? root.parameters[0].name.elements : [];
-        for (const element of elements) {
-          if (ts.isIdentifier(element.name))
-            props.push(
-              `${element.name.escapedText}${element.initializer && ts.isNonNullExpression(element.initializer) ? ":" : "?:"} typeof ${element.name.escapedText}`
-            );
-        }
-        const shouldWrapByCall = (ts.isArrowFunction(node.expression) || ts.isFunctionExpression(node.expression)) && map.defineComponent;
-        _tsmacro.replaceRange.call(void 0, 
-          codes,
-          node.getStart(ast),
-          node.expression.getStart(ast),
-          `return {
-props: {} as { ${props.join(", ")} }`,
-          `,
-slots: {} as ${_nullishCoalesce(map.defineSlots, () => ( "{}"))}`,
-          `,
-expose: (exposed: import('vue').ShallowUnwrapRef<${_nullishCoalesce(map.defineExpose, () => ( "{}"))}>) => {}`,
-          `,
-render: `,
-          shouldWrapByCall ? "(" : ""
-        );
-        _tsmacro.replaceRange.call(void 0, 
-          codes,
-          node.expression.end,
-          node.expression.end,
-          shouldWrapByCall ? ")()" : "",
-          `
-}`
-        );
-      }
-    });
-  }
+	const { ts, codes, ast } = options;
+	for (const [root, map] of rootMap) {
+		transformDefineStyle(map.defineStyle, options);
+		if (!root?.body) continue;
+		const asyncModifier = root.modifiers?.find((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword);
+		if (asyncModifier && map.defineComponent) (0, ts_macro.replaceRange)(codes, asyncModifier.pos, asyncModifier.end);
+		const result = `({}) as __VLS_PickNotAny<typeof ${__vue_macros_common.HELPER_PREFIX}ctx.render, {}> & { __ctx: typeof ${__vue_macros_common.HELPER_PREFIX}ctx }`;
+		const propsType = root.parameters[0]?.type ? String(root.parameters[0].type.getText(ast)) : "{}";
+		(0, ts_macro.replaceRange)(codes, root.parameters.pos, root.parameters.pos, ts.isArrowFunction(root) && root.parameters.pos === root.pos ? "(" : "", `${__vue_macros_common.HELPER_PREFIX}props: typeof ${__vue_macros_common.HELPER_PREFIX}ctx.props & ${propsType}, `, `${__vue_macros_common.HELPER_PREFIX}placeholder?: {}, `, `${__vue_macros_common.HELPER_PREFIX}ctx = {} as Awaited<ReturnType<typeof ${__vue_macros_common.HELPER_PREFIX}setup>>, `, `${__vue_macros_common.HELPER_PREFIX}setup = (${asyncModifier ? "async" : ""}(`);
+		if (ts.isArrowFunction(root)) (0, ts_macro.replaceRange)(codes, root.end, root.end, `))${root.pos === root.parameters.pos ? ")" : ""} => `, result);
+		else {
+			(0, ts_macro.replaceRange)(codes, root.body.getStart(ast), root.body.getStart(ast), "=>");
+			(0, ts_macro.replaceRange)(codes, root.end, root.end, `)){ return `, result, "}");
+		}
+		ts.forEachChild(root.body, (node) => {
+			if (ts.isReturnStatement(node) && node.expression) {
+				const props = [...map.defineModel ?? []];
+				const elements = root.parameters[0] && !root.parameters[0].type && ts.isObjectBindingPattern(root.parameters[0].name) ? root.parameters[0].name.elements : [];
+				for (const element of elements) if (ts.isIdentifier(element.name)) props.push(`${element.name.escapedText}${element.initializer && ts.isNonNullExpression(element.initializer) ? ":" : "?:"} typeof ${element.name.escapedText}`);
+				const shouldWrapByCall = (ts.isArrowFunction(node.expression) || ts.isFunctionExpression(node.expression)) && map.defineComponent;
+				(0, ts_macro.replaceRange)(codes, node.getStart(ast), node.expression.getStart(ast), `const ${__vue_macros_common.HELPER_PREFIX}render = `, shouldWrapByCall ? "(" : "");
+				(0, ts_macro.replaceRange)(codes, node.expression.end, node.expression.end, shouldWrapByCall ? ")()" : "", `
+return {
+  props: {} as {${props.join(", ")}},
+  slots: {} as ${map.defineSlots ?? "{}"},
+  expose: (exposed: import('vue').ShallowUnwrapRef<${map.defineExpose ?? "{}"}>) => {},
+  render: ${__vue_macros_common.HELPER_PREFIX}render,
+}`);
+			}
+		});
+	}
 }
 
-// src/volar/global-types.ts
-
+//#endregion
+//#region src/volar/global-types.ts
 function getGlobalTypes(options) {
-  const defineSlots = options.defineSlots.alias.flatMap((alias) => [
-    `declare function ${alias}<T extends Record<string, any>>(): Partial<T>;`,
-    `declare function ${alias}<T extends Record<string, any>>(slots: T): T;
-`
-  ]).join("");
-  const defineExpose = options.defineExpose.alias.map(
-    (alias) => `declare function ${alias}<Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed): Exposed;`
-  ).join("");
-  const defineStyle = options.defineStyle.alias.map(
-    (alias) => `declare const ${alias}: { <T>(...args: ${_common.HELPER_PREFIX}StyleArgs): T; scss: <T>(...args: ${_common.HELPER_PREFIX}StyleArgs)=> T; sass: <T>(...args: ${_common.HELPER_PREFIX}StyleArgs)=> T; stylus: <T>(...args: ${_common.HELPER_PREFIX}StyleArgs)=> T; less: <T>(...args: ${_common.HELPER_PREFIX}StyleArgs)=> T; postcss: <T>(...args: ${_common.HELPER_PREFIX}StyleArgs)=> T };
-`
-  ).join("");
-  const defineModel = options.defineModel.alias.map(
-    (alias) => alias === "defineModel" ? "defineModel" : `defineModel: ${alias}`
-  ).join(", ");
-  const defineComponent = options.defineComponent.alias.map(
-    (alias) => ["defineComponent", "defineVaporComponent"].includes(alias) ? "" : `defineComponent: ${alias}`
-  ).filter(Boolean).join(", ");
-  return `
+	const defineSlots = options.defineSlots.alias.flatMap((alias) => [`declare function ${alias}<T extends Record<string, any>>(): Partial<T>;`, `declare function ${alias}<T extends Record<string, any>>(slots: T): T;\n`]).join("");
+	const defineExpose = options.defineExpose.alias.map((alias) => `declare function ${alias}<Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed): Exposed;`).join("");
+	const defineStyle = options.defineStyle.alias.map((alias) => `declare const ${alias}: { <T>(...args: ${__vue_macros_common.HELPER_PREFIX}StyleArgs): T; scss: <T>(...args: ${__vue_macros_common.HELPER_PREFIX}StyleArgs)=> T; sass: <T>(...args: ${__vue_macros_common.HELPER_PREFIX}StyleArgs)=> T; stylus: <T>(...args: ${__vue_macros_common.HELPER_PREFIX}StyleArgs)=> T; less: <T>(...args: ${__vue_macros_common.HELPER_PREFIX}StyleArgs)=> T; postcss: <T>(...args: ${__vue_macros_common.HELPER_PREFIX}StyleArgs)=> T };\n`).join("");
+	const defineModel = options.defineModel.alias.map((alias) => alias === "defineModel" ? "defineModel" : `defineModel: ${alias}`).join(", ");
+	const defineComponent = options.defineComponent.alias.map((alias) => ["defineComponent", "defineVaporComponent"].includes(alias) ? "" : `defineComponent: ${alias}`).filter(Boolean).join(", ");
+	return `
 declare const { ${defineModel}, ${defineComponent} }: typeof import('vue')
 ${defineSlots}
 ${defineExpose}
 ${defineStyle}
-type ${_common.HELPER_PREFIX}StyleArgs = [style: string, options?: { scoped?: boolean }];
-type ${_common.HELPER_PREFIX}PrettifyLocal<T> = { [K in keyof T]: T[K]; } & {};
+type ${__vue_macros_common.HELPER_PREFIX}StyleArgs = [style: string, options?: { scoped?: boolean }];
+type ${__vue_macros_common.HELPER_PREFIX}PrettifyLocal<T> = { [K in keyof T]: T[K]; } & {};
 // @ts-ignore
 type __VLS_IsAny<T> = 0 extends 1 & T ? true : false; type __VLS_PickNotAny<A, B> = __VLS_IsAny<A> extends true ? B : A;
 `;
 }
 
-// src/volar/index.ts
+//#endregion
+//#region src/volar/index.ts
 function getMacro(node, ts, options) {
-  if (!node) return;
-  if (ts.isVariableStatement(node)) {
-    return ts.forEachChild(node.declarationList, (decl) => getExpression(decl));
-  } else {
-    return getExpression(node);
-  }
-  function getExpression(decl) {
-    if (ts.isVariableDeclaration(decl) && decl.initializer) {
-      const initializer = ts.isCallExpression(decl.initializer) && ts.isIdentifier(decl.initializer.expression) && decl.initializer.expression.escapedText === "$" && decl.initializer.arguments[0] ? decl.initializer.arguments[0] : decl.initializer;
-      const expression = getMacroExpression(initializer);
-      if (expression) {
-        return {
-          expression,
-          initializer: decl.initializer,
-          isRequired: ts.isNonNullExpression(initializer)
-        };
-      }
-    } else if (ts.isExpressionStatement(decl)) {
-      const expression = getMacroExpression(decl.expression);
-      if (expression)
-        return {
-          expression,
-          initializer: decl.expression,
-          isRequired: ts.isNonNullExpression(decl.expression)
-        };
-    }
-  }
-  function getMacroExpression(node2) {
-    if (ts.isNonNullExpression(node2)) {
-      node2 = node2.expression;
-    }
-    if (!ts.isCallExpression(node2)) return;
-    const expression = ts.isPropertyAccessExpression(node2.expression) ? node2.expression : node2;
-    return ts.isIdentifier(expression.expression) && [
-      ...options.defineModel.alias,
-      ...options.defineSlots.alias,
-      ...options.defineStyle.alias,
-      ...options.defineExpose.alias,
-      ...options.defineComponent.alias
-    ].includes(expression.expression.escapedText) && node2;
-  }
+	if (!node) return;
+	if (ts.isVariableStatement(node)) return ts.forEachChild(node.declarationList, (decl) => getExpression(decl));
+	else return getExpression(node);
+	function getExpression(decl) {
+		if (ts.isVariableDeclaration(decl) && decl.initializer) {
+			const initializer = ts.isCallExpression(decl.initializer) && ts.isIdentifier(decl.initializer.expression) && decl.initializer.expression.escapedText === "$" && decl.initializer.arguments[0] ? decl.initializer.arguments[0] : decl.initializer;
+			const expression = getMacroExpression(initializer);
+			if (expression) return {
+				expression,
+				initializer: decl.initializer,
+				isRequired: ts.isNonNullExpression(initializer)
+			};
+		} else if (ts.isExpressionStatement(decl)) {
+			const expression = getMacroExpression(decl.expression);
+			if (expression) return {
+				expression,
+				initializer: decl.expression,
+				isRequired: ts.isNonNullExpression(decl.expression)
+			};
+		}
+	}
+	function getMacroExpression(node$1) {
+		if (ts.isNonNullExpression(node$1)) node$1 = node$1.expression;
+		if (!ts.isCallExpression(node$1)) return;
+		const expression = ts.isPropertyAccessExpression(node$1.expression) ? node$1.expression : node$1;
+		return ts.isIdentifier(expression.expression) && [
+			...options.defineModel.alias,
+			...options.defineSlots.alias,
+			...options.defineStyle.alias,
+			...options.defineExpose.alias,
+			...options.defineComponent.alias
+		].includes(expression.expression.escapedText) && node$1;
+	}
 }
 function getRootMap(options) {
-  const { ts, ast, codes } = options;
-  const rootMap = /* @__PURE__ */ new Map();
-  function walk(node, parents) {
-    ts.forEachChild(node, (child) => {
-      parents.unshift(node);
-      walk(child, parents);
-      parents.shift();
-    });
-    const root = parents[1] && (ts.isArrowFunction(parents[1]) || ts.isFunctionExpression(parents[1]) || ts.isFunctionDeclaration(parents[1])) ? parents[1] : void 0;
-    if (root && parents[2] && ts.isCallExpression(parents[2]) && !parents[2].typeArguments && options.defineComponent.alias.includes(parents[2].expression.getText(ast))) {
-      if (!rootMap.has(root)) rootMap.set(root, {});
-      if (!rootMap.get(root).defineComponent) {
-        rootMap.get(root).defineComponent = true;
-        transformDefineComponent(parents[2], options);
-      }
-    }
-    const macro = getMacro(node, ts, options);
-    if (!macro) return;
-    const { expression, initializer } = macro;
-    let isRequired = macro.isRequired;
-    if (!rootMap.has(root)) rootMap.set(root, {});
-    const macroName = expression.expression.getText(ast);
-    if (macroName.startsWith("defineStyle")) {
-      ;
-      (rootMap.get(root).defineStyle ??= []).push({
-        expression,
-        isCssModules: !!ts.isVariableStatement(node)
-      });
-    }
-    if (!root) return;
-    if (options.defineModel.alias.includes(macroName)) {
-      const modelName = expression.arguments[0] && ts.isStringLiteralLike(expression.arguments[0]) ? expression.arguments[0].text : "modelValue";
-      const modelOptions = expression.arguments[0] && ts.isStringLiteralLike(expression.arguments[0]) ? expression.arguments[1] : expression.arguments[0];
-      if (modelOptions && ts.isObjectLiteralExpression(modelOptions)) {
-        let hasRequired = false;
-        for (const prop of modelOptions.properties) {
-          if (ts.isPropertyAssignment(prop) && prop.name.getText(ast) === "required") {
-            hasRequired = true;
-            isRequired = prop.initializer.kind === ts.SyntaxKind.TrueKeyword;
-          }
-        }
-        if (!hasRequired && isRequired) {
-          _tsmacro.replaceRange.call(void 0, 
-            codes,
-            modelOptions.end - 1,
-            modelOptions.end - 1,
-            `${!modelOptions.properties.hasTrailingComma && modelOptions.properties.length ? "," : ""} required: true`
-          );
-        }
-      } else if (isRequired) {
-        _tsmacro.replaceRange.call(void 0, 
-          codes,
-          expression.arguments.end,
-          expression.arguments.end,
-          `${!expression.arguments.hasTrailingComma && expression.arguments.length ? "," : ""} { required: true }`
-        );
-      }
-      const id = toValidAssetId(modelName, `${_common.HELPER_PREFIX}model`);
-      const typeString = `import('vue').UnwrapRef<typeof ${id}>`;
-      const defineModel = rootMap.get(root).defineModel ??= [];
-      defineModel.push(
-        `${modelName.includes("-") ? `'${modelName}'` : modelName}${isRequired ? ":" : "?:"} ${typeString}`,
-        `'onUpdate:${modelName}'?: ($event: ${typeString}) => any`
-      );
-      if (_optionalChain([expression, 'access', _11 => _11.typeArguments, 'optionalAccess', _12 => _12[1]])) {
-        defineModel.push(
-          `${modelName}Modifiers?: Partial<Record<${expression.typeArguments[1].getText(ast)}, boolean>>`
-        );
-      }
-      _tsmacro.replaceRange.call(void 0, 
-        codes,
-        initializer.getStart(ast),
-        initializer.getStart(ast),
-        `// @ts-ignore
-${id};
-let ${id} = `
-      );
-    } else if (options.defineSlots.alias.includes(macroName)) {
-      _tsmacro.replaceRange.call(void 0, 
-        codes,
-        expression.getStart(ast),
-        expression.getStart(ast),
-        `// @ts-ignore
-${_common.HELPER_PREFIX}slots;
-const ${_common.HELPER_PREFIX}slots = `
-      );
-      rootMap.get(root).defineSlots = `Partial<typeof ${_common.HELPER_PREFIX}slots>`;
-    } else if (options.defineExpose.alias.includes(macroName)) {
-      _tsmacro.replaceRange.call(void 0, 
-        codes,
-        expression.getStart(ast),
-        expression.getStart(ast),
-        `// @ts-ignore
-${_common.HELPER_PREFIX}exposed;
-const ${_common.HELPER_PREFIX}exposed = `
-      );
-      rootMap.get(root).defineExpose = `typeof ${_common.HELPER_PREFIX}exposed`;
-    }
-  }
-  ts.forEachChild(ast, (node) => walk(node, []));
-  return rootMap;
+	const { ts, ast, codes } = options;
+	const rootMap = new Map();
+	function walk(node, parents) {
+		ts.forEachChild(node, (child) => {
+			parents.unshift(node);
+			walk(child, parents);
+			parents.shift();
+		});
+		const root = parents[1] && (ts.isArrowFunction(parents[1]) || ts.isFunctionExpression(parents[1]) || ts.isFunctionDeclaration(parents[1])) ? parents[1] : void 0;
+		if (root && parents[2] && ts.isCallExpression(parents[2]) && !parents[2].typeArguments && options.defineComponent.alias.includes(parents[2].expression.getText(ast))) {
+			if (!rootMap.has(root)) rootMap.set(root, {});
+			if (!rootMap.get(root).defineComponent) {
+				rootMap.get(root).defineComponent = true;
+				transformDefineComponent(parents[2], parents[3], options);
+			}
+		}
+		const macro = getMacro(node, ts, options);
+		if (!macro) return;
+		const { expression, initializer } = macro;
+		let isRequired = macro.isRequired;
+		if (!rootMap.has(root)) rootMap.set(root, {});
+		const macroName = expression.expression.getText(ast);
+		if (macroName.startsWith("defineStyle")) (rootMap.get(root).defineStyle ??= []).push({
+			expression,
+			isCssModules: !!ts.isVariableStatement(node)
+		});
+		if (!root) return;
+		if (options.defineModel.alias.includes(macroName)) {
+			const modelName = expression.arguments[0] && ts.isStringLiteralLike(expression.arguments[0]) ? expression.arguments[0].text : "modelValue";
+			const modelOptions = expression.arguments[0] && ts.isStringLiteralLike(expression.arguments[0]) ? expression.arguments[1] : expression.arguments[0];
+			if (modelOptions && ts.isObjectLiteralExpression(modelOptions)) {
+				let hasRequired = false;
+				for (const prop of modelOptions.properties) if (ts.isPropertyAssignment(prop) && prop.name.getText(ast) === "required") {
+					hasRequired = true;
+					isRequired = prop.initializer.kind === ts.SyntaxKind.TrueKeyword;
+				}
+				if (!hasRequired && isRequired) (0, ts_macro.replaceRange)(codes, modelOptions.end - 1, modelOptions.end - 1, `${!modelOptions.properties.hasTrailingComma && modelOptions.properties.length ? "," : ""} required: true`);
+			} else if (isRequired) (0, ts_macro.replaceRange)(codes, expression.arguments.end, expression.arguments.end, `${!expression.arguments.hasTrailingComma && expression.arguments.length ? "," : ""} { required: true }`);
+			const id = toValidAssetId(modelName, `${__vue_macros_common.HELPER_PREFIX}model`);
+			const typeString = `import('vue').UnwrapRef<typeof ${id}>`;
+			const defineModel = rootMap.get(root).defineModel ??= [];
+			defineModel.push(`${modelName.includes("-") ? `'${modelName}'` : modelName}${isRequired ? ":" : "?:"} ${typeString}`, `'onUpdate:${modelName}'?: ($event: ${typeString}) => any`);
+			if (expression.typeArguments?.[1]) defineModel.push(`${modelName}Modifiers?: Partial<Record<${expression.typeArguments[1].getText(ast)}, boolean>>`);
+			(0, ts_macro.replaceRange)(codes, initializer.getStart(ast), initializer.getStart(ast), `// @ts-ignore\n${id};\nlet ${id} = `);
+		} else if (options.defineSlots.alias.includes(macroName)) {
+			(0, ts_macro.replaceRange)(codes, expression.getStart(ast), expression.getStart(ast), `// @ts-ignore\n${__vue_macros_common.HELPER_PREFIX}slots;\nconst ${__vue_macros_common.HELPER_PREFIX}slots = `);
+			rootMap.get(root).defineSlots = `Partial<typeof ${__vue_macros_common.HELPER_PREFIX}slots>`;
+		} else if (options.defineExpose.alias.includes(macroName)) {
+			(0, ts_macro.replaceRange)(codes, expression.getStart(ast), expression.getStart(ast), `// @ts-ignore\n${__vue_macros_common.HELPER_PREFIX}exposed;\nconst ${__vue_macros_common.HELPER_PREFIX}exposed = `);
+			rootMap.get(root).defineExpose = `typeof ${__vue_macros_common.HELPER_PREFIX}exposed`;
+		}
+	}
+	ts.forEachChild(ast, (node) => walk(node, []));
+	return rootMap;
 }
 function toValidAssetId(name, type) {
-  return `_${type}_${name.replaceAll(/\W/g, (searchValue, replaceValue) => {
-    return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString();
-  })}`;
+	return `_${type}_${name.replaceAll(/\W/g, (searchValue, replaceValue) => {
+		return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString();
+	})}`;
 }
 
-// src/volar.ts
-var plugin = _tsmacro.createPlugin.call(void 0, 
-  ({ ts }, userOptions = {}) => {
-    const resolvedOptions = _chunk53TNKVYDcjs.resolveOptions.call(void 0, userOptions);
-    const filter = _common.createFilter.call(void 0, resolvedOptions);
-    return {
-      name: "@vue-jsx-vapor/macros",
-      resolveVirtualCode(virtualCode) {
-        const { filePath, codes } = virtualCode;
-        if (!filter(filePath)) return;
-        const options = {
-          ts,
-          ...virtualCode,
-          ...resolvedOptions
-        };
-        const rootMap = getRootMap(options);
-        if (rootMap.size) {
-          transformJsxMacros(rootMap, options);
-          codes.push(getGlobalTypes(options));
-        }
-      }
-    };
-  }
-);
+//#endregion
+//#region src/volar.ts
+const plugin = (0, ts_macro.createPlugin)(({ ts }, userOptions = {}) => {
+	const resolvedOptions = require_options.resolveOptions(userOptions);
+	const filter = (0, __vue_macros_common.createFilter)(resolvedOptions);
+	return {
+		name: "@vue-jsx-vapor/macros",
+		resolveVirtualCode(virtualCode) {
+			const { filePath, codes } = virtualCode;
+			if (!filter(filePath)) return;
+			const options = {
+				ts,
+				...virtualCode,
+				...resolvedOptions
+			};
+			const rootMap = getRootMap(options);
+			if (rootMap.size) {
+				transformJsxMacros(rootMap, options);
+				codes.push(getGlobalTypes(options));
+			}
+		}
+	};
+});
 var volar_default = plugin;
 
-
-exports.default = volar_default;
-
-module.exports = exports.default;
+//#endregion
+exports.default = volar_default