mediacms/frontend/packages/scripts/dist/webpack-dev-env.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var __assign = function() {
    __assign = Object.assign || function __assign(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
function __spreadArray(to, from, pack) {
    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
        }
    }
    return to.concat(ar || from);
}

function bodySnippet(id) {
    return '<div id="' + id + '"></div>';
}
var homePage = {
    staticPage: true,
    buildExclude: false,
    title: 'Home',
    filename: 'index.html',
    html: {
        head: {},
        body: {
            scripts: [],
            snippet: bodySnippet('page-home'),
        }
    },
    window: {},
    render: 'import { renderPage } from \'./js/helpers\'; import { HomePage } from \'./js/pages/HomePage\'; renderPage( \'page-home\', HomePage );',
};
var errorPage = {
    staticPage: true,
    buildExclude: false,
    title: 'Error',
    filename: 'error.html',
    html: {
        head: {},
        body: {
            scripts: [],
            snippet: bodySnippet('page-error'),
        }
    },
    window: {},
    render: 'import { renderPage } from \'./js/helpers\'; import { ErrorPage } from \'./js/pages/ErrorPage\'; renderPage( \'page-error\', ErrorPage );',
};
var pages = {
    home: homePage,
    error: errorPage,
};
var htmlHead = {
    meta: [
        { charset: 'utf-8' },
        { content: 'ie=edge', 'http-equiv': 'x-ua-compatible' },
        { name: 'viewport', content: 'width=device-width, initial-scale=1' },
    ],
    links: [],
    scripts: [],
};
var htmlBody = {
    scripts: [],
    snippet: '',
};
var html = {
    head: htmlHead,
    body: htmlBody,
};
var config$3 = {
    src: '',
    build: '',
    pages: pages,
    html: html,
    window: {},
    postcssConfigFile: '',
};

/*const chunksCacheGroups_0 = {
    commons: {
        test: /[\\/]src[\\/]/,
        name: "_commons",
        chunks: "all",
        enforce: true,
        reuseExistingChunk: true,
    },
};*/
/*const chunksCacheGroups_1 = {
    commons: {
        test: /[\\/]src[\\/]/,
        name: "_commons",
        // priority: -10,
        chunks: "all",
        enforce: true,
        reuseExistingChunk: true,
    },
    vendors: {
        test: /[\\/]node_modules[\\/]/,
        // test: /[\\/]node_modules[\\/](react|react-dom)[\\/]/,
        // test: /[\\/]node_modules[\\/](!MediaCmsPlayer)[\\/]/,
        name: "_vendors",
        // priority: -20,
        chunks: "all",
        enforce: true,
        // reuseExistingChunk: true,
    },
};*/
/*const chunksCacheGroups_2 = {
    commons: {
        minChunks: 2,
        // maxInitialRequests: 8, // @note: Tested values from 0 to 10, and changes applied with values 0, 4, 5, 6, 7, 8.
        // minSize: 0,
        name: "_commons",
        chunks: "all",
        enforce: true,
        reuseExistingChunk: true,
    },
};*/
/*const chunksCacheGroups_3 = {
    vendors: {
        test: /[\\/]node_modules[\\/]/,
        name: "_commons",
        priority: 1,
        chunks: "initial",
    },
};*/
var config$2 = {
    mode: 'production',
    devtool: 'source-map',
    optimization: {
        runtimeChunk: false,
        /*splitChunks: {
            // minSize: 1000000,
            chunks: 'all',
            automaticNameDelimiter: '-',
        },*/
        /*splitChunks: {
            // minSize: 1000000,
            chunks: 'all',
            automaticNameDelimiter: '-',
            cacheGroups: chunksCacheGroups_0,
        },*/
        /*splitChunks: {
            chunks: 'all',
            automaticNameDelimiter: '-',
            cacheGroups: chunksCacheGroups_1,
        },*/
        /*splitChunks: {
            chunks: 'all',
            automaticNameDelimiter: '-',
            cacheGroups: chunksCacheGroups_2,
        },*/
        /*splitChunks: {
            chunks: 'all',
            automaticNameDelimiter: '-',
            cacheGroups: chunksCacheGroups_3,
        },*/
        splitChunks: {
            chunks: 'all',
            automaticNameDelimiter: '-',
            cacheGroups: {
                vendors: {
                    test: /[\\/]node_modules[\\/]/,
                    name: "_commons",
                    priority: 1,
                    chunks: "initial",
                },
            },
        },
    }
};

/*const chunksCacheGroups_0 = {
    commons: {
        test: /[\\/]src[\\/]/,
        name: "_commons",
        chunks: "all",
        enforce: true,
        reuseExistingChunk: true,
    },
};

const chunksCacheGroups_1 = {
    commons: {
        test: /[\\/]src[\\/]/,
        name: "_commons",
        // priority: -10,
        chunks: "all",
        enforce: true,
        reuseExistingChunk: true,
    },
    vendors: {
        test: /[\\/]node_modules[\\/]/,
        // test: /[\\/]node_modules[\\/](react|react-dom)[\\/]/,
        // test: /[\\/]node_modules[\\/](!MediaCmsPlayer)[\\/]/,
        name: "_vendors",
        // priority: -20,
        chunks: "all",
        enforce: true,
        // reuseExistingChunk: true,
    },
};

const chunksCacheGroups_2 = {
    commons: {
        minChunks: 2,
        // maxInitialRequests: 8, // @note: Tested values from 0 to 10, and changes applied with values 0, 4, 5, 6, 7, 8.
        // minSize: 0,
        name: "_commons",
        chunks: "all",
        enforce: true,
        reuseExistingChunk: true,
    },
};

const chunksCacheGroups_3 = {
    vendors: {
        test: /[\\/]node_modules[\\/]/,
        name: "_commons",
        priority: 1,
        chunks: "initial",
    },
};*/
var config$1 = {
    mode: 'production',
    optimization: {
        minimize: true,
        runtimeChunk: false,
        splitChunks: {
            chunks: 'all',
            automaticNameDelimiter: '-',
            cacheGroups: {
                vendors: {
                    test: /[\\/]node_modules[\\/]/,
                    name: "_commons",
                    priority: 1,
                    chunks: "initial",
                },
            },
        },
    }
};

/**
 * @see {link: https://github.com/seeyoulater/html-beautify-webpack-plugin/blob/master/index.js}
 */
var prettify = require('html-prettify');
var HtmlWebpackPlugin$1 = require('html-webpack-plugin');
require('webpack/lib/WebpackError.js');
function htmlPluginDataFunction(pluginData, options, callback) {
    pluginData.html = prettify(options.replace.reduce(function (res, item) { return res.replace(item instanceof RegExp ? new RegExp(item, 'gi') : item, ''); }, pluginData.html) /*,
    options.config*/);
    callback(null, pluginData);
}
var MyHtmlBeautifyWebpackPlugin = /** @class */ (function () {
    function MyHtmlBeautifyWebpackPlugin() {
    }
    MyHtmlBeautifyWebpackPlugin.prototype.apply = function (compiler) {
        var options = {
            config: {
                indent_size: 4,
                indent_with_tabs: false,
                html: {
                    end_with_newline: true,
                    indent_inner_html: true,
                    preserve_newlines: true,
                    max_preserve_newlines: 0,
                }
            },
            replace: []
        };
        function tapAsyncCallback(pluginData, callback) {
            return htmlPluginDataFunction(pluginData, options, callback);
        }
        function tapHookCallback(compilation) {
            return HtmlWebpackPlugin$1.getHooks(compilation).beforeEmit.tapAsync('MyHtmlBeautifyWebpackPlugin', tapAsyncCallback);
        }
        compiler.hooks.compilation.tap('MyHtmlBeautifyWebpackPlugin', tapHookCallback);
    };
    return MyHtmlBeautifyWebpackPlugin;
}());

var fs = require('fs');
var path$1 = require('path');
var ejs = require('ejs');
var templatePath = path$1.join(__dirname, '../templates');
var sitemapTemplatePath = path$1.join(templatePath, 'sitemap.ejs');
var sitemapTemplate = ejs.compile(fs.readFileSync(sitemapTemplatePath, 'utf8'), { root: [templatePath], filename: sitemapTemplatePath, outputFunctionName: 'echo' });
function pagesConfig(pagesKeys) {
    var pages = {};
    if (-1 === pagesKeys.indexOf('sitemap')) {
        pages.sitemap = {
            staticPage: true,
            buildExclude: true,
            title: 'Sitemap',
            filename: 'sitemap.html',
            html: {
                head: {},
                body: {
                    scripts: [],
                    snippet: sitemapTemplate({ pages: __spreadArray(__spreadArray([], pagesKeys), Object.keys(pages)) }),
                },
            },
            window: {},
            render: ''
        };
    }
    return pages;
}

var merge = require('lodash.merge');
function validateBoolean(value, defaultValue) {
    if (defaultValue === void 0) { defaultValue = false; }
    if (true === value || false === value) {
        return value;
    }
    if (0 === value || 1 === value) {
        return !!value;
    }
    return defaultValue;
}
function validateString(value, defaultValue) {
    if (defaultValue === void 0) { defaultValue = ''; }
    return value ? value : defaultValue;
}
function getArrayType(sourcesArr, pageArr) {
    if (pageArr === void 0) { pageArr = []; }
    if ((!sourcesArr || !sourcesArr.length) && (!pageArr || !pageArr.length)) {
        return [];
    }
    if (sourcesArr && sourcesArr.length && pageArr && pageArr.length) {
        return sourcesArr.concat(pageArr);
    }
    if (sourcesArr && sourcesArr.length) {
        return sourcesArr;
    }
    return pageArr;
}
function formatPagesConfig(sources, pages) {
    var ret = {};
    for (var pk in pages) {
        ret[pk] = {
            staticPage: validateBoolean(pages[pk].staticPage, false),
            buildExclude: validateBoolean(pages[pk].buildExclude, false),
            title: validateString(pages[pk].title, sources.title),
            filename: validateString(pages[pk].filename, sources.filename),
            html: {
                head: {
                    meta: getArrayType(sources.html.head.meta, pages[pk].html.head.meta),
                    links: getArrayType(sources.html.head.links, pages[pk].html.head.links),
                    scripts: getArrayType(sources.html.head.scripts, pages[pk].html.head.scripts),
                },
                body: {
                    scripts: getArrayType(sources.html.body.scripts, pages[pk].html.body.scripts),
                    snippet: validateString(pages[pk].html.body.snippet, sources.html.body.snippet),
                },
            },
            window: merge({}, sources.window, pages[pk].window),
            render: validateString(sources.render, pages[pk].render),
        };
    }
    return ret;
}

var path = require('path');
var NodePolyfillPlugin = require("node-polyfill-webpack-plugin");
// Webpack plugins.
var DefinePlugin = require('webpack').DefinePlugin;
var LimitChunkCountPlugin = require('webpack').optimize.LimitChunkCountPlugin;
var HtmlWebpackPlugin = require('html-webpack-plugin');
var VirtualModulesPlugin = require('webpack-virtual-modules');
var MiniCssExtractPlugin = require('mini-css-extract-plugin');
var ProgressBarPlugin = require('progress-bar-webpack-plugin');
var CssMinimizerPlugin = require('css-minimizer-webpack-plugin');
var CopyPlugin = require("copy-webpack-plugin");
var dotenv = require('dotenv').config({ path: path.resolve(__dirname + '../../../../.env') });
function webpackEntry(env, srcDir, pages) {
    var ret = {};
    for (var p in pages) {
        if ('development' === env || !pages[p].buildExclude) {
            ret[p] = path.resolve(srcDir + '/' + p + '.js');
        }
    }
    return ret;
}
function webpackOutput(env, destinationDir, buildDir, chunkhash, hash) {
    var ret = {
        path: destinationDir,
        filename: '',
    };
    var prefix = 'development' === env ? '' : buildDir;
    var tmp;
    if (undefined !== chunkhash) {
        tmp = chunkhash.trim();
        if ('' === tmp) {
            throw Error('Invalid chunkhash argument value: ' + chunkhash);
        }
        ret.filename = (prefix || '') + '[name]-[chunkhash].js';
    }
    else if (undefined !== hash) {
        tmp = hash.trim();
        if ('' === tmp) {
            throw Error('Invalid hash argument value: ' + hash);
        }
        ret.filename = (prefix || '') + '[name]-[hash].js';
    }
    else {
        ret.filename = (prefix || '') + '[name].js';
    }
    return ret;
}
function webpackAlias() {
    return {
    // modernizr$: path.resolve(__dirname, "../../.modernizrrc"),   // TODO: Enable this?
    };
}
function webpackRules(env, srcDir, postcssConfigFile) {
    return [{
            test: /\.(jsx|js)?$/,
            use: 'babel-loader'
        },
        {
            test: /\.(tsx|ts)?$/,
            use: 'ts-loader',
            // exclude: /node_modules/,
            // options: {
            //   compilerOptions: {
            // 	"sourceMap": !isProduction,
            //   },
            // },
        },
        {
            test: /\.ejs$/,
            use: {
                loader: 'ejs-compiled-loader',
                options: {
                    // beautify: true,
                    htmlmin: true,
                    // htmlminOptions: {
                    //     removeComments: true,
                    //     collapseWhitespace: true,
                    //     preserveLineBreaks: true
                    // }
                }
            }
        },
        {
            test: /\.(sa|sc|c)ss$/,
            use: [
                { loader: MiniCssExtractPlugin.loader },
                // { loader: 'development' === env ? MiniCssExtractPlugin.loader : 'style-loader' },  // Use inline <style> tag.
                { loader: 'css-loader', options: { importLoaders: 1 } },
                { loader: 'postcss-loader', options: { postcssOptions: { config: postcssConfigFile } } },
                { loader: 'sass-loader' },
            ],
        },
        {
            test: /\.module\.(sa|sc|c)ss$/,
            use: [
                { loader: MiniCssExtractPlugin.loader },
                // { loader: 'development' === env ? MiniCssExtractPlugin.loader : 'style-loader' },  // Use inline <style> tag.
                { loader: 'css-loader', options: { importLoaders: 1, modules: true, onlyLocals: false } },
                { loader: 'postcss-loader', options: { postcssOptions: { config: postcssConfigFile } } },
                { loader: 'sass-loader' },
            ]
        },
        {
            test: /\.(png|jpe?g|gif)(\?\S*)?$/,
            use: {
                loader: 'url-loader',
                options: {
                    limit: 1024,
                    fallback: 'file-loader',
                    name: function (file) {
                        return '.' + path.join(file.replace(srcDir, ''), '..').replace(/\\/g, '/') + '/[name].[ext]';
                    },
                },
            },
        },
        {
            test: /\.svg(\?v=\d+\.\d+\.\d+)?$/,
            /*issuer: {
                    test: /\.jsx?$/
                },*/
            use: ['babel-loader', '@svgr/webpack', 'url-loader']
        },
        {
            test: /\.svg(\?v=\d+\.\d+\.\d+)?$/,
            loader: 'url-loader'
        },
        {
            test: /\.(woff(2)?|ttf|eot|svg)(\?v=\d+\.\d+\.\d+)?$/,
            use: [{
                    loader: 'file-loader',
                    options: {
                        name: function (file) {
                            return '.' + path.join(file.replace(srcDir, ''), '..').replace(/\\/g, '/') + '/[name].[ext]';
                        },
                    }
                }]
        },
        {
            test: /\.modernizrrc.js$/,
            use: 'modernizr-loader',
        },
        {
            test: /\.modernizrrc(\.json)?$/,
            use: ['modernizr-loader', 'json-loader'],
        }];
}
function webpackPlugins(env, srcDir, pages, cssSrc) {
    var ret = [
        new DefinePlugin({ "process.env": JSON.stringify(dotenv.parsed) }),
        new NodePolyfillPlugin(),
        new MyHtmlBeautifyWebpackPlugin(),
    ];
    if ('development' !== env) {
        ret.push(new CopyPlugin({
            patterns: [
                {
                    from: path.resolve(__dirname, '../../../src/static/lib'),
                    to: path.resolve(__dirname, '../../../' + env + '/static/lib'),
                },
                {
                    from: path.resolve(__dirname, '../../../src/static/images'),
                    to: path.resolve(__dirname, '../../../' + env + '/static/images'),
                },
                {
                    from: path.resolve(__dirname, '../../../src/static/favicons'),
                    to: path.resolve(__dirname, '../../../' + env + '/static/favicons'),
                },
                {
                    from: path.resolve(__dirname, '../../../src/static/css/_extra.css'),
                    to: path.resolve(__dirname, '../../../' + env + '/static/css/_extra.css'),
                },
            ],
        }));
    }
    var virtualPages = {};
    var file;
    for (var k in pages) {
        if ('production' !== env || !pages[k].buildExclude) {
            file = path.resolve(srcDir + '/' + k + '.js');
            if ((void 0 !== pages[k].staticPage && pages[k].staticPage) || void 0 === pages[k].render) {
                virtualPages[file] = '';
            }
            else {
                virtualPages[file] = pages[k].render;
            }
        }
        if ('development' === env) {
            // Export pages HTML files.
            ret.push(new HtmlWebpackPlugin(__assign({ template: path.resolve(__dirname, '../templates/index.ejs'), hash: false, chunks: [k] }, pages[k])));
        }
    }
    ret.push(new VirtualModulesPlugin(virtualPages));
    ret.push(new MiniCssExtractPlugin({
        ignoreOrder: true,
        // filename: ! is_build ? '[name].css' : '[name].[hash].css',
        // chunkFilename: ! is_build ? '[id].css' : '[id].[hash].css',
        filename: cssSrc + '[name].css',
        // chunkFilename: "../css/[id].css",
    }));
    if ('development' !== env) {
        ret.push(new LimitChunkCountPlugin({ maxChunks: 1 }));
        ret.push(new ProgressBarPlugin({
            clear: false,
        }));
    }
    if ('production' === env) {
        ret.push(new CssMinimizerPlugin({
            cache: true,
            minimizerOptions: {
                preset: [
                    'default',
                    {
                        discardComments: { removeAll: true },
                    },
                ],
            },
        }));
    }
    return ret;
}
function generateConfig(env, config) {
    var srcDir = config.src;
    var buildDir = config.build + '/' + env + ('development' === env ? '' : '/static');
    var cssbuild = './css/';
    var jsbuild = './js/';
    var configPages = config.pages;
    var configPagesKeys = config.pages ? Object.keys(configPages) : [];
    var defPages = pagesConfig(configPagesKeys);
    var pages = formatPagesConfig({ title: '', filename: '', render: '', html: config.html, window: config.window }, __assign(__assign({}, configPages), defPages));
    var ret = {
        entry: webpackEntry(env, srcDir, pages),
        output: 'development' === env ? webpackOutput(env, srcDir, void 0, void 0, void 0) : webpackOutput(env, buildDir, jsbuild, void 0, void 0),
        plugins: webpackPlugins(env, srcDir, pages, cssbuild),
        module: {
            rules: webpackRules(env, srcDir, config.postcssConfigFile),
        },
        resolve: {
            alias: webpackAlias(),
            extensions: ['.tsx', '.ts', '.jsx', '.js'],
        },
    };
    return ret;
}

var isAbsolutePath$2 = require('path').isAbsolute;
var webpack$2 = require('webpack');
var webpackFormatMessages$1 = require('webpack-format-messages');
var BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
var defaultOptions$2 = {
    env: 'production',
    host: '127.0.0.1',
    port: 8888,
    mode: 'static',
    config: config$3,
};
function analyzer(analyzerOptions) {
    if (analyzerOptions === void 0) { analyzerOptions = defaultOptions$2; }
    var options = __assign(__assign({}, defaultOptions$2), analyzerOptions);
    options.config = __assign(__assign({}, defaultOptions$2.config), analyzerOptions.config);
    var config = generateConfig(options.env, options.config);
    if (!isAbsolutePath$2(options.config.src)) {
        throw Error('"src" is not an absolute path');
    }
    if (!isAbsolutePath$2(options.config.build)) {
        throw Error('"build" is not an absolute path');
    }
    if (!isAbsolutePath$2(options.config.postcssConfigFile)) {
        throw Error('"postcssConfigFile" is not an absolute path');
    }
    var analyzerConfig = {
        analyzerMode: options.mode,
        analyzerHost: options.host,
        analyzerPort: options.port,
        generateStatsFile: 'server' !== options.mode,
        startAnalyzer: 'server' === options.mode,
        statsFilename: 'analyzer-stats.json',
        reportFilename: 'analyzer-report.html',
    };
    var compiler = 'dist' === options.env ? webpack$2(__assign(__assign({}, config$1), config)) : webpack$2(__assign(__assign({}, config$2), config));
    var analyzer = new BundleAnalyzerPlugin(analyzerConfig);
    analyzer.apply(compiler);
    compiler.run(function (err, stats) {
        if (err)
            throw err;
        var messages = webpackFormatMessages$1(stats);
        if (!messages.errors.length && !messages.warnings.length) {
            console.log('Compiled successfully!', '\n');
        }
        if (messages.errors.length) {
            console.log('Failed to compile.', '\n');
            for (var _i = 0, _a = messages.errors; _i < _a.length; _i++) {
                var m = _a[_i];
                console.log(m);
            }
        }
        else if (messages.warnings.length) {
            console.log('Compiled with warnings.', '\n');
            for (var _b = 0, _c = messages.warnings; _b < _c.length; _b++) {
                var m = _c[_b];
                console.log(m);
            }
        }
    });
}

var isAbsolutePath$1 = require('path').isAbsolute;
var webpack$1 = require('webpack');
var webpackFormatMessages = require('webpack-format-messages');
var defaultOptions$1 = {
    env: 'production',
    config: config$3,
};
function build(buildOptions) {
    if (buildOptions === void 0) { buildOptions = defaultOptions$1; }
    var options = __assign(__assign({}, defaultOptions$1), buildOptions);
    options.config = __assign(__assign({}, defaultOptions$1.config), buildOptions.config);
    if (!isAbsolutePath$1(options.config.src)) {
        throw Error('"src" is not an absolute path');
    }
    if (!isAbsolutePath$1(options.config.build)) {
        throw Error('"build" is not an absolute path');
    }
    if (!isAbsolutePath$1(options.config.postcssConfigFile)) {
        throw Error('"postcssConfigFile" is not an absolute path');
    }
    var config = generateConfig(options.env, options.config);
    var compiler = 'dist' === options.env ? webpack$1(__assign(__assign({}, config$1), config)) : webpack$1(__assign(__assign({}, config$2), config));
    compiler.run(function (err, stats) {
        if (err)
            throw err;
        var messages = webpackFormatMessages(stats);
        if (!messages.errors.length && !messages.warnings.length) {
            console.log('Compiled successfully!', '\n');
        }
        if (messages.errors.length) {
            console.log('Failed to compile.', '\n');
            for (var _i = 0, _a = messages.errors; _i < _a.length; _i++) {
                var m = _a[_i];
                console.log(m);
            }
        }
        else if (messages.warnings.length) {
            console.log('Compiled with warnings.', '\n');
            for (var _b = 0, _c = messages.warnings; _b < _c.length; _b++) {
                var m = _c[_b];
                console.log(m);
            }
        }
    });
}

var config = {
    mode: 'development',
    // devtool: 'eval',
    // devtool: 'source-map',
    // devtool: 'eval-cheap-source-map',
    optimization: {
        minimize: false
    }
};

function configFunc(contentBase) {
    return {
        watchOptions: {
            poll: true,
        },
        contentBase: contentBase,
        compress: true,
        hot: true
    };
}

var isAbsolutePath = require('path').isAbsolute;
var webpack = require('webpack');
var WebpackDevServer = require('webpack-dev-server');
var defaultOptions = {
    env: 'development',
    host: '0.0.0.0',
    port: 8080,
    config: config$3,
};
function dev(devOptions) {
    if (devOptions === void 0) { devOptions = defaultOptions; }
    var options = __assign(__assign({}, defaultOptions), devOptions);
    options.config = __assign(__assign({}, defaultOptions.config), devOptions.config);
    var config$1 = generateConfig(options.env, options.config);
    if (!isAbsolutePath(options.config.src)) {
        throw Error('"src" is not an absolute path');
    }
    if (!isAbsolutePath(options.config.build)) {
        throw Error('"build" is not an absolute path');
    }
    if (!isAbsolutePath(options.config.postcssConfigFile)) {
        throw Error('"postcssConfigFile" is not an absolute path');
    }
    var compilerConfig = __assign(__assign({}, config), config$1);
    var serverOptions = configFunc(options.config.src);
    WebpackDevServer.addDevServerEntrypoints(compilerConfig, serverOptions);
    var compiler = webpack(compilerConfig);
    var server = new WebpackDevServer(compiler, serverOptions);
    server.listen(options.port, options.host, function (err) {
        if (err)
            throw err;
    });
}

exports.analyzer = analyzer;
exports.build = build;
exports.dev = dev;