xhs-mp-pack 1.1.0-beta.0

package/dist/plugins/DefaultStatsFactoryPlugin.js

@@ -0,0 +1,1552 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = __importDefault(require("util"));
+const ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const ModuleDependency_1 = __importDefault(require("@/dependencies/ModuleDependency"));
+const formatLocation_1 = __importDefault(require("@/base/formatLocation"));
+const Logger_1 = require("@/base/logging/Logger");
+const AggressiveSplittingPlugin_1 = __importDefault(require("@/plugins/optimize/AggressiveSplittingPlugin"));
+const IterableHelpers_1 = require("@/base/IterableHelpers");
+const comparators_1 = require("@/base/comparators");
+const identifier_1 = require("@/base/identifier");
+const uniqueArray = (items, selector) => {
+    const set = new Set();
+    for (const item of items) {
+        for (const i of selector(item)) {
+            set.add(i);
+        }
+    }
+    return Array.from(set);
+};
+const uniqueOrderedArray = (items, selector, comparator) => uniqueArray(items, selector).sort(comparator);
+const mapObject = (obj, fn) => {
+    const newObj = Object.create(null);
+    for (const key of Object.keys(obj)) {
+        newObj[key] = fn(obj[key], key);
+    }
+    return newObj;
+};
+const countWithChildren = (compilation, getItems) => {
+    let count = getItems(compilation, '').length;
+    for (const child of compilation.children) {
+        count += countWithChildren(child, (c, type) => getItems(c, `.children[].compilation${type}`));
+    }
+    return count;
+};
+const EXTRACT_ERROR = {
+    _: (object, error, context, { requestShortener }) => {
+        // TODO webpack 6 disallow strings in the errors/warnings list
+        if (typeof error === 'string') {
+            object.message = error;
+        }
+        else {
+            if (error.chunk) {
+                object.chunkName = error.chunk.name;
+                object.chunkEntry = error.chunk.hasRuntime();
+                object.chunkInitial = error.chunk.canBeInitial();
+            }
+            if (error.file) {
+                object.file = error.file;
+            }
+            if (error.module) {
+                object.moduleIdentifier = error.module.identifier();
+                object.moduleName = error.module.readableIdentifier(requestShortener);
+            }
+            if (error.loc) {
+                object.loc = (0, formatLocation_1.default)(error.loc);
+            }
+            object.message = error.message;
+        }
+    },
+    ids: (object, error, { compilation: { chunkGraph } }) => {
+        if (typeof error !== 'string') {
+            if (error.chunk) {
+                object.chunkId = error.chunk.id;
+            }
+            if (error.module) {
+                object.moduleId = chunkGraph.getModuleId(error.module);
+            }
+        }
+    },
+    moduleTrace: (object, error, context, options, factory) => {
+        if (typeof error !== 'string' && error.module) {
+            const { type, compilation: { moduleGraph }, } = context;
+            const visitedModules = new Set();
+            const moduleTrace = [];
+            let current = error.module;
+            while (current) {
+                if (visitedModules.has(current))
+                    break; // circular (technically impossible, but how knows)
+                visitedModules.add(current);
+                const origin = moduleGraph.getIssuer(current);
+                if (!origin)
+                    break;
+                moduleTrace.push({ origin, module: current });
+                current = origin;
+            }
+            object.moduleTrace = factory.create(`${type}.moduleTrace`, moduleTrace, context);
+        }
+    },
+    errorDetails: (object, error, { type, compilation, cachedGetErrors, cachedGetWarnings }, { errorDetails }) => {
+        if (typeof error !== 'string' &&
+            (errorDetails === true ||
+                (type.endsWith('.error') && cachedGetErrors(compilation).length < 3))) {
+            object.details = error.details;
+        }
+    },
+    errorStack: (object, error) => {
+        if (typeof error !== 'string') {
+            object.stack = error.stack;
+        }
+    },
+};
+const SIMPLE_EXTRACTORS = {
+    compilation: {
+        _: (object, compilation, context, options) => {
+            if (!context.makePathsRelative) {
+                context.makePathsRelative = identifier_1.makePathsRelative.bindContextCache(compilation.compiler.context, compilation.compiler.root);
+            }
+            if (!context.cachedGetErrors) {
+                const map = new WeakMap();
+                context.cachedGetErrors = compilation => (map.get(compilation) ||
+                    // eslint-disable-next-line no-sequences
+                    (errors => (map.set(compilation, errors), errors))(compilation.getErrors()));
+            }
+            if (!context.cachedGetWarnings) {
+                const map = new WeakMap();
+                context.cachedGetWarnings = compilation => (map.get(compilation) ||
+                    // eslint-disable-next-line no-sequences
+                    (warnings => (map.set(compilation, warnings), warnings))(compilation.getWarnings()));
+            }
+            if (compilation.name) {
+                object.name = compilation.name;
+            }
+            if (compilation.needAdditionalPass) {
+                object.needAdditionalPass = true;
+            }
+            const { logging, loggingDebug, loggingTrace } = options;
+            if (logging || (loggingDebug && loggingDebug.length > 0)) {
+                object.logging = {};
+                let acceptedTypes;
+                let collapsedGroups = false;
+                switch (logging) {
+                    default:
+                        acceptedTypes = new Set();
+                        break;
+                    case 'error':
+                        acceptedTypes = new Set([Logger_1.LogType.error]);
+                        break;
+                    case 'warn':
+                        acceptedTypes = new Set([Logger_1.LogType.error, Logger_1.LogType.warn]);
+                        break;
+                    case 'info':
+                        acceptedTypes = new Set([Logger_1.LogType.error, Logger_1.LogType.warn, Logger_1.LogType.info]);
+                        break;
+                    case 'log':
+                        acceptedTypes = new Set([
+                            Logger_1.LogType.error,
+                            Logger_1.LogType.warn,
+                            Logger_1.LogType.info,
+                            Logger_1.LogType.log,
+                            Logger_1.LogType.group,
+                            Logger_1.LogType.groupEnd,
+                            Logger_1.LogType.groupCollapsed,
+                            Logger_1.LogType.clear,
+                        ]);
+                        break;
+                    case 'verbose':
+                        acceptedTypes = new Set([
+                            Logger_1.LogType.error,
+                            Logger_1.LogType.warn,
+                            Logger_1.LogType.info,
+                            Logger_1.LogType.log,
+                            Logger_1.LogType.group,
+                            Logger_1.LogType.groupEnd,
+                            Logger_1.LogType.groupCollapsed,
+                            Logger_1.LogType.profile,
+                            Logger_1.LogType.profileEnd,
+                            Logger_1.LogType.time,
+                            Logger_1.LogType.status,
+                            Logger_1.LogType.clear,
+                        ]);
+                        collapsedGroups = true;
+                        break;
+                }
+                const cachedMakePathsRelative = identifier_1.makePathsRelative.bindContextCache(options.context, compilation.compiler.root);
+                let depthInCollapsedGroup = 0;
+                for (const [origin, logEntries] of compilation.logging) {
+                    const debugMode = loggingDebug.some(fn => fn(origin));
+                    if (logging === false && !debugMode)
+                        continue;
+                    const groupStack = [];
+                    const rootList = [];
+                    let currentList = rootList;
+                    let processedLogEntries = 0;
+                    for (const entry of logEntries) {
+                        let type = entry.type;
+                        if (!debugMode && !acceptedTypes.has(type))
+                            continue;
+                        // Expand groups in verbose and debug modes
+                        if (type === Logger_1.LogType.groupCollapsed && (debugMode || collapsedGroups))
+                            type = Logger_1.LogType.group;
+                        if (depthInCollapsedGroup === 0) {
+                            processedLogEntries++;
+                        }
+                        if (type === Logger_1.LogType.groupEnd) {
+                            groupStack.pop();
+                            if (groupStack.length > 0) {
+                                currentList = groupStack[groupStack.length - 1].children;
+                            }
+                            else {
+                                currentList = rootList;
+                            }
+                            if (depthInCollapsedGroup > 0)
+                                depthInCollapsedGroup--;
+                            continue;
+                        }
+                        let message;
+                        if (entry.type === Logger_1.LogType.time) {
+                            message = `${entry.args[0]}: ${entry.args[1] * 1000 + entry.args[2] / 1000000} ms`;
+                        }
+                        else if (entry.args && entry.args.length > 0) {
+                            message = util_1.default.format(entry.args[0], ...entry.args.slice(1));
+                        }
+                        const newEntry = Object.assign(Object.assign({}, entry), { type,
+                            message, trace: loggingTrace ? entry.trace : undefined, children: type === Logger_1.LogType.group || type === Logger_1.LogType.groupCollapsed ? [] : undefined });
+                        currentList.push(newEntry);
+                        if (newEntry.children) {
+                            groupStack.push(newEntry);
+                            currentList = newEntry.children;
+                            if (depthInCollapsedGroup > 0) {
+                                depthInCollapsedGroup++;
+                            }
+                            else if (type === Logger_1.LogType.groupCollapsed) {
+                                depthInCollapsedGroup = 1;
+                            }
+                        }
+                    }
+                    let name = cachedMakePathsRelative(origin).replace(/\|/g, ' ');
+                    if (name in object.logging) {
+                        let i = 1;
+                        while (`${name}#${i}` in object.logging) {
+                            i++;
+                        }
+                        name = `${name}#${i}`;
+                    }
+                    object.logging[name] = {
+                        entries: rootList,
+                        filteredEntries: logEntries.length - processedLogEntries,
+                        debug: debugMode,
+                    };
+                }
+            }
+        },
+        hash: (object, compilation) => {
+            object.hash = compilation.hash;
+        },
+        version: object => {
+            object.version = require('../../../package.json').version;
+        },
+        env: (object, compilation, context, { _env }) => {
+            object.env = _env;
+        },
+        timings: (object, compilation) => {
+            object.time = compilation.endTime - compilation.startTime;
+        },
+        builtAt: (object, compilation) => {
+            object.builtAt = compilation.endTime;
+        },
+        publicPath: (object, compilation) => {
+            object.publicPath = compilation.getPath(compilation.outputOptions.publicPath);
+        },
+        outputPath: (object, compilation) => {
+            object.outputPath = compilation.outputOptions.path;
+        },
+        assets: (object, compilation, context, options, factory) => {
+            const { type } = context;
+            const compilationFileToChunks = new Map();
+            const compilationAuxiliaryFileToChunks = new Map();
+            for (const chunk of compilation.chunks) {
+                for (const file of chunk.files) {
+                    let array = compilationFileToChunks.get(file);
+                    if (array === undefined) {
+                        array = [];
+                        compilationFileToChunks.set(file, array);
+                    }
+                    array.push(chunk);
+                }
+                for (const file of chunk.auxiliaryFiles) {
+                    let array = compilationAuxiliaryFileToChunks.get(file);
+                    if (array === undefined) {
+                        array = [];
+                        compilationAuxiliaryFileToChunks.set(file, array);
+                    }
+                    array.push(chunk);
+                }
+            }
+            const assetMap = new Map();
+            const assets = new Set();
+            for (const asset of compilation.getAssets()) {
+                const item = Object.assign(Object.assign({}, asset), { type: 'asset', related: undefined });
+                assets.add(item);
+                assetMap.set(asset.name, item);
+            }
+            for (const item of assetMap.values()) {
+                const related = item.info.related;
+                if (!related)
+                    continue;
+                for (const type of Object.keys(related)) {
+                    const relatedEntry = related[type];
+                    const deps = Array.isArray(relatedEntry) ? relatedEntry : [relatedEntry];
+                    for (const dep of deps) {
+                        const depItem = assetMap.get(dep);
+                        if (!depItem)
+                            continue;
+                        assets.delete(depItem);
+                        depItem.type = type;
+                        item.related = item.related || [];
+                        item.related.push(depItem);
+                    }
+                }
+            }
+            object.assetsByChunkName = {};
+            for (const [file, chunks] of compilationFileToChunks) {
+                for (const chunk of chunks) {
+                    const name = chunk.name;
+                    if (!name)
+                        continue;
+                    if (!Object.prototype.hasOwnProperty.call(object.assetsByChunkName, name)) {
+                        object.assetsByChunkName[name] = [];
+                    }
+                    object.assetsByChunkName[name].push(file);
+                }
+            }
+            const groupedAssets = factory.create(`${type}.assets`, Array.from(assets), Object.assign(Object.assign({}, context), { compilationFileToChunks,
+                compilationAuxiliaryFileToChunks }));
+            const limited = spaceLimited(groupedAssets, options.assetsSpace);
+            object.assets = limited.children;
+            object.filteredAssets = limited.filteredChildren;
+        },
+        chunks: (object, compilation, context, options, factory) => {
+            const { type } = context;
+            object.chunks = factory.create(`${type}.chunks`, Array.from(compilation.chunks), context);
+        },
+        modules: (object, compilation, context, options, factory) => {
+            const { type } = context;
+            const array = Array.from(compilation.modules);
+            const groupedModules = factory.create(`${type}.modules`, array, context);
+            const limited = spaceLimited(groupedModules, options.modulesSpace);
+            object.modules = limited.children;
+            object.filteredModules = limited.filteredChildren;
+        },
+        entrypoints: (object, compilation, context, { entrypoints, chunkGroups, chunkGroupAuxiliary, chunkGroupChildren }, factory) => {
+            const { type } = context;
+            const array = Array.from(compilation.entrypoints, ([key, value]) => ({
+                name: key,
+                chunkGroup: value,
+            }));
+            if (entrypoints === 'auto' && !chunkGroups) {
+                if (array.length > 5)
+                    return;
+                if (!chunkGroupChildren &&
+                    array.every(({ chunkGroup }) => {
+                        if (chunkGroup.chunks.length !== 1)
+                            return false;
+                        const chunk = chunkGroup.chunks[0];
+                        return (chunk.files.size === 1 && (!chunkGroupAuxiliary || chunk.auxiliaryFiles.size === 0));
+                    })) {
+                    return;
+                }
+            }
+            object.entrypoints = factory.create(`${type}.entrypoints`, array, context);
+        },
+        chunkGroups: (object, compilation, context, options, factory) => {
+            const { type } = context;
+            const array = Array.from(compilation.namedChunkGroups, ([key, value]) => ({
+                name: key,
+                chunkGroup: value,
+            }));
+            object.namedChunkGroups = factory.create(`${type}.namedChunkGroups`, array, context);
+        },
+        errors: (object, compilation, context, options, factory) => {
+            const { type, cachedGetErrors } = context;
+            const rawErrors = cachedGetErrors(compilation);
+            const factorizedErrors = factory.create(`${type}.errors`, cachedGetErrors(compilation), context);
+            let filtered = 0;
+            if (options.errorDetails === 'auto' && rawErrors.length >= 3) {
+                filtered = rawErrors.map(e => typeof e !== 'string' && e.details).filter(Boolean).length;
+            }
+            if (options.errorDetails === true || !Number.isFinite(options.errorsSpace)) {
+                object.errors = factorizedErrors;
+                if (filtered)
+                    object.filteredErrorDetailsCount = filtered;
+                return;
+            }
+            const [errors, filteredBySpace] = errorsSpaceLimit(factorizedErrors, options.errorsSpace);
+            object.filteredErrorDetailsCount = filtered + filteredBySpace;
+            object.errors = errors;
+        },
+        errorsCount: (object, compilation, { cachedGetErrors }) => {
+            object.errorsCount = countWithChildren(compilation, c => cachedGetErrors(c));
+        },
+        warnings: (object, compilation, context, options, factory) => {
+            const { type, cachedGetWarnings } = context;
+            const rawWarnings = factory.create(`${type}.warnings`, cachedGetWarnings(compilation), context);
+            let filtered = 0;
+            if (options.errorDetails === 'auto') {
+                filtered = cachedGetWarnings(compilation)
+                    .map(e => typeof e !== 'string' && e.details)
+                    .filter(Boolean).length;
+            }
+            if (options.errorDetails === true || !Number.isFinite(options.warningsSpace)) {
+                object.warnings = rawWarnings;
+                if (filtered)
+                    object.filteredWarningDetailsCount = filtered;
+                return;
+            }
+            const [warnings, filteredBySpace] = errorsSpaceLimit(rawWarnings, options.warningsSpace);
+            object.filteredWarningDetailsCount = filtered + filteredBySpace;
+            object.warnings = warnings;
+        },
+        warningsCount: (object, compilation, context, { warningsFilter }, factory) => {
+            const { type, cachedGetWarnings } = context;
+            object.warningsCount = countWithChildren(compilation, (c, childType) => {
+                if (!warningsFilter && warningsFilter.length === 0)
+                    return cachedGetWarnings(c);
+                return factory
+                    .create(`${type}${childType}.warnings`, cachedGetWarnings(c), context)
+                    .filter(warning => {
+                    const warningString = Object.keys(warning)
+                        .map(key => `${warning[key]}`)
+                        .join('\n');
+                    return !warningsFilter.some(filter => filter(warning, warningString));
+                });
+            });
+        },
+        children: (object, compilation, context, options, factory) => {
+            const { type } = context;
+            object.children = factory.create(`${type}.children`, compilation.children, context);
+        },
+    },
+    asset: {
+        _: (object, asset, context, options, factory) => {
+            const { compilation } = context;
+            object.type = asset.type;
+            object.name = asset.name;
+            object.size = asset.source.size();
+            object.emitted = compilation.emittedAssets.has(asset.name);
+            object.comparedForEmit = compilation.comparedForEmitAssets.has(asset.name);
+            const cached = !object.emitted && !object.comparedForEmit;
+            object.cached = cached;
+            object.info = asset.info;
+            if (!cached || options.cachedAssets) {
+                Object.assign(object, factory.create(`${context.type}$visible`, asset, context));
+            }
+        },
+    },
+    asset$visible: {
+        _: (object, asset, { compilation, compilationFileToChunks, compilationAuxiliaryFileToChunks }) => {
+            const chunks = compilationFileToChunks.get(asset.name) || [];
+            const auxiliaryChunks = compilationAuxiliaryFileToChunks.get(asset.name) || [];
+            object.chunkNames = uniqueOrderedArray(chunks, c => (c.name ? [c.name] : []), comparators_1.compareIds);
+            object.chunkIdHints = uniqueOrderedArray(chunks, c => Array.from(c.idNameHints), comparators_1.compareIds);
+            object.auxiliaryChunkNames = uniqueOrderedArray(auxiliaryChunks, c => (c.name ? [c.name] : []), comparators_1.compareIds);
+            object.auxiliaryChunkIdHints = uniqueOrderedArray(auxiliaryChunks, c => Array.from(c.idNameHints), comparators_1.compareIds);
+            object.filteredRelated = asset.related ? asset.related.length : undefined;
+        },
+        relatedAssets: (object, asset, context, options, factory) => {
+            const { type } = context;
+            object.related = factory.create(`${type.slice(0, -8)}.related`, asset.related, context);
+            object.filteredRelated = asset.related
+                ? asset.related.length - object.related.length
+                : undefined;
+        },
+        ids: (object, asset, { compilationFileToChunks, compilationAuxiliaryFileToChunks }) => {
+            const chunks = compilationFileToChunks.get(asset.name) || [];
+            const auxiliaryChunks = compilationAuxiliaryFileToChunks.get(asset.name) || [];
+            object.chunks = uniqueOrderedArray(chunks, c => c.ids, comparators_1.compareIds);
+            object.auxiliaryChunks = uniqueOrderedArray(auxiliaryChunks, c => c.ids, comparators_1.compareIds);
+        },
+    },
+    chunkGroup: {
+        _: (object, { name, chunkGroup }, { compilation, compilation: { moduleGraph, chunkGraph, getAsset } }, { ids, chunkGroupAuxiliary, chunkGroupChildren, chunkGroupMaxAssets }) => {
+            const children = chunkGroupChildren && chunkGroup.getChildrenByOrders(moduleGraph, chunkGraph);
+            const toAsset = name => {
+                const asset = compilation.getAsset(name);
+                return {
+                    name,
+                    size: asset ? asset.info.size : -1,
+                };
+            };
+            const sizeReducer = (total, { size }) => total + size;
+            const assets = uniqueArray(chunkGroup.chunks, c => c.files).map(toAsset);
+            const auxiliaryAssets = uniqueOrderedArray(chunkGroup.chunks, c => c.auxiliaryFiles, comparators_1.compareIds).map(toAsset);
+            const assetsSize = assets.reduce(sizeReducer, 0);
+            const auxiliaryAssetsSize = auxiliaryAssets.reduce(sizeReducer, 0);
+            const statsChunkGroup = {
+                name,
+                chunks: ids ? chunkGroup.chunks.map(c => c.id) : undefined,
+                assets: assets.length <= chunkGroupMaxAssets ? assets : undefined,
+                filteredAssets: assets.length <= chunkGroupMaxAssets ? 0 : assets.length,
+                assetsSize,
+                auxiliaryAssets: chunkGroupAuxiliary && auxiliaryAssets.length <= chunkGroupMaxAssets
+                    ? auxiliaryAssets
+                    : undefined,
+                filteredAuxiliaryAssets: chunkGroupAuxiliary && auxiliaryAssets.length <= chunkGroupMaxAssets
+                    ? 0
+                    : auxiliaryAssets.length,
+                auxiliaryAssetsSize,
+                children: children
+                    ? mapObject(children, groups => groups.map(group => {
+                        const assets = uniqueArray(group.chunks, c => c.files).map(toAsset);
+                        const auxiliaryAssets = uniqueOrderedArray(group.chunks, c => c.auxiliaryFiles, comparators_1.compareIds).map(toAsset);
+                        const childStatsChunkGroup = {
+                            name: group.name,
+                            chunks: ids ? group.chunks.map(c => c.id) : undefined,
+                            assets: assets.length <= chunkGroupMaxAssets ? assets : undefined,
+                            filteredAssets: assets.length <= chunkGroupMaxAssets ? 0 : assets.length,
+                            auxiliaryAssets: chunkGroupAuxiliary && auxiliaryAssets.length <= chunkGroupMaxAssets
+                                ? auxiliaryAssets
+                                : undefined,
+                            filteredAuxiliaryAssets: chunkGroupAuxiliary && auxiliaryAssets.length <= chunkGroupMaxAssets
+                                ? 0
+                                : auxiliaryAssets.length,
+                        };
+                        return childStatsChunkGroup;
+                    }))
+                    : undefined,
+                childAssets: children
+                    ? mapObject(children, groups => {
+                        const set = new Set();
+                        for (const group of groups) {
+                            for (const chunk of group.chunks) {
+                                for (const asset of chunk.files) {
+                                    set.add(asset);
+                                }
+                            }
+                        }
+                        return Array.from(set);
+                    })
+                    : undefined,
+            };
+            Object.assign(object, statsChunkGroup);
+        },
+    },
+    module: {
+        _: (object, module, context, options, factory) => {
+            const { compilation, type } = context;
+            const built = compilation.builtModules.has(module);
+            const codeGenerated = compilation.codeGeneratedModules.has(module);
+            const buildTimeExecuted = compilation.buildTimeExecutedModules.has(module);
+            const sizes = {};
+            for (const sourceType of module.getSourceTypes()) {
+                sizes[sourceType] = module.size(sourceType);
+            }
+            const statsModule = {
+                type: 'module',
+                moduleType: module.type,
+                layer: module.layer,
+                size: module.size(),
+                sizes,
+                built,
+                codeGenerated,
+                buildTimeExecuted,
+                cached: !built && !codeGenerated,
+            };
+            Object.assign(object, statsModule);
+            if (built || codeGenerated || options.cachedModules) {
+                Object.assign(object, factory.create(`${type}$visible`, module, context));
+            }
+        },
+    },
+    module$visible: {
+        _: (object, module, context, { requestShortener }, factory) => {
+            const { compilation, type, rootModules } = context;
+            const { moduleGraph } = compilation;
+            const path = [];
+            const issuer = moduleGraph.getIssuer(module);
+            let current = issuer;
+            while (current) {
+                path.push(current);
+                current = moduleGraph.getIssuer(current);
+            }
+            path.reverse();
+            const profile = moduleGraph.getProfile(module);
+            const errors = module.getErrors();
+            const errorsCount = errors !== undefined ? (0, IterableHelpers_1.countIterable)(errors) : 0;
+            const warnings = module.getWarnings();
+            const warningsCount = warnings !== undefined ? (0, IterableHelpers_1.countIterable)(warnings) : 0;
+            const sizes = {};
+            for (const sourceType of module.getSourceTypes()) {
+                sizes[sourceType] = module.size(sourceType);
+            }
+            const statsModule = {
+                identifier: module.identifier(),
+                name: module.readableIdentifier(requestShortener),
+                nameForCondition: module.nameForCondition(),
+                index: moduleGraph.getPreOrderIndex(module),
+                preOrderIndex: moduleGraph.getPreOrderIndex(module),
+                index2: moduleGraph.getPostOrderIndex(module),
+                postOrderIndex: moduleGraph.getPostOrderIndex(module),
+                cacheable: module.buildInfo.cacheable,
+                optional: module.isOptional(moduleGraph),
+                orphan: !type.endsWith('module.modules[].module$visible') &&
+                    compilation.chunkGraph.getNumberOfModuleChunks(module) === 0,
+                dependent: rootModules ? !rootModules.has(module) : undefined,
+                issuer: issuer === null || issuer === void 0 ? void 0 : issuer.identifier(),
+                issuerName: issuer === null || issuer === void 0 ? void 0 : issuer.readableIdentifier(requestShortener),
+                issuerPath: issuer && factory.create(`${type.slice(0, -8)}.issuerPath`, path, context),
+                failed: errorsCount > 0,
+                errors: errorsCount,
+                warnings: warningsCount,
+            };
+            Object.assign(object, statsModule);
+            if (profile) {
+                object.profile = factory.create(`${type.slice(0, -8)}.profile`, profile, context);
+            }
+        },
+        ids: (object, module, { compilation: { chunkGraph, moduleGraph } }) => {
+            object.id = chunkGraph.getModuleId(module);
+            const issuer = moduleGraph.getIssuer(module);
+            object.issuerId = issuer && chunkGraph.getModuleId(issuer);
+            object.chunks = Array.from(chunkGraph.getOrderedModuleChunksIterable(module, comparators_1.compareChunksById), (chunk) => chunk.id);
+        },
+        moduleAssets: (object, module) => {
+            object.assets = module.buildInfo.assets ? Object.keys(module.buildInfo.assets) : [];
+        },
+        reasons: (object, module, context, options, factory) => {
+            const { type, compilation: { moduleGraph }, } = context;
+            const groupsReasons = factory.create(`${type.slice(0, -8)}.reasons`, Array.from(moduleGraph.getIncomingConnections(module)), context);
+            const limited = spaceLimited(groupsReasons, options.reasonsSpace);
+            object.reasons = limited.children;
+            object.filteredReasons = limited.filteredChildren;
+        },
+        usedExports: (object, module, { runtime, compilation: { moduleGraph } }) => {
+            const usedExports = moduleGraph.getUsedExports(module, runtime);
+            if (usedExports === null) {
+                object.usedExports = null;
+            }
+            else if (typeof usedExports === 'boolean') {
+                object.usedExports = usedExports;
+            }
+            else {
+                object.usedExports = Array.from(usedExports);
+            }
+        },
+        providedExports: (object, module, { compilation: { moduleGraph } }) => {
+            const providedExports = moduleGraph.getProvidedExports(module);
+            object.providedExports = Array.isArray(providedExports) ? providedExports : null;
+        },
+        optimizationBailout: (object, module, { compilation: { moduleGraph } }, { requestShortener }) => {
+            object.optimizationBailout = moduleGraph.getOptimizationBailout(module).map(item => {
+                if (typeof item === 'function')
+                    return item(requestShortener);
+                return item;
+            });
+        },
+        depth: (object, module, { compilation: { moduleGraph } }) => {
+            object.depth = moduleGraph.getDepth(module);
+        },
+        nestedModules: (object, module, context, options, factory) => {
+            const { type } = context;
+            const innerModules = module.modules;
+            if (Array.isArray(innerModules)) {
+                const groupedModules = factory.create(`${type.slice(0, -8)}.modules`, innerModules, context);
+                const limited = spaceLimited(groupedModules, options.nestedModulesSpace);
+                object.modules = limited.children;
+                object.filteredModules = limited.filteredChildren;
+            }
+        },
+        source: (object, module) => {
+            const originalSource = module.originalSource();
+            if (originalSource) {
+                object.source = originalSource.source();
+            }
+        },
+    },
+    profile: {
+        _: (object, profile) => {
+            const statsProfile = {
+                total: profile.factory +
+                    profile.restoring +
+                    profile.integration +
+                    profile.building +
+                    profile.storing,
+                resolving: profile.factory,
+                restoring: profile.restoring,
+                building: profile.building,
+                integration: profile.integration,
+                storing: profile.storing,
+                additionalResolving: profile.additionalFactories,
+                additionalIntegration: profile.additionalIntegration,
+                // TODO remove this in webpack 6
+                factory: profile.factory,
+                // TODO remove this in webpack 6
+                dependencies: profile.additionalFactories,
+            };
+            Object.assign(object, statsProfile);
+        },
+    },
+    moduleIssuer: {
+        _: (object, module, context, { requestShortener }, factory) => {
+            const { compilation, type } = context;
+            const { moduleGraph } = compilation;
+            const profile = moduleGraph.getProfile(module);
+            const statsModuleIssuer = {
+                identifier: module.identifier(),
+                name: module.readableIdentifier(requestShortener),
+            };
+            Object.assign(object, statsModuleIssuer);
+            if (profile) {
+                object.profile = factory.create(`${type}.profile`, profile, context);
+            }
+        },
+        ids: (object, module, { compilation: { chunkGraph } }) => {
+            object.id = chunkGraph.getModuleId(module);
+        },
+    },
+    moduleReason: {
+        _: (object, reason, { runtime }, { requestShortener }) => {
+            const dep = reason.dependency;
+            const moduleDep = dep && dep instanceof ModuleDependency_1.default ? dep : undefined;
+            const statsModuleReason = {
+                moduleIdentifier: reason.originModule ? reason.originModule.identifier() : null,
+                module: reason.originModule
+                    ? reason.originModule.readableIdentifier(requestShortener)
+                    : null,
+                moduleName: reason.originModule
+                    ? reason.originModule.readableIdentifier(requestShortener)
+                    : null,
+                resolvedModuleIdentifier: reason.resolvedOriginModule
+                    ? reason.resolvedOriginModule.identifier()
+                    : null,
+                resolvedModule: reason.resolvedOriginModule
+                    ? reason.resolvedOriginModule.readableIdentifier(requestShortener)
+                    : null,
+                type: reason.dependency ? reason.dependency.type : null,
+                active: reason.isActive(runtime),
+                explanation: reason.explanation,
+                userRequest: (moduleDep === null || moduleDep === void 0 ? void 0 : moduleDep.userRequest) || null,
+            };
+            Object.assign(object, statsModuleReason);
+            if (reason.dependency) {
+                const locInfo = (0, formatLocation_1.default)(reason.dependency.loc);
+                if (locInfo) {
+                    object.loc = locInfo;
+                }
+            }
+        },
+        ids: (object, reason, { compilation: { chunkGraph } }) => {
+            object.moduleId = reason.originModule ? chunkGraph.getModuleId(reason.originModule) : null;
+            object.resolvedModuleId = reason.resolvedOriginModule
+                ? chunkGraph.getModuleId(reason.resolvedOriginModule)
+                : null;
+        },
+    },
+    chunk: {
+        _: (object, chunk, { makePathsRelative, compilation: { chunkGraph } }) => {
+            const childIdByOrder = chunk.getChildIdsByOrders(chunkGraph);
+            const statsChunk = {
+                rendered: chunk.rendered,
+                initial: chunk.canBeInitial(),
+                entry: chunk.hasRuntime(),
+                recorded: AggressiveSplittingPlugin_1.default.wasChunkRecorded(chunk),
+                reason: chunk.chunkReason,
+                size: chunkGraph.getChunkModulesSize(chunk),
+                sizes: chunkGraph.getChunkModulesSizes(chunk),
+                names: chunk.name ? [chunk.name] : [],
+                idHints: Array.from(chunk.idNameHints),
+                runtime: chunk.runtime === undefined
+                    ? undefined
+                    : typeof chunk.runtime === 'string'
+                        ? [makePathsRelative(chunk.runtime)]
+                        : Array.from(chunk.runtime.sort(), makePathsRelative),
+                files: Array.from(chunk.files),
+                auxiliaryFiles: Array.from(chunk.auxiliaryFiles).sort(comparators_1.compareIds),
+                hash: chunk.renderedHash,
+                childrenByOrder: childIdByOrder,
+            };
+            Object.assign(object, statsChunk);
+        },
+        ids: (object, chunk) => {
+            object.id = chunk.id;
+        },
+        chunkRelations: (object, chunk, { compilation: { chunkGraph } }) => {
+            const parents = new Set();
+            const children = new Set();
+            const siblings = new Set();
+            for (const chunkGroup of chunk.groupsIterable) {
+                for (const parentGroup of chunkGroup.parentsIterable) {
+                    for (const chunk of parentGroup.chunks) {
+                        parents.add(chunk.id);
+                    }
+                }
+                for (const childGroup of chunkGroup.childrenIterable) {
+                    for (const chunk of childGroup.chunks) {
+                        children.add(chunk.id);
+                    }
+                }
+                for (const sibling of chunkGroup.chunks) {
+                    if (sibling !== chunk)
+                        siblings.add(sibling.id);
+                }
+            }
+            object.siblings = Array.from(siblings).sort(comparators_1.compareIds);
+            object.parents = Array.from(parents).sort(comparators_1.compareIds);
+            object.children = Array.from(children).sort(comparators_1.compareIds);
+        },
+        chunkModules: (object, chunk, context, options, factory) => {
+            const { type, compilation: { chunkGraph }, } = context;
+            const array = chunkGraph.getChunkModules(chunk);
+            const groupedModules = factory.create(`${type}.modules`, array, Object.assign(Object.assign({}, context), { runtime: chunk.runtime, rootModules: new Set(chunkGraph.getChunkRootModules(chunk)) }));
+            const limited = spaceLimited(groupedModules, options.chunkModulesSpace);
+            object.modules = limited.children;
+            object.filteredModules = limited.filteredChildren;
+        },
+        chunkOrigins: (object, chunk, context, options, factory) => {
+            const { type, compilation: { chunkGraph }, } = context;
+            const originsKeySet = new Set();
+            const origins = [];
+            for (const g of chunk.groupsIterable) {
+                origins.push(...g.origins);
+            }
+            const array = origins.filter((origin) => {
+                const key = [
+                    origin.module ? chunkGraph.getModuleId(origin.module) : undefined,
+                    (0, formatLocation_1.default)(origin.loc),
+                    origin.request,
+                ].join();
+                if (originsKeySet.has(key))
+                    return false;
+                originsKeySet.add(key);
+                return true;
+            });
+            object.origins = factory.create(`${type}.origins`, array, context);
+        },
+    },
+    chunkOrigin: {
+        _: (object, origin, context, { requestShortener }) => {
+            const statsChunkOrigin = {
+                module: origin.module ? origin.module.identifier() : '',
+                moduleIdentifier: origin.module ? origin.module.identifier() : '',
+                moduleName: origin.module ? origin.module.readableIdentifier(requestShortener) : '',
+                loc: (0, formatLocation_1.default)(origin.loc),
+                request: origin.request,
+            };
+            Object.assign(object, statsChunkOrigin);
+        },
+        ids: (object, origin, { compilation: { chunkGraph } }) => {
+            object.moduleId = origin.module ? chunkGraph.getModuleId(origin.module) : undefined;
+        },
+    },
+    error: EXTRACT_ERROR,
+    warning: EXTRACT_ERROR,
+    moduleTraceItem: {
+        _: (object, { origin, module }, context, { requestShortener }, factory) => {
+            const { type, compilation: { moduleGraph }, } = context;
+            object.originIdentifier = origin.identifier();
+            object.originName = origin.readableIdentifier(requestShortener);
+            object.moduleIdentifier = module.identifier();
+            object.moduleName = module.readableIdentifier(requestShortener);
+            const dependencies = Array.from(moduleGraph.getIncomingConnections(module))
+                .filter((c) => c.resolvedOriginModule === origin && c.dependency)
+                .map((c) => c.dependency);
+            object.dependencies = factory.create(`${type}.dependencies`, Array.from(new Set(dependencies)), context);
+        },
+        ids: (object, { origin, module }, { compilation: { chunkGraph } }) => {
+            object.originId = chunkGraph.getModuleId(origin);
+            object.moduleId = chunkGraph.getModuleId(module);
+        },
+    },
+    moduleTraceDependency: {
+        _: (object, dependency) => {
+            object.loc = (0, formatLocation_1.default)(dependency.loc);
+        },
+    },
+};
+const FILTER = {
+    'module.reasons': {
+        '!orphanModules': (reason, { compilation: { chunkGraph } }) => {
+            if (reason.originModule && chunkGraph.getNumberOfModuleChunks(reason.originModule) === 0) {
+                return false;
+            }
+        },
+    },
+};
+const FILTER_RESULTS = {
+    'compilation.warnings': {
+        warningsFilter: util_1.default.deprecate((warning, context, { warningsFilter }) => {
+            const warningString = Object.keys(warning)
+                .map(key => `${warning[key]}`)
+                .join('\n');
+            return !warningsFilter.some(filter => filter(warning, warningString));
+        }, '@/config.stats.warningsFilter is deprecated in favor of config.ignoreWarnings', 'DEP_WEBPACK_STATS_WARNINGS_FILTER'),
+    },
+};
+const MODULES_SORTER = {
+    _: (comparators, { compilation: { moduleGraph } }) => {
+        comparators.push((0, comparators_1.compareSelect)(m => moduleGraph.getDepth(m), comparators_1.compareNumbers), (0, comparators_1.compareSelect)(m => moduleGraph.getPreOrderIndex(m), comparators_1.compareNumbers), (0, comparators_1.compareSelect)(m => m.identifier(), comparators_1.compareIds));
+    },
+};
+const SORTERS = {
+    'compilation.chunks': {
+        _: comparators => {
+            comparators.push((0, comparators_1.compareSelect)(c => c.id, comparators_1.compareIds));
+        },
+    },
+    'compilation.modules': MODULES_SORTER,
+    'chunk.rootModules': MODULES_SORTER,
+    'chunk.modules': MODULES_SORTER,
+    'module.modules': MODULES_SORTER,
+    'module.reasons': {
+        _: (comparators, { compilation: { chunkGraph } }) => {
+            comparators.push((0, comparators_1.compareSelect)(x => x.originModule, comparators_1.compareModulesByIdentifier));
+            comparators.push((0, comparators_1.compareSelect)(x => x.resolvedOriginModule, comparators_1.compareModulesByIdentifier));
+            comparators.push((0, comparators_1.compareSelect)(x => x.dependency, (0, comparators_1.concatComparators)((0, comparators_1.compareSelect)(x => x.loc, comparators_1.compareLocations), (0, comparators_1.compareSelect)(x => x.type, comparators_1.compareIds))));
+        },
+    },
+    'chunk.origins': {
+        _: (comparators, { compilation: { chunkGraph } }) => {
+            comparators.push((0, comparators_1.compareSelect)(origin => (origin.module ? chunkGraph.getModuleId(origin.module) : undefined), comparators_1.compareIds), (0, comparators_1.compareSelect)(origin => (0, formatLocation_1.default)(origin.loc), comparators_1.compareIds), (0, comparators_1.compareSelect)(origin => origin.request, comparators_1.compareIds));
+        },
+    },
+};
+const getItemSize = item => 
+// Each item takes 1 line
+// + the size of the children
+// + 1 extra line when it has children and filteredChildren
+!item.children
+    ? 1
+    : item.filteredChildren
+        ? 2 + getTotalSize(item.children)
+        : 1 + getTotalSize(item.children);
+const getTotalSize = children => {
+    let size = 0;
+    for (const child of children) {
+        size += getItemSize(child);
+    }
+    return size;
+};
+const getTotalItems = children => {
+    let count = 0;
+    for (const child of children) {
+        if (!child.children && !child.filteredChildren) {
+            count++;
+        }
+        else {
+            if (child.children)
+                count += getTotalItems(child.children);
+            if (child.filteredChildren)
+                count += child.filteredChildren;
+        }
+    }
+    return count;
+};
+const collapse = children => {
+    // After collapse each child must take exactly one line
+    const newChildren = [];
+    for (const child of children) {
+        if (child.children) {
+            let filteredChildren = child.filteredChildren || 0;
+            filteredChildren += getTotalItems(child.children);
+            newChildren.push(Object.assign(Object.assign({}, child), { children: undefined, filteredChildren }));
+        }
+        else {
+            newChildren.push(child);
+        }
+    }
+    return newChildren;
+};
+const spaceLimited = (itemsAndGroups, max, filteredChildrenLineReserved = false) => {
+    if (max < 1) {
+        return {
+            children: undefined,
+            filteredChildren: getTotalItems(itemsAndGroups),
+        };
+    }
+    let children;
+    let filteredChildren;
+    // This are the groups, which take 1+ lines each
+    const groups = [];
+    // The sizes of the groups are stored in groupSizes
+    const groupSizes = [];
+    // This are the items, which take 1 line each
+    const items = [];
+    // The total of group sizes
+    let groupsSize = 0;
+    for (const itemOrGroup of itemsAndGroups) {
+        // is item
+        if (!itemOrGroup.children && !itemOrGroup.filteredChildren) {
+            items.push(itemOrGroup);
+        }
+        else {
+            groups.push(itemOrGroup);
+            const size = getItemSize(itemOrGroup);
+            groupSizes.push(size);
+            groupsSize += size;
+        }
+    }
+    if (groupsSize + items.length <= max) {
+        // The total size in the current state fits into the max
+        // keep all
+        children = groups.length > 0 ? groups.concat(items) : items;
+    }
+    else if (groups.length === 0) {
+        // slice items to max
+        // inner space marks that lines for filteredChildren already reserved
+        const limit = max - (filteredChildrenLineReserved ? 0 : 1);
+        filteredChildren = items.length - limit;
+        items.length = limit;
+        children = items;
+    }
+    else {
+        // limit is the size when all groups are collapsed
+        const limit = groups.length + (filteredChildrenLineReserved || items.length === 0 ? 0 : 1);
+        if (limit < max) {
+            // calculate how much we are over the size limit
+            // this allows to approach the limit faster
+            let oversize;
+            // If each group would take 1 line the total would be below the maximum
+            // collapse some groups, keep items
+            while ((oversize =
+                groupsSize +
+                    items.length +
+                    (filteredChildren && !filteredChildrenLineReserved ? 1 : 0) -
+                    max) > 0) {
+                // Find the maximum group and process only this one
+                const maxGroupSize = Math.max(...groupSizes);
+                if (maxGroupSize < items.length) {
+                    filteredChildren = items.length;
+                    items.length = 0;
+                    continue;
+                }
+                for (let i = 0; i < groups.length; i++) {
+                    if (groupSizes[i] === maxGroupSize) {
+                        const group = groups[i];
+                        // run this algorithm recursively and limit the size of the children to
+                        // current size - oversize / number of groups
+                        // So it should always end up being smaller
+                        const headerSize = group.filteredChildren ? 2 : 1;
+                        const limited = spaceLimited(group.children, maxGroupSize -
+                            // we should use ceil to always feet in max
+                            Math.ceil(oversize / groups.length) -
+                            // we substitute size of group head
+                            headerSize, headerSize === 2);
+                        groups[i] = Object.assign(Object.assign({}, group), { children: limited.children, filteredChildren: limited.filteredChildren
+                                ? (group.filteredChildren || 0) + limited.filteredChildren
+                                : group.filteredChildren });
+                        const newSize = getItemSize(groups[i]);
+                        groupsSize -= maxGroupSize - newSize;
+                        groupSizes[i] = newSize;
+                        break;
+                    }
+                }
+            }
+            children = groups.concat(items);
+        }
+        else if (limit === max) {
+            // If we have only enough space to show one line per group and one line for the filtered items
+            // collapse all groups and items
+            children = collapse(groups);
+            filteredChildren = items.length;
+        }
+        else {
+            // If we have no space
+            // collapse complete group
+            filteredChildren = getTotalItems(itemsAndGroups);
+        }
+    }
+    return {
+        children,
+        filteredChildren,
+    };
+};
+const errorsSpaceLimit = (errors, max) => {
+    let filtered = 0;
+    // Can not fit into limit
+    // print only messages
+    if (errors.length + 1 >= max)
+        return [
+            errors.map(error => {
+                if (typeof error === 'string' || !error.details)
+                    return error;
+                filtered++;
+                return Object.assign(Object.assign({}, error), { details: '' });
+            }),
+            filtered,
+        ];
+    let fullLength = errors.length;
+    let result = errors;
+    let i = 0;
+    for (; i < errors.length; i++) {
+        const error = errors[i];
+        if (typeof error !== 'string' && error.details) {
+            const splitted = error.details.split('\n');
+            const len = splitted.length;
+            fullLength += len;
+            if (fullLength > max) {
+                result = i > 0 ? errors.slice(0, i) : [];
+                const overLimit = fullLength - max + 1;
+                const error = errors[i++];
+                result.push(Object.assign(Object.assign({}, error), { details: error.details.split('\n').slice(0, -overLimit).join('\n'), filteredDetails: overLimit }));
+                filtered = errors.length - i;
+                for (; i < errors.length; i++) {
+                    const error = errors[i];
+                    if (typeof error === 'string' || !error.details)
+                        result.push(error);
+                    result.push(Object.assign(Object.assign({}, error), { details: '' }));
+                }
+                break;
+            }
+            else if (fullLength === max) {
+                result = errors.slice(0, ++i);
+                filtered = errors.length - i;
+                for (; i < errors.length; i++) {
+                    const error = errors[i];
+                    if (typeof error === 'string' || !error.details)
+                        result.push(error);
+                    result.push(Object.assign(Object.assign({}, error), { details: '' }));
+                }
+                break;
+            }
+        }
+    }
+    return [result, filtered];
+};
+const assetGroup = (children, assets) => {
+    let size = 0;
+    for (const asset of children) {
+        size += asset.size;
+    }
+    return {
+        size,
+    };
+};
+const moduleGroup = (children, modules) => {
+    let size = 0;
+    const sizes = {};
+    for (const module of children) {
+        size += module.size;
+        for (const key of Object.keys(module.sizes)) {
+            sizes[key] = (sizes[key] || 0) + module.sizes[key];
+        }
+    }
+    return {
+        size,
+        sizes,
+    };
+};
+const reasonGroup = (children, reasons) => {
+    let active = false;
+    for (const reason of children) {
+        active = active || reason.active;
+    }
+    return {
+        active,
+    };
+};
+const GROUP_EXTENSION_REGEXP = /(\.[^.]+?)(?:\?|(?: \+ \d+ modules?)?$)/;
+const GROUP_PATH_REGEXP = /(.+)[/\\][^/\\]+?(?:\?|(?: \+ \d+ modules?)?$)/;
+const ASSETS_GROUPERS = {
+    _: (groupConfigs, context, options) => {
+        const groupByFlag = (name, exclude) => {
+            groupConfigs.push({
+                getKeys: asset => asset[name] ? ['1'] : undefined,
+                getOptions: () => ({
+                    groupChildren: !exclude,
+                    force: exclude,
+                }),
+                createGroup: (key, children, assets) => exclude
+                    ? Object.assign({ type: 'assets by status', [name]: !!key, filteredChildren: assets.length }, assetGroup(children, assets)) : Object.assign({ type: 'assets by status', [name]: !!key, children }, assetGroup(children, assets)),
+            });
+        };
+        const { groupAssetsByEmitStatus, groupAssetsByPath, groupAssetsByExtension } = options;
+        if (groupAssetsByEmitStatus) {
+            groupByFlag('emitted');
+            groupByFlag('comparedForEmit');
+            groupByFlag('isOverSizeLimit');
+        }
+        if (groupAssetsByEmitStatus || !options.cachedAssets) {
+            groupByFlag('cached', !options.cachedAssets);
+        }
+        if (groupAssetsByPath || groupAssetsByExtension) {
+            groupConfigs.push({
+                getKeys: asset => {
+                    const extensionMatch = groupAssetsByExtension && GROUP_EXTENSION_REGEXP.exec(asset.name);
+                    const extension = extensionMatch ? extensionMatch[1] : '';
+                    const pathMatch = groupAssetsByPath && GROUP_PATH_REGEXP.exec(asset.name);
+                    const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
+                    const keys = [];
+                    if (groupAssetsByPath) {
+                        keys.push('.');
+                        if (extension)
+                            keys.push(path.length ? `${path.join('/')}/*${extension}` : `*${extension}`);
+                        while (path.length > 0) {
+                            keys.push(`${path.join('/')}/`);
+                            path.pop();
+                        }
+                    }
+                    else if (extension)
+                        keys.push(`*${extension}`);
+                    return keys;
+                },
+                createGroup: (key, children, assets) => (Object.assign({ type: groupAssetsByPath ? 'assets by path' : 'assets by extension', name: key, children }, assetGroup(children, assets))),
+            });
+        }
+    },
+    groupAssetsByInfo: (groupConfigs, context, options) => {
+        const groupByAssetInfoFlag = name => {
+            groupConfigs.push({
+                getKeys: asset => { var _a; return ((_a = asset.info) === null || _a === void 0 ? void 0 : _a[name]) ? ['1'] : undefined; },
+                createGroup: (key, children, assets) => (Object.assign({ type: 'assets by info', info: {
+                        [name]: !!key,
+                    }, children }, assetGroup(children, assets))),
+            });
+        };
+        groupByAssetInfoFlag('immutable');
+        groupByAssetInfoFlag('development');
+        groupByAssetInfoFlag('hotModuleReplacement');
+    },
+    groupAssetsByChunk: (groupConfigs, context, options) => {
+        const groupByNames = name => {
+            groupConfigs.push({
+                getKeys: asset => asset[name],
+                createGroup: (key, children, assets) => (Object.assign({ type: 'assets by chunk', [name]: [key], children }, assetGroup(children, assets))),
+            });
+        };
+        groupByNames('chunkNames');
+        groupByNames('auxiliaryChunkNames');
+        groupByNames('chunkIdHints');
+        groupByNames('auxiliaryChunkIdHints');
+    },
+    excludeAssets: (groupConfigs, context, { excludeAssets }) => {
+        groupConfigs.push({
+            getKeys: asset => {
+                const ident = asset.name;
+                const excluded = excludeAssets.some(fn => fn(ident, asset));
+                if (excluded)
+                    return ['excluded'];
+            },
+            getOptions: () => ({
+                groupChildren: false,
+                force: true,
+            }),
+            createGroup: (key, children, assets) => (Object.assign({ type: 'hidden assets', filteredChildren: assets.length }, assetGroup(children, assets))),
+        });
+    },
+};
+const MODULES_GROUPERS = type => ({
+    _: (groupConfigs, context, options) => {
+        const groupByFlag = (name, type, exclude) => {
+            groupConfigs.push({
+                getKeys: module => module[name] ? ['1'] : undefined,
+                getOptions: () => ({
+                    groupChildren: !exclude,
+                    force: exclude,
+                }),
+                createGroup: (key, children, modules) => (Object.assign(Object.assign({ type, [name]: !!key }, (exclude ? { filteredChildren: modules.length } : { children })), moduleGroup(children, modules))),
+            });
+        };
+        const { groupModulesByCacheStatus, groupModulesByLayer, groupModulesByAttributes, groupModulesByType, groupModulesByPath, groupModulesByExtension, } = options;
+        if (groupModulesByAttributes) {
+            groupByFlag('errors', 'modules with errors');
+            groupByFlag('warnings', 'modules with warnings');
+            groupByFlag('assets', 'modules with assets');
+            groupByFlag('optional', 'optional modules');
+        }
+        if (groupModulesByCacheStatus) {
+            groupByFlag('cacheable', 'cacheable modules');
+            groupByFlag('built', 'built modules');
+            groupByFlag('codeGenerated', 'code generated modules');
+        }
+        if (groupModulesByCacheStatus || !options.cachedModules) {
+            groupByFlag('cached', 'cached modules', !options.cachedModules);
+        }
+        if (groupModulesByAttributes || !options.orphanModules) {
+            groupByFlag('orphan', 'orphan modules', !options.orphanModules);
+        }
+        if (groupModulesByAttributes || !options.dependentModules) {
+            groupByFlag('dependent', 'dependent modules', !options.dependentModules);
+        }
+        if (groupModulesByType || !options.runtimeModules) {
+            groupConfigs.push({
+                getKeys: module => {
+                    if (!module.moduleType)
+                        return;
+                    if (groupModulesByType) {
+                        return [module.moduleType.split('/', 1)[0]];
+                    }
+                    if (module.moduleType === ModuleTypeConstants_1.WEBPACK_MODULE_TYPE_RUNTIME) {
+                        return [ModuleTypeConstants_1.WEBPACK_MODULE_TYPE_RUNTIME];
+                    }
+                },
+                getOptions: key => {
+                    const exclude = key === ModuleTypeConstants_1.WEBPACK_MODULE_TYPE_RUNTIME && !options.runtimeModules;
+                    return {
+                        groupChildren: !exclude,
+                        force: exclude,
+                    };
+                },
+                createGroup: (key, children, modules) => {
+                    const exclude = key === ModuleTypeConstants_1.WEBPACK_MODULE_TYPE_RUNTIME && !options.runtimeModules;
+                    return Object.assign(Object.assign({ type: `${key} modules`, moduleType: key }, (exclude ? { filteredChildren: modules.length } : { children })), moduleGroup(children, modules));
+                },
+            });
+        }
+        if (groupModulesByLayer) {
+            groupConfigs.push({
+                getKeys: module => [module.layer],
+                createGroup: (key, children, modules) => (Object.assign({ type: 'modules by layer', layer: key, children }, moduleGroup(children, modules))),
+            });
+        }
+        if (groupModulesByPath || groupModulesByExtension) {
+            groupConfigs.push({
+                getKeys: module => {
+                    if (!module.name)
+                        return;
+                    const resource = (0, identifier_1.parseResource)(module.name.split('!').pop()).path;
+                    const dataUrl = /^data:[^,;]+/.exec(resource);
+                    if (dataUrl)
+                        return [dataUrl[0]];
+                    const extensionMatch = groupModulesByExtension && GROUP_EXTENSION_REGEXP.exec(resource);
+                    const extension = extensionMatch ? extensionMatch[1] : '';
+                    const pathMatch = groupModulesByPath && GROUP_PATH_REGEXP.exec(resource);
+                    const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
+                    const keys = [];
+                    if (groupModulesByPath) {
+                        if (extension)
+                            keys.push(path.length ? `${path.join('/')}/*${extension}` : `*${extension}`);
+                        while (path.length > 0) {
+                            keys.push(`${path.join('/')}/`);
+                            path.pop();
+                        }
+                    }
+                    else if (extension)
+                        keys.push(`*${extension}`);
+                    return keys;
+                },
+                createGroup: (key, children, modules) => {
+                    const isDataUrl = key.startsWith('data:');
+                    return Object.assign({ type: isDataUrl
+                            ? 'modules by mime type'
+                            : groupModulesByPath
+                                ? 'modules by path'
+                                : 'modules by extension', name: isDataUrl ? key.slice(/* 'data:'.length */ 5) : key, children }, moduleGroup(children, modules));
+                },
+            });
+        }
+    },
+    excludeModules: (groupConfigs, context, { excludeModules }) => {
+        groupConfigs.push({
+            getKeys: module => {
+                const name = module.name;
+                if (name) {
+                    const excluded = excludeModules.some(fn => fn(name, module, type));
+                    if (excluded)
+                        return ['1'];
+                }
+            },
+            getOptions: () => ({
+                groupChildren: false,
+                force: true,
+            }),
+            createGroup: (key, children, modules) => (Object.assign({ type: 'hidden modules', filteredChildren: children.length }, moduleGroup(children, modules))),
+        });
+    },
+});
+const RESULT_GROUPERS = {
+    'compilation.assets': ASSETS_GROUPERS,
+    'asset.related': ASSETS_GROUPERS,
+    'compilation.modules': MODULES_GROUPERS('module'),
+    'chunk.modules': MODULES_GROUPERS('chunk'),
+    'chunk.rootModules': MODULES_GROUPERS('root-of-chunk'),
+    'module.modules': MODULES_GROUPERS('nested'),
+    'module.reasons': {
+        groupReasonsByOrigin: groupConfigs => {
+            groupConfigs.push({
+                getKeys: reason => [reason.module],
+                createGroup: (key, children, reasons) => (Object.assign({ type: 'from origin', module: key, children }, reasonGroup(children, reasons))),
+            });
+        },
+    },
+};
+// remove a prefixed "!" that can be specified to reverse sort order
+const normalizeFieldKey = field => {
+    if (field[0] === '!') {
+        return field.slice(1);
+    }
+    return field;
+};
+// if a field is prefixed by a "!" reverse sort order
+const sortOrderRegular = field => {
+    if (field[0] === '!') {
+        return false;
+    }
+    return true;
+};
+const sortByField = (field) => {
+    if (!field) {
+        const noSort = (a, b) => 0;
+        return noSort;
+    }
+    const fieldKey = normalizeFieldKey(field);
+    let sortFn = (0, comparators_1.compareSelect)(m => m[fieldKey], comparators_1.compareIds);
+    // if a field is prefixed with a "!" the sort is reversed!
+    const sortIsRegular = sortOrderRegular(field);
+    if (!sortIsRegular) {
+        const oldSortFn = sortFn;
+        sortFn = (a, b) => oldSortFn(b, a);
+    }
+    return sortFn;
+};
+const ASSET_SORTERS = {
+    assetsSort: (comparators, context, { assetsSort }) => {
+        comparators.push(sortByField(assetsSort));
+    },
+    _: comparators => {
+        comparators.push((0, comparators_1.compareSelect)(a => a.name, comparators_1.compareIds));
+    },
+};
+const RESULT_SORTERS = {
+    'compilation.chunks': {
+        chunksSort: (comparators, context, { chunksSort }) => {
+            comparators.push(sortByField(chunksSort));
+        },
+    },
+    'compilation.modules': {
+        modulesSort: (comparators, context, { modulesSort }) => {
+            comparators.push(sortByField(modulesSort));
+        },
+    },
+    'chunk.modules': {
+        chunkModulesSort: (comparators, context, { chunkModulesSort }) => {
+            comparators.push(sortByField(chunkModulesSort));
+        },
+    },
+    'module.modules': {
+        nestedModulesSort: (comparators, context, { nestedModulesSort }) => {
+            comparators.push(sortByField(nestedModulesSort));
+        },
+    },
+    'compilation.assets': ASSET_SORTERS,
+    'asset.related': ASSET_SORTERS,
+};
+const iterateConfig = (config, options, fn) => {
+    for (const hookFor of Object.keys(config)) {
+        const subConfig = config[hookFor];
+        for (const option of Object.keys(subConfig)) {
+            if (option !== '_') {
+                if (option.startsWith('!')) {
+                    if (options[option.slice(1)])
+                        continue;
+                }
+                else {
+                    const value = options[option];
+                    if (value === false ||
+                        value === undefined ||
+                        (Array.isArray(value) && value.length === 0))
+                        continue;
+                }
+            }
+            fn(hookFor, subConfig[option]);
+        }
+    }
+};
+const ITEM_NAMES = {
+    'compilation.children[]': 'compilation',
+    'compilation.modules[]': 'module',
+    'compilation.entrypoints[]': 'chunkGroup',
+    'compilation.namedChunkGroups[]': 'chunkGroup',
+    'compilation.errors[]': 'error',
+    'compilation.warnings[]': 'warning',
+    'chunk.modules[]': 'module',
+    'chunk.rootModules[]': 'module',
+    'chunk.origins[]': 'chunkOrigin',
+    'compilation.chunks[]': 'chunk',
+    'compilation.assets[]': 'asset',
+    'asset.related[]': 'asset',
+    'module.issuerPath[]': 'moduleIssuer',
+    'module.reasons[]': 'moduleReason',
+    'module.modules[]': 'module',
+    'module.children[]': 'module',
+    'moduleTrace[]': 'moduleTraceItem',
+    'moduleTraceItem.dependencies[]': 'moduleTraceDependency',
+};
+const mergeToObject = (items) => {
+    const obj = Object.create(null);
+    for (const item of items) {
+        obj[item.name] = item;
+    }
+    return obj;
+};
+const MERGER = {
+    'compilation.entrypoints': mergeToObject,
+    'compilation.namedChunkGroups': mergeToObject,
+};
+class DefaultStatsFactoryPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap('DefaultStatsFactoryPlugin', compilation => {
+            compilation.hooks.statsFactory.tap('DefaultStatsFactoryPlugin', (stats, options, context) => {
+                iterateConfig(SIMPLE_EXTRACTORS, options, (hookFor, fn) => {
+                    stats.hooks.extract
+                        .for(hookFor)
+                        .tap('DefaultStatsFactoryPlugin', (obj, data, ctx) => fn(obj, data, ctx, options, stats));
+                });
+                iterateConfig(FILTER, options, (hookFor, fn) => {
+                    stats.hooks.filter
+                        .for(hookFor)
+                        .tap('DefaultStatsFactoryPlugin', (item, ctx, idx, i) => fn(item, ctx, options, idx, i));
+                });
+                iterateConfig(FILTER_RESULTS, options, (hookFor, fn) => {
+                    stats.hooks.filterResults
+                        .for(hookFor)
+                        .tap('DefaultStatsFactoryPlugin', (item, ctx, idx, i) => fn(item, ctx, options, idx, i));
+                });
+                iterateConfig(SORTERS, options, (hookFor, fn) => {
+                    stats.hooks.sort
+                        .for(hookFor)
+                        .tap('DefaultStatsFactoryPlugin', (comparators, ctx) => fn(comparators, ctx, options));
+                });
+                iterateConfig(RESULT_SORTERS, options, (hookFor, fn) => {
+                    stats.hooks.sortResults
+                        .for(hookFor)
+                        .tap('DefaultStatsFactoryPlugin', (comparators, ctx) => fn(comparators, ctx, options));
+                });
+                iterateConfig(RESULT_GROUPERS, options, (hookFor, fn) => {
+                    stats.hooks.groupResults
+                        .for(hookFor)
+                        .tap('DefaultStatsFactoryPlugin', (groupConfigs, ctx) => fn(groupConfigs, ctx, options));
+                });
+                for (const key of Object.keys(ITEM_NAMES)) {
+                    const itemName = ITEM_NAMES[key];
+                    stats.hooks.getItemName.for(key).tap('DefaultStatsFactoryPlugin', () => itemName);
+                }
+                for (const key of Object.keys(MERGER)) {
+                    const merger = MERGER[key];
+                    stats.hooks.merge.for(key).tap('DefaultStatsFactoryPlugin', merger);
+                }
+                if (options.children) {
+                    if (Array.isArray(options.children)) {
+                        stats.hooks.getItemFactory
+                            .for('compilation.children[].compilation')
+                            .tap('DefaultStatsFactoryPlugin', (comp, { _index: idx }) => {
+                            if (idx < options.children.length) {
+                                return compilation.createStatsFactory(compilation.createStatsOptions(options.children[idx], context));
+                            }
+                        });
+                    }
+                    else if (options.children !== true) {
+                        const childFactory = compilation.createStatsFactory(compilation.createStatsOptions(options.children, context));
+                        stats.hooks.getItemFactory
+                            .for('compilation.children[].compilation')
+                            .tap('DefaultStatsFactoryPlugin', () => childFactory);
+                    }
+                }
+            });
+        });
+    }
+}
+exports.default = DefaultStatsFactoryPlugin;