@vue-jsx/macros 3.3.0-beta.0

package/dist/volar.js

@@ -0,0 +1,385 @@
+import { resolveOptions } from "./options.js";
+import { allCodeFeatures, createPlugin, getText } from "ts-macro";
+import { createFilter } from "unplugin-utils";
+//#region src/volar/define-component.ts
+function transformDefineComponent(node, parent, options) {
+	const { codes, ast, ts } = options;
+	const [comp, compOptions] = node.arguments;
+	codes.replaceRange(comp.end, node.end - 1);
+	const isFnComponent = (ts.isArrowFunction(comp) || ts.isFunctionExpression(comp)) && comp.typeParameters?.length;
+	const isVaporComponent = node.expression.getText(ast).includes("defineVapor");
+	codes.replaceRange(node.getStart(ast), node.expression.end, ts.isExpressionStatement(parent) ? ";" : "", isFnComponent ? "" : `(() => {
+const __setup = `);
+	if (isFnComponent) {
+		codes.push("\n;[", [node.expression.getText(ast), node.expression.getStart(ast)], "]");
+		return;
+	}
+	codes.replaceRange(node.end, node.end, `
+  type __Setup = typeof __setup
+  type __Props = Parameters<__Setup>[0]
+  type __Slots = Parameters<__Setup>[1] extends { slots?: infer Slots } | undefined ? Slots : {}
+  type __Exposed = Parameters<__Setup>[1] extends { expose?: (exposed: infer Exposed) => any } | undefined ? Exposed : {}`, "\n  return ", [node.expression.getText(ast), node.expression.getStart(ast)], `({\n  ...{} as {
+    setup: (props: __Props) => __Exposed,
+    render: () => ReturnType<__Setup>,
+    slots: ${isVaporComponent ? "__Slots" : `import('vue').SlotsType<__Slots>`}
+  },`, ...compOptions ? ["...", [compOptions.getText(ast), compOptions.getStart(ast)]] : [], `})`, `\n})()`);
+}
+//#endregion
+//#region src/volar/global-types.ts
+function getGlobalTypes(rootMap, options) {
+	let defineStyle = "";
+	if (options.defineSlots.alias) {
+		defineStyle = options.defineStyle.alias.map((alias) => `declare const ${alias}: { <T>(...args: __StyleArgs): T; scss: <T>(...args: __StyleArgs)=> T; sass: <T>(...args: __StyleArgs)=> T; stylus: <T>(...args: __StyleArgs)=> T; less: <T>(...args: __StyleArgs)=> T; postcss: <T>(...args: __StyleArgs)=> T };`).join("\n");
+		defineStyle += `\ntype __StyleArgs = [style: string, options?: { scoped?: boolean }];`;
+	}
+	if (!rootMap.size) return `\n${defineStyle}`;
+	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("\n");
+	const defineExpose = options.defineExpose.alias.map((alias) => `declare function ${alias}<Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed): Exposed;`).join("\n");
+	const defineModel = options.defineModel.alias.map((alias) => alias === "defineModel" ? "defineModel" : `defineModel: ${alias}`);
+	return `
+${defineModel.length ? `declare const { ${defineModel.join(",")} }: typeof import('vue');` : ""}
+${defineSlots}
+${defineExpose}
+${defineStyle}
+type __ResolveSlots<T> = {
+  [K in keyof T]?: T[K] extends Record<string, any>
+    ? (props: T[K]) => any
+    : T[K]
+};
+`;
+}
+//#endregion
+//#region src/volar/define-style.ts
+function transformDefineStyle({ expression, isCssModules }, index, root, options) {
+	const { ts, codes, ast } = options;
+	if (isCssModules && expression?.arguments[0] && !expression.typeArguments && ts.isTemplateLiteral(expression.arguments[0])) codes.replaceRange(expression.arguments.pos - 1, expression.arguments.pos - 1, `<{`, ...parseCssClassNames(expression.arguments[0].getText(ast).slice(1, -1)).flatMap(({ text, offset }) => [
+		`\n`,
+		[
+			`'${text.slice(1)}'`,
+			`style_${index}`,
+			expression.arguments.pos + offset + 1,
+			{ navigation: true }
+		],
+		`: string`
+	]), "\n}>");
+	else if (root?.body) {
+		const returnNode = root.body.forEachChild((node) => ts.isReturnStatement(node) ? node : void 0);
+		if (returnNode) {
+			codes.replaceRange(expression.getStart(ast), expression.getEnd());
+			codes.replaceRange(returnNode.pos, returnNode.pos, ";", [expression.getText(ast), expression.getStart(ast)]);
+		}
+	}
+	addEmbeddedCode(expression, index, options);
+}
+const commentReg = /(?<=\/\*)[\s\S]*?(?=\*\/)|(?<=\/\/)[\s\S]*?(?=\n)/g;
+const cssClassNameReg = /(?=(\.[a-z_][-\w]*)[\s.,+~>:#)[{])/gi;
+const fragmentReg = /(?<=\{)[^{]*(?=(?<!\\);)/g;
+function parseCssClassNames(css) {
+	for (const reg of [commentReg, fragmentReg]) css = css.replace(reg, (match) => " ".repeat(match.length));
+	const matches = css.matchAll(cssClassNameReg);
+	const result = [];
+	for (const match of matches) {
+		const matchText = match[1];
+		if (matchText) result.push({
+			offset: match.index,
+			text: matchText
+		});
+	}
+	return result;
+}
+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: allCodeFeatures
+		}],
+		embeddedCodes: []
+	});
+}
+//#endregion
+//#region src/volar/slot.ts
+function transformSlot(slotNode, options) {
+	const { ts, codes, ast } = options;
+	if (slotNode.tagName.getText(ast) === "slot") {
+		let nameProp = ["default"];
+		const props = [];
+		let has_directive = false;
+		slotNode.attributes.forEachChild((node) => {
+			if (ts.isJsxAttribute(node)) {
+				const name = node.name.getText(ast);
+				if (name.startsWith("v-")) {
+					has_directive = true;
+					return;
+				}
+				if (name === "name" && node.initializer) nameProp = ts.isJsxExpression(node.initializer) && node.initializer.expression ? [
+					"[",
+					[node.initializer.expression.getText(ast), node.initializer.expression.getStart(ast)],
+					"]"
+				] : [[node.initializer.getText(ast), node.initializer.getStart(ast)]];
+				else {
+					const shouldResolve = name.includes("-") || ts.isJsxNamespacedName(node.name);
+					props.push(shouldResolve ? "\"" : "", [name, node.name.getStart(ast)], shouldResolve ? "\"" : "", ": ", node.initializer ? ts.isJsxExpression(node.initializer) && node.initializer.expression ? [node.initializer.expression.getText(ast), node.initializer.expression.getStart(ast)] : [node.initializer.getText(ast), node.initializer.getStart(ast)] : "true", ", ");
+				}
+			}
+		});
+		if (has_directive) return;
+		codes.replaceRange(slotNode.attributes.pos, slotNode.attributes.end, " {...(__slots = { ...__slots || {}, ", ...nameProp, ": { ", ...props, "}})}");
+	}
+}
+//#endregion
+//#region src/volar/transform.ts
+function transformJsxMacros(rootMap, options) {
+	const { ts, codes, ast } = options;
+	let defineStyleIndex = 0;
+	for (const [root, macros] of rootMap) {
+		macros.defineStyle?.forEach((defaultStyle) => transformDefineStyle(defaultStyle, defineStyleIndex++, root, options));
+		if (!root?.body || ts.isExpression(root.body) || Object.keys(macros).length === 1 && macros.defineStyle) continue;
+		const asyncModifier = root.modifiers?.find((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword);
+		if (asyncModifier && macros.defineComponent) codes.replaceRange(asyncModifier.pos, asyncModifier.end);
+		const result = "({}) as typeof __ctx.render & { __ctx?: { props: typeof __ctx.props } & typeof __ctx.context }";
+		const propsType = root.parameters[0]?.type ? root.parameters[0].type.getText(ast) : "{}";
+		codes.replaceRange(root.parameters.pos, root.parameters.pos, ts.isArrowFunction(root) && root.parameters.pos === root.pos ? "(" : "", `__props: typeof __ctx.props & ${propsType}, `, `__context?: typeof __ctx.context, `, `__ctx = {} as Awaited<ReturnType<typeof __fn>>, `, `__fn = (${asyncModifier ? "async" : ""}(`);
+		if (ts.isArrowFunction(root)) codes.replaceRange(root.end, root.end, `))${root.pos === root.parameters.pos ? ")" : ""} => `, result);
+		else {
+			codes.replaceRange(root.body.getStart(ast), root.body.getStart(ast), "=>");
+			codes.replaceRange(root.end, root.end, `)){ return `, result, "}");
+		}
+		if (macros.slots && !macros.defineSlots) {
+			macros.defineSlots = "__ResolveSlots<typeof __slots>";
+			const start = root.body.getStart(ast);
+			codes.replaceRange(start + 1, start + 1, "let __slots;");
+			macros.slots.map((node) => transformSlot(node, options));
+		}
+		root.body.forEachChild((node) => {
+			if (ts.isReturnStatement(node) && node.expression) {
+				const props = [...macros.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)) {
+					const isRequired = element.initializer && ts.isNonNullExpression(element.initializer);
+					props.push(`${element.name.escapedText}${isRequired ? ":" : "?:"} typeof ${element.name.escapedText}`);
+				}
+				const isDefineComponent = macros.defineComponent && ["defineComponent", "defineCustomElement"].includes(macros.defineComponent.expression.getText(ast));
+				codes.replaceRange(node.getStart(ast), node.expression.getStart(ast), "const ", [
+					`__rndr`,
+					node.getStart(ast),
+					{ verification: true }
+				], isDefineComponent ? macros.slots ? " = (" : ": () => JSX.Element = " : " = ");
+				codes.replaceRange(node.expression.end, node.expression.end, isDefineComponent && macros.slots ? ")()" : "", `
+return {} as {
+  props: {${props.join(", ")}},
+  context: ${root.parameters[1]?.type ? `${root.parameters[1].type.getText(ast)} & ` : ""}{
+    slots: ${macros.defineSlots ?? "{}"},
+    expose: (exposed: import('vue').ShallowUnwrapRef<${macros.defineExpose ?? "Record<string, any>"}>) => void,
+    attrs: Record<string, any>
+  },
+  render: ${isDefineComponent ? `ReturnType<` : ""}typeof __rndr${isDefineComponent ? ">" : ""}
+}`);
+			}
+		});
+	}
+}
+//#endregion
+//#region src/volar/index.ts
+function getMacro(node, ts, options) {
+	if (!node) return;
+	if (ts.isVariableStatement(node)) return node.declarationList.forEachChild((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,
+				variableDeclaration: decl,
+				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) {
+		if (ts.isNonNullExpression(node)) node = node.expression;
+		if (!ts.isCallExpression(node)) return;
+		const expression = ts.isPropertyAccessExpression(node.expression) ? node.expression : node;
+		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;
+	}
+}
+const getModifierPropName = (name) => {
+	return `${name === "modelValue" || name === "model-value" ? "model" : name}Modifiers${name === "model" ? "$" : ""}`;
+};
+function getRootMap(options) {
+	const { ts, ast, codes } = options;
+	const rootMap = /* @__PURE__ */ new Map();
+	function walk(node, parents, scopes) {
+		const root = parents[1] && (ts.isArrowFunction(parents[1]) || ts.isFunctionExpression(parents[1]) || ts.isFunctionDeclaration(parents[1])) ? parents[1] : void 0;
+		function getDefineComponentCaller(node) {
+			if (!node) return;
+			if (ts.isVariableDeclaration(node) && node.initializer) node = node.initializer;
+			if (ts.isCallExpression(node) && !node.typeArguments && options.defineComponent.alias.includes(node.expression.getText(ast))) return node;
+		}
+		if (root) {
+			const caller = getDefineComponentCaller(parents[2]);
+			if (caller) {
+				if (!rootMap.has(root)) rootMap.set(root, {});
+				if (!rootMap.get(root).defineComponent) {
+					rootMap.get(root).defineComponent = caller;
+					transformDefineComponent(caller, parents[3], options);
+				}
+			}
+		}
+		const macro = getMacro(node, ts, options);
+		if (macro) {
+			const { expression, initializer, variableDeclaration } = 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)
+				});
+				return;
+			}
+			if (root) {
+				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) codes.replaceRange(modelOptions.end - 1, modelOptions.end - 1, `${!modelOptions.properties.hasTrailingComma && modelOptions.properties.length ? "," : ""} required: true`);
+					} else if (isRequired) codes.replaceRange(expression.arguments.end, expression.arguments.end, `${!expression.arguments.hasTrailingComma && expression.arguments.length ? "," : ""} { required: true }`);
+					const id = toValidAssetId(modelName, `_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(`${getModifierPropName(modelName)}?: Partial<Record<${getText(expression.typeArguments[1], ast, ts)}, boolean>>`);
+					codes.replaceRange(initializer.getStart(ast), initializer.getStart(ast), variableDeclaration ? `// @ts-ignore\n${id};\n` : "", `let ${id} = `);
+				} else if (options.defineSlots.alias.includes(macroName)) {
+					codes.replaceRange(expression.getStart(ast), expression.getStart(ast), variableDeclaration ? "// @ts-ignore\n__slots;\n" : "", `const __slots = `);
+					rootMap.get(root).defineSlots = `Partial<typeof __slots>`;
+				} else if (options.defineExpose.alias.includes(macroName)) {
+					codes.replaceRange(expression.getStart(ast), expression.getStart(ast), variableDeclaration ? "// @ts-ignore\n__exposed;\n" : "", `const __exposed = `);
+					rootMap.get(root).defineExpose = `typeof __exposed`;
+				}
+			}
+		}
+		const slotNode = ts.isJsxElement(node) ? node.openingElement : ts.isJsxSelfClosingElement(node) ? node : null;
+		const scope = scopes[0];
+		if (scope && slotNode?.tagName.getText(ast) === "slot") {
+			if (!rootMap.has(scope)) rootMap.set(scope, {});
+			(rootMap.get(scope).slots ??= []).push(slotNode);
+		}
+		node.forEachChild((child) => {
+			parents.unshift(node);
+			const scopeNode = (ts.isArrowFunction(child) || ts.isFunctionExpression(child) || ts.isFunctionDeclaration(child)) && !ts.isReturnStatement(node);
+			if (scopeNode) scopes.unshift(child);
+			walk(child, parents, scopes);
+			parents.shift();
+			if (scopeNode) scopes.shift();
+		});
+	}
+	ast.forEachChild((node) => walk(node, [], []));
+	return rootMap;
+}
+function toValidAssetId(name, type) {
+	return `_${type}_${name.replaceAll(/\W/g, (searchValue, replaceValue) => {
+		return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString();
+	})}`;
+}
+//#endregion
+//#region src/volar/jsx-element.ts
+const isCompRex = /^[\W_]/;
+var jsx_element_default = createPlugin(({ ts }) => {
+	return {
+		name: "@vue-jsx/jsx-element",
+		resolveVirtualCode({ ast, codes }) {
+			let transformed = false;
+			ast.forEachChild(function walk(node, parent = ast) {
+				if (!ts.isJsxElement(parent) && !ts.isJsxFragment(parent) && !ts.isJsxExpression(parent) && !(parent.parent ? isConditionalExpression(ts, parent) : false)) {
+					const openingElement = ts.isJsxElement(node) ? node.openingElement : ts.isJsxSelfClosingElement(node) ? node : null;
+					if (openingElement) {
+						const tagName = openingElement.tagName.getText(ast);
+						if (!tagName.includes("-") && tagName !== "slot") {
+							transformed = true;
+							codes.replaceRange(node.getStart(ast), node.getStart(ast) + 1, "(<");
+							codes.replaceRange(node.end, node.end, " as unknown as __InferJsxElement<", isCompRex.test(tagName) ? `typeof ${tagName}` : `'${tagName}'`, ">)");
+						}
+					}
+				}
+				if (!ts.isCallExpression(node) || node.expression.getText(ast) !== "defineSlots") node.forEachChild((child) => walk(child, node));
+			});
+			if (transformed) codes.push(`
+type __InferJsxElement<T> = T extends keyof HTMLElementTagNameMap
+  ? HTMLElementTagNameMap[T]
+  : T extends keyof SVGElementTagNameMap
+    ? SVGElementTagNameMap[T]
+    : T extends (props: infer Props extends Record<string, any>, ctx: { slots: infer Slots extends Record<string, any>, expose: (exposed: infer Exposed extends Record<string, any>) => void, attrs: any, emit: any }) => infer TypeBlock
+      ? TypeBlock extends import('vue').Block
+          ? import('vue').VaporComponentInstance<Props, {}, Slots, Exposed, TypeBlock>
+          : TypeBlock
+      : T extends { new (...args: any[]): infer Instance }
+        ? Instance extends { $: any }
+          ? import('vue').VNode
+          : Instance
+        : JSX.Element
+      `);
+		}
+	};
+});
+function isConditionalExpression(ts, node) {
+	return !!(node && (ts.isBinaryExpression(node) || ts.isConditionalExpression(node)) && node.parent && (ts.isJsxExpression(node.parent) || isConditionalExpression(ts, node.parent)));
+}
+//#endregion
+//#region src/volar.ts
+const REGEX_VUE_SFC = /\.vue$/;
+const plugin = createPlugin(({ ts }, userOptions = {}) => {
+	const resolvedOptions = resolveOptions(userOptions);
+	resolvedOptions.include.push(REGEX_VUE_SFC);
+	const filter = createFilter(resolvedOptions.include, resolvedOptions.exclude);
+	return {
+		name: "@vue-jsx/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(rootMap, options));
+		}
+	};
+});
+//#endregion
+export { plugin as default, plugin as "module.exports", jsx_element_default as jsxElement };

package/dist/webpack.d.ts

@@ -0,0 +1,7 @@
+import { n as Options } from "./options-CtTcew0x.js";
+import * as _$webpack from "webpack";
+
+//#region src/webpack.d.ts
+declare const _default: (options?: Options | undefined) => _$webpack.WebpackPluginInstance;
+//#endregion
+export { _default as default };

package/dist/webpack.js

@@ -0,0 +1,5 @@
+import unplugin from "./index.js";
+//#region src/webpack.ts
+var webpack_default = unplugin.webpack;
+//#endregion
+export { webpack_default as default };

package/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "@vue-jsx/macros",
+  "type": "module",
+  "version": "3.3.0-beta.0",
+  "description": "Macros for Vue JSX",
+  "license": "MIT",
+  "homepage": "https://github.com/vuejs/vue-jsx-vapor#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/vue-jsx-vapor.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vuejs/vue-jsx-vapor/issues"
+  },
+  "keywords": [
+    "transform",
+    "vue-jsx",
+    "macros",
+    "volar",
+    "vapor"
+  ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./astro": "./dist/astro.js",
+    "./rspack": "./dist/rspack.js",
+    "./rsbuild": "./dist/rsbuild.js",
+    "./vite": "./dist/vite.js",
+    "./webpack": "./dist/webpack.js",
+    "./rollup": "./dist/rollup.js",
+    "./esbuild": "./dist/esbuild.js",
+    "./nuxt": "./dist/nuxt.js",
+    "./bun": "./dist/bun.js",
+    "./api": "./dist/api.js",
+    "./raw": "./dist/raw.js",
+    "./volar": "./dist/volar.js",
+    "./*": "./*"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*",
+        "./*"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@nuxt/kit": "^3",
+    "@nuxt/schema": "^3",
+    "esbuild": "*",
+    "rollup": "^3",
+    "vite": ">=3",
+    "vue": ">=3",
+    "webpack": "^4 || ^5"
+  },
+  "peerDependenciesMeta": {
+    "@nuxt/kit": {
+      "optional": true
+    },
+    "@nuxt/schema": {
+      "optional": true
+    },
+    "esbuild": {
+      "optional": true
+    },
+    "rollup": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    },
+    "webpack": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "hash-sum": "^2.0.0",
+    "magic-string": "^0.30.21",
+    "ts-macro": "^0.3.7",
+    "unplugin": "^3.0.0",
+    "unplugin-utils": "^0.3.1"
+  },
+  "devDependencies": {
+    "@babel/parser": "^7.29.3",
+    "@babel/types": "^7.29.0",
+    "@nuxt/kit": "^3.21.4",
+    "@nuxt/schema": "^3.21.4",
+    "@types/hash-sum": "^1.0.2",
+    "ast-kit": "^2.2.0",
+    "vue": "3.6.0-rc.5"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "DEV=true tsdown"
+  }
+}