rolldown 0.10.3 → 0.10.4

package/dist/types/cli/colors.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="colorette" />
+export declare const bold: import("colorette").Color, cyan: import("colorette").Color, dim: import("colorette").Color, gray: import("colorette").Color, green: import("colorette").Color, red: import("colorette").Color, underline: import("colorette").Color, yellow: import("colorette").Color;

package/dist/types/cli/commands/bundle.d.ts

@@ -0,0 +1 @@
+export declare function bundle(configPath: string): Promise<void>;

package/dist/types/cli/constants.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_CONFIG_FILENAME = "rolldown.config.js";

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

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

package/dist/types/cli/utils.d.ts

@@ -0,0 +1,6 @@
+import type { ConfigExport } from '../types/config-export';
+/**
+ * Console logger
+ */
+export declare const logger: import("consola").ConsolaInstance;
+export declare function ensureConfig(configPath: string): Promise<ConfigExport>;

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+import { RolldownOutput, RolldownOutputChunk } from './types/rolldown-output';
+import type { InputOptions } from './options/input-options';
+import type { OutputOptions } from './options/output-options';
+import type { RolldownOptions } from './types/rolldown-options';
+import type { Plugin } from './plugin';
+import { defineParallelPlugin, DefineParallelPluginResult } from './plugin';
+import { defineConfig } from './utils/define-config';
+import { rolldown, experimental_scan } from './rolldown';
+import { ConfigExport } from './types/config-export';
+export { defineConfig, defineParallelPlugin, rolldown, experimental_scan };
+export type { RolldownOutputChunk, RolldownOptions, RolldownOutput, InputOptions, OutputOptions, Plugin, DefineParallelPluginResult, ConfigExport, };
+export type { RolldownOutput as RollupOutput, RolldownOptions as RollupOptions };

package/dist/types/log/logHandler.d.ts

@@ -0,0 +1,4 @@
+import type { LoggingFunctionWithPosition, LogHandler, RollupLog } from '../rollup';
+import { type LogLevel, type LogLevelOption } from './logging';
+export declare const normalizeLog: (log: RollupLog | string | (() => RollupLog | string)) => RollupLog;
+export declare function getLogHandler(level: LogLevel, code: string, logger: LogHandler, pluginName: string, logLevel: LogLevelOption): LoggingFunctionWithPosition;

package/dist/types/log/logger.d.ts

@@ -0,0 +1,13 @@
+import type { LoggingFunction, LogHandler, RollupError } from '../rollup';
+import type { Plugin } from '../plugin';
+import { type LogLevelOption } from './logging';
+import type { InputOptions } from '../options/input-options';
+import type { NormalizedInputOptions } from '../options/normalized-input-options';
+export interface MinimalPluginContext {
+    debug: LoggingFunction;
+    error: (error: RollupError | string) => never;
+    info: LoggingFunction;
+    warn: LoggingFunction;
+}
+export declare function getLogger(plugins: Plugin[], onLog: LogHandler, logLevel: LogLevelOption): LogHandler;
+export declare const getOnLog: (config: InputOptions, logLevel: LogLevelOption, printLog?: LogHandler) => NormalizedInputOptions['onLog'];

package/dist/types/log/logging.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const LogLevelSchema: z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"info">, z.ZodLiteral<"debug">]>, z.ZodLiteral<"warn">]>;
+export declare const LogLevelWithErrorSchema: z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"info">, z.ZodLiteral<"debug">]>, z.ZodLiteral<"warn">]>, z.ZodLiteral<"error">]>;
+export type LogLevel = z.infer<typeof LogLevelSchema>;
+export declare const LogLevelOptionSchema: z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"info">, z.ZodLiteral<"debug">]>, z.ZodLiteral<"warn">]>, z.ZodLiteral<"silent">]>;
+export type LogLevelOption = z.infer<typeof LogLevelOptionSchema>;
+export declare const LOG_LEVEL_SILENT: LogLevelOption;
+export declare const LOG_LEVEL_ERROR = "error";
+export declare const LOG_LEVEL_WARN: LogLevel;
+export declare const LOG_LEVEL_INFO: LogLevel;
+export declare const LOG_LEVEL_DEBUG: LogLevel;
+export declare const logLevelPriority: Record<LogLevelOption, number>;
+export declare const RollupLogSchema: z.ZodAny;
+export declare const RollupLogWithStringSchema: z.ZodUnion<[z.ZodAny, z.ZodString]>;

package/dist/types/log/logs.d.ts

@@ -0,0 +1,13 @@
+import type { RollupLog } from '../rollup';
+export declare function logInvalidLogPosition(pluginName: string): RollupLog;
+export declare function logPluginError(error: Omit<RollupLog, 'code'> & {
+    code?: unknown;
+}, plugin: string, { hook, id }?: {
+    hook?: string;
+    id?: string;
+}): RollupLog;
+export declare function error(base: Error | RollupLog): never;
+export declare function augmentCodeLocation(properties: RollupLog, pos: number | {
+    column: number;
+    line: number;
+}, source: string, id: string): void;

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

@@ -0,0 +1,4 @@
+import type { BindingInputOptions } from '../binding';
+import type { NormalizedInputOptions } from './normalized-input-options';
+import type { NormalizedOutputOptions } from './normalized-output-options';
+export declare function bindingifyInputOptions(options: NormalizedInputOptions, outputOptions: NormalizedOutputOptions): BindingInputOptions;

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

@@ -0,0 +1,3 @@
+import type { BindingOutputOptions } from '../binding';
+import type { NormalizedOutputOptions } from './normalized-output-options';
+export declare function bindingifyOutputOptions(outputOptions: NormalizedOutputOptions): BindingOutputOptions;

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

@@ -0,0 +1,93 @@
+import type { Plugin, ParallelPlugin } from '../plugin';
+import { z } from 'zod';
+declare const inputOptionsSchema: z.ZodObject<{
+    input: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodType<Plugin | ParallelPlugin, z.ZodTypeDef, Plugin | ParallelPlugin>, "many">>;
+    external: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, "many">]>, z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodString>, z.ZodBoolean], z.ZodUnknown>, z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodVoid, z.ZodNull]>, z.ZodUndefined]>, z.ZodBoolean]>>>]>>;
+    resolve: z.ZodOptional<z.ZodObject<{
+        alias: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        aliasFields: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">>;
+        conditionNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        exportsFields: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">>;
+        extensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        mainFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        mainFiles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        modules: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        symlinks: z.ZodOptional<z.ZodBoolean>;
+        tsconfigFilename: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        modules?: string[] | undefined;
+        alias?: Record<string, string> | undefined;
+        aliasFields?: string[][] | undefined;
+        conditionNames?: string[] | undefined;
+        exportsFields?: string[][] | undefined;
+        extensions?: string[] | undefined;
+        mainFields?: string[] | undefined;
+        mainFiles?: string[] | undefined;
+        symlinks?: boolean | undefined;
+        tsconfigFilename?: string | undefined;
+    }, {
+        modules?: string[] | undefined;
+        alias?: Record<string, string> | undefined;
+        aliasFields?: string[][] | undefined;
+        conditionNames?: string[] | undefined;
+        exportsFields?: string[][] | undefined;
+        extensions?: string[] | undefined;
+        mainFields?: string[] | undefined;
+        mainFiles?: string[] | undefined;
+        symlinks?: boolean | undefined;
+        tsconfigFilename?: string | undefined;
+    }>>;
+    cwd: z.ZodOptional<z.ZodString>;
+    platform: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"node">, z.ZodLiteral<"browser">]>, z.ZodLiteral<"neutral">]>>;
+    shimMissingExports: z.ZodOptional<z.ZodBoolean>;
+    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>>;
+}, "strict", z.ZodTypeAny, {
+    input?: string | string[] | Record<string, string> | undefined;
+    plugins?: (Plugin | ParallelPlugin)[] | undefined;
+    external?: string | RegExp | (string | RegExp)[] | ((args_0: string, args_1: string | undefined, args_2: boolean, ...args_3: unknown[]) => boolean | void | null | undefined) | undefined;
+    resolve?: {
+        modules?: string[] | undefined;
+        alias?: Record<string, string> | undefined;
+        aliasFields?: string[][] | undefined;
+        conditionNames?: string[] | undefined;
+        exportsFields?: string[][] | undefined;
+        extensions?: string[] | undefined;
+        mainFields?: string[] | undefined;
+        mainFiles?: string[] | undefined;
+        symlinks?: boolean | undefined;
+        tsconfigFilename?: string | undefined;
+    } | undefined;
+    cwd?: string | undefined;
+    platform?: "node" | "browser" | "neutral" | undefined;
+    shimMissingExports?: boolean | undefined;
+    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;
+}, {
+    input?: string | string[] | Record<string, string> | undefined;
+    plugins?: (Plugin | ParallelPlugin)[] | undefined;
+    external?: string | RegExp | (string | RegExp)[] | ((args_0: string, args_1: string | undefined, args_2: boolean, ...args_3: unknown[]) => boolean | void | null | undefined) | undefined;
+    resolve?: {
+        modules?: string[] | undefined;
+        alias?: Record<string, string> | undefined;
+        aliasFields?: string[][] | undefined;
+        conditionNames?: string[] | undefined;
+        exportsFields?: string[][] | undefined;
+        extensions?: string[] | undefined;
+        mainFields?: string[] | undefined;
+        mainFiles?: string[] | undefined;
+        symlinks?: boolean | undefined;
+        tsconfigFilename?: string | undefined;
+    } | undefined;
+    cwd?: string | undefined;
+    platform?: "node" | "browser" | "neutral" | undefined;
+    shimMissingExports?: boolean | undefined;
+    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;
+}>;
+export type InputOptions = z.infer<typeof inputOptionsSchema>;
+export {};

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

@@ -0,0 +1,10 @@
+import type { LogLevelOption, RollupLog, NormalizedInputOptions as RollupNormalizedInputOptions } from '../rollup';
+import type { InputOptions } from './input-options';
+import type { Plugin, ParallelPlugin } from '../plugin';
+import type { LogLevel } from '../log/logging';
+export interface NormalizedInputOptions extends InputOptions {
+    input: RollupNormalizedInputOptions['input'];
+    plugins: (Plugin | ParallelPlugin)[];
+    onLog: (level: LogLevel, log: RollupLog) => void;
+    logLevel: LogLevelOption;
+}

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

@@ -0,0 +1,20 @@
+import type { SourcemapIgnoreListOption, SourcemapPathTransformOption } from '../rollup';
+import type { OutputOptions } from './output-options';
+import type { Plugin, ParallelPlugin } from '../plugin';
+import type { RenderedChunk } from '@src/binding';
+type InternalModuleFormat = 'es' | 'cjs';
+type AddonFunction = (chunk: RenderedChunk) => string | Promise<string>;
+export interface NormalizedOutputOptions extends OutputOptions {
+    plugins: (Plugin | ParallelPlugin)[];
+    dir: string | undefined;
+    format: InternalModuleFormat;
+    exports: 'named';
+    sourcemap: boolean | 'inline' | 'hidden';
+    sourcemapIgnoreList: SourcemapIgnoreListOption;
+    sourcemapPathTransform: SourcemapPathTransformOption | undefined;
+    banner: AddonFunction;
+    footer: AddonFunction;
+    entryFileNames: string;
+    chunkFileNames: string;
+}
+export {};

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

@@ -0,0 +1,40 @@
+import type { RenderedChunk } from '../binding';
+import { z } from 'zod';
+declare const outputOptionsSchema: z.ZodObject<{
+    dir: z.ZodOptional<z.ZodString>;
+    exports: z.ZodOptional<z.ZodLiteral<"named">>;
+    format: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"es">, z.ZodLiteral<"cjs">]>, z.ZodLiteral<"es">]>, z.ZodLiteral<"esm">]>, z.ZodLiteral<"module">]>, z.ZodLiteral<"commonjs">]>>;
+    sourcemap: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"inline">]>, z.ZodLiteral<"hidden">]>>;
+    sourcemapIgnoreList: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodType<SourcemapIgnoreListOption, z.ZodTypeDef, SourcemapIgnoreListOption>]>>;
+    sourcemapPathTransform: z.ZodOptional<z.ZodType<SourcemapPathTransformOption, z.ZodTypeDef, SourcemapPathTransformOption>>;
+    banner: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<RenderedChunk, z.ZodTypeDef, RenderedChunk>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;
+    footer: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<RenderedChunk, z.ZodTypeDef, RenderedChunk>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;
+    entryFileNames: z.ZodOptional<z.ZodString>;
+    chunkFileNames: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    exports?: "named" | undefined;
+    banner?: string | ((args_0: RenderedChunk, ...args_1: unknown[]) => string | Promise<string>) | undefined;
+    footer?: string | ((args_0: RenderedChunk, ...args_1: unknown[]) => string | Promise<string>) | undefined;
+    dir?: string | undefined;
+    format?: "es" | "cjs" | "esm" | "module" | "commonjs" | undefined;
+    sourcemap?: boolean | "inline" | "hidden" | undefined;
+    sourcemapIgnoreList?: boolean | SourcemapIgnoreListOption | undefined;
+    sourcemapPathTransform?: SourcemapPathTransformOption | undefined;
+    entryFileNames?: string | undefined;
+    chunkFileNames?: string | undefined;
+}, {
+    exports?: "named" | undefined;
+    banner?: string | ((args_0: RenderedChunk, ...args_1: unknown[]) => string | Promise<string>) | undefined;
+    footer?: string | ((args_0: RenderedChunk, ...args_1: unknown[]) => string | Promise<string>) | undefined;
+    dir?: string | undefined;
+    format?: "es" | "cjs" | "esm" | "module" | "commonjs" | undefined;
+    sourcemap?: boolean | "inline" | "hidden" | undefined;
+    sourcemapIgnoreList?: boolean | SourcemapIgnoreListOption | undefined;
+    sourcemapPathTransform?: SourcemapPathTransformOption | undefined;
+    entryFileNames?: string | undefined;
+    chunkFileNames?: string | undefined;
+}>;
+export type OutputOptions = z.infer<typeof outputOptionsSchema>;
+export type SourcemapIgnoreListOption = (relativeSourcePath: string, sourcemapPath: string) => boolean;
+export type SourcemapPathTransformOption = (relativeSourcePath: string, sourcemapPath: string) => string;
+export {};

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

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

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

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

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

@@ -0,0 +1,10 @@
+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'];

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

@@ -0,0 +1,10 @@
+import type { BindingPluginOptions } from '../binding';
+import type { NormalizedInputOptions } from '../options/normalized-input-options';
+import type { Plugin } from './index';
+import { NormalizedOutputOptions } from '@src/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'];

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

@@ -0,0 +1,5 @@
+import type { BindingPluginOptions } from '../binding';
+import type { Plugin } from './index';
+import type { NormalizedInputOptions } from '../options/normalized-input-options';
+import type { NormalizedOutputOptions } from '@src/options/normalized-output-options';
+export declare function bindingifyPlugin(plugin: Plugin, options: NormalizedInputOptions, outputOptions: NormalizedOutputOptions): BindingPluginOptions;

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

@@ -0,0 +1,65 @@
+import type { BindingHookResolveIdExtraOptions, RenderedChunk } from '../binding';
+import type { NormalizedInputOptions } from '../options/normalized-input-options';
+import type { AnyFn, AnyObj, NullValue, MaybePromise } from '../types/utils';
+import type { SourceMapInput } from '../types/sourcemap';
+import type { ModuleInfo } from '../types/module-info';
+import type { OutputBundle } from '../types/output-bundle';
+import type { PluginContext } from './plugin-context';
+import type { TransformPluginContext } from './transfrom-plugin-context';
+import type { NormalizedOutputOptions } from '@src/options/normalized-output-options';
+import type { LogLevel } from '../log/logging';
+import type { RollupLog } from '../rollup';
+import type { MinimalPluginContext } from '../log/logger';
+type FormalHook<Handler extends AnyFn, HookOptions extends AnyObj = AnyObj> = {
+    handler: Handler;
+} & HookOptions;
+export type Hook<Handler extends AnyFn, HookOptions extends AnyObj = AnyObj> = FormalHook<Handler, HookOptions> | Handler;
+export type ModuleSideEffects = boolean | 'no-treeshake' | null;
+export type ResolveIdResult = string | NullValue | false | {
+    id: string;
+    external?: boolean;
+    moduleSideEffects?: ModuleSideEffects;
+};
+export interface Plugin {
+    name?: string;
+    onLog?: Hook<(this: MinimalPluginContext, level: LogLevel, log: RollupLog) => NullValue | boolean>;
+    options?: Hook<(this: MinimalPluginContext, options: NormalizedInputOptions) => NullValue>;
+    buildStart?: Hook<(this: PluginContext, options: NormalizedInputOptions) => MaybePromise<NullValue>>;
+    resolveId?: Hook<(this: PluginContext, source: string, importer: string | undefined, extraOptions: BindingHookResolveIdExtraOptions) => MaybePromise<ResolveIdResult>>;
+    /**
+     * @deprecated
+     * This hook is only for rollup plugin compatibility. Please use `resolveId` instead.
+     */
+    resolveDynamicImport?: Hook<(this: PluginContext, source: string, importer: string | undefined) => MaybePromise<ResolveIdResult>>;
+    load?: Hook<(this: PluginContext, id: string) => MaybePromise<NullValue | string | {
+        code: string;
+        map?: SourceMapInput;
+        moduleSideEffects?: ModuleSideEffects;
+    }>>;
+    transform?: Hook<(this: TransformPluginContext, code: string, id: string) => MaybePromise<NullValue | string | {
+        code: string;
+        map?: string | null | SourceMapInput;
+        moduleSideEffects?: ModuleSideEffects;
+    }>>;
+    moduleParsed?: Hook<(this: PluginContext, moduleInfo: ModuleInfo) => MaybePromise<NullValue>>;
+    buildEnd?: Hook<(this: PluginContext, err?: Error) => MaybePromise<NullValue>>;
+    renderStart?: Hook<(this: PluginContext, outputOptions: NormalizedOutputOptions, inputOptions: NormalizedInputOptions) => MaybePromise<NullValue>>;
+    renderChunk?: Hook<(this: PluginContext, code: string, chunk: RenderedChunk, outputOptions: NormalizedOutputOptions) => MaybePromise<NullValue | string | {
+        code: string;
+        map?: string | null | SourceMapInput;
+    }>>;
+    augmentChunkHash?: Hook<(this: PluginContext, chunk: RenderedChunk) => MaybePromise<string | void>>;
+    renderError?: Hook<(this: PluginContext, error: Error) => MaybePromise<NullValue>>;
+    generateBundle?: Hook<(this: PluginContext, outputOptions: NormalizedOutputOptions, bundle: OutputBundle, isWrite: boolean) => MaybePromise<NullValue>>;
+    writeBundle?: Hook<(this: PluginContext, outputOptions: NormalizedOutputOptions, bundle: OutputBundle) => MaybePromise<NullValue>>;
+}
+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>;
+export {};

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/plugin-context.d.ts

@@ -0,0 +1,12 @@
+import type { RollupError, LoggingFunction } from '../rollup';
+import type { BindingPluginContext } from '../binding';
+import type { NormalizedInputOptions } from '../options/normalized-input-options';
+import type { Plugin } from './index';
+export declare class PluginContext {
+    debug: LoggingFunction;
+    info: LoggingFunction;
+    warn: LoggingFunction;
+    error: (error: RollupError | string) => never;
+    resolve: BindingPluginContext['resolve'];
+    constructor(options: NormalizedInputOptions, context: BindingPluginContext, plugin: Plugin);
+}

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

@@ -0,0 +1,4 @@
+import { NormalizedInputOptions } from '../options/normalized-input-options';
+export declare class PluginDriver {
+    callOptionsHook(inputOptions: NormalizedInputOptions): void;
+}

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

@@ -0,0 +1,13 @@
+import type { BindingPluginContext, BindingTransformPluginContext } from '@src/binding';
+import type { SourceMap } from '@src/types/rolldown-output';
+import type { LoggingFunction, RollupError } from '../rollup';
+import type { PluginContext } from './plugin-context';
+export declare class TransformPluginContext {
+    debug: LoggingFunction;
+    info: LoggingFunction;
+    warn: LoggingFunction;
+    error: (error: RollupError | string) => never;
+    resolve: BindingPluginContext['resolve'];
+    getCombinedSourcemap: () => SourceMap;
+    constructor(inner: BindingTransformPluginContext, context: PluginContext, moduleId: string, moduleSource: string);
+}

package/dist/types/rolldown-build.d.ts

@@ -0,0 +1,10 @@
+import type { OutputOptions } from './options/output-options';
+import type { RolldownOutput } from './types/rolldown-output';
+import type { InputOptions } from './options/input-options';
+export declare class RolldownBuild {
+    #private;
+    constructor(inputOptions: InputOptions);
+    generate(outputOptions?: OutputOptions): Promise<RolldownOutput>;
+    write(outputOptions?: OutputOptions): Promise<RolldownOutput>;
+    destroy(): Promise<void>;
+}

package/dist/types/rolldown.d.ts

@@ -0,0 +1,9 @@
+import type { InputOptions } from './options/input-options';
+import { RolldownBuild } from './rolldown-build';
+export declare const rolldown: (input: InputOptions) => Promise<RolldownBuild>;
+/**
+ * @description
+ * This is an experimental API. It's behavior may change in the future.
+ * Calling this API will only execute the scan stage of rolldown.
+ */
+export declare const experimental_scan: (input: InputOptions) => Promise<void>;

package/dist/types/rollup-types.d.ts

@@ -0,0 +1 @@
+export type { OutputOptions, InputOptions, Plugin, OutputPlugin, OutputChunk, NormalizedInputOptions, OutputAsset, OutputBundle, SourceMapInput, } from './rollup';

package/dist/types/types/config-export.d.ts

@@ -0,0 +1,5 @@
+import type { RolldownOptions } from './rolldown-options';
+/**
+ * Type for `default export` of `rolldown.config.js` file.
+ */
+export type ConfigExport = RolldownOptions | RolldownOptions[];

package/dist/types/types/module-info.d.ts

@@ -0,0 +1,13 @@
+export interface ModuleInfo {
+    /**
+     *  Unsupported at rolldown
+     */
+    ast: any;
+    code: string | null;
+    id: string;
+    importers: string[];
+    dynamicImporters: string[];
+    importedIds: string[];
+    dynamicallyImportedIds: string[];
+    isEntry: boolean;
+}

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

@@ -0,0 +1,4 @@
+import type { RolldownOutputAsset, RolldownOutputChunk } from './rolldown-output';
+export interface OutputBundle {
+    [fileName: string]: RolldownOutputAsset | RolldownOutputChunk;
+}

package/dist/types/types/rendered-module.d.ts

@@ -0,0 +1,2 @@
+export interface RenderedModule {
+}

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

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

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

@@ -0,0 +1,38 @@
+import type { RenderedModule } from './rendered-module';
+export interface RolldownOutputAsset {
+    type: 'asset';
+    fileName: string;
+    source: string | Uint8Array;
+}
+export interface SourceMap {
+    file: string;
+    mappings: string;
+    names: string[];
+    sources: string[];
+    sourcesContent: string[];
+    version: number;
+}
+export interface RolldownOutputChunk {
+    type: 'chunk';
+    code: string;
+    isEntry: boolean;
+    exports: string[];
+    fileName: string;
+    modules: {
+        [id: string]: RenderedModule;
+    };
+    imports: string[];
+    dynamicImports: string[];
+    facadeModuleId: string | null;
+    isDynamicEntry: boolean;
+    moduleIds: string[];
+    map: SourceMap | null;
+    sourcemapFileName: string | null;
+    preliminaryFileName: string;
+}
+export interface RolldownOutput {
+    output: [
+        RolldownOutputChunk,
+        ...(RolldownOutputChunk | RolldownOutputAsset)[]
+    ];
+}

package/dist/types/types/sourcemap.d.ts

@@ -0,0 +1,10 @@
+export interface SourceMapInputObject {
+    file?: string;
+    mappings: string;
+    names?: string[];
+    sources?: (string | null)[];
+    sourcesContent?: (string | null)[];
+    sourceRoot?: string;
+    version: number;
+}
+export type SourceMapInput = SourceMapInputObject | string | null;

package/dist/types/types/utils.d.ts

@@ -0,0 +1,7 @@
+export type MaybePromise<T> = T | Promise<T>;
+export interface AnyFn {
+    (...args: any[]): any;
+}
+export interface AnyObj {
+}
+export type NullValue<T = void> = T | undefined | null | void;

package/dist/types/utils/async-flatten.d.ts

@@ -0,0 +1 @@
+export declare function asyncFlatten<T>(array: T[]): Promise<T[]>;

package/dist/types/utils/code-frame.d.ts

@@ -0,0 +1 @@
+export declare function getCodeFrame(source: string, line: number, column: number): string;

package/dist/types/utils/create-bundler.d.ts

@@ -0,0 +1,7 @@
+import { Bundler } from '../binding';
+import type { InputOptions } from '../options/input-options';
+import type { OutputOptions } from '../options/output-options';
+export declare function createBundler(inputOptions: InputOptions, outputOptions: OutputOptions): Promise<{
+    bundler: Bundler;
+    stopWorkers?: () => Promise<void>;
+}>;

package/dist/types/utils/define-config.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigExport } from '../types/config-export';
+export declare function defineConfig(config: ConfigExport): ConfigExport;

package/dist/types/utils/ensure-array.d.ts

@@ -0,0 +1 @@
+export declare function ensureArray<T>(items: (T | false | null | undefined)[] | T | false | null | undefined): T[];

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

@@ -0,0 +1,13 @@
+export * from './async-flatten';
+export * from './transform-to-rollup-output';
+export * from './normalize-plugin-option';
+export * from './ensure-array';
+export * from './create-bundler';
+export * from './transform-sourcemap';
+export * from './transform-module-info';
+export * from './code-frame';
+export declare function arraify<T>(value: T | T[]): T[];
+export declare function unimplemented(info?: string): never;
+export declare function unreachable(info?: string): never;
+export declare function unsupported(info: string): never;
+export declare function noop(..._args: any[]): void;

package/dist/types/utils/initialize-parallel-plugins.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { Worker } from 'node:worker_threads';
+import type { ParallelPlugin, Plugin } from '../plugin';
+import { ParallelJsPluginRegistry } from '../binding';
+export type WorkerData = {
+    registryId: number;
+    pluginInfos: ParallelPluginInfo[];
+    threadNumber: number;
+};
+type ParallelPluginInfo = {
+    index: number;
+    fileUrl: string;
+    options: unknown;
+};
+export declare function initializeParallelPlugins(plugins: (Plugin | ParallelPlugin)[]): Promise<{
+    registry: ParallelJsPluginRegistry;
+    stopWorkers: () => Promise<void>;
+} | undefined>;
+export declare function initializeWorkers(registryId: number, count: number, pluginInfos: ParallelPluginInfo[]): Promise<Worker[]>;
+export {};

package/dist/types/utils/normalize-hook.d.ts

@@ -0,0 +1,5 @@
+import type { Hook } from '../plugin';
+import type { AnyFn, AnyObj } from '../types/utils';
+type NotFn<T> = T extends AnyFn ? never : T;
+export declare function normalizeHook<H extends Hook<AnyFn, AnyObj>>(hook: H): H extends Hook<infer Handler, infer Options> ? [Handler, NotFn<Options>] : never;
+export {};

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

@@ -0,0 +1,3 @@
+import type { InputOptions } from '../options/input-options';
+import type { NormalizedInputOptions } from '../options/normalized-input-options';
+export declare function normalizeInputOptions(config: InputOptions): Promise<NormalizedInputOptions>;

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

@@ -0,0 +1,3 @@
+import type { OutputOptions } from '@src/options/output-options';
+import type { NormalizedOutputOptions } from '@src/options/normalized-output-options';
+export declare function normalizeOutputOptions(opts: OutputOptions): NormalizedOutputOptions;