rolldown 0.11.0 → 0.11.1

package/dist/shared/{utils_index-DAvBTBzR.mjs → utils_index-Xz4uA-99.mjs}

@@ -512,7 +512,7 @@ function noop(..._args) {}
 
 //#endregion
 //#region src/utils/transform-module-info.ts
-function transformModuleInfo(info) {
+function transformModuleInfo(info, option) {
 	return {
 		get ast() {
 			return unsupported('ModuleInfo#ast');
@@ -525,7 +525,8 @@ function transformModuleInfo(info) {
 		dynamicImporters: info.dynamicImporters,
 		importedIds: info.importedIds,
 		dynamicallyImportedIds: info.dynamicallyImportedIds,
-		isEntry: info.isEntry
+		isEntry: info.isEntry,
+		...option
 	};
 }
 
@@ -742,9 +743,7 @@ class PluginContext {
 	getModuleInfo;
 	getModuleIds;
 	parse;
-	modules = new Map();
-	moduleIds = null;
-	constructor(options, context, plugin) {
+	constructor(options, context, plugin, data) {
 		const onLog = options.onLog;
 		const pluginName = plugin.name || 'unknown';
 		const logLevel = options.logLevel;
@@ -765,45 +764,18 @@ class PluginContext {
 			});
 		};
 		this.getFileName = context.getFileName.bind(context);
-		this.getModuleInfo = (id) => {
-			if (this.modules.has(id)) {
-				return this.modules.get(id) ?? null;
-			}
-			const bindingInfo = context.getModuleInfo(id);
-			if (bindingInfo) {
-				const info = transformModuleInfo(bindingInfo);
-				this.modules.set(id, info);
-				return info;
-			}
-			return null;
-		};
-		this.getModuleIds = () => {
-			if (this.moduleIds) {
-				return this.moduleIds.values();
-			}
-			const moduleIds = context.getModuleIds();
-			if (moduleIds) {
-				this.moduleIds = moduleIds;
-				return moduleIds.values();
-			}
-			return [].values();
-		};
+		this.getModuleInfo = (id) => data.getModuleInfo(id, context);
+		this.getModuleIds = () => data.getModuleIds(context);
 		this.parse = unsupported('`PluginContext#parse` is not supported by rolldown.');
 	}
 }
 
 //#endregion
 //#region src/plugin/transfrom-plugin-context.ts
-class TransformPluginContext {
-	debug;
-	info;
-	warn;
+class TransformPluginContext extends PluginContext {
 	error;
-	resolve;
-	emitFile;
-	getFileName;
-	parse;
-	constructor(inner, context, moduleId, moduleSource) {
+	constructor(options, context, plugin, data, inner, moduleId, moduleSource) {
+		super(options, context, plugin, data);
 		const getLogHandler$1 = (handler) => (log, pos) => {
 			log = normalizeLog(log);
 			if (pos) augmentCodeLocation(log, pos, moduleSource, moduleId);
@@ -811,20 +783,16 @@ class TransformPluginContext {
 			log.hook = 'transform';
 			handler(log);
 		};
-		this.debug = getLogHandler$1(context.debug);
-		this.warn = getLogHandler$1(context.warn);
-		this.info = getLogHandler$1(context.info);
+		this.debug = getLogHandler$1(this.debug);
+		this.warn = getLogHandler$1(this.warn);
+		this.info = getLogHandler$1(this.info);
 		this.error = (error$1, pos) => {
 			if (typeof error$1 === 'string') error$1 = {message: error$1};
 			if (pos) augmentCodeLocation(error$1, pos, moduleSource, moduleId);
 			error$1.id = moduleId;
 			error$1.hook = 'transform';
-			return context.error(error$1);
+			return this.error(error$1);
 		};
-		this.resolve = context.resolve;
-		this.parse = context.parse;
-		this.emitFile = context.emitFile;
-		this.getFileName = context.getFileName;
 	}
 }
 
@@ -844,34 +812,34 @@ function bindingifySideEffects(sideEffects) {
 
 //#endregion
 //#region src/plugin/bindingify-build-hooks.ts
-function bindingifyBuildStart(plugin, options) {
+function bindingifyBuildStart(plugin, options, pluginContextData) {
 	const hook = plugin.buildStart;
 	if (!hook) {
 		return undefined;
 	}
 	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
 	return async (ctx) => {
-		await handler.call(new PluginContext(options, ctx, plugin), options);
+		await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), options);
 	};
 }
-function bindingifyBuildEnd(plugin, options) {
+function bindingifyBuildEnd(plugin, options, pluginContextData) {
 	const hook = plugin.buildEnd;
 	if (!hook) {
 		return undefined;
 	}
 	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
 	return async (ctx, err) => {
-		await handler.call(new PluginContext(options, ctx, plugin), err ? new Error(err) : undefined);
+		await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), err ? new Error(err) : undefined);
 	};
 }
-function bindingifyResolveId(plugin, options) {
+function bindingifyResolveId(plugin, options, pluginContextData) {
 	const hook = plugin.resolveId;
 	if (!hook) {
 		return undefined;
 	}
 	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
 	return async (ctx, specifier, importer, extraOptions) => {
-		const ret = await handler.call(new PluginContext(options, ctx, plugin), specifier, importer ?? undefined, extraOptions);
+		const ret = await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), specifier, importer ?? undefined, extraOptions);
 		if (ret == false || ret == null) {
 			return;
 		}
@@ -885,17 +853,21 @@ function bindingifyResolveId(plugin, options) {
 		if (ret.moduleSideEffects !== null) {
 			result.sideEffects = bindingifySideEffects(ret.moduleSideEffects);
 		}
+		pluginContextData.updateModuleOption(ret.id, {
+			meta: ret.meta || {},
+			moduleSideEffects: ret.moduleSideEffects || null
+		});
 		return result;
 	};
 }
-function bindingifyResolveDynamicImport(plugin, options) {
+function bindingifyResolveDynamicImport(plugin, options, pluginContextData) {
 	const hook = plugin.resolveDynamicImport;
 	if (!hook) {
 		return undefined;
 	}
 	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
 	return async (ctx, specifier, importer) => {
-		const ret = await handler.call(new PluginContext(options, ctx, plugin), specifier, importer ?? undefined);
+		const ret = await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), specifier, importer ?? undefined);
 		if (ret == false || ret == null) {
 			return;
 		}
@@ -909,23 +881,31 @@ function bindingifyResolveDynamicImport(plugin, options) {
 		if (ret.moduleSideEffects !== null) {
 			result.sideEffects = bindingifySideEffects(ret.moduleSideEffects);
 		}
+		pluginContextData.updateModuleOption(ret.id, {
+			meta: ret.meta || {},
+			moduleSideEffects: ret.moduleSideEffects || null
+		});
 		return result;
 	};
 }
-function bindingifyTransform(plugin, options) {
+function bindingifyTransform(plugin, options, pluginContextData) {
 	const hook = plugin.transform;
 	if (!hook) {
 		return undefined;
 	}
 	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
 	return async (ctx, code, id) => {
-		const ret = await handler.call(new TransformPluginContext(ctx, new PluginContext(options, ctx.inner(), plugin), id, code), code, id);
+		const ret = await handler.call(new TransformPluginContext(options, ctx.inner(), plugin, pluginContextData, ctx, id, code), code, id);
 		if (ret == null) {
 			return undefined;
 		}
 		if (typeof ret === 'string') {
 			return {code: ret};
 		}
+		pluginContextData.updateModuleOption(id, {
+			meta: ret.meta || {},
+			moduleSideEffects: ret.moduleSideEffects || null
+		});
 		return {
 			code: ret.code,
 			map: bindingifySourcemap$1(ret.map),
@@ -933,14 +913,14 @@ function bindingifyTransform(plugin, options) {
 		};
 	};
 }
-function bindingifyLoad(plugin, options) {
+function bindingifyLoad(plugin, options, pluginContextData) {
 	const hook = plugin.load;
 	if (!hook) {
 		return undefined;
 	}
 	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
 	return async (ctx, id) => {
-		const ret = await handler.call(new PluginContext(options, ctx, plugin), id);
+		const ret = await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), id);
 		if (ret == null) {
 			return;
 		}
@@ -963,40 +943,44 @@ function bindingifyLoad(plugin, options) {
 		if (ret.moduleSideEffects !== null) {
 			result.sideEffects = bindingifySideEffects(ret.moduleSideEffects);
 		}
+		pluginContextData.updateModuleOption(id, {
+			meta: ret.meta || {},
+			moduleSideEffects: ret.moduleSideEffects || null
+		});
 		return result;
 	};
 }
-function bindingifyModuleParsed(plugin, options) {
+function bindingifyModuleParsed(plugin, options, pluginContextData) {
 	const hook = plugin.moduleParsed;
 	if (!hook) {
 		return undefined;
 	}
 	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
 	return async (ctx, moduleInfo) => {
-		await handler.call(new PluginContext(options, ctx, plugin), transformModuleInfo(moduleInfo));
+		await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), transformModuleInfo(moduleInfo, pluginContextData.moduleOptionMap.get(moduleInfo.id)));
 	};
 }
 
 //#endregion
 //#region src/plugin/bindingify-output-hooks.ts
-function bindingifyRenderStart(plugin, options, outputOptions) {
+function bindingifyRenderStart(plugin, options, outputOptions, pluginContextData) {
 	const hook = plugin.renderStart;
 	if (!hook) {
 		return undefined;
 	}
 	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
 	return async (ctx) => {
-		handler.call(new PluginContext(options, ctx, plugin), outputOptions, options);
+		handler.call(new PluginContext(options, ctx, plugin, pluginContextData), outputOptions, options);
 	};
 }
-function bindingifyRenderChunk(plugin, options, outputOptions) {
+function bindingifyRenderChunk(plugin, options, outputOptions, pluginContextData) {
 	const hook = plugin.renderChunk;
 	if (!hook) {
 		return undefined;
 	}
 	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
 	return async (ctx, code, chunk) => {
-		const ret = await handler.call(new PluginContext(options, ctx, plugin), code, chunk, outputOptions);
+		const ret = await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), code, chunk, outputOptions);
 		if (ret == null) {
 			return;
 		}
@@ -1012,65 +996,108 @@ function bindingifyRenderChunk(plugin, options, outputOptions) {
 		};
 	};
 }
-function bindingifyAugmentChunkHash(plugin, options) {
+function bindingifyAugmentChunkHash(plugin, options, pluginContextData) {
 	const hook = plugin.augmentChunkHash;
 	if (!hook) {
 		return undefined;
 	}
 	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
 	return async (ctx, chunk) => {
-		return await handler.call(new PluginContext(options, ctx, plugin), chunk);
+		return await handler.call(new PluginContext(options, ctx, plugin, pluginContextData), chunk);
 	};
 }
-function bindingifyRenderError(plugin, options) {
+function bindingifyRenderError(plugin, options, pluginContextData) {
 	const hook = plugin.renderError;
 	if (!hook) {
 		return undefined;
 	}
 	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
 	return async (ctx, err) => {
-		handler.call(new PluginContext(options, ctx, plugin), new Error(err));
+		handler.call(new PluginContext(options, ctx, plugin, pluginContextData), new Error(err));
 	};
 }
-function bindingifyGenerateBundle(plugin, options, outputOptions) {
+function bindingifyGenerateBundle(plugin, options, outputOptions, pluginContextData) {
 	const hook = plugin.generateBundle;
 	if (!hook) {
 		return undefined;
 	}
 	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
 	return async (ctx, bundle, isWrite) => {
-		handler.call(new PluginContext(options, ctx, plugin), outputOptions, transformToOutputBundle(bundle), isWrite);
+		handler.call(new PluginContext(options, ctx, plugin, pluginContextData), outputOptions, transformToOutputBundle(bundle), isWrite);
 	};
 }
-function bindingifyWriteBundle(plugin, options, outputOptions) {
+function bindingifyWriteBundle(plugin, options, outputOptions, pluginContextData) {
 	const hook = plugin.writeBundle;
 	if (!hook) {
 		return undefined;
 	}
 	const [handler, _optionsIgnoredSofar] = normalizeHook(hook);
 	return async (ctx, bundle) => {
-		handler.call(new PluginContext(options, ctx, plugin), outputOptions, transformToOutputBundle(bundle));
+		handler.call(new PluginContext(options, ctx, plugin, pluginContextData), outputOptions, transformToOutputBundle(bundle));
 	};
 }
 
+//#endregion
+//#region src/plugin/plugin-context-data.ts
+class PluginContextData {
+	modules = new Map();
+	moduleIds = null;
+	moduleOptionMap = new Map();
+	updateModuleOption(id, option) {
+		const existing = this.moduleOptionMap.get(id);
+		if (existing) {
+			Object.assign(existing, option);
+			if (option.meta != null) {
+				Object.assign(existing.meta, option.meta);
+			}
+		} else {
+			this.moduleOptionMap.set(id, option);
+		}
+	}
+	getModuleInfo(id, context) {
+		if (this.modules.has(id)) {
+			return this.modules.get(id) ?? null;
+		}
+		const bindingInfo = context.getModuleInfo(id);
+		if (bindingInfo) {
+			const info = transformModuleInfo(bindingInfo, this.moduleOptionMap.get(id));
+			this.modules.set(id, info);
+			return info;
+		}
+		return null;
+	}
+	getModuleIds(context) {
+		if (this.moduleIds) {
+			return this.moduleIds.values();
+		}
+		const moduleIds = context.getModuleIds();
+		if (moduleIds) {
+			this.moduleIds = moduleIds;
+			return moduleIds.values();
+		}
+		return [].values();
+	}
+}
+
 //#endregion
 //#region src/plugin/bindingify-plugin.ts
 function bindingifyPlugin(plugin, options, outputOptions) {
+	const pluginContextData = new PluginContextData();
 	return {
 		name: plugin.name ?? 'unknown',
-		buildStart: bindingifyBuildStart(plugin, options),
-		resolveId: bindingifyResolveId(plugin, options),
-		resolveDynamicImport: bindingifyResolveDynamicImport(plugin, options),
-		buildEnd: bindingifyBuildEnd(plugin, options),
-		transform: bindingifyTransform(plugin, options),
-		moduleParsed: bindingifyModuleParsed(plugin, options),
-		load: bindingifyLoad(plugin, options),
-		renderChunk: bindingifyRenderChunk(plugin, options, outputOptions),
-		augmentChunkHash: bindingifyAugmentChunkHash(plugin, options),
-		renderStart: bindingifyRenderStart(plugin, options, outputOptions),
-		renderError: bindingifyRenderError(plugin, options),
-		generateBundle: bindingifyGenerateBundle(plugin, options, outputOptions),
-		writeBundle: bindingifyWriteBundle(plugin, options, outputOptions)
+		buildStart: bindingifyBuildStart(plugin, options, pluginContextData),
+		resolveId: bindingifyResolveId(plugin, options, pluginContextData),
+		resolveDynamicImport: bindingifyResolveDynamicImport(plugin, options, pluginContextData),
+		buildEnd: bindingifyBuildEnd(plugin, options, pluginContextData),
+		transform: bindingifyTransform(plugin, options, pluginContextData),
+		moduleParsed: bindingifyModuleParsed(plugin, options, pluginContextData),
+		load: bindingifyLoad(plugin, options, pluginContextData),
+		renderChunk: bindingifyRenderChunk(plugin, options, outputOptions, pluginContextData),
+		augmentChunkHash: bindingifyAugmentChunkHash(plugin, options, pluginContextData),
+		renderStart: bindingifyRenderStart(plugin, options, outputOptions, pluginContextData),
+		renderError: bindingifyRenderError(plugin, options, pluginContextData),
+		generateBundle: bindingifyGenerateBundle(plugin, options, outputOptions, pluginContextData),
+		writeBundle: bindingifyWriteBundle(plugin, options, outputOptions, pluginContextData)
 	};
 }
 
@@ -1401,14 +1428,15 @@ function normalizeTreeshakeOptions(config) {
 	if (config === true || config === undefined) {
 		return {moduleSideEffects: 'true'};
 	}
+	let normalizedConfig = {moduleSideEffects: ''};
 	if (config.moduleSideEffects === undefined) {
-		config.moduleSideEffects = 'true';
+		normalizedConfig.moduleSideEffects = 'true';
 	} else if (isRegExp(config.moduleSideEffects)) {
-		config.moduleSideEffects = config.moduleSideEffects.source;
+		normalizedConfig.moduleSideEffects = config.moduleSideEffects.source;
 	} else {
-		config.moduleSideEffects = config.moduleSideEffects.toString();
+		normalizedConfig.moduleSideEffects = config.moduleSideEffects.toString();
 	}
-	return config;
+	return normalizedConfig;
 }
 
 //#endregion

package/dist/types/binding.d.ts

@@ -1,12 +1,12 @@
 type MaybePromise<T> = T | Promise<T>
 type Nullable<T> = T | null | undefined
 type VoidNullable<T = void> = T | null | undefined | void
-export class BindingLog {
+export declare class BindingLog {
   code: string
   message: string
 }
 
-export class BindingModuleInfo {
+export declare class BindingModuleInfo {
   id: string
   importers: Array<string>
   dynamicImporters: Array<string>
@@ -16,13 +16,13 @@ export class BindingModuleInfo {
   get code(): string | null
 }
 
-export class BindingOutputAsset {
+export declare class BindingOutputAsset {
   get fileName(): string
   get source(): BindingAssetSource
   set source(source: BindingAssetSource)
 }
 
-export class BindingOutputChunk {
+export declare class BindingOutputChunk {
   get isEntry(): boolean
   get isDynamicEntry(): boolean
   get facadeModuleId(): string | null
@@ -43,13 +43,13 @@ export class BindingOutputChunk {
 }
 
 /** The `BindingOutputs` owner `Vec<Output>` the mutable reference, it avoid `Clone` at call `writeBundle/generateBundle` hook, and make it mutable. */
-export class BindingOutputs {
+export declare class BindingOutputs {
   get chunks(): Array<BindingOutputChunk>
   get assets(): Array<BindingOutputAsset>
   delete(fileName: string): void
 }
 
-export class BindingPluginContext {
+export declare class BindingPluginContext {
   resolve(specifier: string, importer?: string | undefined | null, extraOptions?: BindingPluginContextResolveOptions | undefined | null): Promise<BindingPluginContextResolvedId | null>
   emitFile(file: BindingEmittedAsset): string
   getFileName(referenceId: string): string
@@ -57,11 +57,11 @@ export class BindingPluginContext {
   getModuleIds(): Array<string> | null
 }
 
-export class BindingTransformPluginContext {
+export declare class BindingTransformPluginContext {
   inner(): BindingPluginContext
 }
 
-export class Bundler {
+export declare class Bundler {
   constructor(inputOptions: BindingInputOptions, outputOptions: BindingOutputOptions, parallelPluginsRegistry?: ParallelJsPluginRegistry | undefined | null)
   write(): Promise<FinalBindingOutputs>
   generate(): Promise<FinalBindingOutputs>
@@ -72,12 +72,12 @@ export class Bundler {
  * The `FinalBindingOutputs` is used at `write()` or `generate()`, it is similar to `BindingOutputs`, if using `BindingOutputs` has unexpected behavior.
  * TODO find a way to export it gracefully.
  */
-export class FinalBindingOutputs {
+export declare class FinalBindingOutputs {
   get chunks(): Array<BindingOutputChunk>
   get assets(): Array<BindingOutputAsset>
 }
 
-export class ParallelJsPluginRegistry {
+export declare class ParallelJsPluginRegistry {
   id: number
   workerCount: number
   constructor(workerCount: number)
@@ -101,7 +101,7 @@ export interface BindingBuiltinPlugin {
   options?: unknown
 }
 
-export enum BindingBuiltinPluginName {
+export declare enum BindingBuiltinPluginName {
   WasmPlugin = 0,
   GlobImportPlugin = 1
 }
@@ -134,12 +134,18 @@ export interface BindingHookResolveIdOutput {
   sideEffects?: BindingHookSideEffects
 }
 
-export enum BindingHookSideEffects {
+export declare enum BindingHookSideEffects {
   True = 0,
   False = 1,
   NoTreeshake = 2
 }
 
+export interface BindingHookTransformOutput {
+  code?: string
+  sideEffects?: BindingHookSideEffects
+  map?: BindingSourcemap
+}
+
 export interface BindingInputItem {
   name?: string
   import: string
@@ -168,7 +174,7 @@ export interface BindingJsonSourcemap {
   names?: Array<string>
 }
 
-export enum BindingLogLevel {
+export declare enum BindingLogLevel {
   Silent = 0,
   Warn = 1,
   Info = 2,
@@ -205,7 +211,7 @@ export interface BindingPluginOptions {
   resolveId?: (ctx: BindingPluginContext, specifier: string, importer: Nullable<string>, options: BindingHookResolveIdExtraOptions) => MaybePromise<VoidNullable<BindingHookResolveIdOutput>>
   resolveDynamicImport?: (ctx: BindingPluginContext, specifier: string, importer: Nullable<string>) => MaybePromise<VoidNullable<BindingHookResolveIdOutput>>
   load?: (ctx: BindingPluginContext, id: string) => MaybePromise<VoidNullable<BindingHookLoadOutput>>
-  transform?: (ctx:  BindingTransformPluginContext, id: string, code: string) => MaybePromise<VoidNullable<BindingHookLoadOutput>>
+  transform?: (ctx:  BindingTransformPluginContext, id: string, code: string) => MaybePromise<VoidNullable<BindingHookTransformOutput>>
   moduleParsed?: (ctx: BindingPluginContext, module: BindingModuleInfo) => MaybePromise<VoidNullable>
   buildEnd?: (ctx: BindingPluginContext, error: Nullable<string>) => MaybePromise<VoidNullable>
   renderChunk?: (ctx: BindingPluginContext, code: string, chunk: RenderedChunk) => MaybePromise<VoidNullable<BindingHookRenderChunkOutput>>
@@ -251,7 +257,7 @@ export interface Es2015BindingOptions {
 }
 
 /** TypeScript Isolated Declarations for Standalone DTS Emit */
-function isolatedDeclaration(filename: string, sourceText: string): IsolatedDeclarationsResult
+export declare function isolatedDeclaration(filename: string, sourceText: string): IsolatedDeclarationsResult
 
 export interface IsolatedDeclarationsResult {
   sourceText: string
@@ -270,7 +276,7 @@ export interface ReactBindingOptions {
   useSpread?: boolean
 }
 
-function registerPlugins(id: number, plugins: Array<BindingPluginWithIndex>): void
+export declare function registerPlugins(id: number, plugins: Array<BindingPluginWithIndex>): void
 
 export interface RenderedChunk {
   name: string
@@ -294,9 +300,10 @@ export interface Sourcemap {
   names?: Array<string>
 }
 
-function transform(filename: string, sourceText: string, options?: TransformBindingOptions | undefined | null): TransformResult
+export declare function transform(filename: string, sourceText: string, options?: TransformOptions | undefined | null): TransformResult
 
-export interface TransformBindingOptions {
+export interface TransformOptions {
+  sourceType?: 'script' | 'module' | 'unambiguous' | undefined
   typescript?: TypeScriptBindingOptions
   react?: ReactBindingOptions
   es2015?: Es2015BindingOptions

package/dist/types/options/input-options.d.ts

@@ -56,7 +56,7 @@ declare const inputOptionsSchema: z.ZodObject<{
     logLevel: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"info">, z.ZodLiteral<"debug">]>, z.ZodLiteral<"warn">]>, z.ZodLiteral<"silent">]>>;
     onLog: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"info">, z.ZodLiteral<"debug">]>, z.ZodLiteral<"warn">]>, z.ZodAny, z.ZodFunction<z.ZodTuple<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"info">, z.ZodLiteral<"debug">]>, z.ZodLiteral<"warn">]>, z.ZodLiteral<"error">]>, z.ZodUnion<[z.ZodAny, z.ZodString]>], z.ZodUnknown>, z.ZodUnknown>], z.ZodUnknown>, z.ZodUnknown>>;
     onwarn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny, z.ZodFunction<z.ZodTuple<[z.ZodUnion<[z.ZodUnion<[z.ZodAny, z.ZodString]>, z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnion<[z.ZodAny, z.ZodString]>>]>], z.ZodUnknown>, z.ZodUnknown>], z.ZodUnknown>, z.ZodUnknown>>;
-    moduleTypes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"js">, z.ZodLiteral<"jsx">]>, z.ZodLiteral<"ts">]>, z.ZodLiteral<"tsx">]>, z.ZodLiteral<"empty">]>, z.ZodLiteral<"json">]>, z.ZodLiteral<"text">]>, z.ZodLiteral<"base64">]>, z.ZodLiteral<"binary">]>, z.ZodLiteral<"empty">]>>>;
+    moduleTypes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"js">, z.ZodLiteral<"jsx">]>, z.ZodLiteral<"ts">]>, z.ZodLiteral<"tsx">]>, z.ZodLiteral<"json">]>, z.ZodLiteral<"text">]>, z.ZodLiteral<"base64">]>, z.ZodLiteral<"dataurl">]>, z.ZodLiteral<"binary">]>, z.ZodLiteral<"empty">]>>>;
 }, "strict", z.ZodTypeAny, {
     input?: string | string[] | Record<string, string> | undefined;
     plugins?: RolldownPlugin[] | undefined;
@@ -82,7 +82,7 @@ declare const inputOptionsSchema: z.ZodObject<{
     logLevel?: "info" | "debug" | "warn" | "silent" | undefined;
     onLog?: ((args_0: "info" | "debug" | "warn", args_1: any, args_2: (args_0: "info" | "debug" | "warn" | "error", args_1: any, ...args_2: unknown[]) => unknown, ...args_3: unknown[]) => unknown) | undefined;
     onwarn?: ((args_0: any, args_1: (args_0: any, ...args_1: unknown[]) => unknown, ...args_2: unknown[]) => unknown) | undefined;
-    moduleTypes?: Record<string, "js" | "jsx" | "ts" | "tsx" | "empty" | "json" | "text" | "base64" | "binary"> | undefined;
+    moduleTypes?: Record<string, "js" | "jsx" | "ts" | "tsx" | "json" | "text" | "base64" | "dataurl" | "binary" | "empty"> | undefined;
 }, {
     input?: string | string[] | Record<string, string> | undefined;
     plugins?: RolldownPlugin[] | undefined;
@@ -108,7 +108,7 @@ declare const inputOptionsSchema: z.ZodObject<{
     logLevel?: "info" | "debug" | "warn" | "silent" | undefined;
     onLog?: ((args_0: "info" | "debug" | "warn", args_1: any, args_2: (args_0: "info" | "debug" | "warn" | "error", args_1: any, ...args_2: unknown[]) => unknown, ...args_3: unknown[]) => unknown) | undefined;
     onwarn?: ((args_0: any, args_1: (args_0: any, ...args_1: unknown[]) => unknown, ...args_2: unknown[]) => unknown) | undefined;
-    moduleTypes?: Record<string, "js" | "jsx" | "ts" | "tsx" | "empty" | "json" | "text" | "base64" | "binary"> | undefined;
+    moduleTypes?: Record<string, "js" | "jsx" | "ts" | "tsx" | "json" | "text" | "base64" | "dataurl" | "binary" | "empty"> | undefined;
 }>;
 export type InputOption = z.infer<typeof inputOptionSchema>;
 export type ExternalOption = z.infer<typeof externalSchema>;

package/dist/types/options/normalized-input-options.d.ts

@@ -3,7 +3,7 @@ import type { InputOptions } from './input-options';
 import type { RolldownPlugin } from '../plugin';
 import type { LogLevel } from '../log/logging';
 import { NormalizedTreeshakingOptions } from '../../src/treeshake';
-export interface NormalizedInputOptions extends InputOptions {
+export interface NormalizedInputOptions extends Omit<InputOptions, 'treeshake'> {
     input: RollupNormalizedInputOptions['input'];
     plugins: RolldownPlugin[];
     onLog: (level: LogLevel, log: RollupLog) => void;

package/dist/types/plugin/bindingify-build-hooks.d.ts

@@ -1,10 +1,11 @@
 import type { BindingPluginOptions } from '../binding';
 import type { Plugin } from './index';
 import { NormalizedInputOptions } from '../options/normalized-input-options';
-export declare function bindingifyBuildStart(plugin: Plugin, options: NormalizedInputOptions): BindingPluginOptions['buildStart'];
-export declare function bindingifyBuildEnd(plugin: Plugin, options: NormalizedInputOptions): BindingPluginOptions['buildEnd'];
-export declare function bindingifyResolveId(plugin: Plugin, options: NormalizedInputOptions): BindingPluginOptions['resolveId'];
-export declare function bindingifyResolveDynamicImport(plugin: Plugin, options: NormalizedInputOptions): BindingPluginOptions['resolveDynamicImport'];
-export declare function bindingifyTransform(plugin: Plugin, options: NormalizedInputOptions): BindingPluginOptions['transform'];
-export declare function bindingifyLoad(plugin: Plugin, options: NormalizedInputOptions): BindingPluginOptions['load'];
-export declare function bindingifyModuleParsed(plugin: Plugin, options: NormalizedInputOptions): BindingPluginOptions['moduleParsed'];
+import { PluginContextData } from './plugin-context-data';
+export declare function bindingifyBuildStart(plugin: Plugin, options: NormalizedInputOptions, pluginContextData: PluginContextData): BindingPluginOptions['buildStart'];
+export declare function bindingifyBuildEnd(plugin: Plugin, options: NormalizedInputOptions, pluginContextData: PluginContextData): BindingPluginOptions['buildEnd'];
+export declare function bindingifyResolveId(plugin: Plugin, options: NormalizedInputOptions, pluginContextData: PluginContextData): BindingPluginOptions['resolveId'];
+export declare function bindingifyResolveDynamicImport(plugin: Plugin, options: NormalizedInputOptions, pluginContextData: PluginContextData): BindingPluginOptions['resolveDynamicImport'];
+export declare function bindingifyTransform(plugin: Plugin, options: NormalizedInputOptions, pluginContextData: PluginContextData): BindingPluginOptions['transform'];
+export declare function bindingifyLoad(plugin: Plugin, options: NormalizedInputOptions, pluginContextData: PluginContextData): BindingPluginOptions['load'];
+export declare function bindingifyModuleParsed(plugin: Plugin, options: NormalizedInputOptions, pluginContextData: PluginContextData): BindingPluginOptions['moduleParsed'];

package/dist/types/plugin/bindingify-output-hooks.d.ts

@@ -2,9 +2,10 @@ import type { BindingPluginOptions } from '../binding';
 import type { NormalizedInputOptions } from '../options/normalized-input-options';
 import type { Plugin } from './index';
 import { NormalizedOutputOptions } from '../options/normalized-output-options';
-export declare function bindingifyRenderStart(plugin: Plugin, options: NormalizedInputOptions, outputOptions: NormalizedOutputOptions): BindingPluginOptions['renderStart'];
-export declare function bindingifyRenderChunk(plugin: Plugin, options: NormalizedInputOptions, outputOptions: NormalizedOutputOptions): BindingPluginOptions['renderChunk'];
-export declare function bindingifyAugmentChunkHash(plugin: Plugin, options: NormalizedInputOptions): BindingPluginOptions['augmentChunkHash'];
-export declare function bindingifyRenderError(plugin: Plugin, options: NormalizedInputOptions): BindingPluginOptions['renderError'];
-export declare function bindingifyGenerateBundle(plugin: Plugin, options: NormalizedInputOptions, outputOptions: NormalizedOutputOptions): BindingPluginOptions['generateBundle'];
-export declare function bindingifyWriteBundle(plugin: Plugin, options: NormalizedInputOptions, outputOptions: NormalizedOutputOptions): BindingPluginOptions['writeBundle'];
+import { PluginContextData } from './plugin-context-data';
+export declare function bindingifyRenderStart(plugin: Plugin, options: NormalizedInputOptions, outputOptions: NormalizedOutputOptions, pluginContextData: PluginContextData): BindingPluginOptions['renderStart'];
+export declare function bindingifyRenderChunk(plugin: Plugin, options: NormalizedInputOptions, outputOptions: NormalizedOutputOptions, pluginContextData: PluginContextData): BindingPluginOptions['renderChunk'];
+export declare function bindingifyAugmentChunkHash(plugin: Plugin, options: NormalizedInputOptions, pluginContextData: PluginContextData): BindingPluginOptions['augmentChunkHash'];
+export declare function bindingifyRenderError(plugin: Plugin, options: NormalizedInputOptions, pluginContextData: PluginContextData): BindingPluginOptions['renderError'];
+export declare function bindingifyGenerateBundle(plugin: Plugin, options: NormalizedInputOptions, outputOptions: NormalizedOutputOptions, pluginContextData: PluginContextData): BindingPluginOptions['generateBundle'];
+export declare function bindingifyWriteBundle(plugin: Plugin, options: NormalizedInputOptions, outputOptions: NormalizedOutputOptions, pluginContextData: PluginContextData): BindingPluginOptions['writeBundle'];