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

package/dist/bundler-plugin.cjs.prod.js

@@ -0,0 +1,506 @@
+/**
+* bundler-plugin v0.1.0-beta.0
+* (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_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 _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(/[?#].*$/, "");
+}
+//#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/**"
+];
+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;
+}
+//#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/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 _compiler$moduleName;
+	const { id, code, compiler, sourcemap = true } = options;
+	const result = await (0, _babel_core.transformAsync)(code, {
+		filename: id,
+		sourceMaps: sourcemap,
+		plugins: [[_zeus_js_compiler.default, {
+			moduleName: (_compiler$moduleName = compiler === null || compiler === void 0 ? void 0 : compiler.moduleName) !== null && _compiler$moduleName !== void 0 ? _compiler$moduleName : "@zeus-js/runtime-dom",
+			generate: "dom",
+			hydratable: false,
+			delegateEvents: true,
+			...compiler
+		}]],
+		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/rollup.ts
+function createZeusPlugin(options = {}) {
+	let shouldTransform = (_id) => false;
+	const virtualModules = new VirtualModuleRegistry();
+	let ctx;
+	return {
+		name: "zeus-bundler-plugin",
+		async buildStart() {
+			var _options$components, _options$components2, _options$plugins;
+			virtualModules.clear();
+			const root = resolveRoot(options.root);
+			const include = resolveComponentInclude((_options$components = options.components) === null || _options$components === void 0 ? void 0 : _options$components.include);
+			const exclude = resolveComponentExclude((_options$components2 = options.components) === null || _options$components2 === void 0 ? void 0 : _options$components2.exclude);
+			shouldTransform = createComponentTransformFilter({
+				root,
+				include,
+				exclude
+			});
+			const dts = await resolveDts({
+				root,
+				mode: options.dts,
+				include,
+				exclude
+			});
+			const manifestResult = await createManifest(root, include, exclude);
+			for (const file of await collectWatchFiles(root, include, exclude)) 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"}`);
+			const outputs = createOutputRegistry();
+			ctx = {
+				root,
+				manifest: manifestResult.manifest,
+				diagnostics,
+				dts,
+				outputs,
+				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 resolved = virtualModules.resolve(id, importer);
+			if (resolved) return {
+				id: resolved,
+				moduleSideEffects: "no-treeshake"
+			};
+			return null;
+		},
+		load(id) {
+			return virtualModules.load(id);
+		},
+		async transform(code, id) {
+			if (!shouldTransform(id)) return null;
+			const result = await transformZeus({
+				id,
+				code,
+				compiler: options.compiler,
+				sourcemap: true
+			});
+			if (!result) return null;
+			return result;
+		},
+		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);
+			}
+		}
+	};
+}
+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 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 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/pluginOptions.ts
+function resolvePluginDts(value, ctx) {
+	if (value === true) return true;
+	if (value === false) return false;
+	return ctx.dts.enabled;
+}
+//#endregion
+//#region packages/web-c/bundler-plugin/src/vite.ts
+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
+exports.createOutputRegistry = createOutputRegistry;
+exports.createZeusPlugin = createZeusPlugin;
+exports.default = createZeusPlugin;
+exports.mergeExternal = mergeExternal;
+exports.resolveComponentExclude = resolveComponentExclude;
+exports.resolveComponentInclude = resolveComponentInclude;
+exports.resolvePluginDts = resolvePluginDts;
+exports.zeus = createZeusPlugin;

package/dist/bundler-plugin.d.ts

@@ -0,0 +1,130 @@
+import { CompilerOptions } from '@zeus-js/compiler';
+import { ComponentManifest, AnalyzerDiagnostic } from '@zeus-js/component-analyzer';
+import { ExternalOption, PluginContext, OutputBundle, Plugin } from 'rollup';
+
+type MaybePromise<T> = T | Promise<T>;
+export type RollupExternalOption = ExternalOption;
+type RootOption = string | (() => string);
+export type ZeusOutputKind = 'wc' | 'react' | 'vue' | 'icons-react' | 'icons-vue' | 'icons-wc' | 'asset';
+export type DtsMode = boolean | 'auto';
+export interface ResolvedDts {
+    enabled: boolean;
+    mode: DtsMode;
+    reason: DtsAutoReason[];
+}
+export type DtsAutoReason = 'explicit-enabled' | 'explicit-disabled' | 'package-types-field' | 'typescript-dependency' | 'tsconfig' | 'typescript-source';
+export interface ZeusBuildContext {
+    root: string;
+    manifest: ComponentManifest;
+    diagnostics: AnalyzerDiagnostic[];
+    dts: ResolvedDts;
+    outputs: ZeusOutputRegistry;
+    emitFile: PluginContext['emitFile'];
+    warn: PluginContext['warn'];
+    error: PluginContext['error'];
+    addWatchFile: PluginContext['addWatchFile'];
+    meta: {
+        watchMode: boolean;
+    };
+}
+export interface ZeusOutputRegistry {
+    register(kind: ZeusOutputKind, options: ZeusOutputRegistration): void;
+    has(kind: ZeusOutputKind): boolean;
+    get(kind: ZeusOutputKind): RequiredZeusOutputRegistration;
+    getDir(kind: ZeusOutputKind): string;
+    getFileName(kind: ZeusOutputKind, tag: string): string;
+    join(kind: ZeusOutputKind, fileName: string): string;
+}
+export interface ZeusOutputRegistration {
+    outDir?: string;
+    stripPrefix?: string | false;
+    fileName?: (tag: string, kind: ZeusOutputKind) => string;
+}
+export interface RequiredZeusOutputRegistration {
+    outDir: string;
+    stripPrefix: string | false;
+    fileName?: (tag: string, kind: ZeusOutputKind) => string;
+}
+export interface ZeusVirtualModule {
+    id: string;
+    code: string;
+    fileName?: string;
+}
+export interface ZeusOutputAsset {
+    type: 'asset';
+    fileName: string;
+    source: string | Uint8Array;
+}
+export interface ZeusOutputChunk {
+    type: 'chunk';
+    id: string;
+    fileName?: string;
+}
+export type ZeusOutputFile = ZeusOutputAsset | ZeusOutputChunk;
+export interface ZeusComponentPlugin {
+    name: string;
+    /**
+     * Register output dirs / externals / plugin metadata.
+     *
+     * This hook runs before virtualModules().
+     */
+    setup?(ctx: ZeusBuildContext): void | Promise<void>;
+    buildStart?(ctx: ZeusBuildContext): MaybePromise<void>;
+    virtualModules?(ctx: ZeusBuildContext): MaybePromise<ZeusVirtualModule[] | void>;
+    generateBundle?(ctx: ZeusBuildContext, bundle: OutputBundle): MaybePromise<ZeusOutputFile[] | void>;
+    /**
+     * Vite adapter can use this to auto externalize framework deps.
+     */
+    external?: string[];
+}
+export interface ZeusBundlerPluginOptions {
+    /**
+     * Project root.
+     *
+     * @default
+     * - Vite: resolved config.root
+     * - Rollup/Rolldown: process.cwd()
+     */
+    root?: RootOption;
+    /**
+     * Component source scan options.
+     * See DEFAULT_COMPONENT_INCLUDE and DEFAULT_COMPONENT_EXCLUDE in defaults.ts.
+     */
+    components?: {
+        include?: string[];
+        exclude?: string[];
+    };
+    /**
+     * Declaration generation mode.
+     *
+     * @default 'auto'
+     */
+    dts?: DtsMode;
+    /**
+     * Compiler options.
+     */
+    compiler?: Partial<CompilerOptions>;
+    /**
+     * Print analyzer diagnostics.
+     *
+     * @default true
+     */
+    diagnostics?: boolean | 'verbose';
+    /**
+     * Component-host plugins.
+     */
+    plugins?: ZeusComponentPlugin[];
+}
+
+export declare function createZeusPlugin(options?: ZeusBundlerPluginOptions): Plugin;
+
+export declare function createOutputRegistry(): ZeusOutputRegistry;
+
+export declare function resolveComponentInclude(include?: string[]): string[];
+export declare function resolveComponentExclude(exclude?: string[]): string[];
+
+export declare function resolvePluginDts(value: DtsMode | undefined, ctx: ZeusBuildContext): boolean;
+
+export declare function mergeExternal(userExternal: RollupExternalOption | undefined, pluginExternal: string[]): RollupExternalOption;
+
+export { createZeusPlugin as default, createZeusPlugin as zeus };