rolldown 1.0.0-beta.1-commit.7c52c94 → 1.0.0-beta.2-commit.f069c5d

package/dist/types/cli/logger.js

@@ -0,0 +1,35 @@
+import { createConsola } from 'consola';
+/**
+ * Console logger
+ */
+export const logger = process.env
+    .ROLLDOWN_TEST
+    ? createTestingLogger()
+    : createConsola({
+        formatOptions: {
+            date: false,
+        },
+    });
+function createTestingLogger() {
+    const types = [
+        'silent',
+        'fatal',
+        'error',
+        'warn',
+        'log',
+        'info',
+        'success',
+        'fail',
+        'ready',
+        'start',
+        'box',
+        'debug',
+        'trace',
+        'verbose',
+    ];
+    const ret = Object.create(null);
+    for (const type of types) {
+        ret[type] = console.log;
+    }
+    return ret;
+}

package/dist/types/constants/plugin-context.js

@@ -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 const SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF = Symbol('plugin-context-resolve-caller');

package/dist/types/constants/plugin.js

@@ -0,0 +1,69 @@
+export const ENUMERATED_INPUT_PLUGIN_HOOK_NAMES = [
+    'options',
+    'buildStart',
+    'resolveId',
+    'load',
+    'transform',
+    'moduleParsed',
+    'buildEnd',
+    'onLog',
+    'resolveDynamicImport',
+    'closeBundle',
+    'closeWatcher',
+    'watchChange',
+];
+export const ENUMERATED_OUTPUT_PLUGIN_HOOK_NAMES = [
+    'augmentChunkHash',
+    'outputOptions',
+    'renderChunk',
+    'renderStart',
+    'renderError',
+    'writeBundle',
+    'generateBundle',
+];
+export const ENUMERATED_PLUGIN_HOOK_NAMES = [
+    // build hooks
+    ...ENUMERATED_INPUT_PLUGIN_HOOK_NAMES,
+    // generate hooks
+    ...ENUMERATED_OUTPUT_PLUGIN_HOOK_NAMES,
+    // addon hooks
+    'footer',
+    'banner',
+    'intro',
+    'outro',
+];
+/**
+ * Names of all defined hooks. It's like
+ * ```js
+ * const DEFINED_HOOK_NAMES ={
+ *   options: 'options',
+ *   buildStart: 'buildStart',
+ *   ...
+ * }
+ * ```
+ */
+export const DEFINED_HOOK_NAMES = {
+    [ENUMERATED_PLUGIN_HOOK_NAMES[0]]: ENUMERATED_PLUGIN_HOOK_NAMES[0],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[1]]: ENUMERATED_PLUGIN_HOOK_NAMES[1],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[2]]: ENUMERATED_PLUGIN_HOOK_NAMES[2],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[3]]: ENUMERATED_PLUGIN_HOOK_NAMES[3],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[4]]: ENUMERATED_PLUGIN_HOOK_NAMES[4],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[5]]: ENUMERATED_PLUGIN_HOOK_NAMES[5],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[6]]: ENUMERATED_PLUGIN_HOOK_NAMES[6],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[7]]: ENUMERATED_PLUGIN_HOOK_NAMES[7],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[8]]: ENUMERATED_PLUGIN_HOOK_NAMES[8],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[9]]: ENUMERATED_PLUGIN_HOOK_NAMES[9],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[10]]: ENUMERATED_PLUGIN_HOOK_NAMES[10],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[11]]: ENUMERATED_PLUGIN_HOOK_NAMES[11],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[12]]: ENUMERATED_PLUGIN_HOOK_NAMES[12],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[13]]: ENUMERATED_PLUGIN_HOOK_NAMES[13],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[14]]: ENUMERATED_PLUGIN_HOOK_NAMES[14],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[15]]: ENUMERATED_PLUGIN_HOOK_NAMES[15],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[16]]: ENUMERATED_PLUGIN_HOOK_NAMES[16],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[17]]: ENUMERATED_PLUGIN_HOOK_NAMES[17],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[18]]: ENUMERATED_PLUGIN_HOOK_NAMES[18],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[19]]: ENUMERATED_PLUGIN_HOOK_NAMES[19],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[20]]: ENUMERATED_PLUGIN_HOOK_NAMES[20],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[21]]: ENUMERATED_PLUGIN_HOOK_NAMES[21],
+    [ENUMERATED_PLUGIN_HOOK_NAMES[22]]: ENUMERATED_PLUGIN_HOOK_NAMES[22],
+};

package/dist/types/experimental-index.js

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

package/dist/types/index.d.ts

@@ -2,7 +2,7 @@ import { RolldownOutput, OutputAsset, OutputChunk, RenderedChunk, SourceMap } fr
 import type { InputOptions, InputOption, ExternalOption, JsxOptions } from './options/input-options';
 import type { ModuleFormat, OutputOptions } from './options/output-options';
 import type { RolldownOptions } from './types/rolldown-options';
-import type { AsyncPluginHooks, CustomPluginOptions, FunctionPluginHooks, ImportKind, LoadResult, ModuleOptions, ModuleType, ObjectHook, ParallelPluginHooks, PartialResolvedId, Plugin, RolldownPlugin, ResolveIdResult, ResolvedId, SourceDescription, TransformResult } from './plugin';
+import type { AsyncPluginHooks, CustomPluginOptions, FunctionPluginHooks, ImportKind, LoadResult, ModuleOptions, ModuleType, ObjectHook, ParallelPluginHooks, PartialResolvedId, Plugin, RolldownPlugin, RolldownPluginOption, ResolveIdResult, ResolvedId, SourceDescription, TransformResult } from './plugin';
 import { DefineParallelPluginResult } from './plugin/parallel-plugin';
 import { defineConfig } from './utils/define-config';
 import { rolldown } from './api/rolldown';
@@ -24,5 +24,5 @@ import { RolldownWatcher } from './api/watch/watch-emitter';
 import { build, type BuildOptions } from './api/build';
 export { defineConfig, rolldown, watch, build };
 export declare const VERSION: string;
-export type { OutputAsset, OutputChunk, RolldownOptions, RolldownOutput, RolldownBuild, InputOptions, NormalizedInputOptions, OutputOptions, NormalizedOutputOptions, Plugin, RolldownPlugin, DefineParallelPluginResult, ConfigExport, ImportKind, InputOption, ExternalOption, ModuleFormat, ModuleType, InternalModuleFormat, LoadResult, TransformResult, ResolveIdResult, PluginContext, TransformPluginContext, ObjectHook, PreRenderedChunk, SourceMap, SourceDescription, PartialNull, PartialResolvedId, ResolvedId, ModuleOptions, ModuleInfo, MinimalPluginContext, EmittedFile, EmittedAsset, CustomPluginOptions, AsyncPluginHooks, ParallelPluginHooks, FunctionPluginHooks, ExistingRawSourceMap, SourceMapInput, OutputBundle, JsxOptions, WatchOptions, RolldownWatcher, BuildOptions, RenderedChunk, };
+export type { OutputAsset, OutputChunk, RolldownOptions, RolldownOutput, RolldownBuild, InputOptions, NormalizedInputOptions, OutputOptions, NormalizedOutputOptions, Plugin, RolldownPlugin, RolldownPluginOption, DefineParallelPluginResult, ConfigExport, ImportKind, InputOption, ExternalOption, ModuleFormat, ModuleType, InternalModuleFormat, LoadResult, TransformResult, ResolveIdResult, PluginContext, TransformPluginContext, ObjectHook, PreRenderedChunk, SourceMap, SourceDescription, PartialNull, PartialResolvedId, ResolvedId, ModuleOptions, ModuleInfo, MinimalPluginContext, EmittedFile, EmittedAsset, CustomPluginOptions, AsyncPluginHooks, ParallelPluginHooks, FunctionPluginHooks, ExistingRawSourceMap, SourceMapInput, OutputBundle, JsxOptions, WatchOptions, RolldownWatcher, BuildOptions, RenderedChunk, };
 export type { RollupError, RollupLog, LoggingFunction } from './types/misc';

package/dist/types/index.js

@@ -0,0 +1,7 @@
+import { defineConfig } from './utils/define-config';
+import { rolldown } from './api/rolldown';
+import { watch } from './api/watch';
+import { version } from '../package.json';
+import { build } from './api/build';
+export { defineConfig, rolldown, watch, build };
+export const VERSION = version;

package/dist/types/log/logHandler.js

@@ -0,0 +1,25 @@
+import { noop } from '../utils/misc';
+import { LOG_LEVEL_WARN, logLevelPriority, } from './logging';
+import { logInvalidLogPosition } from './logs';
+export const normalizeLog = (log) => typeof log === 'string'
+    ? { message: log }
+    : typeof log === 'function'
+        ? normalizeLog(log())
+        : log;
+export function getLogHandler(level, code, logger, pluginName, logLevel) {
+    if (logLevelPriority[level] < logLevelPriority[logLevel]) {
+        return noop;
+    }
+    return (log, pos) => {
+        if (pos != null) {
+            logger(LOG_LEVEL_WARN, logInvalidLogPosition(pluginName));
+        }
+        log = normalizeLog(log);
+        if (log.code && !log.pluginCode) {
+            log.pluginCode = log.code;
+        }
+        log.code = code;
+        log.plugin = pluginName;
+        logger(level, log);
+    };
+}

package/dist/types/log/logger.js

@@ -0,0 +1,107 @@
+import { LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_WARN, LOG_LEVEL_ERROR, logLevelPriority, } from './logging';
+import { error } from './logs';
+import { normalizeLog } from './logHandler';
+import path from 'node:path';
+import { VERSION } from '..';
+import { getSortedPlugins } from '../plugin/plugin-driver';
+export function getLogger(plugins, onLog, logLevel) {
+    const minimalPriority = logLevelPriority[logLevel];
+    const logger = (level, log, skipped = new Set()) => {
+        const logPriority = logLevelPriority[level];
+        if (logPriority < minimalPriority) {
+            return;
+        }
+        for (const plugin of getSortedPlugins('onLog', plugins)) {
+            if (skipped.has(plugin))
+                continue;
+            const { onLog: pluginOnLog } = plugin;
+            if (pluginOnLog) {
+                const getLogHandler = (level) => {
+                    if (logLevelPriority[level] < minimalPriority) {
+                        return () => { };
+                    }
+                    return (log) => logger(level, normalizeLog(log), new Set(skipped).add(plugin));
+                };
+                const handler = 'handler' in pluginOnLog ? pluginOnLog.handler : pluginOnLog;
+                if (handler.call({
+                    debug: getLogHandler(LOG_LEVEL_DEBUG),
+                    error: (log) => error(normalizeLog(log)),
+                    info: getLogHandler(LOG_LEVEL_INFO),
+                    meta: {
+                        rollupVersion: '4.23.0',
+                        rolldownVersion: VERSION,
+                        watchMode: false,
+                    },
+                    warn: getLogHandler(LOG_LEVEL_WARN),
+                    pluginName: plugin.name || 'unknown',
+                }, level, log) === false) {
+                    return;
+                }
+            }
+        }
+        onLog(level, log);
+    };
+    return logger;
+}
+export const getOnLog = (config, logLevel, printLog = defaultPrintLog) => {
+    const { onwarn, onLog } = config;
+    const defaultOnLog = getDefaultOnLog(printLog, onwarn);
+    if (onLog) {
+        const minimalPriority = logLevelPriority[logLevel];
+        return (level, log) => onLog(level, addLogToString(log), (level, handledLog) => {
+            if (level === LOG_LEVEL_ERROR) {
+                return error(normalizeLog(handledLog));
+            }
+            if (logLevelPriority[level] >= minimalPriority) {
+                defaultOnLog(level, normalizeLog(handledLog));
+            }
+        });
+    }
+    return defaultOnLog;
+};
+const getDefaultOnLog = (printLog, onwarn) => onwarn
+    ? (level, log) => {
+        if (level === LOG_LEVEL_WARN) {
+            onwarn(addLogToString(log), (warning) => printLog(LOG_LEVEL_WARN, normalizeLog(warning)));
+        }
+        else {
+            printLog(level, log);
+        }
+    }
+    : printLog;
+const addLogToString = (log) => {
+    Object.defineProperty(log, 'toString', {
+        value: () => getExtendedLogMessage(log),
+        writable: true,
+    });
+    return log;
+};
+const defaultPrintLog = (level, log) => {
+    const message = getExtendedLogMessage(log);
+    switch (level) {
+        case LOG_LEVEL_WARN: {
+            return console.warn(message);
+        }
+        case LOG_LEVEL_DEBUG: {
+            return console.debug(message);
+        }
+        default: {
+            return console.info(message);
+        }
+    }
+};
+const getExtendedLogMessage = (log) => {
+    let prefix = '';
+    if (log.plugin) {
+        prefix += `(${log.plugin} plugin) `;
+    }
+    if (log.loc) {
+        prefix += `${relativeId(log.loc.file)} (${log.loc.line}:${log.loc.column}) `;
+    }
+    return prefix + log.message;
+};
+function relativeId(id) {
+    if (!path.isAbsolute(id))
+        return id;
+    return path.relative(path.resolve(), id);
+}

package/dist/types/log/logging.js

@@ -0,0 +1,11 @@
+export const LOG_LEVEL_SILENT = 'silent';
+export const LOG_LEVEL_ERROR = 'error';
+export const LOG_LEVEL_WARN = 'warn';
+export const LOG_LEVEL_INFO = 'info';
+export const LOG_LEVEL_DEBUG = 'debug';
+export const logLevelPriority = {
+    [LOG_LEVEL_DEBUG]: 0,
+    [LOG_LEVEL_INFO]: 1,
+    [LOG_LEVEL_WARN]: 2,
+    [LOG_LEVEL_SILENT]: 3,
+};

package/dist/types/log/logs.js

@@ -0,0 +1,86 @@
+import { getCodeFrame } from '../utils/code-frame';
+import { locate } from './locate-character';
+import { colors } from '../cli/colors';
+const INVALID_LOG_POSITION = 'INVALID_LOG_POSITION', PLUGIN_ERROR = 'PLUGIN_ERROR', INPUT_HOOK_IN_OUTPUT_PLUGIN = 'INPUT_HOOK_IN_OUTPUT_PLUGIN', CYCLE_LOADING = 'CYCLE_LOADING', MULTIPLY_NOTIFY_OPTION = 'MULTIPLY_NOTIFY_OPTION', MINIFY_WARNING = 'MINIFY_WARNING', PARSE_ERROR = 'PARSE_ERROR';
+export function logParseError(message) {
+    return {
+        code: PARSE_ERROR,
+        message,
+    };
+}
+export function logMinifyWarning() {
+    return {
+        code: MINIFY_WARNING,
+        message: colors.yellow('The built-in minifier is still under development. Setting "minify: true" is not recommended for production use.'),
+    };
+}
+export function logInvalidLogPosition(pluginName) {
+    return {
+        code: INVALID_LOG_POSITION,
+        message: `Plugin "${pluginName}" tried to add a file position to a log or warning. This is only supported in the "transform" hook at the moment and will be ignored.`,
+    };
+}
+export function logInputHookInOutputPlugin(pluginName, hookName) {
+    return {
+        code: INPUT_HOOK_IN_OUTPUT_PLUGIN,
+        message: `The "${hookName}" hook used by the output plugin ${pluginName} is a build time hook and will not be run for that plugin. Either this plugin cannot be used as an output plugin, or it should have an option to configure it as an output plugin.`,
+    };
+}
+export function logCycleLoading(pluginName, moduleId) {
+    return {
+        code: CYCLE_LOADING,
+        message: `Found the module "${moduleId}" cycle loading at ${pluginName} plugin, it maybe blocking fetching modules.`,
+    };
+}
+export function logMultiplyNotifyOption() {
+    return {
+        code: MULTIPLY_NOTIFY_OPTION,
+        message: `Found multiply notify option at watch options, using first one to start notify watcher.`,
+    };
+}
+export function logPluginError(error, plugin, { hook, id } = {}) {
+    const code = error.code;
+    if (!error.pluginCode &&
+        code != null &&
+        (typeof code !== 'string' || !code.startsWith('PLUGIN_'))) {
+        error.pluginCode = code;
+    }
+    error.code = PLUGIN_ERROR;
+    error.plugin = plugin;
+    if (hook) {
+        error.hook = hook;
+    }
+    if (id) {
+        error.id = id;
+    }
+    return error;
+}
+export function error(base) {
+    if (!(base instanceof Error)) {
+        base = Object.assign(new Error(base.message), base);
+        Object.defineProperty(base, 'name', {
+            value: 'RollupError',
+            writable: true,
+        });
+    }
+    throw base;
+}
+export function augmentCodeLocation(properties, pos, source, id) {
+    if (typeof pos === 'object') {
+        const { line, column } = pos;
+        properties.loc = { column, file: id, line };
+    }
+    else {
+        properties.pos = pos;
+        const location = locate(source, pos, { offsetLine: 1 });
+        if (!location) {
+            return;
+        }
+        const { line, column } = location;
+        properties.loc = { column, file: id, line };
+    }
+    if (properties.frame === undefined) {
+        const { line, column } = properties.loc;
+        properties.frame = getCodeFrame(source, line, column);
+    }
+}

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

@@ -26,7 +26,7 @@ export interface WatchOptions {
 }
 export interface ChecksOptions {
     /**
-     * Wether to emit warnings when detecting circular dependencies.
+     * Whether to emit warnings when detecting circular dependencies.
      * @default false
      */
     circularDependency?: boolean;
@@ -76,6 +76,52 @@ export interface InputOptions {
         viteMode?: boolean;
         resolveNewUrlToAsset?: boolean;
     };
+    /**
+     * 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.
@@ -103,7 +149,6 @@ export interface InputOptions {
     inject?: Record<string, string | [string, string]>;
     profilerNames?: boolean;
     /**
-     * JSX options.
      * The `false` is disabled jsx parser, it will give you a syntax error if you use jsx syntax
      * The `mode: preserve` is disabled jsx transformer, it perverse original jsx syntax in the output.
      * The `mode: classic` is enabled jsx `classic` transformer.

package/dist/types/options/input-options.js

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

package/dist/types/options/normalized-input-options.js

@@ -0,0 +1,21 @@
+// TODO: I guess we make these getters enumerable so it act more like a plain object
+export class NormalizedInputOptionsImpl {
+    onLog;
+    inner;
+    constructor(inner, onLog) {
+        this.onLog = onLog;
+        this.inner = inner;
+    }
+    get shimMissingExports() {
+        return this.inner.shimMissingExports;
+    }
+    get input() {
+        return this.inner.input;
+    }
+    get cwd() {
+        return this.inner.cwd ?? undefined;
+    }
+    get platform() {
+        return this.inner.platform;
+    }
+}

package/dist/types/options/normalized-output-options.js

@@ -0,0 +1,99 @@
+import { unsupported } from '../utils/misc';
+function mapFunctionOption(option, name) {
+    return typeof option === 'undefined'
+        ? () => {
+            unsupported(`You should not take \`NormalizedOutputOptions#${name}\` and call it directly`);
+        }
+        : option;
+}
+// TODO: I guess we make these getters enumerable so it act more like a plain object
+export class NormalizedOutputOptionsImpl {
+    inner;
+    constructor(inner) {
+        this.inner = inner;
+    }
+    get dir() {
+        return this.inner.dir ?? undefined;
+    }
+    get entryFileNames() {
+        return mapFunctionOption(this.inner.entryFilenames, 'entryFileNames');
+    }
+    get chunkFileNames() {
+        return mapFunctionOption(this.inner.chunkFilenames, 'chunkFileNames');
+    }
+    get assetFileNames() {
+        return this.inner.assetFilenames;
+    }
+    get format() {
+        return this.inner.format;
+    }
+    get exports() {
+        return this.inner.exports;
+    }
+    get sourcemap() {
+        return this.inner.sourcemap;
+    }
+    get cssEntryFileNames() {
+        return mapFunctionOption(this.inner.cssEntryFilenames, 'cssEntryFileNames');
+    }
+    get cssChunkFileNames() {
+        return mapFunctionOption(this.inner.cssChunkFilenames, 'cssChunkFileNames');
+    }
+    get shimMissingExports() {
+        return this.inner.shimMissingExports;
+    }
+    get name() {
+        return this.inner.name ?? undefined;
+    }
+    get file() {
+        return this.inner.file ?? undefined;
+    }
+    get inlineDynamicImports() {
+        return this.inner.inlineDynamicImports;
+    }
+    get externalLiveBindings() {
+        return this.inner.externalLiveBindings;
+    }
+    get banner() {
+        return mapFunctionOption(this.inner.banner, 'banner') ?? undefined;
+    }
+    get footer() {
+        return mapFunctionOption(this.inner.footer, 'footer') ?? undefined;
+    }
+    get intro() {
+        return mapFunctionOption(this.inner.intro, 'intro') ?? undefined;
+    }
+    get outro() {
+        return mapFunctionOption(this.inner.outro, 'outro') ?? undefined;
+    }
+    get esModule() {
+        return this.inner.esModule;
+    }
+    get extend() {
+        return this.inner.extend;
+    }
+    get globals() {
+        return mapFunctionOption(this.inner.globals, 'globals');
+    }
+    get hashCharacters() {
+        return this.inner.hashCharacters;
+    }
+    get sourcemapDebugIds() {
+        return this.inner.sourcemapDebugIds;
+    }
+    get sourcemapIgnoreList() {
+        return mapFunctionOption(void 0, 'sourcemapIgnoreList');
+    }
+    get sourcemapPathTransform() {
+        return mapFunctionOption(void 0, 'sourcemapPathTransform');
+    }
+    get minify() {
+        return this.inner.minify;
+    }
+    get comments() {
+        return this.inner.comments;
+    }
+    get polyfillRequire() {
+        return this.inner.polyfillRequire;
+    }
+}

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

@@ -44,6 +44,9 @@ export interface OutputOptions {
     inlineDynamicImports?: boolean;
     advancedChunks?: {
         minSize?: number;
+        maxSize?: number;
+        maxModuleSize?: number;
+        minModuleSize?: number;
         minShareCount?: number;
         groups?: {
             name: string;
@@ -51,6 +54,9 @@ export interface OutputOptions {
             priority?: number;
             minSize?: number;
             minShareCount?: number;
+            maxSize?: number;
+            maxModuleSize?: number;
+            minModuleSize?: number;
         }[];
     };
     /**

package/dist/types/options/output-options.js

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

package/dist/types/options/watch-options.js

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

package/dist/types/parallel-plugin-worker.js

@@ -0,0 +1,31 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { registerPlugins } from './binding';
+import { bindingifyPlugin } from './plugin/bindingify-plugin';
+import { PluginContextData } from './plugin/plugin-context-data';
+const { registryId, pluginInfos, threadNumber } = workerData;
+(async () => {
+    try {
+        const plugins = await Promise.all(pluginInfos.map(async (pluginInfo) => {
+            const pluginModule = await import(pluginInfo.fileUrl);
+            const definePluginImpl = pluginModule.default;
+            const plugin = await definePluginImpl(pluginInfo.options, {
+                threadNumber,
+            });
+            return {
+                index: pluginInfo.index,
+                // TODO(sapphi-red): support inputOptions and outputOptions
+                plugin: bindingifyPlugin(plugin, {}, {}, 
+                // TODO need to find a way to share pluginContextData
+                new PluginContextData(), () => { }, 'info'),
+            };
+        }));
+        registerPlugins(registryId, plugins);
+        parentPort.postMessage({ type: 'success' });
+    }
+    catch (error) {
+        parentPort.postMessage({ type: 'error', error });
+    }
+    finally {
+        parentPort.unref();
+    }
+})();

package/dist/types/parallel-plugin.js

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