@umijs/bundler-webpack 3.5.18 → 4.0.0-beta.2

package/dist/schema.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemas = void 0;
+const types_1 = require("./types");
+const options = [
+    'cheap-source-map',
+    'cheap-eval-source-map',
+    'cheap-hidden-source-map',
+    'cheap-inline-source-map',
+    'cheap-module-source-map',
+    'cheap-module-eval-source-map',
+    'cheap-module-hidden-source-map',
+    'cheap-module-inline-source-map',
+    'eval',
+    'eval-source-map',
+    'source-map',
+    'hidden-source-map',
+    'inline-source-map',
+];
+const DEVTOOL_REGEX = new RegExp('^' + // start of string
+    '(#@|@|#)?' + // maybe one of the pragmas
+    `(${options.join('$|')})`);
+function getSchemas() {
+    return {
+        alias: (Joi) => Joi.object(),
+        autoCSSModules: (Joi) => Joi.boolean(),
+        chainWebpack: (Joi) => Joi.function(),
+        copy: (Joi) => Joi.array().items(Joi.alternatives().try(Joi.object({
+            from: Joi.string(),
+            to: Joi.string(),
+        }), Joi.string())),
+        cssLoader: (Joi) => Joi.object(),
+        cssLoaderModules: (Joi) => Joi.object(),
+        cssMinifier: (Joi) => Joi.string().valid(types_1.CSSMinifier.cssnano, types_1.CSSMinifier.esbuild, types_1.CSSMinifier.none),
+        cssMinifierOptions: (Joi) => Joi.object(),
+        define: (Joi) => Joi.object(),
+        depTranspiler: (Joi) => Joi.string().valid(types_1.Transpiler.babel, types_1.Transpiler.esbuild, types_1.Transpiler.swc, types_1.Transpiler.none),
+        devtool: (Joi) => Joi.alternatives().try(Joi.string().regex(DEVTOOL_REGEX), Joi.boolean()),
+        externals: (Joi) => Joi.alternatives().try(Joi.object().pattern(/.+/, [
+            Joi.string(),
+            Joi.boolean(),
+            Joi.object().pattern(/.+/, [Joi.string(), Joi.boolean()]),
+        ]), Joi.string(), Joi.func().arity(3), Joi.object().regex()),
+        extraBabelPlugins: (Joi) => Joi.alternatives().try(Joi.string(), Joi.array().items(Joi.alternatives().try(Joi.string(), Joi.object()))),
+        extraBabelPresets: (Joi) => Joi.alternatives().try(Joi.string(), Joi.array().items(Joi.alternatives().try(Joi.string(), Joi.object()))),
+        extraPostCSSPlugins: (Joi) => Joi.array(),
+        fastRefresh: (Joi) => Joi.boolean(),
+        hash: (Joi) => Joi.boolean(),
+        ignoreMomentLocale: (Joi) => Joi.boolean(),
+        jsMinifier: (Joi) => Joi.string().valid(types_1.JSMinifier.esbuild, types_1.JSMinifier.swc, types_1.JSMinifier.terser, types_1.JSMinifier.uglifyJs, types_1.JSMinifier.none),
+        jsMinifierOptions: (Joi) => Joi.object(),
+        lessLoader: (Joi) => Joi.object(),
+        mfsu: (Joi) => Joi.alternatives(Joi.object(), Joi.boolean()),
+        outputPath: (Joi) => Joi.string(),
+        postcssLoader: (Joi) => Joi.object(),
+        proxy: (Joi) => Joi.object(),
+        publicPath: (Joi) => Joi.string(),
+        purgeCSS: (Joi) => Joi.object(),
+        sassLoader: (Joi) => Joi.object(),
+        srcTranspiler: (Joi) => Joi.string().valid(types_1.Transpiler.babel, types_1.Transpiler.esbuild, types_1.Transpiler.swc, types_1.Transpiler.none),
+        styleLoader: (Joi) => Joi.object(),
+        svgr: (Joi) => Joi.object(),
+        svgo: (Joi) => Joi.alternatives().try(Joi.object(), Joi.boolean()),
+        targets: (Joi) => Joi.object(),
+        writeToDisk: (Joi) => Joi.boolean(),
+    };
+}
+exports.getSchemas = getSchemas;

package/dist/server/server.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { Configuration } from '@umijs/bundler-webpack/compiled/webpack';
+import http from 'http';
+import { IConfig } from '../types';
+interface IOpts {
+    cwd: string;
+    port?: number;
+    host?: string;
+    webpackConfig: Configuration;
+    userConfig: IConfig;
+    beforeMiddlewares?: any[];
+    afterMiddlewares?: any[];
+    onDevCompileDone?: Function;
+}
+export declare function createServer(opts: IOpts): Promise<http.Server>;
+export {};

package/dist/server/server.js

@@ -0,0 +1,157 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = void 0;
+const express_1 = __importDefault(require("@umijs/bundler-webpack/compiled/express"));
+const http_proxy_middleware_1 = require("@umijs/bundler-webpack/compiled/http-proxy-middleware");
+const webpack_1 = __importDefault(require("@umijs/bundler-webpack/compiled/webpack"));
+const utils_1 = require("@umijs/utils");
+const fs_1 = require("fs");
+const http_1 = __importDefault(require("http"));
+const path_1 = require("path");
+const constants_1 = require("../constants");
+const ws_1 = require("./ws");
+function createServer(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { webpackConfig, userConfig } = opts;
+        const { proxy } = userConfig;
+        const app = (0, express_1.default)();
+        // compression
+        app.use(require('@umijs/bundler-webpack/compiled/compression')());
+        // TODO: headers
+        // before middlewares
+        (opts.beforeMiddlewares || []).forEach((m) => app.use(m));
+        // webpack dev middleware
+        const compiler = (0, webpack_1.default)(Array.isArray(webpackConfig) ? webpackConfig : [webpackConfig]);
+        const webpackDevMiddleware = require('@umijs/bundler-webpack/compiled/webpack-dev-middleware');
+        const compilerMiddleware = webpackDevMiddleware(compiler, {
+            publicPath: '/',
+            writeToDisk: userConfig.writeToDisk,
+            stats: 'none',
+            // watchOptions: { ignored }
+        });
+        app.use(compilerMiddleware);
+        // hmr hooks
+        let stats;
+        let isFirstCompile = true;
+        compiler.compilers.forEach(addHooks);
+        function addHooks(compiler) {
+            compiler.hooks.invalid.tap('server', () => {
+                sendMessage(constants_1.MESSAGE_TYPE.invalid);
+            });
+            compiler.hooks.done.tap('server', (_stats) => {
+                var _a;
+                stats = _stats;
+                sendStats(getStats(stats));
+                (_a = opts.onDevCompileDone) === null || _a === void 0 ? void 0 : _a.call(opts, {
+                    stats,
+                    isFirstCompile,
+                    time: stats.endTime - stats.startTime,
+                });
+                isFirstCompile = false;
+            });
+        }
+        function sendStats(stats, force, sender) {
+            const shouldEmit = !force &&
+                stats &&
+                (!stats.errors || stats.errors.length === 0) &&
+                (!stats.warnings || stats.warnings.length === 0) &&
+                stats.assets &&
+                stats.assets.every((asset) => !asset.emitted);
+            if (shouldEmit) {
+                sendMessage(constants_1.MESSAGE_TYPE.stillOk, null, sender);
+                return;
+            }
+            sendMessage(constants_1.MESSAGE_TYPE.hash, stats.hash, sender);
+            if ((stats.errors && stats.errors.length > 0) ||
+                (stats.warnings && stats.warnings.length > 0)) {
+                if (stats.warnings && stats.warnings.length > 0) {
+                    sendMessage(constants_1.MESSAGE_TYPE.warnings, stats.warnings, sender);
+                }
+                if (stats.errors && stats.errors.length > 0) {
+                    sendMessage(constants_1.MESSAGE_TYPE.errors, stats.errors, sender);
+                }
+            }
+            else {
+                sendMessage(constants_1.MESSAGE_TYPE.ok, null, sender);
+            }
+        }
+        function getStats(stats) {
+            return stats.toJson({
+                all: false,
+                hash: true,
+                assets: true,
+                warnings: true,
+                errors: true,
+                errorDetails: false,
+            });
+        }
+        function sendMessage(type, data, sender) {
+            (sender || ws).send(JSON.stringify({ type, data }));
+        }
+        // mock
+        // proxy
+        if (proxy) {
+            Object.keys(proxy).forEach((key) => {
+                app.use(key, (0, http_proxy_middleware_1.createProxyMiddleware)(proxy[key]));
+            });
+        }
+        // after middlewares
+        (opts.afterMiddlewares || []).forEach((m) => app.use(m));
+        // history fallback
+        app.use(require('@umijs/bundler-webpack/compiled/connect-history-api-fallback')({
+            index: '/',
+        }));
+        // hmr reconnect ping
+        app.use('/__umi_ping', (_, res) => {
+            res.end('pong');
+        });
+        // TODO: remove me
+        app.use((req, res, next) => {
+            if (req.path === '/umi.js' && (0, fs_1.existsSync)((0, path_1.join)(opts.cwd, 'umi.js'))) {
+                res.send((0, fs_1.readFileSync)((0, path_1.join)(opts.cwd, 'umi.js'), 'utf-8'));
+            }
+            else {
+                next();
+            }
+        });
+        // index.html
+        // TODO: remove me
+        app.get('/', (_req, res, next) => {
+            res.set('Content-Type', 'text/html');
+            const htmlPath = (0, path_1.join)(opts.cwd, 'index.html');
+            if ((0, fs_1.existsSync)(htmlPath)) {
+                const html = (0, fs_1.readFileSync)(htmlPath, 'utf-8');
+                res.send(html);
+            }
+            else {
+                next();
+            }
+        });
+        const server = http_1.default.createServer(app);
+        const ws = (0, ws_1.createWebSocketServer)(server);
+        ws.wss.on('connection', (socket) => {
+            if (stats) {
+                sendStats(getStats(stats), false, socket);
+            }
+        });
+        const port = opts.port || 8000;
+        server.listen(port, () => {
+            const host = opts.host && opts.host !== '0.0.0.0' ? opts.host : '127.0.0.1';
+            utils_1.logger.ready(`App listening at http://${host}:${port}`);
+        });
+        return server;
+    });
+}
+exports.createServer = createServer;

package/dist/server/ws.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { Server } from 'http';
+import WebSocket from 'ws';
+export declare function createWebSocketServer(server: Server): {
+    send(message: string): void;
+    wss: WebSocket.Server;
+    close(): void;
+};

package/dist/server/ws.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebSocketServer = void 0;
+const utils_1 = require("@umijs/utils");
+const ws_1 = __importDefault(require("ws"));
+function createWebSocketServer(server) {
+    const wss = new ws_1.default.Server({
+        noServer: true,
+    });
+    server.on('upgrade', (req, socket, head) => {
+        if (req.headers['sec-websocket-protocol'] === 'webpack-hmr') {
+            wss.handleUpgrade(req, socket, head, (ws) => {
+                wss.emit('connection', ws, req);
+            });
+        }
+    });
+    wss.on('connection', (socket) => {
+        socket.send(JSON.stringify({ type: 'connected' }));
+    });
+    wss.on('error', (e) => {
+        if (e.code !== 'EADDRINUSE') {
+            console.error(utils_1.chalk.red(`WebSocket server error:\n${e.stack || e.message}`));
+        }
+    });
+    return {
+        send(message) {
+            wss.clients.forEach((client) => {
+                if (client.readyState === ws_1.default.OPEN) {
+                    client.send(message);
+                }
+            });
+        },
+        wss,
+        close() {
+            wss.close();
+        },
+    };
+}
+exports.createWebSocketServer = createWebSocketServer;

package/dist/types.d.ts

@@ -0,0 +1,97 @@
+import type { Options as ProxyOptions } from '../compiled/http-proxy-middleware';
+import { Configuration } from '../compiled/webpack';
+import Config from '../compiled/webpack-5-chain';
+export declare enum Env {
+    development = "development",
+    production = "production"
+}
+export declare enum Transpiler {
+    babel = "babel",
+    swc = "swc",
+    esbuild = "esbuild",
+    none = "none"
+}
+export declare enum JSMinifier {
+    terser = "terser",
+    swc = "swc",
+    esbuild = "esbuild",
+    uglifyJs = "uglifyJs",
+    none = "none"
+}
+export declare enum CSSMinifier {
+    esbuild = "esbuild",
+    cssnano = "cssnano",
+    none = "none"
+}
+export interface ICopy {
+    from: string;
+    to: string;
+}
+declare type WebpackConfig = Required<Configuration>;
+declare type IBabelPlugin = Function | string | [string, {
+    [key: string]: any;
+}];
+export interface IConfig {
+    alias?: Record<string, string>;
+    autoCSSModules?: boolean;
+    chainWebpack?: Function;
+    copy?: ICopy[] | string[];
+    cssLoader?: {
+        [key: string]: any;
+    };
+    cssLoaderModules?: {
+        [key: string]: any;
+    };
+    cssMinifier?: CSSMinifier;
+    cssMinifierOptions?: {
+        [key: string]: any;
+    };
+    define?: {
+        [key: string]: any;
+    };
+    depTranspiler?: Transpiler;
+    devtool?: Config.DevTool;
+    externals?: WebpackConfig['externals'];
+    extraBabelPlugins?: IBabelPlugin[];
+    extraBabelPresets?: IBabelPlugin[];
+    extraPostCSSPlugins?: any[];
+    hash?: boolean;
+    ignoreMomentLocale?: boolean;
+    jsMinifier?: JSMinifier;
+    jsMinifierOptions?: {
+        [key: string]: any;
+    };
+    lessLoader?: {
+        [key: string]: any;
+    };
+    outputPath?: string;
+    postcssLoader?: {
+        [key: string]: any;
+    };
+    proxy?: {
+        [key: string]: ProxyOptions;
+    };
+    publicPath?: string;
+    purgeCSS?: {
+        [key: string]: any;
+    };
+    sassLoader?: {
+        [key: string]: any;
+    };
+    srcTranspiler?: Transpiler;
+    styleLoader?: {
+        [key: string]: any;
+    };
+    svgr?: {
+        [key: string]: any;
+    };
+    svgo?: {
+        [key: string]: any;
+    } | false;
+    targets?: {
+        [key: string]: any;
+    };
+    writeToDisk?: boolean;
+    [key: string]: any;
+}
+export {};

package/dist/types.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSSMinifier = exports.JSMinifier = exports.Transpiler = exports.Env = void 0;
+var Env;
+(function (Env) {
+    Env["development"] = "development";
+    Env["production"] = "production";
+})(Env = exports.Env || (exports.Env = {}));
+var Transpiler;
+(function (Transpiler) {
+    Transpiler["babel"] = "babel";
+    Transpiler["swc"] = "swc";
+    Transpiler["esbuild"] = "esbuild";
+    Transpiler["none"] = "none";
+})(Transpiler = exports.Transpiler || (exports.Transpiler = {}));
+var JSMinifier;
+(function (JSMinifier) {
+    JSMinifier["terser"] = "terser";
+    JSMinifier["swc"] = "swc";
+    JSMinifier["esbuild"] = "esbuild";
+    JSMinifier["uglifyJs"] = "uglifyJs";
+    JSMinifier["none"] = "none";
+})(JSMinifier = exports.JSMinifier || (exports.JSMinifier = {}));
+var CSSMinifier;
+(function (CSSMinifier) {
+    CSSMinifier["esbuild"] = "esbuild";
+    CSSMinifier["cssnano"] = "cssnano";
+    CSSMinifier["none"] = "none";
+})(CSSMinifier = exports.CSSMinifier || (exports.CSSMinifier = {}));

package/dist/utils/browsersList.d.ts

@@ -0,0 +1,5 @@
+interface IOpts {
+    targets: Record<string, any>;
+}
+export declare function getBrowsersList({ targets }: IOpts): any;
+export {};

package/dist/utils/browsersList.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBrowsersList = void 0;
+function getBrowsersList({ targets }) {
+    return (targets.browsers ||
+        Object.keys(targets).map((key) => {
+            return `${key} >= ${targets[key] === true ? '0' : targets[key]}`;
+        }));
+}
+exports.getBrowsersList = getBrowsersList;

package/dist/utils/depMatch.d.ts

@@ -0,0 +1,6 @@
+export declare function cleanCache(): void;
+export declare function isMatch(opts: {
+    path: string;
+    pkgs: Record</*name*/ string, /*version*/ string[]>;
+}): boolean;
+export declare function es5ImcompatibleVersionsToPkg(): Record<string, string[]>;

package/dist/utils/depMatch.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.es5ImcompatibleVersionsToPkg = exports.isMatch = exports.cleanCache = void 0;
+const utils_1 = require("@umijs/utils");
+const path_1 = require("path");
+const cache = new Map();
+function cleanCache() {
+    cache.clear();
+}
+exports.cleanCache = cleanCache;
+function isMatch(opts) {
+    // cache by dir, 命中率会更高
+    const dir = (0, utils_1.winPath)((0, path_1.dirname)(opts.path));
+    if (cache.has(dir)) {
+        return !!cache.get(dir);
+    }
+    else {
+        const pkgPath = utils_1.pkgUp.sync({ cwd: opts.path });
+        let ret;
+        if (!pkgPath) {
+            ret = false;
+        }
+        else {
+            const { name, version } = require(pkgPath);
+            if (opts.pkgs[name]) {
+                ret = opts.pkgs[name].some((v) => {
+                    return utils_1.semver.satisfies(version, v);
+                });
+            }
+            else {
+                ret = false;
+            }
+        }
+        cache.set(dir, ret);
+        return ret;
+    }
+}
+exports.isMatch = isMatch;
+function es5ImcompatibleVersionsToPkg() {
+    const { config: { 'es5-imcompatible-versions': config }, } = require('es5-imcompatible-versions/package.json');
+    return Object.keys(config).reduce((memo, key) => {
+        memo[key] = /* versions */ Object.keys(config[key]);
+        return memo;
+    }, {});
+}
+exports.es5ImcompatibleVersionsToPkg = es5ImcompatibleVersionsToPkg;

package/dist/utils/formatWebpackMessages.d.ts

@@ -0,0 +1,12 @@
+export declare function formatMessage(message: string | {
+    message: string;
+} | {
+    message: string;
+}[]): string;
+export declare function formatWebpackMessages(json: {
+    errors: string[];
+    warnings: string[];
+}): {
+    errors: string[];
+    warnings: string[];
+};

package/dist/utils/formatWebpackMessages.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatWebpackMessages = exports.formatMessage = void 0;
+const strip_ansi_1 = __importDefault(require("@umijs/utils/compiled/strip-ansi"));
+const friendlySyntaxErrorLabel = 'Syntax error:';
+function isLikelyASyntaxError(message) {
+    return (0, strip_ansi_1.default)(message).indexOf(friendlySyntaxErrorLabel) !== -1;
+}
+function formatMessage(message) {
+    let lines = [];
+    if (typeof message === 'string') {
+        lines = message.split('\n');
+    }
+    else if ('message' in message) {
+        lines = message['message'].split('\n');
+    }
+    else if (Array.isArray(message)) {
+        message.forEach((message) => {
+            if ('message' in message) {
+                lines = message['message'].split('\n');
+            }
+        });
+    }
+    // Strip webpack-added headers off errors/warnings
+    // https://github.com/webpack/webpack/blob/master/lib/ModuleError.js
+    lines = lines.filter((line) => !/Module [A-z ]+\(from/.test(line));
+    // Transform parsing error into syntax error
+    // TODO: move this to our ESLint formatter?
+    lines = lines.map((line) => {
+        const parsingError = /Line (\d+):(?:(\d+):)?\s*Parsing error: (.+)$/.exec(line);
+        if (!parsingError) {
+            return line;
+        }
+        const [, errorLine, errorColumn, errorMessage] = parsingError;
+        return `${friendlySyntaxErrorLabel} ${errorMessage} (${errorLine}:${errorColumn})`;
+    });
+    message = lines.join('\n');
+    // Smoosh syntax errors (commonly found in CSS)
+    message = message.replace(/SyntaxError\s+\((\d+):(\d+)\)\s*(.+?)\n/g, `${friendlySyntaxErrorLabel} $3 ($1:$2)\n`);
+    // Clean up export errors
+    message = message.replace(/^.*export '(.+?)' was not found in '(.+?)'.*$/gm, `Attempted import error: '$1' is not exported from '$2'.`);
+    message = message.replace(/^.*export 'default' \(imported as '(.+?)'\) was not found in '(.+?)'.*$/gm, `Attempted import error: '$2' does not contain a default export (imported as '$1').`);
+    message = message.replace(/^.*export '(.+?)' \(imported as '(.+?)'\) was not found in '(.+?)'.*$/gm, `Attempted import error: '$1' is not exported from '$3' (imported as '$2').`);
+    lines = message.split('\n');
+    // Remove leading newline
+    if (lines.length > 2 && lines[1].trim() === '') {
+        lines.splice(1, 1);
+    }
+    // Clean up file name
+    lines[0] = lines[0].replace(/^(.*) \d+:\d+-\d+$/, '$1');
+    // Cleans up verbose "module not found" messages for files and packages.
+    if (lines[1] && lines[1].indexOf('Module not found: ') === 0) {
+        lines = [
+            lines[0],
+            lines[1]
+                .replace('Error: ', '')
+                .replace('Module not found: Cannot find file:', 'Cannot find file:'),
+        ];
+    }
+    // Add helpful message for users trying to use Sass for the first time
+    if (lines[1] && lines[1].match(/Cannot find module.+sass/)) {
+        lines[1] = 'To import Sass files, you first need to install sass.\n';
+        lines[1] +=
+            'Run `npm install sass` or `yarn add sass` inside your workspace.';
+    }
+    message = lines.join('\n');
+    // Internal stacks are generally useless so we strip them... with the
+    // exception of stacks containing `webpack:` because they're normally
+    // from user code generated by webpack. For more information see
+    // https://github.com/facebook/create-react-app/pull/1050
+    message = message.replace(/^\s*at\s((?!webpack:).)*:\d+:\d+[\s)]*(\n|$)/gm, ''); // at ... ...:x:y
+    message = message.replace(/^\s*at\s<anonymous>(\n|$)/gm, ''); // at <anonymous>
+    lines = message.split('\n');
+    // Remove duplicated newlines
+    lines = lines.filter((line, index, arr) => index === 0 ||
+        line.trim() !== '' ||
+        line.trim() !== arr[index - 1].trim());
+    // Reassemble the message
+    message = lines.join('\n');
+    return message.trim();
+}
+exports.formatMessage = formatMessage;
+function formatWebpackMessages(json) {
+    const formattedErrors = json.errors.map(function (message) {
+        return formatMessage(message);
+    });
+    const formattedWarnings = json.warnings.map(function (message) {
+        return formatMessage(message);
+    });
+    const result = { errors: formattedErrors, warnings: formattedWarnings };
+    if (result.errors.some(isLikelyASyntaxError)) {
+        // If there are any syntax errors, show just them.
+        result.errors = result.errors.filter(isLikelyASyntaxError);
+    }
+    return result;
+}
+exports.formatWebpackMessages = formatWebpackMessages;