unplugin-zed-gpui 0.0.2 → 0.0.3

package/dist/index.cjs

@@ -2,6 +2,296 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_src = require("./src-CQKToE8V.cjs");
-exports.default = require_src.zedGpuiPlugin;
-exports.zedGpuiPlugin = require_src.zedGpuiPlugin;
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let unplugin = require("unplugin");
+let _babel_parser = require("@babel/parser");
+let _babel_types = require("@babel/types");
+_babel_types = __toESM(_babel_types, 1);
+let _babel_generator = require("@babel/generator");
+_babel_generator = __toESM(_babel_generator, 1);
+//#region src/index.ts
+const defaultOptions = {
+	zedGpuiPackageName: "zed-gpui",
+	elementPath: "zed-gpui/element",
+	debug: false
+};
+const keepHTMLElementMethods = /* @__PURE__ */ new Set([
+	"on",
+	"off",
+	"on_",
+	"off_"
+]);
+const factoryElementTypes = {
+	div: "HTMLDivElement",
+	span: "HTMLSpanElement",
+	section: "HTMLElement",
+	p: "HTMLParagraphElement",
+	input: "HTMLInputElement",
+	textarea: "HTMLTextAreaElement",
+	btn: "HTMLButtonElement",
+	select: "HTMLSelectElement"
+};
+const tagElementTypes = {
+	a: "HTMLAnchorElement",
+	button: "HTMLButtonElement",
+	details: "HTMLDetailsElement",
+	dialog: "HTMLDialogElement",
+	form: "HTMLFormElement",
+	img: "HTMLImageElement",
+	input: "HTMLInputElement",
+	label: "HTMLLabelElement",
+	meter: "HTMLMeterElement",
+	option: "HTMLOptionElement",
+	progress: "HTMLProgressElement",
+	select: "HTMLSelectElement",
+	textarea: "HTMLTextAreaElement",
+	video: "HTMLMediaElement",
+	audio: "HTMLMediaElement"
+};
+/**
+* Unplugin for zed-gpui tree-shaking optimization
+* Removes unused zed-gpui methods from the bundle
+*/
+const zedGpuiPlugin = (0, unplugin.createUnplugin)((options = {}) => {
+	const opts = {
+		...defaultOptions,
+		...options
+	};
+	const usedMethods = {
+		unknown: /* @__PURE__ */ new Set(),
+		byPrototype: /* @__PURE__ */ new Map()
+	};
+	return {
+		name: "unplugin-zed-gpui",
+		transform(code, id) {
+			if (hasElementPrototypeAssign(code)) {
+				if (opts.debug) {
+					console.log(`[zed-gpui] Processing element file: ${id}`);
+					console.log(`[zed-gpui] Used methods:`, formatUsedMethods(usedMethods));
+				}
+				return transformElementFile(code, usedMethods, opts);
+			}
+			if (shouldProcessFile(id)) analyzeUsage(code, usedMethods, opts);
+			return null;
+		},
+		buildEnd() {
+			usedMethods.unknown.clear();
+			usedMethods.byPrototype.clear();
+		}
+	};
+});
+/**
+* Check if a file should be analyzed for zed-gpui usage
+*/
+function shouldProcessFile(id) {
+	if (id.includes("node_modules") || id.includes("dist")) return false;
+	return /\.(ts|js|tsx|jsx)$/.test(id);
+}
+/**
+* Analyze code to find zed-gpui method usage
+*/
+function analyzeUsage(code, usedMethods, options) {
+	try {
+		const ast = (0, _babel_parser.parse)(code, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"]
+		});
+		let hasZedGpuiImport = false;
+		const program = ast.program;
+		for (const node of program.body) if (_babel_types.isImportDeclaration(node)) {
+			const source = node.source.value;
+			if (source === options.zedGpuiPackageName || source.startsWith(options.zedGpuiPackageName + "/")) {
+				hasZedGpuiImport = true;
+				break;
+			}
+		}
+		if (!hasZedGpuiImport && !hasZedGpuiUsage(code)) return;
+		scanNodeForMethodCalls(program, usedMethods, /* @__PURE__ */ new Map());
+		if (options.debug && (usedMethods.unknown.size > 0 || usedMethods.byPrototype.size > 0)) console.log(`[zed-gpui] Found methods in file:`, formatUsedMethods(usedMethods));
+	} catch (error) {
+		if (options.debug) console.warn(`[zed-gpui] Failed to parse:`, error);
+	}
+}
+/**
+* Quick check if code might contain zed-gpui usage
+*/
+function hasZedGpuiUsage(code) {
+	return /\.\s*([a-z_][a-zA-Z0-9_]*)\s*\(/.test(code);
+}
+function hasElementPrototypeAssign(code) {
+	return code.includes("Object.assign") && /HTML[A-Za-z]*Element\.prototype/.test(code);
+}
+/**
+* Recursively scan AST nodes for method calls
+*/
+function scanNodeForMethodCalls(node, usedMethods, bindings) {
+	if (_babel_types.isProgram(node) || _babel_types.isBlockStatement(node)) {
+		const scopedBindings = new Map(bindings);
+		for (const child of node.body) scanNodeForMethodCalls(child, usedMethods, scopedBindings);
+		return;
+	}
+	if (_babel_types.isFunctionDeclaration(node) || _babel_types.isFunctionExpression(node) || _babel_types.isArrowFunctionExpression(node)) {
+		const scopedBindings = new Map(bindings);
+		for (const param of node.params) bindElementType(param, scopedBindings);
+		scanNodeForMethodCalls(node.body, usedMethods, scopedBindings);
+		return;
+	}
+	if (_babel_types.isVariableDeclaration(node)) {
+		for (const declaration of node.declarations) {
+			if (declaration.init) scanNodeForMethodCalls(declaration.init, usedMethods, bindings);
+			if (_babel_types.isIdentifier(declaration.id)) {
+				const elementType = getElementTypeFromTypeAnnotation(declaration.id) ?? (declaration.init ? inferElementType(declaration.init, bindings) : void 0);
+				if (elementType) bindings.set(declaration.id.name, elementType);
+			}
+		}
+		return;
+	}
+	if (_babel_types.isAssignmentExpression(node)) {
+		scanNodeForMethodCalls(node.right, usedMethods, bindings);
+		if (_babel_types.isIdentifier(node.left)) {
+			const elementType = inferElementType(node.right, bindings);
+			if (elementType) bindings.set(node.left.name, elementType);
+		} else scanNodeForMethodCalls(node.left, usedMethods, bindings);
+		return;
+	}
+	if (_babel_types.isCallExpression(node) && _babel_types.isMemberExpression(node.callee) && !_babel_types.isSuper(node.callee.object)) {
+		const property = node.callee.property;
+		if (_babel_types.isIdentifier(property) && /^[a-z][a-zA-Z0-9_]*$/.test(property.name)) addUsedMethod(usedMethods, inferElementType(node.callee.object, bindings), property.name);
+	}
+	for (const key in node) {
+		if (!Object.prototype.hasOwnProperty.call(node, key)) continue;
+		const child = node[key];
+		if (Array.isArray(child)) child.forEach((item) => item?.type && scanNodeForMethodCalls(item, usedMethods, bindings));
+		else if (child?.type) scanNodeForMethodCalls(child, usedMethods, bindings);
+	}
+}
+function bindElementType(node, bindings) {
+	if (_babel_types.isIdentifier(node)) {
+		const elementType = getElementTypeFromTypeAnnotation(node);
+		if (elementType) bindings.set(node.name, elementType);
+	}
+}
+function addUsedMethod(usedMethods, elementType, methodName) {
+	if (!elementType) {
+		usedMethods.unknown.add(methodName);
+		return;
+	}
+	if (!usedMethods.byPrototype.has(elementType)) usedMethods.byPrototype.set(elementType, /* @__PURE__ */ new Set());
+	usedMethods.byPrototype.get(elementType).add(methodName);
+}
+function inferElementType(node, bindings) {
+	if (_babel_types.isIdentifier(node)) return bindings.get(node.name);
+	if (_babel_types.isTSAsExpression(node) || _babel_types.isTSTypeAssertion(node)) return getElementTypeFromTsType(node.typeAnnotation) ?? inferElementType(node.expression, bindings);
+	if (_babel_types.isCallExpression(node)) {
+		if (_babel_types.isIdentifier(node.callee)) {
+			if (node.callee.name === "h" && _babel_types.isStringLiteral(node.arguments[0])) return tagElementTypes[node.arguments[0].value] ?? "HTMLElement";
+			return factoryElementTypes[node.callee.name];
+		}
+		if (_babel_types.isMemberExpression(node.callee)) {
+			if (_babel_types.isMemberExpression(node.callee) && _babel_types.isIdentifier(node.callee.property, { name: "createElement" }) && _babel_types.isIdentifier(node.callee.object, { name: "document" }) && _babel_types.isStringLiteral(node.arguments[0])) return tagElementTypes[node.arguments[0].value] ?? "HTMLElement";
+			return inferElementType(node.callee.object, bindings);
+		}
+	}
+}
+function getElementTypeFromTypeAnnotation(node) {
+	return node.typeAnnotation && _babel_types.isTSTypeAnnotation(node.typeAnnotation) ? getElementTypeFromTsType(node.typeAnnotation.typeAnnotation) : void 0;
+}
+function getElementTypeFromTsType(node) {
+	return _babel_types.isTSTypeReference(node) && _babel_types.isIdentifier(node.typeName) && isElementType(node.typeName.name) ? node.typeName.name : void 0;
+}
+function isElementType(name) {
+	return name === "HTMLElement" || /^HTML[A-Za-z]*Element$/.test(name);
+}
+/**
+* Transform element.ts to remove unused methods
+*/
+function transformElementFile(code, usedMethods, options) {
+	try {
+		const ast = (0, _babel_parser.parse)(code, {
+			sourceType: "module",
+			plugins: ["typescript"]
+		});
+		let modified = false;
+		const prototypeMethods = /* @__PURE__ */ new Map();
+		for (const node of ast.program.body) {
+			if (!_babel_types.isExpressionStatement(node) || !_babel_types.isCallExpression(node.expression)) continue;
+			const targetPrototype = getAssignedPrototype(node.expression.arguments[0]);
+			const sourceArg = unwrapExpression(node.expression.arguments[1]);
+			if (!targetPrototype || !_babel_types.isObjectExpression(sourceArg)) continue;
+			prototypeMethods.set(targetPrototype, new Set(sourceArg.properties.map((prop) => _babel_types.isObjectProperty(prop) || _babel_types.isObjectMethod(prop) ? getPropertyName(prop.key) : void 0).filter((methodName) => !!methodName)));
+		}
+		for (const node of ast.program.body) {
+			if (!_babel_types.isExpressionStatement(node) || !_babel_types.isCallExpression(node.expression)) continue;
+			const callExpr = node.expression;
+			if (!_babel_types.isMemberExpression(callExpr.callee) || !_babel_types.isIdentifier(callExpr.callee.object, { name: "Object" }) || !_babel_types.isIdentifier(callExpr.callee.property, { name: "assign" }) || callExpr.arguments.length < 2) continue;
+			const targetPrototype = getAssignedPrototype(callExpr.arguments[0]);
+			const sourceArg = unwrapExpression(callExpr.arguments[1]);
+			if (!targetPrototype || !_babel_types.isObjectExpression(sourceArg)) continue;
+			const originalProperties = sourceArg.properties.length;
+			sourceArg.properties = sourceArg.properties.filter((prop) => {
+				if (!_babel_types.isObjectProperty(prop) && !_babel_types.isObjectMethod(prop)) return true;
+				const methodName = getPropertyName(prop.key);
+				if (!methodName || isMethodUsed(targetPrototype, methodName, usedMethods, prototypeMethods)) return true;
+				if (options.debug) console.log(`[zed-gpui] Removing unused method: ${targetPrototype}.${methodName}`);
+				return false;
+			});
+			if (sourceArg.properties.length !== originalProperties) {
+				modified = true;
+				if (options.debug) console.log(`[zed-gpui] Removed ${originalProperties - sourceArg.properties.length} unused methods from ${targetPrototype}`);
+			}
+		}
+		if (modified) return { code: (0, _babel_generator.default)(ast, {}, code).code };
+		return null;
+	} catch (error) {
+		console.error("[zed-gpui] Failed to transform element file:", error);
+		return null;
+	}
+}
+function getAssignedPrototype(node) {
+	return _babel_types.isMemberExpression(node) && _babel_types.isIdentifier(node.object) && _babel_types.isIdentifier(node.property, { name: "prototype" }) && isElementType(node.object.name) ? node.object.name : void 0;
+}
+function unwrapExpression(node) {
+	while (_babel_types.isTSAsExpression(node) || _babel_types.isTSTypeAssertion(node) || _babel_types.isTSNonNullExpression(node)) node = node.expression;
+	return node;
+}
+function getPropertyName(node) {
+	if (_babel_types.isIdentifier(node)) return node.name;
+	if (_babel_types.isStringLiteral(node)) return node.value;
+}
+function isMethodUsed(prototypeName, methodName, usedMethods, prototypeMethods) {
+	if (usedMethods.unknown.has(methodName) || usedMethods.byPrototype.get(prototypeName)?.has(methodName)) return true;
+	if (prototypeName !== "HTMLElement") return false;
+	if (keepHTMLElementMethods.has(methodName)) return true;
+	for (const [usedPrototype, methods] of usedMethods.byPrototype) if (usedPrototype !== "HTMLElement" && methods.has(methodName) && !prototypeMethods.get(usedPrototype)?.has(methodName)) return true;
+	return false;
+}
+function formatUsedMethods(usedMethods) {
+	return {
+		unknown: Array.from(usedMethods.unknown).sort(),
+		byPrototype: Object.fromEntries(Array.from(usedMethods.byPrototype.entries()).map(([prototype, methods]) => [prototype, Array.from(methods).sort()]))
+	};
+}
+//#endregion
+exports.default = zedGpuiPlugin;
+exports.zedGpuiPlugin = zedGpuiPlugin;

package/dist/{index.d.cts → index.d.ts}

@@ -22,5 +22,4 @@ interface PluginOptions {
  */
 declare const zedGpuiPlugin: import("unplugin").UnpluginInstance<PluginOptions, boolean>;
 //#endregion
-export { PluginOptions, zedGpuiPlugin as default, zedGpuiPlugin };
-//# sourceMappingURL=index.d.cts.map
+export { PluginOptions, zedGpuiPlugin as default, zedGpuiPlugin };

package/dist/index.mjs

@@ -1,2 +1,268 @@
-import { t as zedGpuiPlugin } from "./src-Cdq30MRu.mjs";
+import { createUnplugin } from "unplugin";
+import { parse } from "@babel/parser";
+import * as t from "@babel/types";
+import generate from "@babel/generator";
+//#region src/index.ts
+const defaultOptions = {
+	zedGpuiPackageName: "zed-gpui",
+	elementPath: "zed-gpui/element",
+	debug: false
+};
+const keepHTMLElementMethods = /* @__PURE__ */ new Set([
+	"on",
+	"off",
+	"on_",
+	"off_"
+]);
+const factoryElementTypes = {
+	div: "HTMLDivElement",
+	span: "HTMLSpanElement",
+	section: "HTMLElement",
+	p: "HTMLParagraphElement",
+	input: "HTMLInputElement",
+	textarea: "HTMLTextAreaElement",
+	btn: "HTMLButtonElement",
+	select: "HTMLSelectElement"
+};
+const tagElementTypes = {
+	a: "HTMLAnchorElement",
+	button: "HTMLButtonElement",
+	details: "HTMLDetailsElement",
+	dialog: "HTMLDialogElement",
+	form: "HTMLFormElement",
+	img: "HTMLImageElement",
+	input: "HTMLInputElement",
+	label: "HTMLLabelElement",
+	meter: "HTMLMeterElement",
+	option: "HTMLOptionElement",
+	progress: "HTMLProgressElement",
+	select: "HTMLSelectElement",
+	textarea: "HTMLTextAreaElement",
+	video: "HTMLMediaElement",
+	audio: "HTMLMediaElement"
+};
+/**
+* Unplugin for zed-gpui tree-shaking optimization
+* Removes unused zed-gpui methods from the bundle
+*/
+const zedGpuiPlugin = createUnplugin((options = {}) => {
+	const opts = {
+		...defaultOptions,
+		...options
+	};
+	const usedMethods = {
+		unknown: /* @__PURE__ */ new Set(),
+		byPrototype: /* @__PURE__ */ new Map()
+	};
+	return {
+		name: "unplugin-zed-gpui",
+		transform(code, id) {
+			if (hasElementPrototypeAssign(code)) {
+				if (opts.debug) {
+					console.log(`[zed-gpui] Processing element file: ${id}`);
+					console.log(`[zed-gpui] Used methods:`, formatUsedMethods(usedMethods));
+				}
+				return transformElementFile(code, usedMethods, opts);
+			}
+			if (shouldProcessFile(id)) analyzeUsage(code, usedMethods, opts);
+			return null;
+		},
+		buildEnd() {
+			usedMethods.unknown.clear();
+			usedMethods.byPrototype.clear();
+		}
+	};
+});
+/**
+* Check if a file should be analyzed for zed-gpui usage
+*/
+function shouldProcessFile(id) {
+	if (id.includes("node_modules") || id.includes("dist")) return false;
+	return /\.(ts|js|tsx|jsx)$/.test(id);
+}
+/**
+* Analyze code to find zed-gpui method usage
+*/
+function analyzeUsage(code, usedMethods, options) {
+	try {
+		const ast = parse(code, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"]
+		});
+		let hasZedGpuiImport = false;
+		const program = ast.program;
+		for (const node of program.body) if (t.isImportDeclaration(node)) {
+			const source = node.source.value;
+			if (source === options.zedGpuiPackageName || source.startsWith(options.zedGpuiPackageName + "/")) {
+				hasZedGpuiImport = true;
+				break;
+			}
+		}
+		if (!hasZedGpuiImport && !hasZedGpuiUsage(code)) return;
+		scanNodeForMethodCalls(program, usedMethods, /* @__PURE__ */ new Map());
+		if (options.debug && (usedMethods.unknown.size > 0 || usedMethods.byPrototype.size > 0)) console.log(`[zed-gpui] Found methods in file:`, formatUsedMethods(usedMethods));
+	} catch (error) {
+		if (options.debug) console.warn(`[zed-gpui] Failed to parse:`, error);
+	}
+}
+/**
+* Quick check if code might contain zed-gpui usage
+*/
+function hasZedGpuiUsage(code) {
+	return /\.\s*([a-z_][a-zA-Z0-9_]*)\s*\(/.test(code);
+}
+function hasElementPrototypeAssign(code) {
+	return code.includes("Object.assign") && /HTML[A-Za-z]*Element\.prototype/.test(code);
+}
+/**
+* Recursively scan AST nodes for method calls
+*/
+function scanNodeForMethodCalls(node, usedMethods, bindings) {
+	if (t.isProgram(node) || t.isBlockStatement(node)) {
+		const scopedBindings = new Map(bindings);
+		for (const child of node.body) scanNodeForMethodCalls(child, usedMethods, scopedBindings);
+		return;
+	}
+	if (t.isFunctionDeclaration(node) || t.isFunctionExpression(node) || t.isArrowFunctionExpression(node)) {
+		const scopedBindings = new Map(bindings);
+		for (const param of node.params) bindElementType(param, scopedBindings);
+		scanNodeForMethodCalls(node.body, usedMethods, scopedBindings);
+		return;
+	}
+	if (t.isVariableDeclaration(node)) {
+		for (const declaration of node.declarations) {
+			if (declaration.init) scanNodeForMethodCalls(declaration.init, usedMethods, bindings);
+			if (t.isIdentifier(declaration.id)) {
+				const elementType = getElementTypeFromTypeAnnotation(declaration.id) ?? (declaration.init ? inferElementType(declaration.init, bindings) : void 0);
+				if (elementType) bindings.set(declaration.id.name, elementType);
+			}
+		}
+		return;
+	}
+	if (t.isAssignmentExpression(node)) {
+		scanNodeForMethodCalls(node.right, usedMethods, bindings);
+		if (t.isIdentifier(node.left)) {
+			const elementType = inferElementType(node.right, bindings);
+			if (elementType) bindings.set(node.left.name, elementType);
+		} else scanNodeForMethodCalls(node.left, usedMethods, bindings);
+		return;
+	}
+	if (t.isCallExpression(node) && t.isMemberExpression(node.callee) && !t.isSuper(node.callee.object)) {
+		const property = node.callee.property;
+		if (t.isIdentifier(property) && /^[a-z][a-zA-Z0-9_]*$/.test(property.name)) addUsedMethod(usedMethods, inferElementType(node.callee.object, bindings), property.name);
+	}
+	for (const key in node) {
+		if (!Object.prototype.hasOwnProperty.call(node, key)) continue;
+		const child = node[key];
+		if (Array.isArray(child)) child.forEach((item) => item?.type && scanNodeForMethodCalls(item, usedMethods, bindings));
+		else if (child?.type) scanNodeForMethodCalls(child, usedMethods, bindings);
+	}
+}
+function bindElementType(node, bindings) {
+	if (t.isIdentifier(node)) {
+		const elementType = getElementTypeFromTypeAnnotation(node);
+		if (elementType) bindings.set(node.name, elementType);
+	}
+}
+function addUsedMethod(usedMethods, elementType, methodName) {
+	if (!elementType) {
+		usedMethods.unknown.add(methodName);
+		return;
+	}
+	if (!usedMethods.byPrototype.has(elementType)) usedMethods.byPrototype.set(elementType, /* @__PURE__ */ new Set());
+	usedMethods.byPrototype.get(elementType).add(methodName);
+}
+function inferElementType(node, bindings) {
+	if (t.isIdentifier(node)) return bindings.get(node.name);
+	if (t.isTSAsExpression(node) || t.isTSTypeAssertion(node)) return getElementTypeFromTsType(node.typeAnnotation) ?? inferElementType(node.expression, bindings);
+	if (t.isCallExpression(node)) {
+		if (t.isIdentifier(node.callee)) {
+			if (node.callee.name === "h" && t.isStringLiteral(node.arguments[0])) return tagElementTypes[node.arguments[0].value] ?? "HTMLElement";
+			return factoryElementTypes[node.callee.name];
+		}
+		if (t.isMemberExpression(node.callee)) {
+			if (t.isMemberExpression(node.callee) && t.isIdentifier(node.callee.property, { name: "createElement" }) && t.isIdentifier(node.callee.object, { name: "document" }) && t.isStringLiteral(node.arguments[0])) return tagElementTypes[node.arguments[0].value] ?? "HTMLElement";
+			return inferElementType(node.callee.object, bindings);
+		}
+	}
+}
+function getElementTypeFromTypeAnnotation(node) {
+	return node.typeAnnotation && t.isTSTypeAnnotation(node.typeAnnotation) ? getElementTypeFromTsType(node.typeAnnotation.typeAnnotation) : void 0;
+}
+function getElementTypeFromTsType(node) {
+	return t.isTSTypeReference(node) && t.isIdentifier(node.typeName) && isElementType(node.typeName.name) ? node.typeName.name : void 0;
+}
+function isElementType(name) {
+	return name === "HTMLElement" || /^HTML[A-Za-z]*Element$/.test(name);
+}
+/**
+* Transform element.ts to remove unused methods
+*/
+function transformElementFile(code, usedMethods, options) {
+	try {
+		const ast = parse(code, {
+			sourceType: "module",
+			plugins: ["typescript"]
+		});
+		let modified = false;
+		const prototypeMethods = /* @__PURE__ */ new Map();
+		for (const node of ast.program.body) {
+			if (!t.isExpressionStatement(node) || !t.isCallExpression(node.expression)) continue;
+			const targetPrototype = getAssignedPrototype(node.expression.arguments[0]);
+			const sourceArg = unwrapExpression(node.expression.arguments[1]);
+			if (!targetPrototype || !t.isObjectExpression(sourceArg)) continue;
+			prototypeMethods.set(targetPrototype, new Set(sourceArg.properties.map((prop) => t.isObjectProperty(prop) || t.isObjectMethod(prop) ? getPropertyName(prop.key) : void 0).filter((methodName) => !!methodName)));
+		}
+		for (const node of ast.program.body) {
+			if (!t.isExpressionStatement(node) || !t.isCallExpression(node.expression)) continue;
+			const callExpr = node.expression;
+			if (!t.isMemberExpression(callExpr.callee) || !t.isIdentifier(callExpr.callee.object, { name: "Object" }) || !t.isIdentifier(callExpr.callee.property, { name: "assign" }) || callExpr.arguments.length < 2) continue;
+			const targetPrototype = getAssignedPrototype(callExpr.arguments[0]);
+			const sourceArg = unwrapExpression(callExpr.arguments[1]);
+			if (!targetPrototype || !t.isObjectExpression(sourceArg)) continue;
+			const originalProperties = sourceArg.properties.length;
+			sourceArg.properties = sourceArg.properties.filter((prop) => {
+				if (!t.isObjectProperty(prop) && !t.isObjectMethod(prop)) return true;
+				const methodName = getPropertyName(prop.key);
+				if (!methodName || isMethodUsed(targetPrototype, methodName, usedMethods, prototypeMethods)) return true;
+				if (options.debug) console.log(`[zed-gpui] Removing unused method: ${targetPrototype}.${methodName}`);
+				return false;
+			});
+			if (sourceArg.properties.length !== originalProperties) {
+				modified = true;
+				if (options.debug) console.log(`[zed-gpui] Removed ${originalProperties - sourceArg.properties.length} unused methods from ${targetPrototype}`);
+			}
+		}
+		if (modified) return { code: generate(ast, {}, code).code };
+		return null;
+	} catch (error) {
+		console.error("[zed-gpui] Failed to transform element file:", error);
+		return null;
+	}
+}
+function getAssignedPrototype(node) {
+	return t.isMemberExpression(node) && t.isIdentifier(node.object) && t.isIdentifier(node.property, { name: "prototype" }) && isElementType(node.object.name) ? node.object.name : void 0;
+}
+function unwrapExpression(node) {
+	while (t.isTSAsExpression(node) || t.isTSTypeAssertion(node) || t.isTSNonNullExpression(node)) node = node.expression;
+	return node;
+}
+function getPropertyName(node) {
+	if (t.isIdentifier(node)) return node.name;
+	if (t.isStringLiteral(node)) return node.value;
+}
+function isMethodUsed(prototypeName, methodName, usedMethods, prototypeMethods) {
+	if (usedMethods.unknown.has(methodName) || usedMethods.byPrototype.get(prototypeName)?.has(methodName)) return true;
+	if (prototypeName !== "HTMLElement") return false;
+	if (keepHTMLElementMethods.has(methodName)) return true;
+	for (const [usedPrototype, methods] of usedMethods.byPrototype) if (usedPrototype !== "HTMLElement" && methods.has(methodName) && !prototypeMethods.get(usedPrototype)?.has(methodName)) return true;
+	return false;
+}
+function formatUsedMethods(usedMethods) {
+	return {
+		unknown: Array.from(usedMethods.unknown).sort(),
+		byPrototype: Object.fromEntries(Array.from(usedMethods.byPrototype.entries()).map(([prototype, methods]) => [prototype, Array.from(methods).sort()]))
+	};
+}
+//#endregion
 export { zedGpuiPlugin as default, zedGpuiPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unplugin-zed-gpui",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Unplugin for zed-gpui tree-shaking optimization - removes unused zed-gpui methods from bundle",
   "author": {
     "name": "Kasukabe Tsumugi",
@@ -8,51 +8,15 @@
   },
   "license": "MIT",
   "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
+      "import": "./dist/index.mjs",
       "require": "./dist/index.cjs",
-      "default": "./dist/index.js"
-    },
-    "./noble": {
-      "types": "./dist/noble.d.ts",
-      "import": "./dist/noble.js",
-      "require": "./dist/noble.cjs",
-      "default": "./dist/noble.js"
-    },
-    "./vite": {
-      "types": "./dist/vite.d.ts",
-      "import": "./dist/vite.mjs",
-      "require": "./dist/vite.cjs",
-      "default": "./dist/vite.mjs"
-    },
-    "./webpack": {
-      "types": "./dist/webpack.d.ts",
-      "import": "./dist/webpack.mjs",
-      "require": "./dist/webpack.cjs",
-      "default": "./dist/webpack.mjs"
-    },
-    "./rollup": {
-      "types": "./dist/rollup.d.ts",
-      "import": "./dist/rollup.mjs",
-      "require": "./dist/rollup.cjs",
-      "default": "./dist/rollup.mjs"
-    },
-    "./esbuild": {
-      "types": "./dist/esbuild.d.ts",
-      "import": "./dist/esbuild.mjs",
-      "require": "./dist/esbuild.cjs",
-      "default": "./dist/esbuild.mjs"
-    },
-    "./rspack": {
-      "types": "./dist/rspack.d.ts",
-      "import": "./dist/rspack.mjs",
-      "require": "./dist/rspack.cjs",
-      "default": "./dist/rspack.mjs"
+      "default": "./dist/index.mjs"
     }
   },
   "files": [
@@ -72,9 +36,6 @@
     "unplugin": "^1.0.0"
   },
   "devDependencies": {
-    "@babel/generator": "^8.0.0",
-    "@babel/parser": "^8.0.0",
-    "@babel/types": "^8.0.0",
     "@types/node": "^25.9.1",
     "tsdown": "^0.22.3",
     "typescript": "^6.0.3",
@@ -85,6 +46,11 @@
     "url": "https://github.com/baendlorel/gpui-ts",
     "directory": "packages/unplugin-zed-gpui-treeshake"
   },
+  "dependencies": {
+    "@babel/generator": "^8.0.0",
+    "@babel/parser": "^8.0.0",
+    "@babel/types": "^8.0.0"
+  },
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch"

package/dist/esbuild.cjs

@@ -1,6 +0,0 @@
-//#region src/esbuild.ts
-var esbuild_default = require("./src-CQKToE8V.cjs").zedGpuiPlugin.esbuild;
-//#endregion
-module.exports = esbuild_default;
-
-//# sourceMappingURL=esbuild.cjs.map

package/dist/esbuild.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"esbuild.cjs","names":["zedGpuiPlugin"],"sources":["../src/esbuild.ts"],"sourcesContent":["import { zedGpuiPlugin } from './index.js';\n\nexport default zedGpuiPlugin.esbuild;\n"],"mappings":";AAEA,IAAA,8CAAeA,CAAAA,CAAAA,cAAc"}

package/dist/esbuild.d.cts

@@ -1,6 +0,0 @@
-import { PluginOptions } from "./index.cjs";
-
-//#region src/esbuild.d.ts
-declare const _default: (options: PluginOptions) => import("unplugin").EsbuildPlugin;
-export = _default;
-//# sourceMappingURL=esbuild.d.cts.map

package/dist/esbuild.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"esbuild.d.cts","names":[],"sources":["../src/esbuild.ts"],"mappings":""}