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

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

@@ -0,0 +1,92 @@
+import { unimplemented } from './misc';
+import { transformRenderedChunk } from './transform-rendered-chunk';
+export function bindingifyOutputOptions(outputOptions) {
+    const { dir, format, exports, hashCharacters, sourcemap, sourcemapIgnoreList, sourcemapPathTransform, name, assetFileNames, entryFileNames, chunkFileNames, cssEntryFileNames, cssChunkFileNames, banner, footer, intro, outro, esModule, globals, file, } = outputOptions;
+    return {
+        dir,
+        // Handle case: rollup/test/sourcemaps/samples/sourcemap-file-hashed/_config.js
+        file: file == null ? undefined : file,
+        format: bindingifyFormat(format),
+        exports,
+        hashCharacters,
+        sourcemap: bindingifySourcemap(sourcemap),
+        sourcemapIgnoreList: bindingifySourcemapIgnoreList(sourcemapIgnoreList),
+        sourcemapPathTransform,
+        banner: bindingifyAddon(banner),
+        footer: bindingifyAddon(footer),
+        intro: bindingifyAddon(intro),
+        outro: bindingifyAddon(outro),
+        extend: outputOptions.extend,
+        globals,
+        esModule,
+        name,
+        assetFileNames,
+        entryFileNames,
+        chunkFileNames,
+        cssEntryFileNames,
+        cssChunkFileNames,
+        // TODO(sapphi-red): support parallel plugins
+        plugins: [],
+        minify: outputOptions.minify,
+        externalLiveBindings: outputOptions.externalLiveBindings,
+        inlineDynamicImports: outputOptions.inlineDynamicImports,
+        advancedChunks: outputOptions.advancedChunks,
+        polyfillRequire: outputOptions.polyfillRequire,
+        target: outputOptions.target,
+    };
+}
+function bindingifyAddon(configAddon) {
+    return async (chunk) => {
+        if (typeof configAddon === 'function') {
+            return configAddon(transformRenderedChunk(chunk));
+        }
+        return configAddon || '';
+    };
+}
+function bindingifyFormat(format) {
+    switch (format) {
+        case undefined:
+        case 'es':
+        case 'esm':
+        case 'module': {
+            return 'es';
+        }
+        case 'cjs':
+        case 'commonjs': {
+            return 'cjs';
+        }
+        case 'iife': {
+            return 'iife';
+        }
+        case 'umd': {
+            return 'umd';
+        }
+        case 'experimental-app': {
+            return 'app';
+        }
+        default:
+            unimplemented(`output.format: ${format}`);
+    }
+}
+function bindingifySourcemap(sourcemap) {
+    switch (sourcemap) {
+        case true:
+            return 'file';
+        case 'inline':
+            return 'inline';
+        case false:
+        case undefined:
+            return undefined;
+        case 'hidden':
+            return 'hidden';
+        default:
+            throw new Error(`unknown sourcemap: ${sourcemap}`);
+    }
+}
+function bindingifySourcemapIgnoreList(sourcemapIgnoreList) {
+    return typeof sourcemapIgnoreList === 'function'
+        ? sourcemapIgnoreList
+        : sourcemapIgnoreList === false
+            ? () => false
+            : (relativeSourcePath, _sourcemapPath) => relativeSourcePath.includes('node_modules');
+}

package/dist/types/utils/code-frame.js

@@ -0,0 +1,46 @@
+function spaces(index) {
+    let result = '';
+    while (index--)
+        result += ' ';
+    return result;
+}
+function tabsToSpaces(value) {
+    return value.replace(/^\t+/, (match) => match.split('\t').join('  '));
+}
+const LINE_TRUNCATE_LENGTH = 120;
+const MIN_CHARACTERS_SHOWN_AFTER_LOCATION = 10;
+const ELLIPSIS = '...';
+export function getCodeFrame(source, line, column) {
+    let lines = source.split('\n');
+    // Needed if a plugin did not generate correct sourcemaps
+    if (line > lines.length)
+        return '';
+    const maxLineLength = Math.max(tabsToSpaces(lines[line - 1].slice(0, column)).length +
+        MIN_CHARACTERS_SHOWN_AFTER_LOCATION +
+        ELLIPSIS.length, LINE_TRUNCATE_LENGTH);
+    const frameStart = Math.max(0, line - 3);
+    let frameEnd = Math.min(line + 2, lines.length);
+    lines = lines.slice(frameStart, frameEnd);
+    while (!/\S/.test(lines[lines.length - 1])) {
+        lines.pop();
+        frameEnd -= 1;
+    }
+    const digits = String(frameEnd).length;
+    return lines
+        .map((sourceLine, index) => {
+        const isErrorLine = frameStart + index + 1 === line;
+        let lineNumber = String(index + frameStart + 1);
+        while (lineNumber.length < digits)
+            lineNumber = ` ${lineNumber}`;
+        let displayedLine = tabsToSpaces(sourceLine);
+        if (displayedLine.length > maxLineLength) {
+            displayedLine = `${displayedLine.slice(0, maxLineLength - ELLIPSIS.length)}${ELLIPSIS}`;
+        }
+        if (isErrorLine) {
+            const indicator = spaces(digits + 2 + tabsToSpaces(sourceLine.slice(0, column)).length) + '^';
+            return `${lineNumber}: ${displayedLine}\n${indicator}`;
+        }
+        return `${lineNumber}: ${displayedLine}`;
+    })
+        .join('\n');
+}

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

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

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

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

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

package/dist/types/utils/error.js

@@ -0,0 +1,65 @@
+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+/, '');
+}