rolldown 1.0.0-beta.3-commit.306867e → 1.0.0-beta.3-commit.f65bde3

package/dist/types/plugin/bindingify-output-hooks.js

@@ -1,189 +0,0 @@
-import { normalizeHook } from '../utils/normalize-hook';
-import { collectChangedBundle, transformToOutputBundle, } from '../utils/transform-to-rollup-output';
-import { PluginContext } from './plugin-context';
-import { bindingifySourcemap } from '../types/sourcemap';
-import { bindingifyPluginHookMeta, } from './bindingify-plugin-hook-meta';
-import { NormalizedInputOptionsImpl } from '../options/normalized-input-options';
-import { NormalizedOutputOptionsImpl } from '../options/normalized-output-options';
-import { transformRenderedChunk } from '../utils/transform-rendered-chunk';
-import { normalizeErrors } from '../utils/error';
-export function bindingifyRenderStart(args) {
-    const hook = args.plugin.renderStart;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, opts) => {
-            handler.call(new PluginContext(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), new NormalizedOutputOptionsImpl(opts), new NormalizedInputOptionsImpl(opts, args.onLog));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyRenderChunk(args) {
-    const hook = args.plugin.renderChunk;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, code, chunk, opts) => {
-            const ret = await handler.call(new PluginContext(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), code, transformRenderedChunk(chunk), new NormalizedOutputOptionsImpl(opts));
-            if (ret == null) {
-                return;
-            }
-            if (typeof ret === 'string') {
-                return { code: ret };
-            }
-            if (!ret.map) {
-                return { code: ret.code };
-            }
-            return {
-                code: ret.code,
-                map: bindingifySourcemap(ret.map),
-            };
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyAugmentChunkHash(args) {
-    const hook = args.plugin.augmentChunkHash;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, chunk) => {
-            return await handler.call(new PluginContext(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), transformRenderedChunk(chunk));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyRenderError(args) {
-    const hook = args.plugin.renderError;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, err) => {
-            handler.call(new PluginContext(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), normalizeErrors(err));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyGenerateBundle(args) {
-    const hook = args.plugin.generateBundle;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, bundle, isWrite, opts) => {
-            const changed = {
-                updated: new Set(),
-                deleted: new Set(),
-            };
-            const output = transformToOutputBundle(bundle, changed);
-            await handler.call(new PluginContext(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), new NormalizedOutputOptionsImpl(opts), output, isWrite);
-            return collectChangedBundle(changed, output);
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyWriteBundle(args) {
-    const hook = args.plugin.writeBundle;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, bundle, opts) => {
-            const changed = {
-                updated: new Set(),
-                deleted: new Set(),
-            };
-            const output = transformToOutputBundle(bundle, changed);
-            await handler.call(new PluginContext(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), new NormalizedOutputOptionsImpl(opts), output);
-            return collectChangedBundle(changed, output);
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyCloseBundle(args) {
-    const hook = args.plugin.closeBundle;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx) => {
-            await handler.call(new PluginContext(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyBanner(args) {
-    const hook = args.plugin.banner;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, chunk) => {
-            if (typeof handler === 'string') {
-                return handler;
-            }
-            return handler.call(new PluginContext(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), transformRenderedChunk(chunk));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyFooter(args) {
-    const hook = args.plugin.footer;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, chunk) => {
-            if (typeof handler === 'string') {
-                return handler;
-            }
-            return handler.call(new PluginContext(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), transformRenderedChunk(chunk));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyIntro(args) {
-    const hook = args.plugin.intro;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, chunk) => {
-            if (typeof handler === 'string') {
-                return handler;
-            }
-            return handler.call(new PluginContext(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), transformRenderedChunk(chunk));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyOutro(args) {
-    const hook = args.plugin.outro;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, chunk) => {
-            if (typeof handler === 'string') {
-                return handler;
-            }
-            return handler.call(new PluginContext(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), transformRenderedChunk(chunk));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}

package/dist/types/plugin/bindingify-plugin-hook-meta.js

@@ -1,19 +0,0 @@
-import { BindingPluginOrder } from '../binding';
-export function bindingifyPluginHookMeta(options) {
-    return {
-        order: bindingPluginOrder(options.order),
-    };
-}
-function bindingPluginOrder(order) {
-    switch (order) {
-        case 'post':
-            return BindingPluginOrder.Post;
-        case 'pre':
-            return BindingPluginOrder.Pre;
-        case null:
-        case undefined:
-            return undefined;
-        default:
-            throw new Error(`Unknown plugin order: ${order}`);
-    }
-}

package/dist/types/plugin/bindingify-plugin.js

@@ -1,124 +0,0 @@
-import { bindingifyBuildEnd, bindingifyBuildStart, bindingifyLoad, bindingifyModuleParsed, bindingifyResolveDynamicImport, bindingifyResolveId, bindingifyTransform, } from './bindingify-build-hooks';
-import { bindingifyRenderStart, bindingifyRenderChunk, bindingifyGenerateBundle, bindingifyWriteBundle, bindingifyRenderError, bindingifyAugmentChunkHash, bindingifyBanner, bindingifyFooter, bindingifyIntro, bindingifyOutro, bindingifyCloseBundle, } from './bindingify-output-hooks';
-import { bindingifyCloseWatcher, bindingifyWatchChange, } from './bindingify-watch-hooks';
-import { error, logPluginError } from '../log/logs';
-// Note: because napi not catch error, so we need to catch error and print error to debugger in adapter.
-export function bindingifyPlugin(plugin, options, outputOptions, pluginContextData, onLog, logLevel) {
-    const args = {
-        plugin,
-        options,
-        outputOptions,
-        pluginContextData,
-        onLog,
-        logLevel,
-    };
-    const { plugin: buildStart, meta: buildStartMeta } = bindingifyBuildStart(args);
-    const { plugin: resolveId, meta: resolveIdMeta, filter: resolveIdFilter, } = bindingifyResolveId(args);
-    const { plugin: resolveDynamicImport, meta: resolveDynamicImportMeta } = bindingifyResolveDynamicImport(args);
-    const { plugin: buildEnd, meta: buildEndMeta } = bindingifyBuildEnd(args);
-    const { plugin: transform, meta: transformMeta, filter: transformFilter, } = bindingifyTransform(args);
-    const { plugin: moduleParsed, meta: moduleParsedMeta } = bindingifyModuleParsed(args);
-    const { plugin: load, meta: loadMeta, filter: loadFilter, } = bindingifyLoad(args);
-    const { plugin: renderChunk, meta: renderChunkMeta } = bindingifyRenderChunk(args);
-    const { plugin: augmentChunkHash, meta: augmentChunkHashMeta } = bindingifyAugmentChunkHash(args);
-    const { plugin: renderStart, meta: renderStartMeta } = bindingifyRenderStart(args);
-    const { plugin: renderError, meta: renderErrorMeta } = bindingifyRenderError(args);
-    const { plugin: generateBundle, meta: generateBundleMeta } = bindingifyGenerateBundle(args);
-    const { plugin: writeBundle, meta: writeBundleMeta } = bindingifyWriteBundle(args);
-    const { plugin: closeBundle, meta: closeBundleMeta } = bindingifyCloseBundle(args);
-    const { plugin: banner, meta: bannerMeta } = bindingifyBanner(args);
-    const { plugin: footer, meta: footerMeta } = bindingifyFooter(args);
-    const { plugin: intro, meta: introMeta } = bindingifyIntro(args);
-    const { plugin: outro, meta: outroMeta } = bindingifyOutro(args);
-    const { plugin: watchChange, meta: watchChangeMeta } = bindingifyWatchChange(args);
-    const { plugin: closeWatcher, meta: closeWatcherMeta } = bindingifyCloseWatcher(args);
-    const result = {
-        // The plugin name already normalized at `normalizePlugins`, see `packages/rolldown/src/utils/normalize-plugin-option.ts`
-        name: plugin.name,
-        buildStart,
-        buildStartMeta,
-        resolveId,
-        resolveIdMeta,
-        // @ts-ignore
-        resolveIdFilter,
-        resolveDynamicImport,
-        resolveDynamicImportMeta,
-        buildEnd,
-        buildEndMeta,
-        transform,
-        transformMeta,
-        transformFilter,
-        moduleParsed,
-        moduleParsedMeta,
-        load,
-        loadMeta,
-        loadFilter,
-        renderChunk,
-        renderChunkMeta,
-        augmentChunkHash,
-        augmentChunkHashMeta,
-        renderStart,
-        renderStartMeta,
-        renderError,
-        renderErrorMeta,
-        generateBundle,
-        generateBundleMeta,
-        writeBundle,
-        writeBundleMeta,
-        closeBundle,
-        closeBundleMeta,
-        banner,
-        bannerMeta,
-        footer,
-        footerMeta,
-        intro,
-        introMeta,
-        outro,
-        outroMeta,
-        watchChange,
-        watchChangeMeta,
-        closeWatcher,
-        closeWatcherMeta,
-    };
-    return wrapHandlers(result);
-}
-function wrapHandlers(plugin) {
-    for (const hookName of [
-        'buildStart',
-        'resolveId',
-        'resolveDynamicImport',
-        'buildEnd',
-        'transform',
-        'moduleParsed',
-        'load',
-        'renderChunk',
-        'augmentChunkHash',
-        'renderStart',
-        'renderError',
-        'generateBundle',
-        'writeBundle',
-        'closeBundle',
-        'banner',
-        'footer',
-        'intro',
-        'outro',
-        'watchChange',
-        'closeWatcher',
-    ]) {
-        const handler = plugin[hookName];
-        if (handler) {
-            plugin[hookName] = async (...args) => {
-                try {
-                    return await handler(...args);
-                }
-                catch (e) {
-                    return error(logPluginError(e, plugin.name, {
-                        hook: hookName,
-                        id: hookName === 'transform' ? args[2] : undefined,
-                    }));
-                }
-            };
-        }
-    }
-    return plugin;
-}

package/dist/types/plugin/bindingify-watch-hooks.js

@@ -1,29 +0,0 @@
-import { normalizeHook } from '../utils/normalize-hook';
-import { PluginContext } from './plugin-context';
-import { bindingifyPluginHookMeta, } from './bindingify-plugin-hook-meta';
-export function bindingifyWatchChange(args) {
-    const hook = args.plugin.watchChange;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx, id, event) => {
-            await handler.call(new PluginContext(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), id, { event: event });
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}
-export function bindingifyCloseWatcher(args) {
-    const hook = args.plugin.closeWatcher;
-    if (!hook) {
-        return {};
-    }
-    const { handler, meta } = normalizeHook(hook);
-    return {
-        plugin: async (ctx) => {
-            await handler.call(new PluginContext(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel));
-        },
-        meta: bindingifyPluginHookMeta(meta),
-    };
-}

package/dist/types/plugin/hook-filter.js

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

package/dist/types/plugin/index.js

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

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

@@ -1,25 +0,0 @@
-import { LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_WARN } from '../log/logging';
-import { error, logPluginError } from '../log/logs';
-import { getLogHandler, normalizeLog } from '../log/logHandler';
-import { VERSION } from '..';
-export class MinimalPluginContext {
-    pluginName;
-    info;
-    warn;
-    debug;
-    meta;
-    constructor(onLog, logLevel, pluginName) {
-        this.pluginName = pluginName;
-        this.debug = getLogHandler(LOG_LEVEL_DEBUG, 'PLUGIN_LOG', onLog, pluginName, logLevel);
-        this.info = getLogHandler(LOG_LEVEL_INFO, 'PLUGIN_LOG', onLog, pluginName, logLevel);
-        this.warn = getLogHandler(LOG_LEVEL_WARN, 'PLUGIN_WARNING', onLog, pluginName, logLevel);
-        this.meta = {
-            rollupVersion: '4.23.0',
-            rolldownVersion: VERSION,
-            watchMode: false,
-        };
-    }
-    error(e) {
-        return error(logPluginError(normalizeLog(e), this.pluginName));
-    }
-}

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

@@ -1,3 +0,0 @@
-export function defineParallelPluginImplementation(plugin) {
-    return plugin;
-}

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

@@ -1,6 +0,0 @@
-import { pathToFileURL } from 'node:url';
-export function defineParallelPlugin(pluginPath) {
-    return (options) => {
-        return { _parallel: { fileUrl: pathToFileURL(pluginPath).href, options } };
-    };
-}

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

@@ -1,55 +0,0 @@
-import { transformModuleInfo } from '../utils/transform-module-info';
-export class PluginContextData {
-    moduleOptionMap = new Map();
-    resolveOptionsMap = new Map();
-    loadModulePromiseMap = new Map();
-    updateModuleOption(id, option) {
-        const existing = this.moduleOptionMap.get(id);
-        if (existing) {
-            if (option.moduleSideEffects != null) {
-                existing.moduleSideEffects = option.moduleSideEffects;
-            }
-            if (option.meta != null) {
-                Object.assign(existing.meta, option.meta);
-            }
-        }
-        else {
-            this.moduleOptionMap.set(id, option);
-        }
-    }
-    getModuleOption(id) {
-        const option = this.moduleOptionMap.get(id);
-        if (!option) {
-            const raw = {
-                moduleSideEffects: null,
-                meta: {},
-            };
-            this.moduleOptionMap.set(id, raw);
-            return raw;
-        }
-        return option;
-    }
-    getModuleInfo(id, context) {
-        const bindingInfo = context.getModuleInfo(id);
-        if (bindingInfo) {
-            const info = transformModuleInfo(bindingInfo, this.getModuleOption(id));
-            return info;
-        }
-        return null;
-    }
-    getModuleIds(context) {
-        const moduleIds = context.getModuleIds();
-        return moduleIds.values();
-    }
-    saveResolveOptions(options) {
-        const index = this.resolveOptionsMap.size;
-        this.resolveOptionsMap.set(index, options);
-        return index;
-    }
-    getSavedResolveOptions(receipt) {
-        return this.resolveOptionsMap.get(receipt);
-    }
-    removeSavedResolveOptions(receipt) {
-        this.resolveOptionsMap.delete(receipt);
-    }
-}

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

@@ -1,124 +0,0 @@
-import { MinimalPluginContext } from '../plugin/minimal-plugin-context';
-import { bindingAssetSource } from '../utils/asset-source';
-import { unimplemented, unsupported } from '../utils/misc';
-import { SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF } from '../constants/plugin-context';
-import { bindingifySideEffects } from '../utils/transform-side-effects';
-import { LOG_LEVEL_WARN } from '../log/logging';
-import { logCycleLoading } from '../log/logs';
-export class PluginContext extends MinimalPluginContext {
-    outputOptions;
-    context;
-    data;
-    onLog;
-    currentLoadingModule;
-    constructor(outputOptions, context, plugin, data, onLog, logLevel, currentLoadingModule) {
-        super(onLog, logLevel, plugin.name);
-        this.outputOptions = outputOptions;
-        this.context = context;
-        this.data = data;
-        this.onLog = onLog;
-        this.currentLoadingModule = currentLoadingModule;
-    }
-    async load(options) {
-        const id = options.id;
-        if (id === this.currentLoadingModule) {
-            this.onLog(LOG_LEVEL_WARN, logCycleLoading(this.pluginName, this.currentLoadingModule));
-        }
-        // resolveDependencies always true at rolldown
-        const moduleInfo = this.data.getModuleInfo(id, this.context);
-        if (moduleInfo && moduleInfo.code !== null /* module already parsed */) {
-            return moduleInfo;
-        }
-        const rawOptions = {
-            meta: options.meta || {},
-            moduleSideEffects: options.moduleSideEffects || null,
-        };
-        this.data.updateModuleOption(id, rawOptions);
-        async function createLoadModulePromise(context, data) {
-            const loadPromise = data.loadModulePromiseMap.get(id);
-            if (loadPromise) {
-                return loadPromise;
-            }
-            let resolveFn;
-            // TODO: If is not resolved, we need to set a time to avoid waiting.
-            const promise = new Promise((resolve, _) => {
-                resolveFn = resolve;
-            });
-            data.loadModulePromiseMap.set(id, promise);
-            try {
-                await context.load(id, bindingifySideEffects(options.moduleSideEffects), resolveFn);
-            }
-            finally {
-                // If the load module has failed, avoid it re-load using unresolved promise.
-                data.loadModulePromiseMap.delete(id);
-            }
-            return promise;
-        }
-        // Here using one promise to avoid pass more callback to rust side, it only accept one callback, other will be ignored.
-        await createLoadModulePromise(this.context, this.data);
-        return this.data.getModuleInfo(id, this.context);
-    }
-    async resolve(source, importer, options) {
-        let receipt = undefined;
-        if (options != null) {
-            receipt = this.data.saveResolveOptions(options);
-        }
-        const res = await this.context.resolve(source, importer, {
-            custom: receipt,
-            skipSelf: options?.skipSelf,
-        });
-        if (receipt != null) {
-            this.data.removeSavedResolveOptions(receipt);
-        }
-        if (res == null)
-            return null;
-        const info = this.data.getModuleOption(res.id) || {};
-        return { ...res, ...info };
-    }
-    emitFile(file) {
-        // @ts-expect-error
-        if (file.type === 'prebuilt-chunk') {
-            return unimplemented('PluginContext.emitFile with type prebuilt-chunk');
-        }
-        if (file.type === 'chunk') {
-            return this.context.emitChunk(file);
-        }
-        const fnSanitizedFileName = file.fileName || typeof this.outputOptions.sanitizeFileName !== 'function'
-            ? undefined
-            : this.outputOptions.sanitizeFileName(file.name || 'asset');
-        const filename = file.fileName ? undefined : this.getAssetFileNames(file);
-        return this.context.emitFile({
-            ...file,
-            originalFileName: file.originalFileName || undefined,
-            source: bindingAssetSource(file.source),
-        }, filename, fnSanitizedFileName);
-    }
-    getAssetFileNames(file) {
-        if (typeof this.outputOptions.assetFileNames === 'function') {
-            return this.outputOptions.assetFileNames({
-                names: file.name ? [file.name] : [],
-                originalFileNames: file.originalFileName ? [file.originalFileName] : [],
-                source: file.source,
-                type: 'asset',
-            });
-        }
-    }
-    getFileName(referenceId) {
-        return this.context.getFileName(referenceId);
-    }
-    getModuleInfo(id) {
-        return this.data.getModuleInfo(id, this.context);
-    }
-    getModuleIds() {
-        return this.data.getModuleIds(this.context);
-    }
-    addWatchFile(id) {
-        this.context.addWatchFile(id);
-    }
-    /**
-     * @deprecated This rollup API won't be supported by rolldown. Using this API will cause runtime error.
-     */
-    parse(_input, _options) {
-        unsupported('`PluginContext#parse` is not supported by rolldown.');
-    }
-}

package/dist/types/plugin/plugin-driver.js

@@ -1,88 +0,0 @@
-import { getLogHandler, normalizeLog } from '../log/logHandler';
-import { LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_WARN } from '../log/logging';
-import { error, logPluginError } from '../log/logs';
-import { normalizeHook } from '../utils/normalize-hook';
-import { VERSION } from '..';
-import { getLogger, getOnLog } from '../log/logger';
-import { BuiltinPlugin } from '../builtin-plugin/constructors';
-import { normalizePluginOption } from '../utils/normalize-plugin-option';
-export class PluginDriver {
-    static async callOptionsHook(inputOptions) {
-        const logLevel = inputOptions.logLevel || LOG_LEVEL_INFO;
-        const plugins = getSortedPlugins('options', getObjectPlugins(await normalizePluginOption(inputOptions.plugins)));
-        const logger = getLogger(plugins, getOnLog(inputOptions, logLevel), logLevel);
-        for (const plugin of plugins) {
-            const name = plugin.name || 'unknown';
-            const options = plugin.options;
-            if (options) {
-                const { handler } = normalizeHook(options);
-                const result = await handler.call({
-                    debug: getLogHandler(LOG_LEVEL_DEBUG, 'PLUGIN_LOG', logger, name, logLevel),
-                    error: (e) => error(logPluginError(normalizeLog(e), name, { hook: 'onLog' })),
-                    info: getLogHandler(LOG_LEVEL_INFO, 'PLUGIN_LOG', logger, name, logLevel),
-                    meta: {
-                        rollupVersion: '4.23.0',
-                        rolldownVersion: VERSION,
-                        watchMode: false,
-                    },
-                    warn: getLogHandler(LOG_LEVEL_WARN, 'PLUGIN_WARNING', logger, name, logLevel),
-                    pluginName: name,
-                }, inputOptions);
-                if (result) {
-                    inputOptions = result;
-                }
-            }
-        }
-        return inputOptions;
-    }
-    static callOutputOptionsHook(rawPlugins, outputOptions) {
-        const sortedPlugins = getSortedPlugins('outputOptions', getObjectPlugins(rawPlugins));
-        for (const plugin of sortedPlugins) {
-            const options = plugin.outputOptions;
-            if (options) {
-                const { handler } = normalizeHook(options);
-                const result = handler.call(null, outputOptions);
-                if (result) {
-                    outputOptions = result;
-                }
-            }
-        }
-        return outputOptions;
-    }
-}
-export function getObjectPlugins(plugins) {
-    return plugins.filter((plugin) => {
-        if (!plugin) {
-            return undefined;
-        }
-        if ('_parallel' in plugin) {
-            return undefined;
-        }
-        if (plugin instanceof BuiltinPlugin) {
-            return undefined;
-        }
-        return plugin;
-    });
-}
-export function getSortedPlugins(hookName, plugins) {
-    const pre = [];
-    const normal = [];
-    const post = [];
-    for (const plugin of plugins) {
-        const hook = plugin[hookName];
-        if (hook) {
-            if (typeof hook === 'object') {
-                if (hook.order === 'pre') {
-                    pre.push(plugin);
-                    continue;
-                }
-                if (hook.order === 'post') {
-                    post.push(plugin);
-                    continue;
-                }
-            }
-            normal.push(plugin);
-        }
-    }
-    return [...pre, ...normal, ...post];
-}