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

package/dist/types/utils/compose-js-plugins.js

@@ -1,400 +0,0 @@
-import { normalizeHook } from './normalize-hook';
-import { isNullish } from './misc';
-import { BuiltinPlugin } from '../builtin-plugin/constructors';
-import * as R from 'remeda';
-import { SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF } from '../constants/plugin-context';
-import { isPluginHookName } from './plugin';
-const unsupportedHookName = [
-    'augmentChunkHash',
-    'generateBundle',
-    'moduleParsed',
-    'onLog',
-    'options',
-    'outputOptions',
-    'renderError',
-    'renderStart',
-    'resolveDynamicImport',
-    'writeBundle',
-];
-const unsupportedHooks = new Set(unsupportedHookName);
-function isUnsupportedHooks(hookName) {
-    return unsupportedHooks.has(hookName);
-}
-function createComposedPlugin(plugins) {
-    // Throw errors if we try to merge plugins with unsupported hooks
-    const names = [];
-    const batchedHooks = {};
-    plugins.forEach((plugin, index) => {
-        const pluginName = plugin.name || `Anonymous(index: ${index})`;
-        names.push(pluginName);
-        R.keys(plugin).forEach((pluginProp) => {
-            if (isUnsupportedHooks(pluginProp)) {
-                throw new Error(`Failed to compose js plugins. Plugin ${pluginName} has an unsupported hook: ${pluginProp}`);
-            }
-            if (!isPluginHookName(pluginProp)) {
-                // Not hooks. Just ignore these properties
-                return;
-            }
-            switch (pluginProp) {
-                case 'buildStart': {
-                    const handlers = batchedHooks.buildStart ?? [];
-                    batchedHooks.buildStart = handlers;
-                    if (plugin.buildStart) {
-                        handlers.push([plugin.buildStart, plugin]);
-                    }
-                    break;
-                }
-                case 'load': {
-                    const handlers = batchedHooks.load ?? [];
-                    batchedHooks.load = handlers;
-                    if (plugin.load) {
-                        handlers.push([plugin.load, plugin]);
-                    }
-                    break;
-                }
-                case 'transform': {
-                    const handlers = batchedHooks.transform ?? [];
-                    batchedHooks.transform = handlers;
-                    if (plugin.transform) {
-                        handlers.push([plugin.transform, plugin]);
-                    }
-                    break;
-                }
-                case 'resolveId': {
-                    const handlers = batchedHooks.resolveId ?? [];
-                    batchedHooks.resolveId = handlers;
-                    if (plugin.resolveId) {
-                        handlers.push([plugin.resolveId, plugin]);
-                    }
-                    break;
-                }
-                case 'buildEnd': {
-                    const handlers = batchedHooks.buildEnd ?? [];
-                    batchedHooks.buildEnd = handlers;
-                    if (plugin.buildEnd) {
-                        handlers.push([plugin.buildEnd, plugin]);
-                    }
-                    break;
-                }
-                case 'renderChunk': {
-                    const handlers = batchedHooks.renderChunk ?? [];
-                    batchedHooks.renderChunk = handlers;
-                    if (plugin.renderChunk) {
-                        handlers.push([plugin.renderChunk, plugin]);
-                    }
-                    break;
-                }
-                case 'banner':
-                case 'footer':
-                case 'intro':
-                case 'outro': {
-                    const hook = plugin[pluginProp];
-                    if (hook) {
-                        ;
-                        (batchedHooks[pluginProp] ??= []).push([hook, plugin]);
-                    }
-                    break;
-                }
-                case 'closeBundle': {
-                    const handlers = batchedHooks.closeBundle ?? [];
-                    batchedHooks.closeBundle = handlers;
-                    if (plugin.closeBundle) {
-                        handlers.push([plugin.closeBundle, plugin]);
-                    }
-                    break;
-                }
-                case 'watchChange': {
-                    const handlers = batchedHooks.watchChange ?? [];
-                    batchedHooks.watchChange = handlers;
-                    if (plugin.watchChange) {
-                        handlers.push([plugin.watchChange, plugin]);
-                    }
-                    break;
-                }
-                case 'closeWatcher': {
-                    const handlers = batchedHooks.closeWatcher ?? [];
-                    batchedHooks.closeWatcher = handlers;
-                    if (plugin.closeWatcher) {
-                        handlers.push([plugin.closeWatcher, plugin]);
-                    }
-                    break;
-                }
-                default: {
-                }
-            }
-        });
-    });
-    const composed = {
-        name: `Composed(${names.join(', ')})`,
-    };
-    const createFixedPluginResolveFnMap = new Map();
-    function applyFixedPluginResolveFn(ctx, plugin) {
-        const createFixedPluginResolveFn = createFixedPluginResolveFnMap.get(plugin);
-        if (createFixedPluginResolveFn) {
-            ctx.resolve = createFixedPluginResolveFn(ctx, ctx.resolve.bind(ctx));
-        }
-        return ctx;
-    }
-    if (batchedHooks.resolveId) {
-        const batchedHandlers = batchedHooks.resolveId;
-        const handlerSymbols = batchedHandlers.map(([_handler, plugin]) => Symbol(plugin.name ?? `Anonymous`));
-        for (let handlerIdx = 0; handlerIdx < batchedHandlers.length; handlerIdx++) {
-            const [_handler, plugin] = batchedHandlers[handlerIdx];
-            const handlerSymbol = handlerSymbols[handlerIdx];
-            const createFixedPluginResolveFn = (ctx, resolve) => {
-                return (source, importer, rawContextResolveOptions) => {
-                    const contextResolveOptions = rawContextResolveOptions ?? {};
-                    if (contextResolveOptions.skipSelf) {
-                        contextResolveOptions[SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF] =
-                            handlerSymbol;
-                        contextResolveOptions.skipSelf = false;
-                    }
-                    return resolve(source, importer, contextResolveOptions);
-                };
-            };
-            createFixedPluginResolveFnMap.set(plugin, createFixedPluginResolveFn);
-        }
-        composed.resolveId = async function (source, importer, rawHookResolveIdOptions) {
-            const hookResolveIdOptions = rawHookResolveIdOptions;
-            const symbolForCallerThatSkipSelf = hookResolveIdOptions?.[SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF];
-            for (let handlerIdx = 0; handlerIdx < batchedHandlers.length; handlerIdx++) {
-                const [handler, plugin] = batchedHandlers[handlerIdx];
-                const handlerSymbol = handlerSymbols[handlerIdx];
-                if (symbolForCallerThatSkipSelf === handlerSymbol) {
-                    continue;
-                }
-                const { handler: handlerFn } = normalizeHook(handler);
-                const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), source, importer, rawHookResolveIdOptions);
-                if (!isNullish(result)) {
-                    return result;
-                }
-            }
-        };
-    }
-    R.keys(batchedHooks).forEach((hookName) => {
-        switch (hookName) {
-            case 'resolveId': {
-                // It's handled above
-                break;
-            }
-            case 'buildStart': {
-                if (batchedHooks.buildStart) {
-                    const batchedHandlers = batchedHooks.buildStart;
-                    composed.buildStart = async function (options) {
-                        await Promise.all(batchedHandlers.map(([handler, plugin]) => {
-                            const { handler: handlerFn } = normalizeHook(handler);
-                            return handlerFn.call(applyFixedPluginResolveFn(this, plugin), options);
-                        }));
-                    };
-                }
-                break;
-            }
-            case 'load': {
-                if (batchedHooks.load) {
-                    const batchedHandlers = batchedHooks.load;
-                    composed.load = async function (id) {
-                        for (const [handler, plugin] of batchedHandlers) {
-                            const { handler: handlerFn } = normalizeHook(handler);
-                            const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), id);
-                            if (!isNullish(result)) {
-                                return result;
-                            }
-                        }
-                    };
-                }
-                break;
-            }
-            case 'transform': {
-                if (batchedHooks.transform) {
-                    const batchedHandlers = batchedHooks.transform;
-                    composed.transform = async function (initialCode, id, moduleType) {
-                        let code = initialCode;
-                        let moduleSideEffects = undefined;
-                        // TODO: we should deal with the returned sourcemap too.
-                        function updateOutput(newCode, newModuleSideEffects) {
-                            code = newCode;
-                            moduleSideEffects = newModuleSideEffects ?? undefined;
-                        }
-                        for (const [handler, plugin] of batchedHandlers) {
-                            const { handler: handlerFn } = normalizeHook(handler);
-                            this.getCombinedSourcemap = () => {
-                                throw new Error(`The getCombinedSourcemap is not implement in transform hook at composedJsPlugins`);
-                            };
-                            const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), code, id, moduleType);
-                            if (!isNullish(result)) {
-                                if (typeof result === 'string') {
-                                    updateOutput(result);
-                                }
-                                else {
-                                    if (result.code) {
-                                        updateOutput(result.code, result.moduleSideEffects);
-                                    }
-                                }
-                            }
-                        }
-                        return {
-                            code,
-                            moduleSideEffects,
-                        };
-                    };
-                }
-                break;
-            }
-            case 'buildEnd': {
-                if (batchedHooks.buildEnd) {
-                    const batchedHandlers = batchedHooks.buildEnd;
-                    composed.buildEnd = async function (err) {
-                        await Promise.all(batchedHandlers.map(([handler, plugin]) => {
-                            const { handler: handlerFn } = normalizeHook(handler);
-                            return handlerFn.call(applyFixedPluginResolveFn(this, plugin), err);
-                        }));
-                    };
-                }
-                break;
-            }
-            case 'renderChunk': {
-                if (batchedHooks.renderChunk) {
-                    const batchedHandlers = batchedHooks.renderChunk;
-                    composed.renderChunk = async function (code, chunk, options) {
-                        for (const [handler, plugin] of batchedHandlers) {
-                            const { handler: handlerFn } = normalizeHook(handler);
-                            const result = await handlerFn.call(applyFixedPluginResolveFn(this, plugin), code, chunk, options);
-                            if (!isNullish(result)) {
-                                return result;
-                            }
-                        }
-                    };
-                }
-                break;
-            }
-            case 'banner':
-            case 'footer':
-            case 'intro':
-            case 'outro': {
-                const hooks = batchedHooks[hookName];
-                if (hooks?.length) {
-                    composed[hookName] = async function (chunk) {
-                        const ret = [];
-                        for (const [hook, plugin] of hooks) {
-                            {
-                                const { handler } = normalizeHook(hook);
-                                ret.push(typeof handler === 'string'
-                                    ? handler
-                                    : await handler.call(applyFixedPluginResolveFn(this, plugin), chunk));
-                            }
-                        }
-                        return ret.join('\n');
-                    };
-                }
-                break;
-            }
-            case 'closeBundle': {
-                if (batchedHooks.closeBundle) {
-                    const batchedHandlers = batchedHooks.closeBundle;
-                    composed.closeBundle = async function () {
-                        await Promise.all(batchedHandlers.map(([handler, plugin]) => {
-                            const { handler: handlerFn } = normalizeHook(handler);
-                            return handlerFn.call(applyFixedPluginResolveFn(this, plugin));
-                        }));
-                    };
-                }
-                break;
-            }
-            case 'watchChange': {
-                if (batchedHooks.watchChange) {
-                    const batchedHandlers = batchedHooks.watchChange;
-                    composed.watchChange = async function (id, event) {
-                        await Promise.all(batchedHandlers.map(([handler, plugin]) => {
-                            const { handler: handlerFn } = normalizeHook(handler);
-                            return handlerFn.call(applyFixedPluginResolveFn(this, plugin), id, event);
-                        }));
-                    };
-                }
-                break;
-            }
-            case 'closeWatcher': {
-                if (batchedHooks.closeWatcher) {
-                    const batchedHandlers = batchedHooks.closeWatcher;
-                    composed.closeWatcher = async function () {
-                        await Promise.all(batchedHandlers.map(([handler, plugin]) => {
-                            const { handler: handlerFn } = normalizeHook(handler);
-                            return handlerFn.call(applyFixedPluginResolveFn(this, plugin));
-                        }));
-                    };
-                }
-                break;
-            }
-            default: {
-            }
-        }
-    });
-    return composed;
-}
-function isComposablePlugin(plugin) {
-    if (plugin instanceof BuiltinPlugin) {
-        return false;
-    }
-    if ('_parallel' in plugin) {
-        return false;
-    }
-    // Check if the plugin has patterns that aren't composable
-    const hasNotComposablePattern = R.keys(plugin).some((hookName) => {
-        if (!isPluginHookName(hookName)) {
-            // Not hooks. Just ignore these properties since they don't affect the composable pattern
-            return false;
-        }
-        const OK_TO_COMPOSE = false;
-        if (isUnsupportedHooks(hookName)) {
-            return !OK_TO_COMPOSE;
-        }
-        if (plugin[hookName]) {
-            const { meta } = normalizeHook(plugin[hookName]);
-            // if `order` is specified with `pre` or `post`, it's unsafe to compose this plugin
-            if (meta.order === 'pre' || meta.order === 'post') {
-                return !OK_TO_COMPOSE;
-            }
-        }
-        return OK_TO_COMPOSE;
-    });
-    if (hasNotComposablePattern) {
-        return false;
-    }
-    return true;
-}
-export function composeJsPlugins(plugins) {
-    const newPlugins = [];
-    const toBeComposed = [];
-    plugins.forEach((plugin) => {
-        if (isComposablePlugin(plugin)) {
-            toBeComposed.push(plugin);
-        }
-        else {
-            if (toBeComposed.length > 0) {
-                if (toBeComposed.length > 1) {
-                    newPlugins.push(createComposedPlugin(toBeComposed));
-                }
-                else {
-                    // push the only plugin in toBeComposed
-                    newPlugins.push(toBeComposed[0]);
-                }
-                toBeComposed.length = 0;
-            }
-            // push the plugin that is not composable
-            newPlugins.push(plugin);
-        }
-    });
-    // Considering the case:
-    // p = [c, c, c, c]
-    // after the loop, toBeComposed = [c, c, c, c], plugins = []
-    // we should consume all the toBeComposed plugins at the end
-    if (toBeComposed.length > 0) {
-        if (toBeComposed.length > 1) {
-            newPlugins.push(createComposedPlugin(toBeComposed));
-        }
-        else {
-            newPlugins.push(toBeComposed[0]);
-        }
-        toBeComposed.length = 0;
-    }
-    return newPlugins;
-}

package/dist/types/utils/create-bundler-option.js

@@ -1,53 +0,0 @@
-import { PluginDriver } from '../plugin/plugin-driver';
-import { bindingifyInputOptions } from './bindingify-input-options';
-import { bindingifyOutputOptions } from './bindingify-output-options';
-import { composeJsPlugins } from './compose-js-plugins';
-import { ANONYMOUS_OUTPUT_PLUGIN_PREFIX, ANONYMOUS_PLUGIN_PREFIX, checkOutputPluginOption, normalizePluginOption, normalizePlugins, } from './normalize-plugin-option';
-import { initializeParallelPlugins } from './initialize-parallel-plugins';
-import { getObjectPlugins } from '../plugin/plugin-driver';
-import { logMinifyWarning } from '../log/logs';
-import { getLogger, getOnLog } from '../log/logger';
-import { validateTreeShakingOptions } from './validator';
-import { LOG_LEVEL_INFO, LOG_LEVEL_WARN } from '../log/logging';
-export async function createBundlerOptions(inputOptions, outputOptions) {
-    if (inputOptions.treeshake !== undefined) {
-        validateTreeShakingOptions(inputOptions.treeshake);
-    }
-    const inputPlugins = await normalizePluginOption(inputOptions.plugins);
-    const outputPlugins = await normalizePluginOption(outputOptions.plugins);
-    const logLevel = inputOptions.logLevel || LOG_LEVEL_INFO;
-    const onLog = getLogger(getObjectPlugins(inputPlugins), getOnLog(inputOptions, logLevel), logLevel);
-    // The `outputOptions` hook is called with the input plugins and the output plugins
-    outputOptions = PluginDriver.callOutputOptionsHook([...inputPlugins, ...outputPlugins], outputOptions);
-    if (outputOptions.minify === true) {
-        onLog(LOG_LEVEL_WARN, logMinifyWarning());
-    }
-    let plugins = [
-        ...normalizePlugins(inputPlugins, ANONYMOUS_PLUGIN_PREFIX),
-        ...checkOutputPluginOption(normalizePlugins(await normalizePluginOption(outputOptions.plugins), ANONYMOUS_OUTPUT_PLUGIN_PREFIX), onLog),
-    ];
-    if (inputOptions.experimental?.enableComposingJsPlugins ?? false) {
-        plugins = composeJsPlugins(plugins);
-    }
-    const parallelPluginInitResult = await initializeParallelPlugins(plugins);
-    try {
-        // Convert `InputOptions` to `BindingInputOptions`
-        const bindingInputOptions = bindingifyInputOptions(plugins, inputOptions, outputOptions, onLog, logLevel);
-        // Convert `OutputOptions` to `BindingInputOptions`
-        const bindingOutputOptions = bindingifyOutputOptions(outputOptions);
-        return {
-            bundlerOptions: {
-                inputOptions: bindingInputOptions,
-                outputOptions: bindingOutputOptions,
-                parallelPluginsRegistry: parallelPluginInitResult?.registry,
-            },
-            inputOptions,
-            onLog,
-            stopWorkers: parallelPluginInitResult?.stopWorkers,
-        };
-    }
-    catch (e) {
-        await parallelPluginInitResult?.stopWorkers();
-        throw e;
-    }
-}

package/dist/types/utils/create-bundler.js

@@ -1,15 +0,0 @@
-import { Bundler } from '../binding';
-import { createBundlerOptions } from './create-bundler-option';
-export async function createBundler(inputOptions, outputOptions) {
-    const option = await createBundlerOptions(inputOptions, outputOptions);
-    try {
-        return {
-            bundler: new Bundler(option.bundlerOptions),
-            stopWorkers: option.stopWorkers,
-        };
-    }
-    catch (e) {
-        await option.stopWorkers?.();
-        throw e;
-    }
-}

package/dist/types/utils/define-config.js

@@ -1,3 +0,0 @@
-export function defineConfig(config) {
-    return config;
-}

package/dist/types/utils/error.js

@@ -1,65 +0,0 @@
-export function normalizeErrors(rawErrors) {
-    const errors = rawErrors.map((e) => e instanceof Error
-        ? e
-        : // strip stacktrace of errors from native diagnostics
-            Object.assign(new Error(), {
-                kind: e.kind,
-                message: e.message,
-                stack: undefined,
-            }));
-    // based on https://github.com/evanw/esbuild/blob/9eca46464ed5615cb36a3beb3f7a7b9a8ffbe7cf/lib/shared/common.ts#L1673
-    // combine error messages as a top level error
-    let summary = `Build failed with ${errors.length} error${errors.length < 2 ? '' : 's'}:\n`;
-    for (let i = 0; i < errors.length; i++) {
-        if (i >= 5) {
-            summary += '\n...';
-            break;
-        }
-        summary += getErrorMessage(errors[i]) + '\n';
-    }
-    const wrapper = new Error(summary);
-    // expose individual errors as getters so that
-    // `console.error(wrapper)` doesn't expand unnecessary details
-    // when they are already presented in `wrapper.message`
-    Object.defineProperty(wrapper, 'errors', {
-        configurable: true,
-        enumerable: true,
-        get: () => errors,
-        set: (value) => Object.defineProperty(wrapper, 'errors', {
-            configurable: true,
-            enumerable: true,
-            value,
-        }),
-    });
-    return wrapper;
-}
-function getErrorMessage(e) {
-    let s = '';
-    if (e.plugin) {
-        s += `[plugin ${e.plugin}]`;
-    }
-    const id = e.id ?? e.loc?.file;
-    if (id) {
-        s += ' ' + id;
-        if (e.loc) {
-            s += `:${e.loc.line}:${e.loc.column}`;
-        }
-    }
-    if (s) {
-        s += '\n';
-    }
-    const message = `${e.name ?? 'Error'}: ${e.message}`;
-    s += message;
-    if (e.frame) {
-        s = joinNewLine(s, e.frame);
-    }
-    // copy stack since it's important for js plugin error
-    if (e.stack) {
-        s = joinNewLine(s, e.stack.replace(message, ''));
-    }
-    return s;
-}
-function joinNewLine(s1, s2) {
-    // ensure single new line in between
-    return s1.replace(/\n+$/, '') + '\n' + s2.replace(/^\n+/, '');
-}

package/dist/types/utils/initialize-parallel-plugins.js

@@ -1,54 +0,0 @@
-import { Worker } from 'node:worker_threads';
-import { availableParallelism } from 'node:os';
-import { ParallelJsPluginRegistry } from '../binding';
-export async function initializeParallelPlugins(plugins) {
-    const pluginInfos = [];
-    for (const [index, plugin] of plugins.entries()) {
-        if ('_parallel' in plugin) {
-            const { fileUrl, options } = plugin._parallel;
-            pluginInfos.push({ index, fileUrl, options });
-        }
-    }
-    if (pluginInfos.length <= 0) {
-        return undefined;
-    }
-    const count = Math.min(availableParallelism(), 8);
-    const parallelJsPluginRegistry = new ParallelJsPluginRegistry(count);
-    const registryId = parallelJsPluginRegistry.id;
-    const workers = await initializeWorkers(registryId, count, pluginInfos);
-    const stopWorkers = async () => {
-        await Promise.all(workers.map((worker) => worker.terminate()));
-    };
-    return { registry: parallelJsPluginRegistry, stopWorkers };
-}
-export function initializeWorkers(registryId, count, pluginInfos) {
-    return Promise.all(Array.from({ length: count }, (_, i) => initializeWorker(registryId, pluginInfos, i)));
-}
-async function initializeWorker(registryId, pluginInfos, threadNumber) {
-    const urlString = import.meta.resolve('#parallel-plugin-worker');
-    const workerData = {
-        registryId,
-        pluginInfos,
-        threadNumber,
-    };
-    let worker;
-    try {
-        worker = new Worker(new URL(urlString), { workerData });
-        worker.unref();
-        await new Promise((resolve, reject) => {
-            worker.once('message', async (message) => {
-                if (message.type === 'error') {
-                    reject(message.error);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-        return worker;
-    }
-    catch (e) {
-        worker?.terminate();
-        throw e;
-    }
-}

package/dist/types/utils/misc.js

@@ -1,22 +0,0 @@
-export function arraify(value) {
-    return Array.isArray(value) ? value : [value];
-}
-export function isNullish(value) {
-    return value === null || value === undefined;
-}
-export function unimplemented(info) {
-    if (info) {
-        throw new Error(`unimplemented: ${info}`);
-    }
-    throw new Error('unimplemented');
-}
-export function unreachable(info) {
-    if (info) {
-        throw new Error(`unreachable: ${info}`);
-    }
-    throw new Error('unreachable');
-}
-export function unsupported(info) {
-    throw new Error(`UNSUPPORTED: ${info}`);
-}
-export function noop(..._args) { }

package/dist/types/utils/normalize-hook.js

@@ -1,21 +0,0 @@
-import { unreachable } from './misc';
-export function normalizeHook(hook) {
-    if (typeof hook === 'function' || typeof hook === 'string') {
-        return {
-            handler: hook,
-            options: {},
-            meta: {},
-        };
-    }
-    if (typeof hook === 'object' && hook !== null) {
-        const { handler, order, ...options } = hook;
-        return {
-            handler,
-            options,
-            meta: {
-                order,
-            },
-        };
-    }
-    unreachable('Invalid hook type');
-}

package/dist/types/utils/normalize-plugin-option.js

@@ -1,35 +0,0 @@
-import { asyncFlatten } from './async-flatten';
-import { ENUMERATED_INPUT_PLUGIN_HOOK_NAMES } from '../constants/plugin';
-import { logInputHookInOutputPlugin } from '../log/logs';
-import { LOG_LEVEL_WARN } from '../log/logging';
-import { BuiltinPlugin } from '../builtin-plugin/constructors';
-export const normalizePluginOption = async (plugins) => (await asyncFlatten([plugins])).filter(Boolean);
-export function checkOutputPluginOption(plugins, onLog) {
-    for (const plugin of plugins) {
-        for (const hook of ENUMERATED_INPUT_PLUGIN_HOOK_NAMES) {
-            if (hook in plugin) {
-                // remove the hook from the plugin if it is not an output plugin hook, avoid the plugin to be called
-                // @ts-expect-error Here the plugin typing should be RolldownPlugin
-                delete plugin[hook];
-                onLog(LOG_LEVEL_WARN, logInputHookInOutputPlugin(plugin.name, hook));
-            }
-        }
-    }
-    return plugins;
-}
-export function normalizePlugins(plugins, anonymousPrefix) {
-    for (const [index, plugin] of plugins.entries()) {
-        if ('_parallel' in plugin) {
-            continue;
-        }
-        if (plugin instanceof BuiltinPlugin) {
-            continue;
-        }
-        if (!plugin.name) {
-            plugin.name = `${anonymousPrefix}${index + 1}`;
-        }
-    }
-    return plugins;
-}
-export const ANONYMOUS_PLUGIN_PREFIX = 'at position ';
-export const ANONYMOUS_OUTPUT_PLUGIN_PREFIX = 'at output position ';