rolldown 1.0.0-beta.3-commit.06372d4 → 1.0.0-beta.3-commit.558ea78

package/dist/types/cli/commands/bundle.js

@@ -1,203 +0,0 @@
-import path from 'node:path';
-import { performance } from 'node:perf_hooks';
-import { onExit } from 'signal-exit';
-import { colors } from '../colors';
-import { logger } from '../logger';
-import { arraify } from '../../utils/misc';
-import { rolldown } from '../../api/rolldown';
-import { watch as rolldownWatch } from '../../api/watch';
-import { loadConfig } from '../load-config';
-export async function bundleWithConfig(configPath, cliOptions) {
-    const config = await loadConfig(configPath);
-    if (!config) {
-        logger.error(`No configuration found at ${config}`);
-        process.exit(1);
-    }
-    // TODO: Could add more validation/diagnostics here to emit a nice error message
-    if (cliOptions.watch) {
-        await watchInner(config, cliOptions);
-    }
-    else {
-        await bundleInner(config, cliOptions);
-    }
-}
-export async function bundleWithCliOptions(cliOptions) {
-    if (cliOptions.output.dir || cliOptions.output.file) {
-        const operation = cliOptions.watch ? watchInner : bundleInner;
-        await operation({}, cliOptions);
-        return;
-    }
-    if (cliOptions.watch) {
-        logger.error('You must specify `output.dir` to use watch mode');
-        process.exit(1);
-    }
-    // Rolldown doesn't yet support the following syntax:
-    // await using build = await rolldown(cliOptions.input)
-    const build = await rolldown(cliOptions.input);
-    try {
-        const { output: outputs } = await build.generate(cliOptions.output);
-        if (outputs.length === 0) {
-            logger.error('No output generated');
-            process.exit(1);
-        }
-        for (const file of outputs) {
-            if (outputs.length > 1) {
-                logger.log(`\n${colors.cyan(colors.bold(`|→ ${file.fileName}:`))}\n`);
-            }
-            // avoid consola since it doesn't print it as raw string
-            // eslint-disable-next-line no-console
-            console.log(file.type === 'asset' ? file.source : file.code);
-        }
-    }
-    finally {
-        await build.close();
-    }
-}
-async function watchInner(config, cliOptions) {
-    // Only if watch is true in CLI can we use watch mode.
-    // We should not make it `await`, as it never ends.
-    let normalizedConfig = arraify(config).map((option) => {
-        return {
-            ...option,
-            ...cliOptions.input,
-            output: arraify(option.output || {}).map((output) => {
-                return {
-                    ...output,
-                    ...cliOptions.output,
-                };
-            }),
-        };
-    });
-    const watcher = await rolldownWatch(normalizedConfig);
-    onExit((code) => {
-        Promise.resolve(watcher.close()).finally(() => {
-            process.exit(typeof code === 'number' ? code : 0);
-        });
-        return true;
-    });
-    const changedFile = [];
-    watcher.on('change', (id, event) => {
-        if (event.event === 'update') {
-            changedFile.push(id);
-        }
-    });
-    watcher.on('event', (event) => {
-        switch (event.code) {
-            case 'BUNDLE_START':
-                if (changedFile.length > 0) {
-                    logger.log(`Found ${colors.bold(changedFile.map(relativeId).join(', '))} changed, rebuilding...`);
-                }
-                changedFile.length = 0;
-                break;
-            case 'BUNDLE_END':
-                logger.success(`Rebuilt ${colors.bold(relativeId(event.output[0]))} in ${colors.bold(ms(event.duration))}.`);
-                break;
-            case 'ERROR':
-                logger.error(event.error);
-                break;
-            default:
-                break;
-        }
-    });
-    logger.log(`Waiting for changes...`);
-}
-async function bundleInner(config, cliOptions) {
-    const startTime = performance.now();
-    const result = [];
-    const configList = arraify(config);
-    for (const config of configList) {
-        const outputList = arraify(config.output || {});
-        const build = await rolldown({ ...config, ...cliOptions.input });
-        for (const output of outputList) {
-            // run multiply instance at sequential
-            try {
-                result.push(await build.write({
-                    ...output,
-                    ...cliOptions.output,
-                }));
-            }
-            finally {
-                await build.close();
-            }
-        }
-    }
-    result.forEach(printBundleOutputPretty);
-    logger.log(``);
-    const endTime = performance.now();
-    const duration = endTime - startTime;
-    // If the build time is more than 1s, we should display it in seconds.
-    logger.success(`Finished in ${colors.bold(ms(duration))}`);
-}
-function printBundleOutputPretty(output) {
-    const outputEntries = collectOutputEntries(output.output);
-    const outputLayoutSizes = collectOutputLayoutAdjustmentSizes(outputEntries);
-    printOutputEntries(outputEntries, outputLayoutSizes, '<DIR>');
-}
-function collectOutputEntries(output) {
-    return output.map((chunk) => ({
-        type: chunk.type,
-        fileName: chunk.fileName,
-        size: chunk.type === 'chunk' ? chunk.code.length : chunk.source.length,
-    }));
-}
-function collectOutputLayoutAdjustmentSizes(entries) {
-    let longest = 0;
-    let biggestSize = 0;
-    for (const entry of entries) {
-        if (entry.fileName.length > longest) {
-            longest = entry.fileName.length;
-        }
-        if (entry.size > biggestSize) {
-            biggestSize = entry.size;
-        }
-    }
-    const sizePad = displaySize(biggestSize).length;
-    return {
-        longest,
-        biggestSize,
-        sizePad,
-    };
-}
-const numberFormatter = new Intl.NumberFormat('en', {
-    maximumFractionDigits: 2,
-    minimumFractionDigits: 2,
-});
-function displaySize(bytes) {
-    return `${numberFormatter.format(bytes / 1000)} kB`;
-}
-const CHUNK_GROUPS = [
-    { type: 'asset', color: 'green' },
-    { type: 'chunk', color: 'cyan' },
-];
-function printOutputEntries(entries, sizeAdjustment, distPath) {
-    for (const group of CHUNK_GROUPS) {
-        const filtered = entries.filter((e) => e.type === group.type);
-        if (!filtered.length) {
-            continue;
-        }
-        for (const entry of filtered.sort((a, z) => a.size - z.size)) {
-            // output format: `path/to/xxx type | size: y.yy kB`
-            let log = colors.dim(withTrailingSlash(distPath));
-            log += colors[group.color](entry.fileName.padEnd(sizeAdjustment.longest + 2));
-            log += colors.dim(entry.type);
-            log += colors.dim(` │ size: ${displaySize(entry.size).padStart(sizeAdjustment.sizePad)}`);
-            logger.log(log);
-        }
-    }
-}
-function withTrailingSlash(path) {
-    if (path[path.length - 1] !== '/') {
-        return `${path}/`;
-    }
-    return path;
-}
-function ms(duration) {
-    return duration < 1000
-        ? `${duration.toFixed(2)} ms`
-        : `${(duration / 1000).toFixed(2)} s`;
-}
-function relativeId(id) {
-    if (!path.isAbsolute(id))
-        return id;
-    return path.relative(path.resolve(), id);
-}

package/dist/types/cli/commands/help.js

@@ -1,88 +0,0 @@
-import { logger } from '../logger';
-import { version, description, } from '../../../package.json' assert { type: 'json' };
-import { colors } from '../colors';
-import { options } from '../arguments';
-import { camelCaseToKebabCase } from '../arguments/utils';
-const introduction = `${colors.gray(`${description} (rolldown v${version})`)}
-
-${colors.bold(colors.underline('USAGE'))} ${colors.cyan('rolldown -c <config>')} or ${colors.cyan('rolldown <input> <options>')}`;
-const examples = [
-    {
-        title: 'Bundle with a config file `rolldown.config.mjs`',
-        command: 'rolldown -c rolldown.config.mjs',
-    },
-    {
-        title: 'Bundle the `src/main.ts` to `dist` with `cjs` format',
-        command: 'rolldown src/main.ts -d dist -f cjs',
-    },
-    {
-        title: 'Bundle the `src/main.ts` and handle the `.png` assets to Data URL',
-        command: 'rolldown src/main.ts -d dist --moduleTypes .png=dataurl',
-    },
-    {
-        title: 'Bundle the `src/main.tsx` and minify the output with sourcemap',
-        command: 'rolldown src/main.tsx -d dist -m -s',
-    },
-    {
-        title: 'Create self-executing IIFE using external jQuery as `$` and `_`',
-        command: 'rolldown src/main.ts -d dist -n bundle -f iife -e jQuery,window._ -g jQuery=$',
-    },
-];
-const notes = [
-    'Due to the API limitation, you need to pass `-s` for `.map` sourcemap file as the last argument.',
-    'If you are using the configuration, please pass the `-c` as the last argument if you ignore the default configuration file.',
-    'CLI options will override the configuration file.',
-    'For more information, please visit https://rolldown.rs/.',
-];
-export function showHelp() {
-    logger.log(introduction);
-    logger.log('');
-    logger.log(`${colors.bold(colors.underline('OPTIONS'))}`);
-    logger.log('');
-    logger.log(Object.entries(options)
-        .sort(([a], [b]) => {
-        // 1. If one of them has a short option, prioritize it.
-        if (options[a].short && !options[b].short) {
-            return -1;
-        }
-        if (!options[a].short && options[b].short) {
-            return 1;
-        }
-        // 2. If both of them have a short option, sort by the short letter.
-        if (options[a].short && options[b].short) {
-            return options[a].short.localeCompare(options[b].short);
-        }
-        // 3. If none of them has a short option, sort by the long option.
-        return a.localeCompare(b);
-    })
-        .map(([option, { type, short, hint, description }]) => {
-        let optionStr = `  --${option} `;
-        option = camelCaseToKebabCase(option);
-        if (short) {
-            optionStr += `-${short}, `;
-        }
-        if (type === 'string') {
-            optionStr += `<${hint ?? option}>`;
-        }
-        if (description && description.length > 0) {
-            description = description[0].toUpperCase() + description.slice(1);
-        }
-        return (colors.cyan(optionStr.padEnd(30)) +
-            description +
-            (description && description?.endsWith('.') ? '' : '.'));
-    })
-        .join('\n'));
-    logger.log('');
-    logger.log(`${colors.bold(colors.underline('EXAMPLES'))}`);
-    logger.log('');
-    examples.forEach(({ title, command }, ord) => {
-        logger.log(`  ${ord + 1}. ${title}:`);
-        logger.log(`    ${colors.cyan(command)}`);
-        logger.log('');
-    });
-    logger.log(`${colors.bold(colors.underline('NOTES'))}`);
-    logger.log('');
-    notes.forEach((note) => {
-        logger.log(`  * ${colors.gray(note)}`);
-    });
-}

package/dist/types/cli/index.js

@@ -1,27 +0,0 @@
-import process from 'node:process';
-import { bundleWithCliOptions, bundleWithConfig } from './commands/bundle';
-import { logger } from './logger';
-import { parseCliArguments } from './arguments';
-import { showHelp } from './commands/help';
-import { version } from '../../package.json';
-async function main() {
-    const cliOptions = parseCliArguments();
-    if (cliOptions.config || cliOptions.config === '') {
-        await bundleWithConfig(cliOptions.config, cliOptions);
-        return;
-    }
-    if ('input' in cliOptions.input) {
-        // If input is specified, we will bundle with the input options
-        await bundleWithCliOptions(cliOptions);
-        return;
-    }
-    if (cliOptions.version) {
-        logger.log(`rolldown v${version}`);
-        return;
-    }
-    showHelp();
-}
-main().catch((err) => {
-    logger.error(err);
-    process.exit(1);
-});

package/dist/types/cli/load-config.js

@@ -1,95 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { cwd } from 'node:process';
-import { readdir } from 'node:fs/promises';
-import { pathToFileURL } from 'node:url';
-import { rolldown } from '../api/rolldown';
-async function bundleTsConfig(configFile) {
-    const dirnameVarName = 'injected_original_dirname';
-    const filenameVarName = 'injected_original_filename';
-    const importMetaUrlVarName = 'injected_original_import_meta_url';
-    const bundle = await rolldown({
-        input: configFile,
-        platform: 'node',
-        resolve: {
-            mainFields: ['main'],
-        },
-        define: {
-            __dirname: dirnameVarName,
-            __filename: filenameVarName,
-            'import.meta.url': importMetaUrlVarName,
-            'import.meta.dirname': dirnameVarName,
-            'import.meta.filename': filenameVarName,
-        },
-        treeshake: false,
-        external: [/^[\w@][^:]/], // external bare imports
-        plugins: [
-            {
-                name: 'inject-file-scope-variables',
-                transform: {
-                    filter: { id: /\.[cm]?[jt]s$/ },
-                    async handler(code, id) {
-                        const injectValues = `const ${dirnameVarName} = ${JSON.stringify(path.dirname(id))};` +
-                            `const ${filenameVarName} = ${JSON.stringify(id)};` +
-                            `const ${importMetaUrlVarName} = ${JSON.stringify(pathToFileURL(id).href)};`;
-                        return { code: injectValues + code, map: null };
-                    },
-                },
-            },
-        ],
-    });
-    const outputDir = path.dirname(configFile);
-    const result = await bundle.write({
-        dir: outputDir,
-        format: 'esm',
-        sourcemap: 'inline',
-        entryFileNames: 'rolldown.config.[hash].js',
-    });
-    const fileName = result.output.find((chunk) => chunk.type === 'chunk' && chunk.isEntry).fileName;
-    return path.join(outputDir, fileName);
-}
-const SUPPORTED_JS_CONFIG_FORMATS = ['.js', '.mjs', '.cjs'];
-const SUPPORTED_TS_CONFIG_FORMATS = ['.ts', '.mts', '.cts'];
-const SUPPORTED_CONFIG_FORMATS = [
-    ...SUPPORTED_JS_CONFIG_FORMATS,
-    ...SUPPORTED_TS_CONFIG_FORMATS,
-];
-const DEFAULT_CONFIG_BASE = 'rolldown.config';
-async function findConfigFileNameInCwd() {
-    const filesInWorkingDirectory = new Set(await readdir(cwd()));
-    for (const extension of SUPPORTED_CONFIG_FORMATS) {
-        const fileName = `${DEFAULT_CONFIG_BASE}${extension}`;
-        if (filesInWorkingDirectory.has(fileName))
-            return fileName;
-    }
-    throw new Error('No `rolldown.config` configuration file found.');
-}
-export async function loadTsConfig(configFile) {
-    const file = await bundleTsConfig(configFile);
-    try {
-        return (await import(pathToFileURL(file).href)).default;
-    }
-    finally {
-        fs.unlink(file, () => { }); // Ignore errors
-    }
-}
-export async function loadConfig(configPath) {
-    const ext = path.extname((configPath = configPath || (await findConfigFileNameInCwd())));
-    try {
-        if (SUPPORTED_JS_CONFIG_FORMATS.includes(ext) ||
-            (process.env.NODE_OPTIONS?.includes('--import=tsx') &&
-                SUPPORTED_TS_CONFIG_FORMATS.includes(ext))) {
-            return (await import(pathToFileURL(configPath).href)).default;
-        }
-        else if (SUPPORTED_TS_CONFIG_FORMATS.includes(ext)) {
-            const rawConfigPath = path.resolve(configPath);
-            return await loadTsConfig(rawConfigPath);
-        }
-        else {
-            throw new Error(`Unsupported config format. Expected: \`${SUPPORTED_CONFIG_FORMATS.join(',')}\` but got \`${ext}\``);
-        }
-    }
-    catch (err) {
-        throw new Error('Error happened while loading config.', { cause: err });
-    }
-}

package/dist/types/cli/logger.js

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

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

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

@@ -1,9 +0,0 @@
-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.js

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

@@ -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.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);
-}