rolldown 1.0.0-beta.2-commit.2666b23 → 1.0.0-beta.20

package/dist/types/log/logHandler.js

@@ -1,25 +0,0 @@
-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.d.ts

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

package/dist/types/log/logger.js

@@ -1,107 +0,0 @@
-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.d.ts

@@ -1,11 +0,0 @@
-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 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/logging.js

@@ -1,11 +0,0 @@
-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.d.ts

@@ -1,18 +0,0 @@
-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/log/logs.js

@@ -1,86 +0,0 @@
-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

@@ -1,170 +0,0 @@
-import type { RolldownPluginOption } from '../plugin';
-import type { LogLevel, LogLevelOption, LogLevelWithError, RollupLog, RollupLogWithString } from '../log/logging';
-import type { NullValue, StringOrRegExp } from '../types/utils';
-import type { TreeshakingOptions } from '../types/module-side-effects';
-export type InputOption = string | string[] | Record<string, string>;
-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;
-    notify?: {
-        pollInterval?: number;
-        compareContents?: boolean;
-    };
-    include?: StringOrRegExp | StringOrRegExp[];
-    exclude?: StringOrRegExp | StringOrRegExp[];
-    chokidar?: any;
-}
-export interface ChecksOptions {
-    /**
-     * Whether to emit warnings when detecting circular dependencies.
-     * @default false
-     */
-    circularDependency?: boolean;
-}
-export interface InputOptions {
-    input?: InputOption;
-    plugins?: RolldownPluginOption;
-    external?: ExternalOption;
-    resolve?: {
-        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: (level: LogLevelWithError, log: RollupLogWithString) => void) => void;
-    onwarn?: (warning: RollupLog, defaultHandler: (warning: RollupLogWithString | (() => RollupLogWithString)) => void) => void;
-    moduleTypes?: ModuleTypes;
-    experimental?: {
-        enableComposingJsPlugins?: boolean;
-        strictExecutionOrder?: boolean;
-        disableLiveBindings?: boolean;
-        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.
-     *
-     * ## 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;
-    /**
-     * 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.
-     * The `mode: automatic` is enabled jsx `automatic` transformer.
-     * @default mode = 'automatic'
-     */
-    jsx?: false | JsxOptions;
-    watch?: WatchOptions | false;
-    dropLabels?: string[];
-    keepNames?: boolean;
-    checks?: ChecksOptions;
-}
-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/input-options.js

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

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

@@ -1,18 +0,0 @@
-import type { LogHandler } from '../types/misc';
-import { BindingNormalizedOptions } from '../binding';
-import { InputOptions } from '..';
-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-input-options.js

@@ -1,21 +0,0 @@
-// 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.d.ts

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

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

@@ -1,99 +0,0 @@
-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;
-    }
-}