@zeus-js/bundler-plugin 0.1.0-beta.1 → 0.1.0-beta.3

package/dist/rolldown.cjs.js

@@ -0,0 +1,691 @@
+/**
+* bundler-plugin v0.1.0-beta.3
+* (c) 2026 baicie
+* Released under the MIT License.
+**/
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#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 node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let _zeus_js_component_analyzer = require("@zeus-js/component-analyzer");
+let fast_glob = require("fast-glob");
+fast_glob = __toESM(fast_glob, 1);
+let picomatch = require("picomatch");
+picomatch = __toESM(picomatch, 1);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises, 1);
+let _babel_core = require("@babel/core");
+let _babel_preset_typescript = require("@babel/preset-typescript");
+_babel_preset_typescript = __toESM(_babel_preset_typescript, 1);
+let _zeus_js_compiler = require("@zeus-js/compiler");
+_zeus_js_compiler = __toESM(_zeus_js_compiler, 1);
+//#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 = (0, picomatch.default)(options.include);
+	const isExcluded = (0, picomatch.default)(options.exclude);
+	return function shouldTransform(id) {
+		const clean = normalizePath$1(cleanUrl(id));
+		const relative = normalizePath$1(node_path.default.relative(options.root, clean));
+		if (relative.startsWith("..") || node_path.default.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 packages/web-c/bundler-plugin/src/dts.ts
+async function resolveDts(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 (await packageDeclaresTypes(options.root)) reason.push("package-types-field");
+	if (await hasTypeScriptDependency(options.root)) reason.push("typescript-dependency");
+	if (await fileExists(node_path.default.join(options.root, "tsconfig.json"))) reason.push("tsconfig");
+	if (await hasTypeScriptSource({
+		root: options.root,
+		include: options.include,
+		exclude: options.exclude
+	})) reason.push("typescript-source");
+	return {
+		enabled: reason.length > 0,
+		mode,
+		reason
+	};
+}
+async function hasTypeScriptDependency(root) {
+	const pkg = await readPackageJson(root);
+	if (!pkg) return false;
+	const deps = {
+		...pkg.dependencies,
+		...pkg.devDependencies,
+		...pkg.peerDependencies,
+		...pkg.optionalDependencies
+	};
+	return Boolean(deps.typescript);
+}
+async function packageDeclaresTypes(root) {
+	const pkg = await readPackageJson(root);
+	if (!pkg) return false;
+	if (pkg.types || pkg.typings) return true;
+	return hasTypesInExports(pkg.exports);
+}
+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);
+}
+async function hasTypeScriptSource(options) {
+	return (await (0, fast_glob.default)(options.include, {
+		cwd: options.root,
+		onlyFiles: true,
+		absolute: false,
+		ignore: options.exclude
+	})).some((file) => file.endsWith(".ts") || file.endsWith(".tsx"));
+}
+async function readPackageJson(root) {
+	try {
+		return JSON.parse(await node_fs_promises.default.readFile(node_path.default.join(root, "package.json"), "utf-8"));
+	} catch {
+		return null;
+	}
+}
+async function fileExists(file) {
+	try {
+		await node_fs_promises.default.access(file);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region packages/web-c/bundler-plugin/src/external.ts
+const ZEUS_LIBRARY_EXTERNALS = [/^@zeus-js\//];
+function collectPluginExternals(options, collectOptions = {}) {
+	var _options$plugins;
+	const entries = [];
+	if (collectOptions.includeZeusLibraryExternals) entries.push(...ZEUS_LIBRARY_EXTERNALS);
+	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 : []) entries.push(dep);
+	}
+	return uniqueExternalEntries(entries);
+}
+function mergeExternal(userExternal, pluginExternal) {
+	if (!userExternal) return pluginExternal;
+	if (typeof userExternal === "function") return (source, importer, isResolved) => {
+		return matchesExternal(source, pluginExternal) || userExternal(source, importer, isResolved);
+	};
+	return uniqueExternalEntries([...Array.isArray(userExternal) ? userExternal : [userExternal], ...pluginExternal]);
+}
+function matchesExternal(source, entries) {
+	return entries.some((entry) => {
+		return typeof entry === "string" ? entry === source : entry.test(source);
+	});
+}
+function uniqueExternalEntries(entries) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const entry of entries) {
+		const key = typeof entry === "string" ? `s:${entry}` : `r:${entry.source}/${entry.flags}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		result.push(entry);
+	}
+	return result;
+}
+//#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 node_path.default.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
+async function transformZeus(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 = await (0, _babel_core.transformAsync)(code, {
+		filename: id,
+		sourceMaps: sourcemap,
+		plugins: shouldRunCompiler ? [[_zeus_js_compiler.default, {
+			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 ? [[_babel_preset_typescript.default, {
+			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
+	};
+}
+//#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 = node_path.default.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(node_path.default.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 = node_path.default.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 cleanedOutputDirs = /* @__PURE__ */ new Set();
+	const virtualModules = new VirtualModuleRegistry();
+	return {
+		name: resolvePluginName(target),
+		options(inputOptions) {
+			if (target === "vite") return null;
+			const pluginExternals = collectPluginExternals(options, { includeZeusLibraryExternals: true });
+			if (!pluginExternals.length) return null;
+			return {
+				...inputOptions,
+				external: mergeExternal(inputOptions.external, pluginExternals)
+			};
+		},
+		outputOptions(outputOptions) {
+			if (target === "vite") return null;
+			cleanOutputDir(outputOptions, {
+				root: resolveRoot(options.root),
+				enabled: options.clean !== false,
+				cleanedOutputDirs
+			});
+			if (outputOptions.chunkFileNames) return null;
+			return {
+				...outputOptions,
+				chunkFileNames: "chunks/[name]-[hash].js"
+			};
+		},
+		async buildStart() {
+			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 = await resolveDts({
+				root,
+				mode: options.dts,
+				include: componentInclude,
+				exclude: componentExclude
+			});
+			const manifestResult = await createManifest(root, componentInclude, componentExclude);
+			for (const file of await 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;
+				await ((_plugin$setup = plugin.setup) === null || _plugin$setup === void 0 ? void 0 : _plugin$setup.call(plugin, ctx));
+			}
+			for (const plugin of plugins) {
+				var _plugin$buildStart;
+				await ((_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 = await ((_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"
+			};
+			const cleanImporter = importer === null || importer === void 0 ? void 0 : importer.replace(/^\x00/, "");
+			if ((cleanImporter === null || cleanImporter === void 0 ? void 0 : cleanImporter.startsWith("zeus:")) && (id.startsWith("./") || id.startsWith("../"))) {
+				const virtualEntryId = resolveVirtualEntryImport(id, cleanImporter);
+				if (virtualEntryId && virtualModules.has(virtualEntryId)) return {
+					id: "\0" + virtualEntryId,
+					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);
+		},
+		async transform(code, id) {
+			const shouldRunZeus = shouldCompileZeus(id);
+			const shouldStripTs = resolveTranspile(options.transpile, target) && isTypeScriptLike(id);
+			if (!shouldRunZeus && !shouldStripTs) return null;
+			return await transformZeus({
+				id,
+				code,
+				compiler: shouldRunZeus ? options.compiler : false,
+				sourcemap: true,
+				transpile: shouldStripTs
+			});
+		},
+		async generateBundle(_, bundle) {
+			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 = await ((_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(this, 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 node_path.default.resolve(root());
+	return node_path.default.resolve(root !== null && root !== void 0 ? root : process.cwd());
+}
+function cleanOutputDir(outputOptions, options) {
+	if (!options.enabled) return;
+	const outputDir = resolveOutputDir(outputOptions, options.root);
+	if (!outputDir || !isSafeCleanTarget(outputDir, options.root)) return;
+	if (options.cleanedOutputDirs.has(outputDir)) return;
+	options.cleanedOutputDirs.add(outputDir);
+	node_fs.default.rmSync(outputDir, {
+		recursive: true,
+		force: true
+	});
+}
+function resolveOutputDir(outputOptions, root) {
+	const dir = outputOptions.dir;
+	if (typeof dir === "string" && dir.length > 0) return node_path.default.resolve(root, dir);
+	const file = outputOptions.file;
+	if (typeof file === "string" && file.length > 0) return node_path.default.dirname(node_path.default.resolve(root, file));
+	return node_path.default.resolve(root, "dist");
+}
+function isSafeCleanTarget(outputDir, root) {
+	const resolvedRoot = node_path.default.resolve(root);
+	const resolvedOutputDir = node_path.default.resolve(outputDir);
+	if (resolvedOutputDir === resolvedRoot) return false;
+	const relative = node_path.default.relative(resolvedRoot, resolvedOutputDir);
+	return Boolean(relative) && !relative.startsWith("..") && !node_path.default.isAbsolute(relative);
+}
+async function createManifest(root, include, exclude) {
+	if (!include.length) return {
+		manifest: {
+			version: 1,
+			components: []
+		},
+		diagnostics: []
+	};
+	return await (0, _zeus_js_component_analyzer.analyzeComponents)({
+		root,
+		include,
+		exclude
+	});
+}
+async function collectWatchFiles(root, include, exclude) {
+	if (!include.length) return [];
+	return await (0, fast_glob.default)(include, {
+		cwd: root,
+		absolute: true,
+		ignore: exclude
+	});
+}
+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 (node_path.default.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 : node_path.default.resolve(node_path.default.dirname(from), source);
+	const candidates = [
+		base,
+		...extensions.map((ext) => `${base}${ext}`),
+		...extensions.map((ext) => node_path.default.join(base, `index${ext}`))
+	];
+	for (const file of candidates) if (node_fs.default.existsSync(file) && node_fs.default.statSync(file).isFile()) return file;
+	return null;
+}
+function isAbsoluteImportPath(id) {
+	return node_path.default.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"
+		});
+	}
+}
+function resolveVirtualEntryImport(id, importer) {
+	const tagName = id.replace(/\.js$/, "").replace(/^\.\//, "").replace(/\.entry$/, "");
+	const lastColon = importer.lastIndexOf(":");
+	if (lastColon <= 0) return null;
+	return `${importer.slice(0, lastColon + 1)}entry:${tagName}`;
+}
+//#endregion
+//#region packages/web-c/bundler-plugin/src/rolldown.ts
+function zeus(options = {}) {
+	return createZeusBundlerPlugin(options, { target: "rolldown" });
+}
+function defineZeusRolldownConfig(config = {}) {
+	const { zeus: zeusOptions = {}, plugins, input, output, external, ...rest } = config;
+	const pluginExternals = collectPluginExternals(zeusOptions, { includeZeusLibraryExternals: true });
+	return {
+		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",
+			chunkFileNames: "chunks/[name]-[hash].js",
+			sourcemap: true
+		}
+	};
+}
+function normalizePlugins(plugins) {
+	if (!plugins) return [];
+	return Array.isArray(plugins) ? plugins.filter(Boolean) : [plugins].filter(Boolean);
+}
+//#endregion
+exports.default = zeus;
+exports.zeus = zeus;
+exports.defineZeusRolldownConfig = defineZeusRolldownConfig;