@rolldown/browser 1.0.0-beta.7-commit.a0a7d95

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

@@ -0,0 +1,182 @@
+import type { PreRenderedChunk } from '../binding';
+import { RolldownOutputPluginOption } from '../plugin';
+import { SourcemapIgnoreListOption, SourcemapPathTransformOption } from '../types/misc';
+import { RenderedChunk } from '../types/rolldown-output';
+import type { StringOrRegExp } from '../types/utils';
+export type ModuleFormat = 'es' | 'cjs' | 'esm' | 'module' | 'commonjs' | 'iife' | 'umd' | 'experimental-app';
+export type AddonFunction = (chunk: RenderedChunk) => string | Promise<string>;
+export type ChunkFileNamesFunction = (chunkInfo: PreRenderedChunk) => string;
+export interface MinifyOptions {
+    mangle: boolean;
+    compress: boolean;
+    removeWhitespace: boolean;
+}
+export interface PreRenderedAsset {
+    names: string[];
+    originalFileNames: string[];
+    source: string | Uint8Array;
+    type: 'asset';
+}
+export type AssetFileNamesFunction = (chunkInfo: PreRenderedAsset) => string;
+export type GlobalsFunction = (name: string) => string;
+export type ESTarget = 'es6' | 'es2015' | 'es2016' | 'es2017' | 'es2018' | 'es2019' | 'es2020' | 'es2021' | 'es2022' | 'es2023' | 'es2024' | 'esnext';
+export interface OutputOptions {
+    dir?: string;
+    file?: string;
+    exports?: 'auto' | 'named' | 'default' | 'none';
+    hashCharacters?: 'base64' | 'base36' | 'hex';
+    /**
+     * Expected format of generated code.
+     * - `'es'`, `'esm'` and `'module'` are the same format, all stand for ES module.
+     * - `'cjs'` and `'commonjs'` are the same format, all stand for CommonJS module.
+     * - `'iife'` stands for [Immediately Invoked Function Expression](https://developer.mozilla.org/en-US/docs/Glossary/IIFE).
+     * - `'umd'` stands for [Universal Module Definition](https://github.com/umdjs/umd).
+     *
+     * @default 'esm'
+     */
+    format?: ModuleFormat;
+    sourcemap?: boolean | 'inline' | 'hidden';
+    sourcemapDebugIds?: boolean;
+    sourcemapIgnoreList?: boolean | SourcemapIgnoreListOption;
+    sourcemapPathTransform?: SourcemapPathTransformOption;
+    banner?: string | AddonFunction;
+    footer?: string | AddonFunction;
+    intro?: string | AddonFunction;
+    outro?: string | AddonFunction;
+    extend?: boolean;
+    esModule?: boolean | 'if-default-prop';
+    assetFileNames?: string | AssetFileNamesFunction;
+    entryFileNames?: string | ChunkFileNamesFunction;
+    chunkFileNames?: string | ChunkFileNamesFunction;
+    cssEntryFileNames?: string | ChunkFileNamesFunction;
+    cssChunkFileNames?: string | ChunkFileNamesFunction;
+    sanitizeFileName?: boolean | ((name: string) => string);
+    minify?: boolean | 'dce-only' | MinifyOptions;
+    name?: string;
+    globals?: Record<string, string> | GlobalsFunction;
+    externalLiveBindings?: boolean;
+    inlineDynamicImports?: boolean;
+    /**
+     * Allows you to do advanced chunking. Use it to reduce the number of common chunks or split out a chunk that hardly changes to obtain better caching.
+     */
+    advancedChunks?: {
+        /**
+         * - Type: `number`
+         *
+         * Global fallback of [`{group}.minSize`](#advancedchunks-groups-minsize), if it's not specified in the group.
+         */
+        minSize?: number;
+        /**
+         * - Type: `number`
+         *
+         * Global fallback of [`{group}.maxSize`](#advancedchunks-groups-maxsize), if it's not specified in the group.
+         */
+        maxSize?: number;
+        /**
+         * - Type: `number`
+         *
+         * Global fallback of [`{group}.maxModuleSize`](#advancedchunks-groups-maxmodulesize), if it's not specified in the group.
+         */
+        maxModuleSize?: number;
+        /**
+         * - Type: `number`
+         *
+         * Global fallback of [`{group}.minModuleSize`](#advancedchunks-groups-minmodulesize), if it's not specified in the group.
+         */
+        minModuleSize?: number;
+        /**
+         * - Type: `number`
+         *
+         * Global fallback of [`{group}.minShareCount`](#advancedchunks-groups-minsharecount), if it's not specified in the group.
+         */
+        minShareCount?: number;
+        /**
+         * Groups to be used for advanced chunking.
+         */
+        groups?: {
+            /**
+             * - Type: `string`
+             *
+             * Name of the group. It will be also used as the name of the chunk and replaced the `[name]` placeholder in the `chunkFileNames` option.
+             */
+            name: string;
+            /**
+             * - Type: `string | RegExp`
+             *
+             * Controls which modules are captured in this group.
+             *
+             * If `test` is a string, the module whose id contains the string will be captured.
+             * If `test` is a regular expression, the module whose id matches the regular expression will be captured.
+             * if `test` is empty, any module will be considered as matched.
+             */
+            test?: StringOrRegExp;
+            /**
+             * - Type: `number`
+             *
+             * Priority of the group. Group with higher priority will be chosen first to match modules and create chunks. When converting the group to a chunk, modules of that group will be removed from other groups.
+             *
+             * If two groups have the same priority, the group whose index is smaller will be chosen.
+             */
+            priority?: number;
+            /**
+             * - Type: `number`
+             * - Default: `0`
+             *
+             * Minimum size of the desired chunk. If accumulated size of captured modules is smaller than this value, this group will be ignored.s
+             */
+            minSize?: number;
+            /**
+             * - Type: `number`
+             * - Default: `1`
+             *
+             * Controls if a module should be captured based on how many entry chunks reference it.
+             */
+            minShareCount?: number;
+            /**
+             * - Type: `number`
+             * - Default: `Infinity`
+             *
+             * If final size of this group is larger than this value, this group will be spit into multiple groups that each has size closed to this value.
+             */
+            maxSize?: number;
+            /**
+             * - Type: `number`
+             * - Default: `Infinity`
+             *
+             * Controls a module could only be captured if its size is smaller or equal than this value.
+             */
+            maxModuleSize?: number;
+            /**
+             * - Type: `number`
+             * - Default: `0`
+             *
+             * Controls a module could only be captured if its size is larger or equal than this value.
+             */
+            minModuleSize?: number;
+        }[];
+    };
+    /**
+     * Control comments in the output.
+     *
+     * - `none`: no comments
+     * - `preserve-legal`: preserve comments that contain `@license`, `@preserve` or starts with `//!` `/*!`
+     */
+    comments?: 'none' | 'preserve-legal';
+    plugins?: RolldownOutputPluginOption;
+    polyfillRequire?: boolean;
+    target?: ESTarget;
+}
+interface OverwriteOutputOptionsForCli {
+    banner?: string;
+    footer?: string;
+    intro?: string;
+    outro?: string;
+    esModule?: boolean;
+    globals?: Record<string, string>;
+    advancedChunks?: {
+        minSize?: number;
+        minShareCount?: number;
+    };
+}
+export type OutputCliOptions = Omit<OutputOptions, keyof OverwriteOutputOptionsForCli | 'sourcemapIgnoreList' | 'sourcemapPathTransform'> & OverwriteOutputOptionsForCli;
+export {};

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

@@ -0,0 +1,5 @@
+import { InputOptions } from '../options/input-options';
+import { OutputOptions } from '../options/output-options';
+export interface WatchOptions extends InputOptions {
+    output?: OutputOptions | OutputOptions[];
+}

package/dist/types/parallel-plugin-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/parallel-plugin.d.ts

@@ -0,0 +1 @@
+export { type Context, defineParallelPluginImplementation, type ParallelPluginImplementation, } from './plugin/parallel-plugin-implementation';

package/dist/types/parse-ast-index.d.ts

@@ -0,0 +1,5 @@
+import { Program } from '@oxc-project/types';
+import type { ParseResult, ParserOptions } from './binding';
+export declare function parseAst(sourceText: string, options?: ParserOptions | undefined | null, filename?: string): Program;
+export declare function parseAstAsync(sourceText: string, options?: ParserOptions | undefined | null, filename?: string): Promise<Program>;
+export type { ParseResult, ParserOptions };

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

@@ -0,0 +1,10 @@
+import type { BindingGeneralHookFilter, BindingPluginOptions, BindingTransformHookFilter } from '../binding';
+import type { BindingifyPluginArgs } from './bindingify-plugin';
+import { PluginHookWithBindingExt } from './bindingify-plugin-hook-meta';
+export declare function bindingifyBuildStart(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['buildStart']>;
+export declare function bindingifyBuildEnd(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['buildEnd']>;
+export declare function bindingifyResolveId(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['resolveId'], BindingGeneralHookFilter | undefined>;
+export declare function bindingifyResolveDynamicImport(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['resolveDynamicImport']>;
+export declare function bindingifyTransform(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['transform'], BindingTransformHookFilter | undefined>;
+export declare function bindingifyLoad(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['load'], BindingGeneralHookFilter | undefined>;
+export declare function bindingifyModuleParsed(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['moduleParsed']>;

package/dist/types/plugin/bindingify-hook-filter.d.ts

@@ -0,0 +1,7 @@
+import type { BindingGeneralHookFilter, BindingTransformHookFilter } from '../binding.d';
+import type { HookFilterExtension } from '.';
+import type { StringFilter } from './hook-filter';
+export declare function bindingifyStringFilter(matcher: StringFilter): BindingGeneralHookFilter;
+export declare function bindingifyResolveIdFilter(filterOption?: HookFilterExtension<'resolveId'>['filter']): BindingGeneralHookFilter | undefined;
+export declare function bindingifyLoadFilter(filterOption?: HookFilterExtension<'load'>['filter']): BindingGeneralHookFilter | undefined;
+export declare function bindingifyTransformFilter(filterOption?: HookFilterExtension<'transform'>['filter']): BindingTransformHookFilter | undefined;

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

@@ -0,0 +1,14 @@
+import type { BindingPluginOptions } from '../binding';
+import type { BindingifyPluginArgs } from './bindingify-plugin';
+import { PluginHookWithBindingExt } from './bindingify-plugin-hook-meta';
+export declare function bindingifyRenderStart(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['renderStart']>;
+export declare function bindingifyRenderChunk(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['renderChunk']>;
+export declare function bindingifyAugmentChunkHash(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['augmentChunkHash']>;
+export declare function bindingifyRenderError(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['renderError']>;
+export declare function bindingifyGenerateBundle(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['generateBundle']>;
+export declare function bindingifyWriteBundle(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['writeBundle']>;
+export declare function bindingifyCloseBundle(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['closeBundle']>;
+export declare function bindingifyBanner(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['banner']>;
+export declare function bindingifyFooter(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['footer']>;
+export declare function bindingifyIntro(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['intro']>;
+export declare function bindingifyOutro(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['outro']>;

package/dist/types/plugin/bindingify-plugin-hook-meta.d.ts

@@ -0,0 +1,8 @@
+import { BindingPluginHookMeta } from '../binding';
+import { ObjectHookMeta } from '.';
+export declare function bindingifyPluginHookMeta(options: ObjectHookMeta): BindingPluginHookMeta;
+export type PluginHookWithBindingExt<T, F = undefined> = {
+    plugin?: T;
+    meta?: BindingPluginHookMeta;
+    filter?: F;
+};

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

@@ -0,0 +1,17 @@
+import type { BindingPluginOptions } from '../binding';
+import type { InputOptions } from '../options/input-options';
+import type { OutputOptions } from '../options/output-options';
+import type { LogHandler, LogLevelOption } from '../types/misc';
+import type { Plugin, RolldownPlugin } from './index';
+import { PluginContextData } from './plugin-context-data';
+export interface BindingifyPluginArgs {
+    plugin: Plugin;
+    options: InputOptions;
+    outputOptions: OutputOptions;
+    pluginContextData: PluginContextData;
+    onLog: LogHandler;
+    logLevel: LogLevelOption;
+    watchMode: boolean;
+    normalizedOutputPlugins: RolldownPlugin[];
+}
+export declare function bindingifyPlugin(plugin: Plugin, options: InputOptions, outputOptions: OutputOptions, pluginContextData: PluginContextData, normalizedOutputPlugins: RolldownPlugin[], onLog: LogHandler, logLevel: LogLevelOption, watchMode: boolean): BindingPluginOptions;

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

@@ -0,0 +1,5 @@
+import type { BindingPluginOptions } from '../binding';
+import { BindingifyPluginArgs } from './bindingify-plugin';
+import { PluginHookWithBindingExt } from './bindingify-plugin-hook-meta';
+export declare function bindingifyWatchChange(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['watchChange']>;
+export declare function bindingifyCloseWatcher(args: BindingifyPluginArgs): PluginHookWithBindingExt<BindingPluginOptions['closeWatcher']>;

package/dist/types/plugin/hook-filter.d.ts

@@ -0,0 +1,49 @@
+import type { ModuleType } from '../index';
+import type { MaybeArray } from '../types/utils';
+import type { StringOrRegExp } from '../types/utils';
+export type StringFilter<Value = StringOrRegExp> = MaybeArray<Value> | {
+    include?: MaybeArray<Value>;
+    exclude?: MaybeArray<Value>;
+};
+interface FormalModuleTypeFilter {
+    include?: ModuleType[];
+}
+export type ModuleTypeFilter = ModuleType[] | FormalModuleTypeFilter;
+export interface HookFilter {
+    /**
+     * This filter is used to do a pre-test to determine whether the hook should be called.
+     *
+     * @example
+     * Include all `id`s that contain `node_modules` in the path.
+     * ```js
+     * { id: 'node_modules' }
+     * ```
+     * @example
+     * Include all `id`s that contain `node_modules` or `src` in the path.
+     * ```js
+     * { id: ['node_modules', 'src'] }
+     * ```
+     * @example
+     * Include all `id`s that start with `http`
+     * ```js
+     * { id: /^http/ }
+     * ```
+     * @example
+     * Exclude all `id`s that contain `node_modules` in the path.
+     * ```js
+     * { id: { exclude: 'node_modules' } }
+     * ```
+     * @example
+     * Formal pattern to define includes and excludes.
+     * ```
+     * { id : {
+     *   include: ["foo", /bar/],
+     *   exclude: ["baz", /qux/]
+     * }}
+     * ```
+     */
+    id?: StringFilter;
+    moduleType?: ModuleTypeFilter;
+    code?: StringFilter;
+}
+export {};

package/dist/types/plugin/index.d.ts

@@ -0,0 +1,141 @@
+import type { InputOptions, OutputOptions } from '..';
+import type { BindingHookResolveIdExtraArgs, BindingTransformHookExtraArgs } from '../binding';
+import type { BuiltinPlugin } from '../builtin-plugin/constructors';
+import type { DefinedHookNames } from '../constants/plugin';
+import type { DEFINED_HOOK_NAMES } from '../constants/plugin';
+import type { SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF } from '../constants/plugin-context';
+import type { LogLevel } from '../log/logging';
+import type { NormalizedInputOptions } from '../options/normalized-input-options';
+import type { NormalizedOutputOptions } from '../options/normalized-output-options';
+import type { RollupLog } from '../types/misc';
+import type { ModuleInfo } from '../types/module-info';
+import type { OutputBundle } from '../types/output-bundle';
+import { RenderedChunk } from '../types/rolldown-output';
+import type { SourceMapInput } from '../types/sourcemap';
+import type { MakeAsync, MaybePromise, NullValue, PartialNull } from '../types/utils';
+import type { HookFilter, StringFilter } from './hook-filter';
+import type { MinimalPluginContext } from './minimal-plugin-context';
+import type { ParallelPlugin } from './parallel-plugin';
+import type { PluginContext } from './plugin-context';
+import type { TransformPluginContext } from './transform-plugin-context';
+export type ModuleSideEffects = boolean | 'no-treeshake' | null;
+export { withFilter } from './with-filter';
+export type ModuleType = 'js' | 'jsx' | 'ts' | 'tsx' | 'json' | 'text' | 'base64' | 'dataurl' | 'binary' | 'empty' | (string & {});
+export type ImportKind = BindingHookResolveIdExtraArgs['kind'];
+export interface CustomPluginOptions {
+    [plugin: string]: any;
+}
+export interface ModuleOptions {
+    moduleSideEffects: ModuleSideEffects;
+    meta: CustomPluginOptions;
+    invalidate?: boolean;
+}
+export interface ResolvedId extends ModuleOptions {
+    external: boolean | 'absolute';
+    id: string;
+}
+export interface PartialResolvedId extends Partial<PartialNull<ModuleOptions>> {
+    external?: boolean | 'absolute' | 'relative';
+    id: string;
+}
+export interface SourceDescription extends Partial<PartialNull<ModuleOptions>> {
+    code: string;
+    map?: SourceMapInput;
+    moduleType?: ModuleType;
+}
+export interface ResolveIdExtraOptions {
+    custom?: CustomPluginOptions;
+    isEntry: boolean;
+    kind: 'import' | 'dynamic-import' | 'require-call';
+}
+export interface PrivateResolveIdExtraOptions extends ResolveIdExtraOptions {
+    [SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF]?: symbol;
+}
+export type ResolveIdResult = string | NullValue | false | PartialResolvedId;
+export type LoadResult = NullValue | string | SourceDescription;
+export type TransformResult = NullValue | string | Partial<SourceDescription>;
+export type RenderedChunkMeta = {
+    chunks: Record<string, RenderedChunk>;
+};
+export interface FunctionPluginHooks {
+    [DEFINED_HOOK_NAMES.onLog]: (this: MinimalPluginContext, level: LogLevel, log: RollupLog) => NullValue | boolean;
+    [DEFINED_HOOK_NAMES.options]: (this: MinimalPluginContext, options: InputOptions) => NullValue | InputOptions;
+    [DEFINED_HOOK_NAMES.outputOptions]: (this: MinimalPluginContext, options: OutputOptions) => NullValue | OutputOptions;
+    [DEFINED_HOOK_NAMES.buildStart]: (this: PluginContext, options: NormalizedInputOptions) => void;
+    [DEFINED_HOOK_NAMES.resolveId]: (this: PluginContext, source: string, importer: string | undefined, extraOptions: ResolveIdExtraOptions) => ResolveIdResult;
+    /**
+     * @deprecated
+     * This hook is only for rollup plugin compatibility. Please use `resolveId` instead.
+     */
+    [DEFINED_HOOK_NAMES.resolveDynamicImport]: (this: PluginContext, source: string, importer: string | undefined) => ResolveIdResult;
+    [DEFINED_HOOK_NAMES.load]: (this: PluginContext, id: string) => MaybePromise<LoadResult>;
+    [DEFINED_HOOK_NAMES.transform]: (this: TransformPluginContext, code: string, id: string, meta: BindingTransformHookExtraArgs & {
+        moduleType: ModuleType;
+    }) => TransformResult;
+    [DEFINED_HOOK_NAMES.moduleParsed]: (this: PluginContext, moduleInfo: ModuleInfo) => void;
+    [DEFINED_HOOK_NAMES.buildEnd]: (this: PluginContext, err?: Error) => void;
+    [DEFINED_HOOK_NAMES.renderStart]: (this: PluginContext, outputOptions: NormalizedOutputOptions, inputOptions: NormalizedInputOptions) => void;
+    [DEFINED_HOOK_NAMES.renderChunk]: (this: PluginContext, code: string, chunk: RenderedChunk, outputOptions: NormalizedOutputOptions, meta: RenderedChunkMeta) => NullValue | string | {
+        code: string;
+        map?: SourceMapInput;
+    };
+    [DEFINED_HOOK_NAMES.augmentChunkHash]: (this: PluginContext, chunk: RenderedChunk) => string | void;
+    [DEFINED_HOOK_NAMES.renderError]: (this: PluginContext, error: Error) => void;
+    [DEFINED_HOOK_NAMES.generateBundle]: (this: PluginContext, outputOptions: NormalizedOutputOptions, bundle: OutputBundle, isWrite: boolean) => void;
+    [DEFINED_HOOK_NAMES.writeBundle]: (this: PluginContext, outputOptions: NormalizedOutputOptions, bundle: OutputBundle) => void;
+    [DEFINED_HOOK_NAMES.closeBundle]: (this: PluginContext) => void;
+    [DEFINED_HOOK_NAMES.watchChange]: (this: PluginContext, id: string, event: {
+        event: ChangeEvent;
+    }) => void;
+    [DEFINED_HOOK_NAMES.closeWatcher]: (this: PluginContext) => void;
+}
+export type ChangeEvent = 'create' | 'update' | 'delete';
+export type PluginOrder = 'pre' | 'post' | null;
+export type ObjectHookMeta = {
+    order?: PluginOrder;
+};
+export type ObjectHook<T, O = {}> = T | ({
+    handler: T;
+} & ObjectHookMeta & O);
+export type SyncPluginHooks = DefinedHookNames['augmentChunkHash' | 'onLog' | 'outputOptions'];
+export type AsyncPluginHooks = Exclude<keyof FunctionPluginHooks, SyncPluginHooks>;
+export type FirstPluginHooks = DefinedHookNames['load' | 'resolveDynamicImport' | 'resolveId'];
+export type SequentialPluginHooks = DefinedHookNames['augmentChunkHash' | 'generateBundle' | 'onLog' | 'options' | 'outputOptions' | 'renderChunk' | 'transform'];
+export type AddonHooks = DefinedHookNames['banner' | 'footer' | 'intro' | 'outro'];
+export type OutputPluginHooks = DefinedHookNames['augmentChunkHash' | 'generateBundle' | 'outputOptions' | 'renderChunk' | 'renderError' | 'renderStart' | 'writeBundle'];
+export type ParallelPluginHooks = Exclude<keyof FunctionPluginHooks | AddonHooks, FirstPluginHooks | SequentialPluginHooks>;
+export type HookFilterExtension<K extends keyof FunctionPluginHooks> = K extends 'transform' ? {
+    filter?: HookFilter;
+} : K extends 'load' ? {
+    filter?: Pick<HookFilter, 'id'>;
+} : K extends 'resolveId' ? {
+    filter?: {
+        id?: StringFilter<RegExp>;
+    };
+} : {};
+export type PluginHooks = {
+    [K in keyof FunctionPluginHooks]: ObjectHook<K extends AsyncPluginHooks ? MakeAsync<FunctionPluginHooks[K]> : FunctionPluginHooks[K], HookFilterExtension<K> & (K extends ParallelPluginHooks ? {
+        /**
+         * @deprecated
+         * this is only for rollup Plugin type compatibility.
+         * hooks always work as `sequential: true`.
+         */
+        sequential?: boolean;
+    } : {})>;
+};
+export type AddonHookFunction = (this: PluginContext, chunk: RenderedChunk) => string | Promise<string>;
+export type AddonHook = string | AddonHookFunction;
+export interface OutputPlugin extends Partial<{
+    [K in OutputPluginHooks]: PluginHooks[K];
+}>, Partial<{
+    [K in AddonHooks]: ObjectHook<AddonHook>;
+}> {
+    name: string;
+}
+export interface Plugin<A = any> extends OutputPlugin, Partial<PluginHooks> {
+    api?: A;
+}
+export type RolldownPlugin<A = any> = Plugin<A> | BuiltinPlugin | ParallelPlugin;
+export type RolldownPluginOption<A = any> = MaybePromise<NullValue<RolldownPlugin<A>> | false | RolldownPluginOption[]>;
+export type RolldownOutputPlugin = OutputPlugin | BuiltinPlugin;
+export type RolldownOutputPluginOption = MaybePromise<NullValue<RolldownOutputPlugin> | false | RolldownOutputPluginOption[]>;

package/dist/types/plugin/minimal-plugin-context.d.ts

@@ -0,0 +1,24 @@
+import type { LoggingFunction, LogHandler, LogLevelOption, RollupError } from '../types/misc';
+export interface PluginContextMeta {
+    rollupVersion: string;
+    rolldownVersion: string;
+    watchMode: boolean;
+}
+export interface MinimalPluginContext {
+    readonly pluginName: string;
+    error: (e: RollupError | string) => never;
+    info: LoggingFunction;
+    warn: LoggingFunction;
+    debug: LoggingFunction;
+    meta: PluginContextMeta;
+}
+export declare class MinimalPluginContextImpl {
+    readonly pluginName: string;
+    private readonly hookName?;
+    info: LoggingFunction;
+    warn: LoggingFunction;
+    debug: LoggingFunction;
+    meta: PluginContextMeta;
+    constructor(onLog: LogHandler, logLevel: LogLevelOption, pluginName: string, watchMode: boolean, hookName?: string | undefined);
+    error(e: RollupError | string): never;
+}

package/dist/types/plugin/parallel-plugin-implementation.d.ts

@@ -0,0 +1,10 @@
+import type { MaybePromise } from '../types/utils';
+import type { Plugin } from './index';
+export type ParallelPluginImplementation = Plugin;
+export type Context = {
+    /**
+     * Thread number
+     */
+    threadNumber: number;
+};
+export declare function defineParallelPluginImplementation<Options>(plugin: (Options: Options, context: Context) => MaybePromise<ParallelPluginImplementation>): (Options: Options, context: Context) => MaybePromise<ParallelPluginImplementation>;

package/dist/types/plugin/parallel-plugin.d.ts

@@ -0,0 +1,9 @@
+export type ParallelPlugin = {
+    /** @internal */
+    _parallel: {
+        fileUrl: string;
+        options: unknown;
+    };
+};
+export type DefineParallelPluginResult<Options> = (options: Options) => ParallelPlugin;
+export declare function defineParallelPlugin<Options>(pluginPath: string): DefineParallelPluginResult<Options>;

package/dist/types/plugin/plugin-context-data.d.ts

@@ -0,0 +1,21 @@
+import { ModuleOptions } from '..';
+import { BindingPluginContext } from '../binding';
+import type { ModuleInfo } from '../types/module-info';
+import { RenderedChunkMeta } from '.';
+import { PluginContextResolveOptions } from './plugin-context';
+export declare class PluginContextData {
+    moduleOptionMap: Map<string, ModuleOptions>;
+    resolveOptionsMap: Map<number, PluginContextResolveOptions>;
+    loadModulePromiseMap: Map<string, Promise<void>>;
+    meta: RenderedChunkMeta | null;
+    updateModuleOption(id: string, option: ModuleOptions): ModuleOptions;
+    getModuleOption(id: string): ModuleOptions;
+    getModuleInfo(id: string, context: BindingPluginContext): ModuleInfo | null;
+    proxyModuleInfo(id: string, info: ModuleInfo): ModuleInfo;
+    getModuleIds(context: BindingPluginContext): ArrayIterator<string>;
+    saveResolveOptions(options: PluginContextResolveOptions): number;
+    getSavedResolveOptions(receipt: number): PluginContextResolveOptions | undefined;
+    removeSavedResolveOptions(receipt: number): void;
+    setRenderChunkMeta(meta: RenderedChunkMeta): void;
+    getRenderChunkMeta(): RenderedChunkMeta | null;
+}

package/dist/types/plugin/plugin-context.d.ts

@@ -0,0 +1,67 @@
+import { Program } from '@oxc-project/types';
+import type { BindingPluginContext, ParserOptions } from '../binding';
+import { SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF } from '../constants/plugin-context';
+import { OutputOptions } from '../options/output-options';
+import { MinimalPluginContext, MinimalPluginContextImpl } from '../plugin/minimal-plugin-context';
+import type { LogHandler, LogLevelOption } from '../types/misc';
+import { ModuleInfo } from '../types/module-info';
+import { PartialNull } from '../types/utils';
+import { AssetSource } from '../utils/asset-source';
+import type { CustomPluginOptions, ModuleOptions, Plugin, ResolvedId } from './index';
+import { PluginContextData } from './plugin-context-data';
+export interface EmittedAsset {
+    type: 'asset';
+    name?: string;
+    fileName?: string;
+    originalFileName?: string | null;
+    source: AssetSource;
+}
+export interface EmittedChunk {
+    type: 'chunk';
+    name?: string;
+    fileName?: string;
+    id: string;
+    importer?: string;
+}
+export type EmittedFile = EmittedAsset | EmittedChunk;
+export interface PluginContextResolveOptions {
+    skipSelf?: boolean;
+    custom?: CustomPluginOptions;
+}
+export interface PrivatePluginContextResolveOptions extends PluginContextResolveOptions {
+    [SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF]?: symbol;
+}
+export type GetModuleInfo = (moduleId: string) => ModuleInfo | null;
+export interface PluginContext extends MinimalPluginContext {
+    emitFile(file: EmittedFile): string;
+    getFileName(referenceId: string): string;
+    getModuleIds(): IterableIterator<string>;
+    getModuleInfo: GetModuleInfo;
+    addWatchFile(id: string): void;
+    load(options: {
+        id: string;
+        resolveDependencies?: boolean;
+    } & Partial<PartialNull<ModuleOptions>>): Promise<ModuleInfo>;
+    parse(input: string, options?: ParserOptions | undefined | null): Program;
+    resolve(source: string, importer?: string, options?: PluginContextResolveOptions): Promise<ResolvedId | null>;
+}
+export declare class PluginContextImpl extends MinimalPluginContextImpl {
+    private outputOptions;
+    private context;
+    private data;
+    private onLog;
+    private currentLoadingModule?;
+    getModuleInfo: GetModuleInfo;
+    constructor(outputOptions: OutputOptions, context: BindingPluginContext, plugin: Plugin, data: PluginContextData, onLog: LogHandler, logLevel: LogLevelOption, watchMode: boolean, currentLoadingModule?: string | undefined);
+    load(options: {
+        id: string;
+        resolveDependencies?: boolean;
+    } & Partial<PartialNull<ModuleOptions>>): Promise<ModuleInfo>;
+    resolve(source: string, importer?: string, options?: PluginContextResolveOptions): Promise<ResolvedId | null>;
+    emitFile: PluginContext['emitFile'];
+    private getAssetFileNames;
+    getFileName(referenceId: string): string;
+    getModuleIds(): IterableIterator<string>;
+    addWatchFile(id: string): void;
+    parse(input: string, options?: ParserOptions | undefined | null): Program;
+}

package/dist/types/plugin/plugin-driver.d.ts

@@ -0,0 +1,10 @@
+import { InputOptions, OutputOptions, RolldownPlugin } from '..';
+import { type LogLevelOption } from '../log/logging';
+import type { LogHandler } from '../types/misc';
+import { Plugin } from './';
+export declare class PluginDriver {
+    static callOptionsHook(inputOptions: InputOptions, watchMode?: boolean): Promise<InputOptions>;
+    static callOutputOptionsHook(rawPlugins: RolldownPlugin[], outputOptions: OutputOptions, onLog: LogHandler, logLevel: LogLevelOption, watchMode: boolean): OutputOptions;
+}
+export declare function getObjectPlugins(plugins: RolldownPlugin[]): Plugin[];
+export declare function getSortedPlugins(hookName: 'options' | 'outputOptions' | 'onLog', plugins: readonly Plugin[]): Plugin[];

package/dist/types/plugin/transform-plugin-context.d.ts

@@ -0,0 +1,28 @@
+import type { BindingPluginContext, BindingTransformPluginContext } from '../binding';
+import { OutputOptions } from '../options/output-options';
+import type { LoggingFunctionWithPosition, LogHandler, LogLevelOption, RollupError } from '../types/misc';
+import { SourceMap } from '../types/rolldown-output';
+import type { Plugin } from './index';
+import { type PluginContext, PluginContextImpl } from './plugin-context';
+import { PluginContextData } from './plugin-context-data';
+export interface TransformPluginContext extends PluginContext {
+    debug: LoggingFunctionWithPosition;
+    info: LoggingFunctionWithPosition;
+    warn: LoggingFunctionWithPosition;
+    error(e: RollupError | string, pos?: number | {
+        column: number;
+        line: number;
+    }): never;
+    getCombinedSourcemap(): SourceMap;
+}
+export declare class TransformPluginContextImpl extends PluginContextImpl {
+    private inner;
+    private moduleId;
+    private moduleSource;
+    constructor(outputOptions: OutputOptions, context: BindingPluginContext, plugin: Plugin, data: PluginContextData, inner: BindingTransformPluginContext, moduleId: string, moduleSource: string, onLog: LogHandler, LogLevelOption: LogLevelOption, watchMode: boolean);
+    error(e: RollupError | string, pos?: number | {
+        column: number;
+        line: number;
+    }): never;
+    getCombinedSourcemap(): SourceMap;
+}