@zeus-js/bundler-plugin 0.1.0-beta.0 → 0.1.0-beta.2

package/dist/rolldown.prod.js

@@ -0,0 +1,745 @@
+/**
+* bundler-plugin v0.1.0-beta.2
+* (c) 2026 baicie
+* Released under the MIT License.
+**/
+import fs from "node:fs";
+import path from "node:path";
+import { analyzeComponents } from "@zeus-js/component-analyzer";
+import fg from "fast-glob";
+import picomatch from "picomatch";
+import fs$1 from "node:fs/promises";
+import { transformAsync } from "@babel/core";
+import presetTypeScript from "@babel/preset-typescript";
+import zeusCompiler from "@zeus-js/compiler";
+//#region packages/web-c/bundler-plugin/src/filter.ts
+function cleanUrl(id) {
+	return id.replace(/[?#].*$/, "");
+}
+function isTypeScriptLike(id) {
+	return /\.[cm]?tsx?$/.test(cleanUrl(id));
+}
+//#endregion
+//#region packages/web-c/bundler-plugin/src/componentTransformFilter.ts
+function normalizePath$1(value) {
+	return value.replace(/\\/g, "/");
+}
+function createComponentTransformFilter(options) {
+	const isIncluded = picomatch(options.include);
+	const isExcluded = picomatch(options.exclude);
+	return function shouldTransform(id) {
+		const clean = normalizePath$1(cleanUrl(id));
+		const relative = normalizePath$1(path.relative(options.root, clean));
+		if (relative.startsWith("..") || path.isAbsolute(relative)) return false;
+		if (isExcluded(relative)) return false;
+		return isIncluded(relative);
+	};
+}
+//#endregion
+//#region packages/web-c/bundler-plugin/src/defaults.ts
+const DEFAULT_COMPONENT_INCLUDE = ["src/**/*.{ts,tsx,js,jsx}", "components/**/*.{ts,tsx,js,jsx}"];
+const DEFAULT_COMPONENT_EXCLUDE = [
+	"**/*.test.*",
+	"**/*.spec.*",
+	"**/__tests__/**",
+	"**/*.d.ts",
+	"src/shared/**",
+	"node_modules/**",
+	"dist/**"
+];
+const DEFAULT_TRANSFORM_INCLUDE = DEFAULT_COMPONENT_INCLUDE;
+const DEFAULT_TRANSFORM_EXCLUDE = [
+	"**/*.test.*",
+	"**/*.spec.*",
+	"**/__tests__/**",
+	"**/*.d.ts",
+	"node_modules/**",
+	"dist/**"
+];
+function resolveComponentInclude(include) {
+	return (include === null || include === void 0 ? void 0 : include.length) ? include : DEFAULT_COMPONENT_INCLUDE;
+}
+function resolveComponentExclude(exclude) {
+	return (exclude === null || exclude === void 0 ? void 0 : exclude.length) ? exclude : DEFAULT_COMPONENT_EXCLUDE;
+}
+function resolveTransformInclude(include, componentInclude) {
+	if (include === null || include === void 0 ? void 0 : include.length) return include;
+	return Array.from(new Set([...DEFAULT_TRANSFORM_INCLUDE, ...componentInclude]));
+}
+function resolveTransformExclude(exclude) {
+	return (exclude === null || exclude === void 0 ? void 0 : exclude.length) ? exclude : DEFAULT_TRANSFORM_EXCLUDE;
+}
+//#endregion
+//#region packages/web-c/bundler-plugin/src/diagnostics.ts
+function formatDiagnostic(diagnostic) {
+	return `[zeus component-analyzer] ${diagnostic.file}: ${diagnostic.message}`;
+}
+function hasErrorDiagnostics(diagnostics) {
+	return diagnostics.some((item) => item.level === "error");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/asyncToGenerator.js
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+	try {
+		var i = n[a](c), u = i.value;
+	} catch (n) {
+		e(n);
+		return;
+	}
+	i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+	return function() {
+		var t = this, e = arguments;
+		return new Promise(function(r, o) {
+			var a = n.apply(t, e);
+			function _next(n) {
+				asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+			}
+			function _throw(n) {
+				asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+			}
+			_next(void 0);
+		});
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/objectSpread2.js
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function(r) {
+			return Object.getOwnPropertyDescriptor(e, r).enumerable;
+		})), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
+			_defineProperty(e, r, t[r]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
+			Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+		});
+	}
+	return e;
+}
+//#endregion
+//#region packages/web-c/bundler-plugin/src/dts.ts
+function resolveDts(_x) {
+	return _resolveDts.apply(this, arguments);
+}
+function _resolveDts() {
+	_resolveDts = _asyncToGenerator(function* (options) {
+		var _options$mode;
+		const mode = (_options$mode = options.mode) !== null && _options$mode !== void 0 ? _options$mode : "auto";
+		if (mode === true) return {
+			enabled: true,
+			mode,
+			reason: ["explicit-enabled"]
+		};
+		if (mode === false) return {
+			enabled: false,
+			mode,
+			reason: ["explicit-disabled"]
+		};
+		const reason = [];
+		if (yield packageDeclaresTypes(options.root)) reason.push("package-types-field");
+		if (yield hasTypeScriptDependency(options.root)) reason.push("typescript-dependency");
+		if (yield fileExists(path.join(options.root, "tsconfig.json"))) reason.push("tsconfig");
+		if (yield hasTypeScriptSource({
+			root: options.root,
+			include: options.include,
+			exclude: options.exclude
+		})) reason.push("typescript-source");
+		return {
+			enabled: reason.length > 0,
+			mode,
+			reason
+		};
+	});
+	return _resolveDts.apply(this, arguments);
+}
+function hasTypeScriptDependency(_x2) {
+	return _hasTypeScriptDependency.apply(this, arguments);
+}
+function _hasTypeScriptDependency() {
+	_hasTypeScriptDependency = _asyncToGenerator(function* (root) {
+		const pkg = yield readPackageJson(root);
+		if (!pkg) return false;
+		const deps = _objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({}, pkg.dependencies), pkg.devDependencies), pkg.peerDependencies), pkg.optionalDependencies);
+		return Boolean(deps.typescript);
+	});
+	return _hasTypeScriptDependency.apply(this, arguments);
+}
+function packageDeclaresTypes(_x3) {
+	return _packageDeclaresTypes.apply(this, arguments);
+}
+function _packageDeclaresTypes() {
+	_packageDeclaresTypes = _asyncToGenerator(function* (root) {
+		const pkg = yield readPackageJson(root);
+		if (!pkg) return false;
+		if (pkg.types || pkg.typings) return true;
+		return hasTypesInExports(pkg.exports);
+	});
+	return _packageDeclaresTypes.apply(this, arguments);
+}
+function hasTypesInExports(value) {
+	if (!value) return false;
+	if (typeof value !== "object") return false;
+	if ("types" in value) return true;
+	return Object.values(value).some(hasTypesInExports);
+}
+function hasTypeScriptSource(_x4) {
+	return _hasTypeScriptSource.apply(this, arguments);
+}
+function _hasTypeScriptSource() {
+	_hasTypeScriptSource = _asyncToGenerator(function* (options) {
+		return (yield fg(options.include, {
+			cwd: options.root,
+			onlyFiles: true,
+			absolute: false,
+			ignore: options.exclude
+		})).some((file) => file.endsWith(".ts") || file.endsWith(".tsx"));
+	});
+	return _hasTypeScriptSource.apply(this, arguments);
+}
+function readPackageJson(_x5) {
+	return _readPackageJson.apply(this, arguments);
+}
+function _readPackageJson() {
+	_readPackageJson = _asyncToGenerator(function* (root) {
+		try {
+			return JSON.parse(yield fs$1.readFile(path.join(root, "package.json"), "utf-8"));
+		} catch (_unused) {
+			return null;
+		}
+	});
+	return _readPackageJson.apply(this, arguments);
+}
+function fileExists(_x6) {
+	return _fileExists.apply(this, arguments);
+}
+function _fileExists() {
+	_fileExists = _asyncToGenerator(function* (file) {
+		try {
+			yield fs$1.access(file);
+			return true;
+		} catch (_unused2) {
+			return false;
+		}
+	});
+	return _fileExists.apply(this, arguments);
+}
+//#endregion
+//#region packages/web-c/bundler-plugin/src/outputRegistry.ts
+function createOutputRegistry() {
+	const map = /* @__PURE__ */ new Map();
+	return {
+		register(kind, options) {
+			map.set(kind, normalizeRegistration(kind, options));
+		},
+		has(kind) {
+			return map.has(kind);
+		},
+		get(kind) {
+			const current = map.get(kind);
+			if (!current) throw new Error(`[zeus] output kind "${kind}" is not registered.`);
+			return current;
+		},
+		getDir(kind) {
+			return this.get(kind).outDir;
+		},
+		getFileName(kind, tag) {
+			const current = this.get(kind);
+			if (current.fileName) return current.fileName(tag, kind);
+			return `${normalizeTagName(tag, current.stripPrefix)}.js`;
+		},
+		join(kind, fileName) {
+			return path.posix.join(this.getDir(kind), fileName);
+		}
+	};
+}
+function normalizeRegistration(kind, options) {
+	var _options$outDir, _options$stripPrefix;
+	return {
+		outDir: (_options$outDir = options.outDir) !== null && _options$outDir !== void 0 ? _options$outDir : defaultDir(kind),
+		stripPrefix: (_options$stripPrefix = options.stripPrefix) !== null && _options$stripPrefix !== void 0 ? _options$stripPrefix : false,
+		fileName: options.fileName
+	};
+}
+function defaultDir(kind) {
+	switch (kind) {
+		case "wc": return "wc";
+		case "react": return "react";
+		case "vue": return "vue";
+		case "icons-react": return "icons/react";
+		case "icons-vue": return "icons/vue";
+		case "icons-wc": return "icons/wc";
+		case "asset": return "";
+	}
+}
+function normalizeTagName(tag, stripPrefix) {
+	if (stripPrefix && tag.startsWith(stripPrefix)) return tag.slice(stripPrefix.length);
+	return tag;
+}
+//#endregion
+//#region packages/web-c/bundler-plugin/src/transform.ts
+function transformZeus(_x) {
+	return _transformZeus.apply(this, arguments);
+}
+function _transformZeus() {
+	_transformZeus = _asyncToGenerator(function* (options) {
+		var _compilerOptions$modu;
+		const { id, code, compiler, sourcemap = true, transpile = false } = options;
+		const isTs = isTypeScriptLike(id);
+		const isTsx = /\.[cm]?tsx$/.test(id.replace(/[?#].*$/, ""));
+		const shouldRunCompiler = compiler !== false;
+		const shouldStripTs = transpile && isTs;
+		if (!shouldRunCompiler && !shouldStripTs) return null;
+		const compilerOptions = compiler === false ? {} : compiler === void 0 ? {} : compiler;
+		const result = yield transformAsync(code, {
+			filename: id,
+			sourceMaps: sourcemap,
+			plugins: shouldRunCompiler ? [[zeusCompiler, _objectSpread2({
+				moduleName: (_compilerOptions$modu = compilerOptions.moduleName) !== null && _compilerOptions$modu !== void 0 ? _compilerOptions$modu : "@zeus-js/runtime-dom",
+				generate: "dom",
+				hydratable: false,
+				delegateEvents: true
+			}, compilerOptions)]] : [],
+			presets: shouldStripTs ? [[presetTypeScript, {
+				allExtensions: true,
+				isTSX: isTsx,
+				allowDeclareFields: true
+			}]] : [],
+			parserOpts: {
+				sourceType: "module",
+				plugins: ["typescript", "jsx"]
+			},
+			generatorOpts: {
+				retainLines: false,
+				compact: false,
+				jsescOption: { minimal: true }
+			}
+		});
+		if (!(result === null || result === void 0 ? void 0 : result.code)) return null;
+		return {
+			code: result.code,
+			map: result.map
+		};
+	});
+	return _transformZeus.apply(this, arguments);
+}
+//#endregion
+//#region packages/web-c/bundler-plugin/src/virtual.ts
+const RESOLVED_VIRTUAL_PREFIX = "\0";
+var VirtualModuleRegistry = class {
+	constructor() {
+		this.modules = /* @__PURE__ */ new Map();
+		this.virtualDirs = /* @__PURE__ */ new Map();
+		this.virtualFileNames = /* @__PURE__ */ new Map();
+		this.idsByFileName = /* @__PURE__ */ new Map();
+	}
+	set(id, code, fileName) {
+		const normalized = normalizeVirtualId(id);
+		this.modules.set(normalized, code);
+		if (fileName) {
+			const dir = path.posix.dirname(fileName);
+			this.virtualDirs.set(normalized, dir);
+			const normalizedFileName = normalizePath(fileName);
+			this.virtualFileNames.set(normalized, normalizedFileName);
+			this.idsByFileName.set(normalizedFileName, normalized);
+		}
+	}
+	has(id) {
+		return this.modules.has(normalizeVirtualId(id));
+	}
+	get(id) {
+		return this.modules.get(normalizeVirtualId(id));
+	}
+	clear() {
+		this.modules.clear();
+		this.virtualDirs.clear();
+		this.virtualFileNames.clear();
+		this.idsByFileName.clear();
+	}
+	resolve(id, importer) {
+		const normalized = normalizeVirtualId(id);
+		if (this.modules.has(normalized)) return RESOLVED_VIRTUAL_PREFIX + normalized;
+		if (importer && (id.startsWith(".") || id.startsWith(".."))) {
+			const importerNormalized = normalizeVirtualId(importer);
+			const importerDir = this.virtualDirs.get(importerNormalized);
+			if (importerDir) {
+				const resolved = normalizePath(path.posix.join(importerDir, id));
+				const resolvedVirtualId = this.idsByFileName.get(resolved);
+				if (resolvedVirtualId) return RESOLVED_VIRTUAL_PREFIX + resolvedVirtualId;
+				const importingPrefix = this.getIdPrefix(importerNormalized);
+				if (importingPrefix !== null) {
+					const baseName = path.posix.basename(resolved, ".js");
+					for (const [key] of this.modules.entries()) if (key === importingPrefix + baseName) return RESOLVED_VIRTUAL_PREFIX + key;
+					for (const stripPrefix of [
+						"z-",
+						"wc-",
+						"wc/",
+						""
+					]) {
+						const candidate = stripPrefix ? importingPrefix + stripPrefix + baseName : importingPrefix + baseName;
+						if (this.modules.has(candidate)) return RESOLVED_VIRTUAL_PREFIX + candidate;
+					}
+					const fullName = baseName;
+					for (const [key] of this.modules.entries()) if (key.endsWith(":" + fullName)) return RESOLVED_VIRTUAL_PREFIX + key;
+				}
+			}
+		}
+		return null;
+	}
+	getIdPrefix(virtualId) {
+		const lastColon = virtualId.lastIndexOf(":");
+		if (lastColon <= 0) return null;
+		return virtualId.slice(0, lastColon + 1);
+	}
+	load(id) {
+		var _this$modules$get;
+		if (!id.startsWith(RESOLVED_VIRTUAL_PREFIX)) return null;
+		const normalized = id.slice(1);
+		return (_this$modules$get = this.modules.get(normalized)) !== null && _this$modules$get !== void 0 ? _this$modules$get : null;
+	}
+};
+function normalizeVirtualId(id) {
+	return id.startsWith("\0") ? id.slice(1) : id;
+}
+function normalizePath(value) {
+	return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+//#endregion
+//#region packages/web-c/bundler-plugin/src/core.ts
+function createZeusBundlerPlugin(options = {}, createOptions) {
+	const target = createOptions.target;
+	let shouldCompileZeus = (_id) => false;
+	let ctx;
+	let root = process.cwd();
+	const virtualModules = new VirtualModuleRegistry();
+	return {
+		name: resolvePluginName(target),
+		buildStart() {
+			var _this = this;
+			return _asyncToGenerator(function* () {
+				var _options$components, _options$components2, _options$transform, _options$transform2, _options$plugins;
+				virtualModules.clear();
+				root = resolveRoot(options.root);
+				const componentInclude = resolveComponentInclude((_options$components = options.components) === null || _options$components === void 0 ? void 0 : _options$components.include);
+				const componentExclude = resolveComponentExclude((_options$components2 = options.components) === null || _options$components2 === void 0 ? void 0 : _options$components2.exclude);
+				const transformInclude = resolveTransformInclude((_options$transform = options.transform) === null || _options$transform === void 0 ? void 0 : _options$transform.include, componentInclude);
+				const transformExclude = resolveTransformExclude((_options$transform2 = options.transform) === null || _options$transform2 === void 0 ? void 0 : _options$transform2.exclude);
+				shouldCompileZeus = createComponentTransformFilter({
+					root,
+					include: transformInclude,
+					exclude: transformExclude
+				});
+				const dts = yield resolveDts({
+					root,
+					mode: options.dts,
+					include: componentInclude,
+					exclude: componentExclude
+				});
+				const manifestResult = yield createManifest(root, componentInclude, componentExclude);
+				for (const file of yield collectWatchFiles(root, componentInclude, componentExclude)) _this.addWatchFile(file);
+				const diagnostics = manifestResult.diagnostics;
+				for (const diagnostic of diagnostics) {
+					const message = formatDiagnostic(diagnostic);
+					if (diagnostic.level === "error") _this.error(message);
+					else if (options.diagnostics !== false) _this.warn(message);
+				}
+				if (hasErrorDiagnostics(diagnostics)) _this.error("[zeus] component analyzer failed.");
+				if (options.diagnostics === "verbose") _this.warn(`[zeus] dts ${dts.enabled ? "enabled" : "disabled"}: ${dts.reason.join(", ") || "no signal"}`);
+				ctx = {
+					root,
+					manifest: manifestResult.manifest,
+					diagnostics,
+					dts,
+					outputs: createOutputRegistry(),
+					emitFile: _this.emitFile.bind(_this),
+					warn: _this.warn.bind(_this),
+					error: _this.error.bind(_this),
+					addWatchFile: _this.addWatchFile.bind(_this),
+					meta: { watchMode: _this.meta.watchMode }
+				};
+				const plugins = (_options$plugins = options.plugins) !== null && _options$plugins !== void 0 ? _options$plugins : [];
+				for (const plugin of plugins) {
+					var _plugin$setup;
+					yield (_plugin$setup = plugin.setup) === null || _plugin$setup === void 0 ? void 0 : _plugin$setup.call(plugin, ctx);
+				}
+				for (const plugin of plugins) {
+					var _plugin$buildStart;
+					yield (_plugin$buildStart = plugin.buildStart) === null || _plugin$buildStart === void 0 ? void 0 : _plugin$buildStart.call(plugin, ctx);
+				}
+				for (const plugin of plugins) {
+					var _plugin$virtualModule;
+					const modules = yield (_plugin$virtualModule = plugin.virtualModules) === null || _plugin$virtualModule === void 0 ? void 0 : _plugin$virtualModule.call(plugin, ctx);
+					if (!modules) continue;
+					for (const mod of modules) virtualModules.set(mod.id, mod.code, mod.fileName);
+					emitVirtualEntries(modules, _this);
+				}
+			})();
+		},
+		resolveId(id, importer) {
+			const resolvedVirtual = virtualModules.resolve(id, importer);
+			if (resolvedVirtual) return {
+				id: resolvedVirtual,
+				moduleSideEffects: "no-treeshake"
+			};
+			if (target === "rollup") {
+				const resolvedTs = resolveTsLikeImport(id, importer, { extensions: options.resolveExtensions });
+				if (resolvedTs) return resolvedTs;
+			}
+			return null;
+		},
+		load(id) {
+			return virtualModules.load(id);
+		},
+		transform(code, id) {
+			return _asyncToGenerator(function* () {
+				const shouldRunZeus = shouldCompileZeus(id);
+				const shouldStripTs = resolveTranspile(options.transpile, target) && isTypeScriptLike(id);
+				if (!shouldRunZeus && !shouldStripTs) return null;
+				return yield transformZeus({
+					id,
+					code,
+					compiler: shouldRunZeus ? options.compiler : false,
+					sourcemap: true,
+					transpile: shouldStripTs
+				});
+			})();
+		},
+		generateBundle(_, bundle) {
+			var _this2 = this;
+			return _asyncToGenerator(function* () {
+				var _options$plugins2;
+				if (!ctx) return;
+				const plugins = (_options$plugins2 = options.plugins) !== null && _options$plugins2 !== void 0 ? _options$plugins2 : [];
+				for (const plugin of plugins) {
+					var _plugin$generateBundl;
+					const files = yield (_plugin$generateBundl = plugin.generateBundle) === null || _plugin$generateBundl === void 0 ? void 0 : _plugin$generateBundl.call(plugin, ctx, bundle);
+					if (!files) continue;
+					for (const file of files) emitOutputFile(_this2, file);
+				}
+			})();
+		}
+	};
+}
+function resolvePluginName(target) {
+	if (target === "vite") return "vite-plugin-zeus";
+	if (target === "rolldown") return "rolldown-plugin-zeus";
+	return "rollup-plugin-zeus";
+}
+function resolveTranspile(value, target) {
+	if (typeof value === "boolean") return value;
+	return target === "rollup";
+}
+function resolveRoot(root) {
+	if (typeof root === "function") return path.resolve(root());
+	return path.resolve(root !== null && root !== void 0 ? root : process.cwd());
+}
+function createManifest(_x, _x2, _x3) {
+	return _createManifest.apply(this, arguments);
+}
+function _createManifest() {
+	_createManifest = _asyncToGenerator(function* (root, include, exclude) {
+		if (!include.length) return {
+			manifest: {
+				version: 1,
+				components: []
+			},
+			diagnostics: []
+		};
+		return yield analyzeComponents({
+			root,
+			include,
+			exclude
+		});
+	});
+	return _createManifest.apply(this, arguments);
+}
+function collectWatchFiles(_x4, _x5, _x6) {
+	return _collectWatchFiles.apply(this, arguments);
+}
+function _collectWatchFiles() {
+	_collectWatchFiles = _asyncToGenerator(function* (root, include, exclude) {
+		if (!include.length) return [];
+		return yield fg(include, {
+			cwd: root,
+			absolute: true,
+			ignore: exclude
+		});
+	});
+	return _collectWatchFiles.apply(this, arguments);
+}
+function resolveTsLikeImport(id, importer, options) {
+	var _options$extensions;
+	if (!importer) return null;
+	if (cleanUrl(id) !== id) return null;
+	const source = cleanUrl(id);
+	const from = cleanUrl(importer);
+	if (source.startsWith("\0") || from.startsWith("\0")) return null;
+	if (!source.startsWith(".") && !isAbsoluteImportPath(source)) return null;
+	if (path.extname(source)) return null;
+	if (options.extensions === false) return null;
+	const extensions = (_options$extensions = options.extensions) !== null && _options$extensions !== void 0 ? _options$extensions : [
+		".ts",
+		".tsx",
+		".mts",
+		".cts",
+		".js",
+		".jsx",
+		".mjs",
+		".cjs"
+	];
+	const base = isAbsoluteImportPath(source) ? source : path.resolve(path.dirname(from), source);
+	const candidates = [
+		base,
+		...extensions.map((ext) => `${base}${ext}`),
+		...extensions.map((ext) => path.join(base, `index${ext}`))
+	];
+	for (const file of candidates) if (fs.existsSync(file) && fs.statSync(file).isFile()) return file;
+	return null;
+}
+function isAbsoluteImportPath(id) {
+	return path.isAbsolute(id) || /^[a-zA-Z]:[\\/]/.test(id);
+}
+function emitOutputFile(pluginContext, file) {
+	if (file.type === "asset") {
+		pluginContext.emitFile({
+			type: "asset",
+			fileName: file.fileName,
+			source: file.source
+		});
+		return;
+	}
+	pluginContext.emitFile({
+		type: "chunk",
+		id: file.id,
+		fileName: file.fileName
+	});
+}
+function emitVirtualEntries(modules, pluginContext) {
+	for (const mod of modules) {
+		if (!mod.fileName) continue;
+		pluginContext.emitFile({
+			type: "chunk",
+			id: mod.id,
+			fileName: mod.fileName,
+			preserveSignature: "strict"
+		});
+	}
+}
+//#endregion
+//#region packages/web-c/bundler-plugin/src/external.ts
+function collectPluginExternals(options) {
+	var _options$plugins;
+	const set = /* @__PURE__ */ new Set();
+	for (const plugin of (_options$plugins = options.plugins) !== null && _options$plugins !== void 0 ? _options$plugins : []) {
+		var _plugin$external;
+		for (const dep of (_plugin$external = plugin.external) !== null && _plugin$external !== void 0 ? _plugin$external : []) set.add(dep);
+	}
+	return Array.from(set);
+}
+function mergeExternal(userExternal, pluginExternal) {
+	if (!userExternal) return pluginExternal;
+	if (typeof userExternal === "function") return (source, importer, isResolved) => {
+		return pluginExternal.includes(source) || userExternal(source, importer, isResolved);
+	};
+	return [...Array.isArray(userExternal) ? userExternal : [userExternal], ...pluginExternal];
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/objectWithoutPropertiesLoose.js
+function _objectWithoutPropertiesLoose(r, e) {
+	if (null == r) return {};
+	var t = {};
+	for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+		if (e.includes(n)) continue;
+		t[n] = r[n];
+	}
+	return t;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/objectWithoutProperties.js
+function _objectWithoutProperties(e, t) {
+	if (null == e) return {};
+	var o, r, i = _objectWithoutPropertiesLoose(e, t);
+	if (Object.getOwnPropertySymbols) {
+		var s = Object.getOwnPropertySymbols(e);
+		for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+	}
+	return i;
+}
+//#endregion
+//#region packages/web-c/bundler-plugin/src/rolldown.ts
+const _excluded = [
+	"zeus",
+	"plugins",
+	"input",
+	"output",
+	"external"
+];
+function zeus(options = {}) {
+	return createZeusBundlerPlugin(options, { target: "rolldown" });
+}
+function defineZeusRolldownConfig(config = {}) {
+	const { zeus: zeusOptions = {}, plugins, input, output, external } = config, rest = _objectWithoutProperties(config, _excluded);
+	const pluginExternals = collectPluginExternals(zeusOptions);
+	return _objectSpread2(_objectSpread2({ input: input !== null && input !== void 0 ? input : "src/index.ts" }, rest), {}, {
+		external: pluginExternals.length ? mergeExternal(external, pluginExternals) : external,
+		plugins: [zeus(zeusOptions), ...normalizePlugins(plugins)],
+		output: output !== null && output !== void 0 ? output : {
+			dir: "dist",
+			format: "esm",
+			sourcemap: true
+		}
+	});
+}
+function normalizePlugins(plugins) {
+	if (!plugins) return [];
+	return Array.isArray(plugins) ? plugins.filter(Boolean) : [plugins].filter(Boolean);
+}
+//#endregion
+export { zeus as default, zeus, defineZeusRolldownConfig };