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

package/dist/types/builtin-plugin/alias-plugin.d.ts

@@ -0,0 +1,10 @@
+import { BuiltinPlugin } from './constructors';
+type AliasPluginAlias = {
+    find: string | RegExp;
+    replacement: string;
+};
+type AliasPluginConfig = {
+    entries: AliasPluginAlias[];
+};
+export declare function aliasPlugin(config: AliasPluginConfig): BuiltinPlugin;
+export {};

package/dist/types/builtin-plugin/constructors.d.ts

@@ -0,0 +1,22 @@
+import { BindingBuildImportAnalysisPluginConfig, type BindingBuiltinPluginName, BindingGlobImportPluginConfig, BindingIsolatedDeclarationPluginConfig, BindingJsonPluginConfig, BindingManifestPluginConfig, BindingMfManifest, BindingModuleFederationPluginOption, BindingModulePreloadPolyfillPluginConfig, BindingRemote, type BindingViteResolvePluginConfig } from '../binding';
+export declare class BuiltinPlugin {
+    name: BindingBuiltinPluginName;
+    _options?: unknown | undefined;
+    constructor(name: BindingBuiltinPluginName, _options?: unknown | undefined);
+}
+export declare function modulePreloadPolyfillPlugin(config?: BindingModulePreloadPolyfillPluginConfig): BuiltinPlugin;
+export declare function dynamicImportVarsPlugin(): BuiltinPlugin;
+export declare function importGlobPlugin(config?: BindingGlobImportPluginConfig): BuiltinPlugin;
+export declare function manifestPlugin(config?: BindingManifestPluginConfig): BuiltinPlugin;
+export declare function wasmHelperPlugin(): BuiltinPlugin;
+export declare function wasmFallbackPlugin(): BuiltinPlugin;
+export declare function loadFallbackPlugin(): BuiltinPlugin;
+export declare function jsonPlugin(config?: BindingJsonPluginConfig): BuiltinPlugin;
+export declare function buildImportAnalysisPlugin(config: BindingBuildImportAnalysisPluginConfig): BuiltinPlugin;
+export declare function viteResolvePlugin(config: Omit<BindingViteResolvePluginConfig, 'runtime'>): BuiltinPlugin;
+export type ModuleFederationPluginOption = Omit<BindingModuleFederationPluginOption, 'remotes'> & {
+    remotes?: Record<string, string | BindingRemote>;
+    manifest?: boolean | BindingMfManifest;
+};
+export declare function moduleFederationPlugin(config: ModuleFederationPluginOption): BuiltinPlugin;
+export declare function isolatedDeclarationPlugin(config?: BindingIsolatedDeclarationPluginConfig): BuiltinPlugin;

package/dist/types/builtin-plugin/replace-plugin.d.ts

@@ -0,0 +1,27 @@
+import { BindingReplacePluginConfig } from '../binding';
+import { BuiltinPlugin } from './constructors';
+/**
+ * Replaces targeted strings in files while bundling.
+ *
+ * @example
+ * // Basic usage
+ * ```js
+ * replacePlugin({
+ *   'process.env.NODE_ENV': JSON.stringify('production'),
+ *    __buildDate__: () => JSON.stringify(new Date()),
+ *    __buildVersion: 15
+ * })
+ * ```
+ * @example
+ * // With options
+ * ```js
+ * replacePlugin({
+ *   'process.env.NODE_ENV': JSON.stringify('production'),
+ *   __buildDate__: () => JSON.stringify(new Date()),
+ *   __buildVersion: 15
+ * }, {
+ *   preventAssignment: false,
+ * })
+ * ```
+ */
+export declare function replacePlugin(values?: BindingReplacePluginConfig['values'], options?: Omit<BindingReplacePluginConfig, 'values'>): BuiltinPlugin;

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

@@ -0,0 +1,9 @@
+import { BuiltinPlugin } from './constructors';
+import { BindingTransformPluginConfig } from '../binding';
+type TransformPattern = string | RegExp | (RegExp | string)[];
+export type TransformPluginConfig = Omit<BindingTransformPluginConfig, 'include' | 'exclude'> & {
+    include?: TransformPattern;
+    exclude?: TransformPattern;
+};
+export declare function transformPlugin(config?: TransformPluginConfig): BuiltinPlugin;
+export {};

package/dist/types/builtin-plugin/utils.d.ts

@@ -0,0 +1,8 @@
+import { BindingBuiltinPlugin, BindingCallableBuiltinPlugin } from '../binding';
+import { BuiltinPlugin } from './constructors';
+type BindingCallableBuiltinPluginLike = {
+    [K in keyof BindingCallableBuiltinPlugin]: BindingCallableBuiltinPlugin[K];
+};
+export declare function makeBuiltinPluginCallable(plugin: BuiltinPlugin): BuiltinPlugin & BindingCallableBuiltinPluginLike;
+export declare function bindingifyBuiltInPlugin(plugin: BuiltinPlugin): BindingBuiltinPlugin;
+export {};

package/dist/types/cli/arguments/alias.d.ts

@@ -0,0 +1,16 @@
+import type { InputCliOptions } from '../../options/input-options';
+import type { OutputCliOptions } from '../../options/output-options';
+export interface CliOptions extends InputCliOptions, OutputCliOptions {
+    config?: string | boolean;
+    help?: boolean;
+    version?: boolean;
+    watch?: boolean;
+}
+export interface OptionConfig {
+    abbreviation?: string;
+    description?: string;
+    default?: string | boolean;
+    hint?: string;
+    reverse?: boolean;
+}
+export declare const alias: Partial<Record<keyof CliOptions, OptionConfig>>;

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

@@ -0,0 +1,15 @@
+import type { Schema } from '../../types/schema';
+import { type NormalizedCliOptions } from './normalize';
+export declare const flattenedSchema: Record<string, Schema>;
+export declare const options: {
+    [k: string]: {
+        type: 'boolean' | 'string';
+        multiple: boolean;
+        short?: string;
+        default?: boolean | string | string[];
+        hint?: string;
+        description: string;
+    };
+};
+export type ParseArgsOptions = typeof options;
+export declare function parseCliArguments(): NormalizedCliOptions;

package/dist/types/cli/arguments/normalize.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @description This file is used for normalize the options.
+ * In CLI, the input options and output options are mixed together. We need to tell them apart.
+ */
+import type { InputOptions } from '../../options/input-options';
+import type { OutputOptions } from '../../options/output-options';
+import type { CliOptions } from './alias';
+export interface NormalizedCliOptions {
+    input: InputOptions;
+    output: OutputOptions;
+    help: boolean;
+    config: string;
+    version: boolean;
+    watch: boolean;
+}
+export declare function normalizeCliOptions(cliOptions: CliOptions, positionals: string[]): NormalizedCliOptions;

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

@@ -0,0 +1,8 @@
+import type { Schema } from '../../types/schema';
+type SchemaType = 'string' | 'boolean' | 'object' | 'number' | 'array';
+export declare function getSchemaType(schema: Schema): SchemaType;
+export declare function flattenSchema(schema: Record<string, Schema>, base?: Record<string, Schema>, parent?: string): Record<string, Schema>;
+export declare function setNestedProperty<T extends object, K>(obj: T, path: string, value: K): void;
+export declare function camelCaseToKebabCase(str: string): string;
+export declare function kebabCaseToCamelCase(str: string): string;
+export {};

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

@@ -0,0 +1,3 @@
+import { NormalizedCliOptions } from '../arguments/normalize';
+export declare function bundleWithConfig(configPath: string, cliOptions: NormalizedCliOptions): Promise<void>;
+export declare function bundleWithCliOptions(cliOptions: NormalizedCliOptions): Promise<void>;

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

@@ -0,0 +1 @@
+export declare function showHelp(): void;

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

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

package/dist/types/cli/load-config.d.ts

@@ -0,0 +1,5 @@
+import type { ConfigExport } from '../types/config-export';
+export declare function loadTsConfig(configFile: string): Promise<ConfigExport>;
+export declare function isFilePathESM(filePath: string): boolean;
+export declare function findNearestPackageData(basedir: string): any | null;
+export declare function loadConfig(configPath: string): Promise<ConfigExport>;

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

@@ -0,0 +1,5 @@
+import { type ConsolaInstance } from 'consola';
+/**
+ * Console logger
+ */
+export declare const logger: Record<string, any> | ConsolaInstance;

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

@@ -0,0 +1,7 @@
+/**
+ * If Composed plugins call `this.resolve` with `skipSelf: true`, the composed plugins will be skipped as a whole.
+ * To prevent that, we use this symbol to store the actual caller of `this.resolve` with `skipSelf: true`. And we
+ * will modify the skipSelf option to `false` and use this symbol to skip the caller itself in the composed plugins
+ * internally.
+ */
+export declare const SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF: unique symbol;

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

@@ -0,0 +1,45 @@
+import { Plugin } from '../plugin';
+export declare const ENUMERATED_INPUT_PLUGIN_HOOK_NAMES: readonly ["options", "buildStart", "resolveId", "load", "transform", "moduleParsed", "buildEnd", "onLog", "resolveDynamicImport", "closeBundle", "closeWatcher", "watchChange"];
+export declare const ENUMERATED_OUTPUT_PLUGIN_HOOK_NAMES: readonly ["augmentChunkHash", "outputOptions", "renderChunk", "renderStart", "renderError", "writeBundle", "generateBundle"];
+export declare const ENUMERATED_PLUGIN_HOOK_NAMES: [
+    ...typeof ENUMERATED_INPUT_PLUGIN_HOOK_NAMES,
+    ...typeof ENUMERATED_OUTPUT_PLUGIN_HOOK_NAMES,
+    'footer',
+    'banner',
+    'intro',
+    'outro'
+];
+/**
+ * Names of all properties in a `Plugin` object. Includes `name` and `api`.
+ */
+export type PluginProps = keyof Plugin;
+type EnumeratedPluginHookNames = typeof ENUMERATED_PLUGIN_HOOK_NAMES;
+/**
+ * Names of all hooks in a `Plugin` object. Does not include `name` and `api`, since they are not hooks.
+ */
+export type PluginHookNames = EnumeratedPluginHookNames[number];
+/**
+ * Names of all defined hooks. It's like
+ * ```ts
+ * type DefinedHookNames = {
+ *   options: 'options',
+ *   buildStart: 'buildStart',
+ *   ...
+ * }
+ * ```
+ */
+export type DefinedHookNames = {
+    readonly [K in PluginHookNames]: K;
+};
+/**
+ * Names of all defined hooks. It's like
+ * ```js
+ * const DEFINED_HOOK_NAMES ={
+ *   options: 'options',
+ *   buildStart: 'buildStart',
+ *   ...
+ * }
+ * ```
+ */
+export declare const DEFINED_HOOK_NAMES: DefinedHookNames;
+export {};

package/dist/types/experimental-index.d.ts

@@ -0,0 +1,9 @@
+export { experimental_scan as scan } from './api/experimental';
+export { moduleRunnerTransform, transform } from './binding';
+export type { TransformOptions, TransformResult } from './binding';
+export { defineParallelPlugin } from './plugin/parallel-plugin';
+export { composeJsPlugins as composePlugins } from './utils/compose-js-plugins';
+export { buildImportAnalysisPlugin, dynamicImportVarsPlugin, importGlobPlugin, isolatedDeclarationPlugin, jsonPlugin, loadFallbackPlugin, manifestPlugin, moduleFederationPlugin, modulePreloadPolyfillPlugin, viteResolvePlugin, wasmFallbackPlugin, wasmHelperPlugin, } from './builtin-plugin/constructors';
+export { aliasPlugin } from './builtin-plugin/alias-plugin';
+export { replacePlugin } from './builtin-plugin/replace-plugin';
+export { transformPlugin } from './builtin-plugin/transform-plugin';

package/dist/types/index.d.ts

@@ -0,0 +1,31 @@
+import { build, type BuildOptions } from './api/build';
+import { rolldown } from './api/rolldown';
+import { RolldownBuild } from './api/rolldown/rolldown-build';
+import { watch } from './api/watch';
+import { RolldownWatcher } from './api/watch/watch-emitter';
+import { PreRenderedChunk } from './binding';
+import type { LogOrStringHandler } from './log/logging';
+import type { ExternalOption, InputOption, InputOptions, JsxOptions } from './options/input-options';
+import { NormalizedInputOptions } from './options/normalized-input-options';
+import { InternalModuleFormat, NormalizedOutputOptions } from './options/normalized-output-options';
+import type { ModuleFormat, OutputOptions, PreRenderedAsset } from './options/output-options';
+import { WatchOptions } from './options/watch-options';
+import type { AsyncPluginHooks, CustomPluginOptions, FunctionPluginHooks, HookFilterExtension, ImportKind, LoadResult, ModuleOptions, ModuleType, ObjectHook, ParallelPluginHooks, PartialResolvedId, Plugin, ResolvedId, ResolveIdExtraOptions, ResolveIdResult, RolldownPlugin, RolldownPluginOption, SourceDescription, TransformResult } from './plugin';
+export { withFilter } from './plugin';
+import type { HookFilter, ModuleTypeFilter, StringFilter } from './plugin/hook-filter';
+import { MinimalPluginContext, PluginContextMeta } from './plugin/minimal-plugin-context';
+import { DefineParallelPluginResult } from './plugin/parallel-plugin';
+import { EmittedAsset, EmittedFile, GetModuleInfo, PluginContext } from './plugin/plugin-context';
+import { TransformPluginContext } from './plugin/transform-plugin-context';
+import { ConfigExport } from './types/config-export';
+import { ModuleInfo } from './types/module-info';
+import { OutputBundle } from './types/output-bundle';
+import type { RolldownOptions } from './types/rolldown-options';
+import { OutputAsset, OutputChunk, RenderedChunk, RenderedModule, RolldownOutput, SourceMap } from './types/rolldown-output';
+import { ExistingRawSourceMap, SourceMapInput } from './types/sourcemap';
+import { PartialNull } from './types/utils';
+import { defineConfig } from './utils/define-config';
+export { build, defineConfig, rolldown, watch };
+export declare const VERSION: string;
+export type { AsyncPluginHooks, BuildOptions, ConfigExport, CustomPluginOptions, DefineParallelPluginResult, EmittedAsset, EmittedFile, ExistingRawSourceMap, ExternalOption, FunctionPluginHooks, GetModuleInfo, HookFilter, HookFilterExtension, ImportKind, InputOption, InputOptions, InternalModuleFormat, JsxOptions, LoadResult, LogOrStringHandler, MinimalPluginContext, ModuleFormat, ModuleInfo, ModuleOptions, ModuleType, ModuleTypeFilter, NormalizedInputOptions, NormalizedOutputOptions, ObjectHook, OutputAsset, OutputBundle, OutputChunk, OutputOptions, ParallelPluginHooks, PartialNull, PartialResolvedId, Plugin, PluginContext, PluginContextMeta, PreRenderedAsset, PreRenderedChunk, RenderedChunk, RenderedModule, ResolvedId, ResolveIdExtraOptions, ResolveIdResult, RolldownBuild, RolldownOptions, RolldownOutput, RolldownPlugin, RolldownPluginOption, RolldownWatcher, SourceDescription, SourceMap, SourceMapInput, StringFilter, TransformPluginContext, TransformResult, WatchOptions, };
+export type { LoggingFunction, LogLevel, RollupError, RollupLog, WarningHandlerWithDefault, } from './types/misc';

package/dist/types/log/log-handler.d.ts

@@ -0,0 +1,4 @@
+import type { LoggingFunctionWithPosition, LogHandler, RollupLog } from '../types/misc';
+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,6 @@
+import type { InputOptions } from '../options/input-options';
+import type { Plugin } from '../plugin';
+import type { LogHandler } from '../types/misc';
+import { type LogLevelOption } from './logging';
+export declare function getLogger(plugins: Plugin[], onLog: LogHandler, logLevel: LogLevelOption, watchMode: boolean): LogHandler;
+export declare const getOnLog: (config: InputOptions, logLevel: LogLevelOption, printLog?: LogHandler) => LogHandler;

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

@@ -0,0 +1,12 @@
+export type LogLevel = 'info' | 'debug' | 'warn';
+export type LogLevelOption = LogLevel | 'silent';
+export type LogLevelWithError = LogLevel | 'error';
+export type RollupLog = any;
+export type RollupLogWithString = RollupLog | string;
+export type LogOrStringHandler = (level: LogLevelWithError, log: RollupLogWithString) => void;
+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>;

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

@@ -0,0 +1,18 @@
+import type { RollupLog } from '../types/misc';
+export declare function logParseError(message: string): RollupLog;
+export declare function logMinifyWarning(): RollupLog;
+export declare function logInvalidLogPosition(pluginName: string): RollupLog;
+export declare function logInputHookInOutputPlugin(pluginName: string, hookName: string): RollupLog;
+export declare function logCycleLoading(pluginName: string, moduleId: string): RollupLog;
+export declare function logMultiplyNotifyOption(): 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/generated/checks-options.d.ts

@@ -0,0 +1,57 @@
+export interface ChecksOptions {
+    /**
+     * Whether to emit warning when detecting circular dependency
+     * @default false
+     */
+    circularDependency?: boolean;
+    /**
+     * Whether to emit warning when detecting eval
+     * @default true
+     */
+    eval?: boolean;
+    /**
+     * Whether to emit warning when detecting missing global name
+     * @default true
+     */
+    missingGlobalName?: boolean;
+    /**
+     * Whether to emit warning when detecting missing name option for iife export
+     * @default true
+     */
+    missingNameOptionForIifeExport?: boolean;
+    /**
+     * Whether to emit warning when detecting mixed export
+     * @default true
+     */
+    mixedExport?: boolean;
+    /**
+     * Whether to emit warning when detecting unresolved entry
+     * @default true
+     */
+    unresolvedEntry?: boolean;
+    /**
+     * Whether to emit warning when detecting unresolved import
+     * @default true
+     */
+    unresolvedImport?: boolean;
+    /**
+     * Whether to emit warning when detecting filename conflict
+     * @default true
+     */
+    filenameConflict?: boolean;
+    /**
+     * Whether to emit warning when detecting common js variable in esm
+     * @default true
+     */
+    commonJsVariableInEsm?: boolean;
+    /**
+     * Whether to emit warning when detecting import is undefined
+     * @default true
+     */
+    importIsUndefined?: boolean;
+    /**
+     * Whether to emit warning when detecting configuration field conflict
+     * @default true
+     */
+    configurationFieldConflict?: boolean;
+}

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

@@ -0,0 +1,185 @@
+import { TransformOptions } from '../binding';
+import type { LogLevel, LogLevelOption, LogOrStringHandler, RollupLog, RollupLogWithString } from '../log/logging';
+import type { RolldownPluginOption } from '../plugin';
+import type { TreeshakingOptions } from '../types/module-side-effects';
+import type { NullValue, StringOrRegExp } from '../types/utils';
+import type { ChecksOptions } from './generated/checks-options';
+export type InputOption = string | string[] | Record<string, string>;
+type OxcTransformOption = Omit<TransformOptions, 'sourceType' | 'lang' | 'cwd' | 'sourcemap' | 'jsx' | 'define' | 'inject' | 'target'>;
+export type ExternalOption = StringOrRegExp | StringOrRegExp[] | ((id: string, parentId: string | undefined, isResolved: boolean) => NullValue<boolean>);
+export type ModuleTypes = Record<string, 'js' | 'jsx' | 'ts' | 'tsx' | 'json' | 'text' | 'base64' | 'dataurl' | 'binary' | 'empty' | 'css'>;
+export interface JsxOptions {
+    mode?: 'classic' | 'automatic' | 'preserve';
+    factory?: string;
+    fragment?: string;
+    importSource?: string;
+    jsxImportSource?: string;
+    refresh?: boolean;
+    development?: boolean;
+}
+export interface WatchOptions {
+    skipWrite?: boolean;
+    buildDelay?: number;
+    notify?: {
+        pollInterval?: number;
+        compareContents?: boolean;
+    };
+    include?: StringOrRegExp | StringOrRegExp[];
+    exclude?: StringOrRegExp | StringOrRegExp[];
+}
+export type MakeAbsoluteExternalsRelative = boolean | 'ifRelativeSource';
+export type HmrOptions = boolean | {
+    host?: string;
+    port?: number;
+    implement?: string;
+};
+export interface InputOptions {
+    input?: InputOption;
+    plugins?: RolldownPluginOption;
+    external?: ExternalOption;
+    resolve?: {
+        /**
+         * > [!WARNING]
+         * > `resolve.alias` will not call `resolveId` hooks of other plugin.
+         * > If you want to call `resolveId` hooks of other plugin, use `aliasPlugin` from `rolldown/experimental` instead.
+         * > You could find more discussion in [this issue](https://github.com/rolldown/rolldown/issues/3615)
+         */
+        alias?: Record<string, string[] | string>;
+        aliasFields?: string[][];
+        conditionNames?: string[];
+        /**
+         * Map of extensions to alternative extensions.
+         *
+         * With writing `import './foo.js'` in a file, you want to resolve it to `foo.ts` instead of `foo.js`.
+         * You can achieve this by setting: `extensionAlias: { '.js': ['.ts', '.js'] }`.
+         */
+        extensionAlias?: Record<string, string[]>;
+        exportsFields?: string[][];
+        extensions?: string[];
+        mainFields?: string[];
+        mainFiles?: string[];
+        modules?: string[];
+        symlinks?: boolean;
+        tsconfigFilename?: string;
+    };
+    cwd?: string;
+    /**
+     * Expected platform where the code run.
+     *
+     * @default
+     * - 'node' if the format is 'cjs'
+     * - 'browser' for other formats
+     */
+    platform?: 'node' | 'browser' | 'neutral';
+    shimMissingExports?: boolean;
+    treeshake?: boolean | TreeshakingOptions;
+    logLevel?: LogLevelOption;
+    onLog?: (level: LogLevel, log: RollupLog, defaultHandler: LogOrStringHandler) => void;
+    onwarn?: (warning: RollupLog, defaultHandler: (warning: RollupLogWithString | (() => RollupLogWithString)) => void) => void;
+    moduleTypes?: ModuleTypes;
+    experimental?: {
+        enableComposingJsPlugins?: boolean;
+        strictExecutionOrder?: boolean;
+        disableLiveBindings?: boolean;
+        viteMode?: boolean;
+        resolveNewUrlToAsset?: boolean;
+        hmr?: HmrOptions;
+    };
+    /**
+     * Replace global variables or [property accessors](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_accessors) with the provided values.
+     *
+     * # Examples
+     *
+     * - Replace the global variable `IS_PROD` with `true`
+     *
+     * ```js rolldown.config.js
+     * export default defineConfig({ define: { IS_PROD: 'true' // or JSON.stringify(true) } })
+     * ```
+     *
+     * Result:
+     *
+     * ```js
+     * // Input
+     * if (IS_PROD) {
+     *   console.log('Production mode')
+     * }
+     *
+     * // After bundling
+     * if (true) {
+     *   console.log('Production mode')
+     * }
+     * ```
+     *
+     * - Replace the property accessor `process.env.NODE_ENV` with `'production'`
+     *
+     * ```js rolldown.config.js
+     * export default defineConfig({ define: { 'process.env.NODE_ENV': "'production'" } })
+     * ```
+     *
+     * Result:
+     *
+     * ```js
+     * // Input
+     * if (process.env.NODE_ENV === 'production') {
+     *  console.log('Production mode')
+     * }
+     *
+     * // After bundling
+     * if ('production' === 'production') {
+     * console.log('Production mode')
+     * }
+     *
+     * ```
+     */
+    define?: Record<string, string>;
+    /**
+     * Inject import statements on demand.
+     *
+     * ## Supported patterns
+     * ```js
+     * {
+     *   // import { Promise } from 'es6-promise'
+     *   Promise: ['es6-promise', 'Promise'],
+     *
+     *   // import { Promise as P } from 'es6-promise'
+     *   P: ['es6-promise', 'Promise'],
+     *
+     *   // import $ from 'jquery'
+     *   $: 'jquery',
+     *
+     *   // import * as fs from 'node:fs'
+     *   fs: ['node:fs', '*'],
+     *
+     *   // Inject shims for property access pattern
+     *   'Object.assign': path.resolve( 'src/helpers/object-assign.js' ),
+     * }
+     * ```
+     */
+    inject?: Record<string, string | [string, string]>;
+    profilerNames?: boolean;
+    /**
+     * - `false` disables the JSX parser, resulting in a syntax error if JSX syntax is used.
+     * - `"preserve"` disables the JSX transformer, preserving the original JSX syntax in the output.
+     * - `"react"` enables the `classic` JSX transformer.
+     * - `"react-jsx"` enables the `automatic` JSX transformer.
+     *
+     * @default mode = "automatic"
+     */
+    jsx?: false | 'react' | 'react-jsx' | 'preserve' | JsxOptions;
+    transform?: OxcTransformOption;
+    watch?: WatchOptions | false;
+    dropLabels?: string[];
+    keepNames?: boolean;
+    checks?: ChecksOptions;
+    makeAbsoluteExternalsRelative?: MakeAbsoluteExternalsRelative;
+    debug?: {
+        buildId?: string;
+    };
+}
+interface OverwriteInputOptionsForCli {
+    external?: string[];
+    inject?: Record<string, string>;
+    treeshake?: boolean;
+}
+export type InputCliOptions = Omit<InputOptions, keyof OverwriteInputOptionsForCli | 'input' | 'plugins' | 'onwarn' | 'onLog' | 'resolve' | 'experimental' | 'profilerNames' | 'watch'> & OverwriteInputOptionsForCli;
+export {};

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

@@ -0,0 +1,18 @@
+import { InputOptions } from '..';
+import { BindingNormalizedOptions } from '../binding';
+import type { LogHandler } from '../types/misc';
+export interface NormalizedInputOptions {
+    input: string[] | Record<string, string>;
+    cwd: string | undefined;
+    platform: InputOptions['platform'];
+    shimMissingExports: boolean;
+}
+export declare class NormalizedInputOptionsImpl implements NormalizedInputOptions {
+    onLog: LogHandler;
+    inner: BindingNormalizedOptions;
+    constructor(inner: BindingNormalizedOptions, onLog: LogHandler);
+    get shimMissingExports(): boolean;
+    get input(): string[] | Record<string, string>;
+    get cwd(): string | undefined;
+    get platform(): 'browser' | 'node' | 'neutral';
+}

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

@@ -0,0 +1,70 @@
+import { RolldownPlugin } from '..';
+import type { BindingMinifyOptions, BindingNormalizedOptions } from '../binding';
+import type { SourcemapIgnoreListOption, SourcemapPathTransformOption } from '../types/misc';
+import type { AddonFunction, AssetFileNamesFunction, ChunkFileNamesFunction, GlobalsFunction, OutputOptions } from './output-options';
+export type InternalModuleFormat = 'es' | 'cjs' | 'iife' | 'umd' | 'app';
+export interface NormalizedOutputOptions {
+    name: string | undefined;
+    file: string | undefined;
+    dir: string | undefined;
+    entryFileNames: string | ChunkFileNamesFunction;
+    chunkFileNames: string | ChunkFileNamesFunction;
+    assetFileNames: string | AssetFileNamesFunction;
+    format: InternalModuleFormat;
+    exports: NonNullable<OutputOptions['exports']>;
+    sourcemap: boolean | 'inline' | 'hidden';
+    cssEntryFileNames: string | ChunkFileNamesFunction;
+    cssChunkFileNames: string | ChunkFileNamesFunction;
+    inlineDynamicImports: boolean;
+    externalLiveBindings: boolean;
+    banner: AddonFunction;
+    footer: AddonFunction;
+    intro: AddonFunction;
+    outro: AddonFunction;
+    esModule: boolean | 'if-default-prop';
+    extend: boolean;
+    globals: Record<string, string> | GlobalsFunction;
+    hashCharacters: 'base64' | 'base36' | 'hex';
+    sourcemapDebugIds: boolean;
+    sourcemapIgnoreList: SourcemapIgnoreListOption;
+    sourcemapPathTransform: SourcemapPathTransformOption | undefined;
+    minify: false | BindingMinifyOptions;
+    comments: 'none' | 'preserve-legal';
+    polyfillRequire: boolean;
+    plugins: RolldownPlugin[];
+}
+export declare class NormalizedOutputOptionsImpl implements NormalizedOutputOptions {
+    private inner;
+    private outputOptions;
+    private normalizedOutputPlugins;
+    constructor(inner: BindingNormalizedOptions, outputOptions: OutputOptions, normalizedOutputPlugins: RolldownPlugin[]);
+    get dir(): string | undefined;
+    get entryFileNames(): string | ChunkFileNamesFunction;
+    get chunkFileNames(): string | ChunkFileNamesFunction;
+    get assetFileNames(): string | AssetFileNamesFunction;
+    get format(): 'es' | 'cjs' | 'app' | 'iife' | 'umd';
+    get exports(): 'default' | 'named' | 'none' | 'auto';
+    get sourcemap(): boolean | 'inline' | 'hidden';
+    get cssEntryFileNames(): string | ChunkFileNamesFunction;
+    get cssChunkFileNames(): string | ChunkFileNamesFunction;
+    get shimMissingExports(): boolean;
+    get name(): string | undefined;
+    get file(): string | undefined;
+    get inlineDynamicImports(): boolean;
+    get externalLiveBindings(): boolean;
+    get banner(): AddonFunction;
+    get footer(): AddonFunction;
+    get intro(): AddonFunction;
+    get outro(): AddonFunction;
+    get esModule(): boolean | 'if-default-prop';
+    get extend(): boolean;
+    get globals(): Record<string, string> | GlobalsFunction;
+    get hashCharacters(): 'base64' | 'base36' | 'hex';
+    get sourcemapDebugIds(): boolean;
+    get sourcemapIgnoreList(): SourcemapIgnoreListOption;
+    get sourcemapPathTransform(): SourcemapPathTransformOption | undefined;
+    get minify(): false | BindingMinifyOptions;
+    get comments(): 'none' | 'preserve-legal';
+    get polyfillRequire(): boolean;
+    get plugins(): RolldownPlugin[];
+}