xhs-mp-pack 1.1.0-beta.0

package/dist/plugins/optimize/SplitChunksPlugin.js

@@ -0,0 +1,1113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Chunk_1 = __importDefault(require("@/chunk/Chunk"));
+const OptimizationStages_1 = require("@/plugins/optimize/OptimizationStages");
+const BaseError_1 = __importDefault(require("@/base/errors/BaseError"));
+const SetHelpers_1 = require("@/base/SetHelpers");
+const SortableSet_1 = __importDefault(require("@/base/SortableSet"));
+const comparators_1 = require("@/base/comparators");
+const createHash_1 = __importDefault(require("@/base/createHash"));
+const deterministicGrouping_1 = __importDefault(require("@/base/deterministicGrouping"));
+const identifier_1 = require("@/base/identifier");
+const memoize_1 = __importDefault(require("@/base/memoize"));
+const IdHelpers_1 = require("../../ids/IdHelpers");
+const MinMaxSizeWarning_1 = __importDefault(require("../../base/errors/MinMaxSizeWarning"));
+const defaultGetName = () => { };
+const deterministicGroupingForModules = deterministicGrouping_1.default;
+const getKeyCache = new WeakMap();
+const hashFilename = (name, outputOptions) => {
+    const digest = (0, createHash_1.default)(outputOptions.hashFunction)
+        .update(name)
+        .digest(outputOptions.hashDigest);
+    return digest.slice(0, 8);
+};
+const getRequests = chunk => {
+    let requests = 0;
+    for (const chunkGroup of chunk.groupsIterable) {
+        requests = Math.max(requests, chunkGroup.chunks.length);
+    }
+    return requests;
+};
+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 isOverlap = (a, b) => {
+    for (const item of a) {
+        if (b.has(item))
+            return true;
+    }
+    return false;
+};
+const compareModuleIterables = (0, comparators_1.compareIterables)(comparators_1.compareModulesByIdentifier);
+const compareEntries = (a, b) => {
+    // 1. by priority
+    const diffPriority = a.cacheGroup.priority - b.cacheGroup.priority;
+    if (diffPriority)
+        return diffPriority;
+    // 2. by number of chunks
+    const diffCount = a.chunks.size - b.chunks.size;
+    if (diffCount)
+        return diffCount;
+    // 3. by size reduction
+    const aSizeReduce = totalSize(a.sizes) * (a.chunks.size - 1);
+    const bSizeReduce = totalSize(b.sizes) * (b.chunks.size - 1);
+    const diffSizeReduce = aSizeReduce - bSizeReduce;
+    if (diffSizeReduce)
+        return diffSizeReduce;
+    // 4. by cache group index
+    const indexDiff = b.cacheGroupIndex - a.cacheGroupIndex;
+    if (indexDiff)
+        return indexDiff;
+    // 5. by number of modules (to be able to compare by identifier)
+    const modulesA = a.modules;
+    const modulesB = b.modules;
+    const diff = modulesA.size - modulesB.size;
+    if (diff)
+        return diff;
+    // 6. by module identifiers
+    modulesA.sort();
+    modulesB.sort();
+    return compareModuleIterables(modulesA, modulesB);
+};
+const INITIAL_CHUNK_FILTER = chunk => chunk.canBeInitial();
+const ASYNC_CHUNK_FILTER = chunk => !chunk.canBeInitial();
+const ALL_CHUNK_FILTER = chunk => true;
+const normalizeSizes = (value, defaultSizeTypes) => {
+    if (typeof value === 'number') {
+        const o = {};
+        for (const sizeType of defaultSizeTypes)
+            o[sizeType] = value;
+        return o;
+    }
+    if (typeof value === 'object' && value !== null) {
+        return Object.assign({}, value);
+    }
+    return {};
+};
+const mergeSizes = (...sizes) => {
+    let merged = {};
+    for (let i = sizes.length - 1; i >= 0; i--) {
+        merged = Object.assign(merged, sizes[i]);
+    }
+    return merged;
+};
+const hasNonZeroSizes = sizes => {
+    for (const key of Object.keys(sizes)) {
+        if (sizes[key] > 0)
+            return true;
+    }
+    return false;
+};
+const combineSizes = (a, b, combine) => {
+    const aKeys = new Set(Object.keys(a));
+    const bKeys = new Set(Object.keys(b));
+    const result = {};
+    for (const key of aKeys) {
+        if (bKeys.has(key)) {
+            result[key] = combine(a[key], b[key]);
+        }
+        else {
+            result[key] = a[key];
+        }
+    }
+    for (const key of bKeys) {
+        if (!aKeys.has(key)) {
+            result[key] = b[key];
+        }
+    }
+    return result;
+};
+const checkMinSize = (sizes, minSize) => {
+    for (const key of Object.keys(minSize)) {
+        const size = sizes[key];
+        if (size === undefined || size === 0)
+            continue;
+        if (size < minSize[key])
+            return false;
+    }
+    return true;
+};
+const checkMinSizeReduction = (sizes, minSizeReduction, chunkCount) => {
+    for (const key of Object.keys(minSizeReduction)) {
+        const size = sizes[key];
+        if (size === undefined || size === 0)
+            continue;
+        if (size * chunkCount < minSizeReduction[key])
+            return false;
+    }
+    return true;
+};
+const getViolatingMinSizes = (sizes, minSize) => {
+    let list;
+    for (const key of Object.keys(minSize)) {
+        const size = sizes[key];
+        if (size === undefined || size === 0)
+            continue;
+        if (size < minSize[key]) {
+            if (list === undefined)
+                list = [key];
+            else
+                list.push(key);
+        }
+    }
+    return list;
+};
+const totalSize = sizes => {
+    let size = 0;
+    for (const key of Object.keys(sizes)) {
+        size += sizes[key];
+    }
+    return size;
+};
+const normalizeName = name => {
+    if (typeof name === 'string') {
+        return () => name;
+    }
+    if (typeof name === 'function') {
+        return name;
+    }
+};
+const normalizeChunksFilter = chunks => {
+    if (chunks === 'initial') {
+        return INITIAL_CHUNK_FILTER;
+    }
+    if (chunks === 'async') {
+        return ASYNC_CHUNK_FILTER;
+    }
+    if (chunks === 'all') {
+        return ALL_CHUNK_FILTER;
+    }
+    if (chunks instanceof RegExp) {
+        return chunk => chunk.name ? chunks.test(chunk.name) : false;
+    }
+    if (typeof chunks === 'function') {
+        return chunks;
+    }
+};
+const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
+    if (typeof cacheGroups === 'function') {
+        return cacheGroups;
+    }
+    if (typeof cacheGroups === 'object' && cacheGroups !== null) {
+        const handlers = [];
+        for (const key of Object.keys(cacheGroups)) {
+            const option = cacheGroups[key];
+            if (option === false) {
+                continue;
+            }
+            if (typeof option === 'string' || option instanceof RegExp) {
+                const source = createCacheGroupSource({}, key, defaultSizeTypes);
+                handlers.push((module, context, results) => {
+                    if (checkTest(option, module, context)) {
+                        results.push(source);
+                    }
+                });
+            }
+            else if (typeof option === 'function') {
+                const cache = new WeakMap();
+                handlers.push((module, context, results) => {
+                    const result = option(module);
+                    if (result) {
+                        const groups = Array.isArray(result) ? result : [result];
+                        for (const group of groups) {
+                            const cachedSource = cache.get(group);
+                            if (cachedSource !== undefined) {
+                                results.push(cachedSource);
+                            }
+                            else {
+                                const source = createCacheGroupSource(group, key, defaultSizeTypes);
+                                cache.set(group, source);
+                                results.push(source);
+                            }
+                        }
+                    }
+                });
+            }
+            else {
+                const source = createCacheGroupSource(option, key, defaultSizeTypes);
+                handlers.push((module, context, results) => {
+                    if (checkTest(option.test, module, context) &&
+                        checkModuleType(option.type, module) &&
+                        checkModuleLayer(option.layer, module)) {
+                        results.push(source);
+                    }
+                });
+            }
+        }
+        const fn = (module, context) => {
+            const results = [];
+            for (const fn of handlers) {
+                fn(module, context, results);
+            }
+            return results;
+        };
+        return fn;
+    }
+    return () => null;
+};
+const checkTest = (test, module, context) => {
+    if (test === undefined)
+        return true;
+    if (typeof test === 'function') {
+        return test(module, context);
+    }
+    if (typeof test === 'boolean')
+        return test;
+    if (typeof test === 'string') {
+        const name = module.nameForCondition();
+        return name === null || name === void 0 ? void 0 : name.startsWith(test);
+    }
+    if (test instanceof RegExp) {
+        const name = module.nameForCondition();
+        return name && test.test(name);
+    }
+    return false;
+};
+const checkModuleType = (test, module) => {
+    if (test === undefined)
+        return true;
+    if (typeof test === 'function') {
+        return test(module.type);
+    }
+    if (typeof test === 'string') {
+        const type = module.type;
+        return test === type;
+    }
+    if (test instanceof RegExp) {
+        const type = module.type;
+        return test.test(type);
+    }
+    return false;
+};
+const checkModuleLayer = (test, module) => {
+    if (test === undefined)
+        return true;
+    if (typeof test === 'function') {
+        return test(module.layer);
+    }
+    if (typeof test === 'string') {
+        const layer = module.layer;
+        return test === '' ? !layer : layer === null || layer === void 0 ? void 0 : layer.startsWith(test);
+    }
+    if (test instanceof RegExp) {
+        const layer = module.layer;
+        return test.test(layer);
+    }
+    return false;
+};
+const createCacheGroupSource = (options, key, defaultSizeTypes) => {
+    const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
+    const minSizeReduction = normalizeSizes(options.minSizeReduction, defaultSizeTypes);
+    const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
+    return {
+        key,
+        priority: options.priority,
+        getName: normalizeName(options.name),
+        chunksFilter: normalizeChunksFilter(options.chunks),
+        enforce: options.enforce,
+        minSize,
+        minSizeReduction,
+        minRemainingSize: mergeSizes(normalizeSizes(options.minRemainingSize, defaultSizeTypes), minSize),
+        enforceSizeThreshold: normalizeSizes(options.enforceSizeThreshold, defaultSizeTypes),
+        maxAsyncSize: mergeSizes(normalizeSizes(options.maxAsyncSize, defaultSizeTypes), maxSize),
+        maxInitialSize: mergeSizes(normalizeSizes(options.maxInitialSize, defaultSizeTypes), maxSize),
+        minChunks: options.minChunks,
+        maxAsyncRequests: options.maxAsyncRequests,
+        maxInitialRequests: options.maxInitialRequests,
+        filename: options.filename,
+        idHint: options.idHint,
+        automaticNameDelimiter: options.automaticNameDelimiter,
+        reuseExistingChunk: options.reuseExistingChunk,
+        usedExports: options.usedExports,
+    };
+};
+class SplitChunksPlugin {
+    constructor(options = {}) {
+        const defaultSizeTypes = options.defaultSizeTypes || ['javascript', 'unknown'];
+        const fallbackCacheGroup = options.fallbackCacheGroup || {};
+        const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
+        const minSizeReduction = normalizeSizes(options.minSizeReduction, defaultSizeTypes);
+        const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
+        this.options = {
+            chunksFilter: normalizeChunksFilter(options.chunks || 'all'),
+            defaultSizeTypes,
+            minSize,
+            minSizeReduction,
+            minRemainingSize: mergeSizes(normalizeSizes(options.minRemainingSize, defaultSizeTypes), minSize),
+            enforceSizeThreshold: normalizeSizes(options.enforceSizeThreshold, defaultSizeTypes),
+            maxAsyncSize: mergeSizes(normalizeSizes(options.maxAsyncSize, defaultSizeTypes), maxSize),
+            maxInitialSize: mergeSizes(normalizeSizes(options.maxInitialSize, defaultSizeTypes), maxSize),
+            minChunks: options.minChunks || 1,
+            maxAsyncRequests: options.maxAsyncRequests || 1,
+            maxInitialRequests: options.maxInitialRequests || 1,
+            hidePathInfo: options.hidePathInfo || false,
+            filename: options.filename || undefined,
+            getCacheGroups: normalizeCacheGroups(options.cacheGroups, defaultSizeTypes),
+            getName: options.name ? normalizeName(options.name) : defaultGetName,
+            automaticNameDelimiter: options.automaticNameDelimiter,
+            usedExports: options.usedExports,
+            fallbackCacheGroup: {
+                chunksFilter: normalizeChunksFilter(fallbackCacheGroup.chunks || options.chunks || 'all'),
+                minSize: mergeSizes(normalizeSizes(fallbackCacheGroup.minSize, defaultSizeTypes), minSize),
+                maxAsyncSize: mergeSizes(normalizeSizes(fallbackCacheGroup.maxAsyncSize, defaultSizeTypes), normalizeSizes(fallbackCacheGroup.maxSize, defaultSizeTypes), normalizeSizes(options.maxAsyncSize, defaultSizeTypes), normalizeSizes(options.maxSize, defaultSizeTypes)),
+                maxInitialSize: mergeSizes(normalizeSizes(fallbackCacheGroup.maxInitialSize, defaultSizeTypes), normalizeSizes(fallbackCacheGroup.maxSize, defaultSizeTypes), normalizeSizes(options.maxInitialSize, defaultSizeTypes), normalizeSizes(options.maxSize, defaultSizeTypes)),
+                automaticNameDelimiter: fallbackCacheGroup.automaticNameDelimiter || options.automaticNameDelimiter || '~',
+            },
+        };
+        this._cacheGroupCache = new WeakMap();
+    }
+    _getCacheGroup(cacheGroupSource) {
+        const cacheEntry = this._cacheGroupCache.get(cacheGroupSource);
+        if (cacheEntry !== undefined)
+            return cacheEntry;
+        const minSize = mergeSizes(cacheGroupSource.minSize, cacheGroupSource.enforce ? undefined : this.options.minSize);
+        const minSizeReduction = mergeSizes(cacheGroupSource.minSizeReduction, cacheGroupSource.enforce ? undefined : this.options.minSizeReduction);
+        const minRemainingSize = mergeSizes(cacheGroupSource.minRemainingSize, cacheGroupSource.enforce ? undefined : this.options.minRemainingSize);
+        const enforceSizeThreshold = mergeSizes(cacheGroupSource.enforceSizeThreshold, cacheGroupSource.enforce ? undefined : this.options.enforceSizeThreshold);
+        const cacheGroup = {
+            key: cacheGroupSource.key,
+            priority: cacheGroupSource.priority || 0,
+            chunksFilter: cacheGroupSource.chunksFilter || this.options.chunksFilter,
+            minSize,
+            minSizeReduction,
+            minRemainingSize,
+            enforceSizeThreshold,
+            maxAsyncSize: mergeSizes(cacheGroupSource.maxAsyncSize, cacheGroupSource.enforce ? undefined : this.options.maxAsyncSize),
+            maxInitialSize: mergeSizes(cacheGroupSource.maxInitialSize, cacheGroupSource.enforce ? undefined : this.options.maxInitialSize),
+            minChunks: cacheGroupSource.minChunks !== undefined
+                ? cacheGroupSource.minChunks
+                : cacheGroupSource.enforce
+                    ? 1
+                    : this.options.minChunks,
+            maxAsyncRequests: cacheGroupSource.maxAsyncRequests !== undefined
+                ? cacheGroupSource.maxAsyncRequests
+                : cacheGroupSource.enforce
+                    ? Infinity
+                    : this.options.maxAsyncRequests,
+            maxInitialRequests: cacheGroupSource.maxInitialRequests !== undefined
+                ? cacheGroupSource.maxInitialRequests
+                : cacheGroupSource.enforce
+                    ? Infinity
+                    : this.options.maxInitialRequests,
+            getName: cacheGroupSource.getName !== undefined ? cacheGroupSource.getName : this.options.getName,
+            usedExports: cacheGroupSource.usedExports !== undefined
+                ? cacheGroupSource.usedExports
+                : this.options.usedExports,
+            filename: cacheGroupSource.filename !== undefined ? cacheGroupSource.filename : this.options.filename,
+            automaticNameDelimiter: cacheGroupSource.automaticNameDelimiter !== undefined
+                ? cacheGroupSource.automaticNameDelimiter
+                : this.options.automaticNameDelimiter,
+            idHint: cacheGroupSource.idHint !== undefined ? cacheGroupSource.idHint : cacheGroupSource.key,
+            reuseExistingChunk: cacheGroupSource.reuseExistingChunk || false,
+            _validateSize: hasNonZeroSizes(minSize),
+            _validateRemainingSize: hasNonZeroSizes(minRemainingSize),
+            _minSizeForMaxSize: mergeSizes(cacheGroupSource.minSize, this.options.minSize),
+            _conditionalEnforce: hasNonZeroSizes(enforceSizeThreshold),
+        };
+        this._cacheGroupCache.set(cacheGroupSource, cacheGroup);
+        return cacheGroup;
+    }
+    apply(compiler) {
+        const cachedMakePathsRelative = identifier_1.makePathsRelative.bindContextCache(compiler.context, compiler.root);
+        compiler.hooks.thisCompilation.tap('SplitChunksPlugin', compilation => {
+            const logger = compilation.getLogger('webpack.SplitChunksPlugin');
+            let alreadyOptimized = false;
+            compilation.hooks.unseal.tap('SplitChunksPlugin', () => {
+                alreadyOptimized = false;
+            });
+            compilation.hooks.optimizeChunks.tap({
+                name: 'SplitChunksPlugin',
+                stage: OptimizationStages_1.STAGE_ADVANCED,
+            }, chunks => {
+                if (alreadyOptimized)
+                    return;
+                alreadyOptimized = true;
+                logger.time('prepare');
+                const chunkGraph = compilation.chunkGraph;
+                const moduleGraph = compilation.moduleGraph;
+                // Give each selected chunk an index (to create strings from chunks)
+                const chunkIndexMap = new Map();
+                const ZERO = BigInt('0');
+                const ONE = BigInt('1');
+                const START = ONE << BigInt('31');
+                let index = START;
+                for (const chunk of chunks) {
+                    chunkIndexMap.set(chunk, index | BigInt((Math.random() * 0x7fffffff) | 0));
+                    index <<= ONE;
+                }
+                const getKey = chunks => {
+                    const iterator = chunks[Symbol.iterator]();
+                    let result = iterator.next();
+                    if (result.done)
+                        return ZERO;
+                    const first = result.value;
+                    result = iterator.next();
+                    if (result.done)
+                        return first;
+                    let key = chunkIndexMap.get(first) | chunkIndexMap.get(result.value);
+                    while (!(result = iterator.next()).done) {
+                        const raw = chunkIndexMap.get(result.value);
+                        key ^= raw;
+                    }
+                    return key;
+                };
+                const keyToString = key => {
+                    if (typeof key === 'bigint')
+                        return key.toString(16);
+                    return chunkIndexMap.get(key).toString(16);
+                };
+                const getChunkSetsInGraph = (0, memoize_1.default)(() => {
+                    const chunkSetsInGraph = new Map();
+                    const singleChunkSets = new Set();
+                    for (const module of compilation.modules) {
+                        const chunks = chunkGraph.getModuleChunksIterable(module);
+                        const chunksKey = getKey(chunks);
+                        if (typeof chunksKey === 'bigint') {
+                            if (!chunkSetsInGraph.has(chunksKey)) {
+                                chunkSetsInGraph.set(chunksKey, new Set(chunks));
+                            }
+                        }
+                        else {
+                            singleChunkSets.add(chunksKey);
+                        }
+                    }
+                    return { chunkSetsInGraph, singleChunkSets };
+                });
+                const groupChunksByExports = module => {
+                    const exportsInfo = moduleGraph.getExportsInfo(module);
+                    const groupedByUsedExports = new Map();
+                    for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
+                        const key = exportsInfo.getUsageKey(chunk.runtime);
+                        const list = groupedByUsedExports.get(key);
+                        if (list !== undefined) {
+                            list.push(chunk);
+                        }
+                        else {
+                            groupedByUsedExports.set(key, [chunk]);
+                        }
+                    }
+                    return groupedByUsedExports.values();
+                };
+                const groupedByExportsMap = new Map();
+                const getExportsChunkSetsInGraph = (0, memoize_1.default)(() => {
+                    const chunkSetsInGraph = new Map();
+                    const singleChunkSets = new Set();
+                    for (const module of compilation.modules) {
+                        const groupedChunks = Array.from(groupChunksByExports(module));
+                        groupedByExportsMap.set(module, groupedChunks);
+                        for (const chunks of groupedChunks) {
+                            if (chunks.length === 1) {
+                                singleChunkSets.add(chunks[0]);
+                            }
+                            else {
+                                const chunksKey = getKey(chunks);
+                                if (!chunkSetsInGraph.has(chunksKey)) {
+                                    chunkSetsInGraph.set(chunksKey, new Set(chunks));
+                                }
+                            }
+                        }
+                    }
+                    return { chunkSetsInGraph, singleChunkSets };
+                });
+                // group these set of chunks by count
+                // to allow to check less sets via isSubset
+                // (only smaller sets can be subset)
+                const groupChunkSetsByCount = chunkSets => {
+                    const chunkSetsByCount = new Map();
+                    for (const chunksSet of chunkSets) {
+                        const count = chunksSet.size;
+                        let array = chunkSetsByCount.get(count);
+                        if (array === undefined) {
+                            array = [];
+                            chunkSetsByCount.set(count, array);
+                        }
+                        array.push(chunksSet);
+                    }
+                    return chunkSetsByCount;
+                };
+                const getChunkSetsByCount = (0, memoize_1.default)(() => groupChunkSetsByCount(getChunkSetsInGraph().chunkSetsInGraph.values()));
+                const getExportsChunkSetsByCount = (0, memoize_1.default)(() => groupChunkSetsByCount(getExportsChunkSetsInGraph().chunkSetsInGraph.values()));
+                // Create a list of possible combinations
+                const createGetCombinations = (chunkSets, singleChunkSets, chunkSetsByCount) => {
+                    const combinationsCache = new Map();
+                    return key => {
+                        const cacheEntry = combinationsCache.get(key);
+                        if (cacheEntry !== undefined)
+                            return cacheEntry;
+                        if (key instanceof Chunk_1.default) {
+                            const result = [key];
+                            combinationsCache.set(key, result);
+                            return result;
+                        }
+                        const chunksSet = chunkSets.get(key);
+                        const array = [chunksSet];
+                        for (const [count, setArray] of chunkSetsByCount) {
+                            // "equal" is not needed because they would have been merge in the first step
+                            if (count < chunksSet.size) {
+                                for (const set of setArray) {
+                                    if ((0, SetHelpers_1.isSubset)(chunksSet, set)) {
+                                        array.push(set);
+                                    }
+                                }
+                            }
+                        }
+                        for (const chunk of singleChunkSets) {
+                            if (chunksSet.has(chunk)) {
+                                array.push(chunk);
+                            }
+                        }
+                        combinationsCache.set(key, array);
+                        return array;
+                    };
+                };
+                const getCombinationsFactory = (0, memoize_1.default)(() => {
+                    const { chunkSetsInGraph, singleChunkSets } = getChunkSetsInGraph();
+                    return createGetCombinations(chunkSetsInGraph, singleChunkSets, getChunkSetsByCount());
+                });
+                // @ts-ignore
+                const getCombinations = key => getCombinationsFactory()(key);
+                const getExportsCombinationsFactory = (0, memoize_1.default)(() => {
+                    const { chunkSetsInGraph, singleChunkSets } = getExportsChunkSetsInGraph();
+                    return createGetCombinations(chunkSetsInGraph, singleChunkSets, getExportsChunkSetsByCount());
+                });
+                // @ts-ignore
+                const getExportsCombinations = key => getExportsCombinationsFactory()(key);
+                const selectedChunksCacheByChunksSet = new WeakMap();
+                const getSelectedChunks = (chunks, chunkFilter) => {
+                    let entry = selectedChunksCacheByChunksSet.get(chunks);
+                    if (entry === undefined) {
+                        entry = new WeakMap();
+                        selectedChunksCacheByChunksSet.set(chunks, entry);
+                    }
+                    let entry2 = entry.get(chunkFilter);
+                    if (entry2 === undefined) {
+                        const selectedChunks = [];
+                        if (chunks instanceof Chunk_1.default) {
+                            if (chunkFilter(chunks))
+                                selectedChunks.push(chunks);
+                        }
+                        else {
+                            for (const chunk of chunks) {
+                                if (chunkFilter(chunk))
+                                    selectedChunks.push(chunk);
+                            }
+                        }
+                        entry2 = {
+                            chunks: selectedChunks,
+                            key: getKey(selectedChunks),
+                        };
+                        entry.set(chunkFilter, entry2);
+                    }
+                    return entry2;
+                };
+                const alreadyValidatedParents = new Map();
+                const alreadyReportedErrors = new Set();
+                // Map a list of chunks to a list of modules
+                // For the key the chunk "index" is used, the value is a SortableSet of modules
+                const chunksInfoMap = new Map();
+                const addModuleToChunksInfoMap = (cacheGroup, cacheGroupIndex, selectedChunks, selectedChunksKey, module) => {
+                    // Break if minimum number of chunks is not reached
+                    if (selectedChunks.length < cacheGroup.minChunks)
+                        return;
+                    // Determine name for split chunk
+                    const name = cacheGroup.getName(module, selectedChunks, cacheGroup.key);
+                    // Check if the name is ok
+                    const existingChunk = compilation.namedChunks.get(name);
+                    if (existingChunk) {
+                        const parentValidationKey = `${name}|${typeof selectedChunksKey === 'bigint'
+                            ? selectedChunksKey
+                            : selectedChunksKey.debugId}`;
+                        const valid = alreadyValidatedParents.get(parentValidationKey);
+                        if (valid === false)
+                            return;
+                        if (valid === undefined) {
+                            // Module can only be moved into the existing chunk if the existing chunk
+                            // is a parent of all selected chunks
+                            let isInAllParents = true;
+                            const queue = new Set();
+                            for (const chunk of selectedChunks) {
+                                for (const group of chunk.groupsIterable) {
+                                    queue.add(group);
+                                }
+                            }
+                            for (const group of queue) {
+                                if (existingChunk.isInGroup(group))
+                                    continue;
+                                let hasParent = false;
+                                for (const parent of group.parentsIterable) {
+                                    hasParent = true;
+                                    queue.add(parent);
+                                }
+                                if (!hasParent) {
+                                    isInAllParents = false;
+                                }
+                            }
+                            const valid = isInAllParents;
+                            alreadyValidatedParents.set(parentValidationKey, valid);
+                            if (!valid) {
+                                if (!alreadyReportedErrors.has(name)) {
+                                    alreadyReportedErrors.add(name);
+                                    compilation.errors.push(new BaseError_1.default('SplitChunksPlugin\n' +
+                                        `Cache group "${cacheGroup.key}" conflicts with existing chunk.\n` +
+                                        `Both have the same name "${name}" and existing chunk is not a parent of the selected modules.\n` +
+                                        'Use a different name for the cache group or make sure that the existing chunk is a parent (e. g. via dependOn).\n' +
+                                        'HINT: You can omit "name" to automatically create a name.\n' +
+                                        'BREAKING CHANGE: webpack < 5 used to allow to use an entrypoint as splitChunk. ' +
+                                        'This is no longer allowed when the entrypoint is not a parent of the selected modules.\n' +
+                                        "Remove this entrypoint and add modules to cache group's 'test' instead. " +
+                                        'If you need modules to be evaluated on startup, add them to the existing entrypoints (make them arrays). ' +
+                                        'See migration guide of more info.'));
+                                }
+                                return;
+                            }
+                        }
+                    }
+                    // Create key for maps
+                    // When it has a name we use the name as key
+                    // Otherwise we create the key from chunks and cache group key
+                    // This automatically merges equal names
+                    const key = cacheGroup.key +
+                        (name ? ` name:${name}` : ` chunks:${keyToString(selectedChunksKey)}`);
+                    // Add module to maps
+                    let info = chunksInfoMap.get(key);
+                    if (info === undefined) {
+                        chunksInfoMap.set(key, (info = {
+                            modules: new SortableSet_1.default(undefined, comparators_1.compareModulesByIdentifier),
+                            cacheGroup,
+                            cacheGroupIndex,
+                            name,
+                            sizes: {},
+                            chunks: new Set(),
+                            reuseableChunks: new Set(),
+                            chunksKeys: new Set(),
+                        }));
+                    }
+                    const oldSize = info.modules.size;
+                    info.modules.add(module);
+                    if (info.modules.size !== oldSize) {
+                        for (const type of module.getSourceTypes()) {
+                            info.sizes[type] = (info.sizes[type] || 0) + module.size(type);
+                        }
+                    }
+                    const oldChunksKeysSize = info.chunksKeys.size;
+                    info.chunksKeys.add(selectedChunksKey);
+                    if (oldChunksKeysSize !== info.chunksKeys.size) {
+                        for (const chunk of selectedChunks) {
+                            info.chunks.add(chunk);
+                        }
+                    }
+                };
+                const context = {
+                    moduleGraph,
+                    chunkGraph,
+                };
+                logger.timeEnd('prepare');
+                logger.time('modules');
+                // Walk through all modules
+                for (const module of compilation.modules) {
+                    // Get cache group
+                    const cacheGroups = this.options.getCacheGroups(module, context);
+                    if (!Array.isArray(cacheGroups) || cacheGroups.length === 0) {
+                        continue;
+                    }
+                    // Prepare some values (usedExports = false)
+                    const getCombs = (0, memoize_1.default)(() => {
+                        const chunks = chunkGraph.getModuleChunksIterable(module);
+                        const chunksKey = getKey(chunks);
+                        return getCombinations(chunksKey);
+                    });
+                    // Prepare some values (usedExports = true)
+                    const getCombsByUsedExports = (0, memoize_1.default)(() => {
+                        // fill the groupedByExportsMap
+                        getExportsChunkSetsInGraph();
+                        const set = new Set();
+                        const groupedByUsedExports = groupedByExportsMap.get(module);
+                        for (const chunks of groupedByUsedExports) {
+                            const chunksKey = getKey(chunks);
+                            for (const comb of getExportsCombinations(chunksKey))
+                                set.add(comb);
+                        }
+                        return set;
+                    });
+                    let cacheGroupIndex = 0;
+                    for (const cacheGroupSource of cacheGroups) {
+                        const cacheGroup = this._getCacheGroup(cacheGroupSource);
+                        const combs = cacheGroup.usedExports ? getCombsByUsedExports() : getCombs();
+                        // For all combination of chunk selection
+                        for (const chunkCombination of combs) {
+                            // Break if minimum number of chunks is not reached
+                            const count = chunkCombination instanceof Chunk_1.default ? 1 : chunkCombination.size;
+                            if (count < cacheGroup.minChunks)
+                                continue;
+                            // Select chunks by configuration
+                            const { chunks: selectedChunks, key: selectedChunksKey } = getSelectedChunks(chunkCombination, cacheGroup.chunksFilter);
+                            addModuleToChunksInfoMap(cacheGroup, cacheGroupIndex, selectedChunks, selectedChunksKey, module);
+                        }
+                        cacheGroupIndex++;
+                    }
+                }
+                logger.timeEnd('modules');
+                logger.time('queue');
+                const removeModulesWithSourceType = (info, sourceTypes) => {
+                    for (const module of info.modules) {
+                        const types = module.getSourceTypes();
+                        if (sourceTypes.some(type => types.has(type))) {
+                            info.modules.delete(module);
+                            for (const type of types) {
+                                info.sizes[type] -= module.size(type);
+                            }
+                        }
+                    }
+                };
+                const removeMinSizeViolatingModules = info => {
+                    if (!info.cacheGroup._validateSize)
+                        return false;
+                    const violatingSizes = getViolatingMinSizes(info.sizes, info.cacheGroup.minSize);
+                    if (violatingSizes === undefined)
+                        return false;
+                    removeModulesWithSourceType(info, violatingSizes);
+                    return info.modules.size === 0;
+                };
+                // Filter items were size < minSize
+                for (const [key, info] of chunksInfoMap) {
+                    if (removeMinSizeViolatingModules(info)) {
+                        chunksInfoMap.delete(key);
+                    }
+                    else if (!checkMinSizeReduction(info.sizes, info.cacheGroup.minSizeReduction, info.chunks.size)) {
+                        chunksInfoMap.delete(key);
+                    }
+                }
+                const maxSizeQueueMap = new Map();
+                while (chunksInfoMap.size > 0) {
+                    // Find best matching entry
+                    let bestEntryKey;
+                    let bestEntry;
+                    for (const pair of chunksInfoMap) {
+                        const key = pair[0];
+                        const info = pair[1];
+                        if (bestEntry === undefined || compareEntries(bestEntry, info) < 0) {
+                            bestEntry = info;
+                            bestEntryKey = key;
+                        }
+                    }
+                    const item = bestEntry;
+                    chunksInfoMap.delete(bestEntryKey);
+                    let chunkName = item.name;
+                    // Variable for the new chunk (lazy created)
+                    let newChunk;
+                    // When no chunk name, check if we can reuse a chunk instead of creating a new one
+                    let isExistingChunk = false;
+                    let isReusedWithAllModules = false;
+                    if (chunkName) {
+                        const chunkByName = compilation.namedChunks.get(chunkName);
+                        if (chunkByName !== undefined) {
+                            newChunk = chunkByName;
+                            const oldSize = item.chunks.size;
+                            item.chunks.delete(newChunk);
+                            isExistingChunk = item.chunks.size !== oldSize;
+                        }
+                    }
+                    else if (item.cacheGroup.reuseExistingChunk) {
+                        outer: for (const chunk of item.chunks) {
+                            if (chunkGraph.getNumberOfChunkModules(chunk) !== item.modules.size) {
+                                continue;
+                            }
+                            if (item.chunks.size > 1 && chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+                                continue;
+                            }
+                            for (const module of item.modules) {
+                                if (!chunkGraph.isModuleInChunk(module, chunk)) {
+                                    continue outer;
+                                }
+                            }
+                            if (!newChunk || !newChunk.name) {
+                                newChunk = chunk;
+                            }
+                            else if (chunk.name && chunk.name.length < newChunk.name.length) {
+                                newChunk = chunk;
+                            }
+                            else if (chunk.name &&
+                                chunk.name.length === newChunk.name.length &&
+                                chunk.name < newChunk.name) {
+                                newChunk = chunk;
+                            }
+                        }
+                        if (newChunk) {
+                            item.chunks.delete(newChunk);
+                            chunkName = undefined;
+                            isExistingChunk = true;
+                            isReusedWithAllModules = true;
+                        }
+                    }
+                    const enforced = item.cacheGroup._conditionalEnforce &&
+                        checkMinSize(item.sizes, item.cacheGroup.enforceSizeThreshold);
+                    const usedChunks = new Set(item.chunks);
+                    // Check if maxRequests condition can be fulfilled
+                    if (!enforced &&
+                        (Number.isFinite(item.cacheGroup.maxInitialRequests) ||
+                            Number.isFinite(item.cacheGroup.maxAsyncRequests))) {
+                        for (const chunk of usedChunks) {
+                            // respect max requests
+                            const maxRequests = chunk.isOnlyInitial()
+                                ? item.cacheGroup.maxInitialRequests
+                                : chunk.canBeInitial()
+                                    ? Math.min(item.cacheGroup.maxInitialRequests, item.cacheGroup.maxAsyncRequests)
+                                    : item.cacheGroup.maxAsyncRequests;
+                            if (isFinite(maxRequests) && getRequests(chunk) >= maxRequests) {
+                                usedChunks.delete(chunk);
+                            }
+                        }
+                    }
+                    outer: for (const chunk of usedChunks) {
+                        for (const module of item.modules) {
+                            if (chunkGraph.isModuleInChunk(module, chunk))
+                                continue outer;
+                        }
+                        usedChunks.delete(chunk);
+                    }
+                    // Were some (invalid) chunks removed from usedChunks?
+                    // => readd all modules to the queue, as things could have been changed
+                    if (usedChunks.size < item.chunks.size) {
+                        if (isExistingChunk)
+                            usedChunks.add(newChunk);
+                        if (usedChunks.size >= item.cacheGroup.minChunks) {
+                            const chunksArr = Array.from(usedChunks);
+                            for (const module of item.modules) {
+                                addModuleToChunksInfoMap(item.cacheGroup, item.cacheGroupIndex, chunksArr, getKey(usedChunks), module);
+                            }
+                        }
+                        continue;
+                    }
+                    // Validate minRemainingSize constraint when a single chunk is left over
+                    if (!enforced && item.cacheGroup._validateRemainingSize && usedChunks.size === 1) {
+                        const [chunk] = usedChunks;
+                        const chunkSizes = Object.create(null);
+                        for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+                            if (!item.modules.has(module)) {
+                                for (const type of module.getSourceTypes()) {
+                                    chunkSizes[type] = (chunkSizes[type] || 0) + module.size(type);
+                                }
+                            }
+                        }
+                        const violatingSizes = getViolatingMinSizes(chunkSizes, item.cacheGroup.minRemainingSize);
+                        if (violatingSizes !== undefined) {
+                            const oldModulesSize = item.modules.size;
+                            removeModulesWithSourceType(item, violatingSizes);
+                            if (item.modules.size > 0 && item.modules.size !== oldModulesSize) {
+                                // queue this item again to be processed again
+                                // without violating modules
+                                chunksInfoMap.set(bestEntryKey, item);
+                            }
+                            continue;
+                        }
+                    }
+                    // Create the new chunk if not reusing one
+                    if (newChunk === undefined) {
+                        newChunk = compilation.addChunk(chunkName);
+                    }
+                    // Walk through all chunks
+                    for (const chunk of usedChunks) {
+                        // Add graph connections for splitted chunk
+                        chunk.split(newChunk);
+                    }
+                    // Add a note to the chunk
+                    newChunk.chunkReason =
+                        (newChunk.chunkReason ? `${newChunk.chunkReason}, ` : '') +
+                            (isReusedWithAllModules ? 'reused as split chunk' : 'split chunk');
+                    if (item.cacheGroup.key) {
+                        newChunk.chunkReason += ` (cache group: ${item.cacheGroup.key})`;
+                    }
+                    if (chunkName) {
+                        newChunk.chunkReason += ` (name: ${chunkName})`;
+                    }
+                    if (item.cacheGroup.filename) {
+                        newChunk.filenameTemplate = item.cacheGroup.filename;
+                    }
+                    if (item.cacheGroup.idHint) {
+                        newChunk.idNameHints.add(item.cacheGroup.idHint);
+                    }
+                    if (!isReusedWithAllModules) {
+                        // Add all modules to the new chunk
+                        for (const module of item.modules) {
+                            if (!module.chunkCondition(newChunk, compilation))
+                                continue;
+                            // Add module to new chunk
+                            chunkGraph.connectChunkAndModule(newChunk, module);
+                            // Remove module from used chunks
+                            for (const chunk of usedChunks) {
+                                chunkGraph.disconnectChunkAndModule(chunk, module);
+                            }
+                        }
+                    }
+                    else {
+                        // Remove all modules from used chunks
+                        for (const module of item.modules) {
+                            for (const chunk of usedChunks) {
+                                chunkGraph.disconnectChunkAndModule(chunk, module);
+                            }
+                        }
+                    }
+                    if (Object.keys(item.cacheGroup.maxAsyncSize).length > 0 ||
+                        Object.keys(item.cacheGroup.maxInitialSize).length > 0) {
+                        const oldMaxSizeSettings = maxSizeQueueMap.get(newChunk);
+                        maxSizeQueueMap.set(newChunk, {
+                            minSize: oldMaxSizeSettings
+                                ? combineSizes(oldMaxSizeSettings.minSize, item.cacheGroup._minSizeForMaxSize, Math.max)
+                                : item.cacheGroup.minSize,
+                            maxAsyncSize: oldMaxSizeSettings
+                                ? combineSizes(oldMaxSizeSettings.maxAsyncSize, item.cacheGroup.maxAsyncSize, Math.min)
+                                : item.cacheGroup.maxAsyncSize,
+                            maxInitialSize: oldMaxSizeSettings
+                                ? combineSizes(oldMaxSizeSettings.maxInitialSize, item.cacheGroup.maxInitialSize, Math.min)
+                                : item.cacheGroup.maxInitialSize,
+                            automaticNameDelimiter: item.cacheGroup.automaticNameDelimiter,
+                            keys: oldMaxSizeSettings
+                                ? oldMaxSizeSettings.keys.concat(item.cacheGroup.key)
+                                : [item.cacheGroup.key],
+                        });
+                    }
+                    // remove all modules from other entries and update size
+                    for (const [key, info] of chunksInfoMap) {
+                        if (isOverlap(info.chunks, usedChunks)) {
+                            // update modules and total size
+                            // may remove it from the map when < minSize
+                            let updated = false;
+                            for (const module of item.modules) {
+                                if (info.modules.has(module)) {
+                                    // remove module
+                                    info.modules.delete(module);
+                                    // update size
+                                    for (const key of module.getSourceTypes()) {
+                                        info.sizes[key] -= module.size(key);
+                                    }
+                                    updated = true;
+                                }
+                            }
+                            if (updated) {
+                                if (info.modules.size === 0) {
+                                    chunksInfoMap.delete(key);
+                                    continue;
+                                }
+                                if (removeMinSizeViolatingModules(info) ||
+                                    !checkMinSizeReduction(info.sizes, info.cacheGroup.minSizeReduction, info.chunks.size)) {
+                                    chunksInfoMap.delete(key);
+                                    continue;
+                                }
+                            }
+                        }
+                    }
+                }
+                logger.timeEnd('queue');
+                logger.time('maxSize');
+                const incorrectMinMaxSizeSet = new Set();
+                const { outputOptions } = compilation;
+                // Make sure that maxSize is fulfilled
+                const { fallbackCacheGroup } = this.options;
+                const allChunks = Array.from(compilation.chunks);
+                for (const chunk of allChunks) {
+                    const chunkConfig = maxSizeQueueMap.get(chunk);
+                    const { minSize, maxAsyncSize, maxInitialSize, automaticNameDelimiter } = chunkConfig || fallbackCacheGroup;
+                    if (!chunkConfig && !fallbackCacheGroup.chunksFilter(chunk))
+                        continue;
+                    let maxSize;
+                    if (chunk.isOnlyInitial()) {
+                        maxSize = maxInitialSize;
+                    }
+                    else if (chunk.canBeInitial()) {
+                        maxSize = combineSizes(maxAsyncSize, maxInitialSize, Math.min);
+                    }
+                    else {
+                        maxSize = maxAsyncSize;
+                    }
+                    if (Object.keys(maxSize).length === 0) {
+                        continue;
+                    }
+                    for (const key of Object.keys(maxSize)) {
+                        const maxSizeValue = maxSize[key];
+                        const minSizeValue = minSize[key];
+                        if (typeof minSizeValue === 'number' && minSizeValue > maxSizeValue) {
+                            const keys = chunkConfig === null || chunkConfig === void 0 ? void 0 : chunkConfig.keys;
+                            const warningKey = `${keys === null || keys === void 0 ? void 0 : keys.join()} ${minSizeValue} ${maxSizeValue}`;
+                            if (!incorrectMinMaxSizeSet.has(warningKey)) {
+                                incorrectMinMaxSizeSet.add(warningKey);
+                                compilation.warnings.push(new MinMaxSizeWarning_1.default(keys, minSizeValue, maxSizeValue));
+                            }
+                        }
+                    }
+                    const results = deterministicGroupingForModules({
+                        minSize,
+                        maxSize: mapObject(maxSize, (value, key) => {
+                            const minSizeValue = minSize[key];
+                            return typeof minSizeValue === 'number' ? Math.max(value, minSizeValue) : value;
+                        }),
+                        items: chunkGraph.getChunkModulesIterable(chunk),
+                        getKey(module) {
+                            var _a;
+                            const cache = getKeyCache.get(module);
+                            if (cache !== undefined)
+                                return cache;
+                            const ident = cachedMakePathsRelative(module.identifier());
+                            const nameForCondition = (_a = module.nameForCondition) === null || _a === void 0 ? void 0 : _a.call(module);
+                            const name = nameForCondition
+                                ? cachedMakePathsRelative(nameForCondition)
+                                : ident.replace(/^.*!|\?[^?!]*$/g, '');
+                            const fullKey = name + automaticNameDelimiter + hashFilename(ident, outputOptions);
+                            const key = (0, IdHelpers_1.requestToId)(fullKey);
+                            getKeyCache.set(module, key);
+                            return key;
+                        },
+                        getSize(module) {
+                            const size = Object.create(null);
+                            for (const key of module.getSourceTypes()) {
+                                size[key] = module.size(key);
+                            }
+                            return size;
+                        },
+                    });
+                    if (results.length <= 1) {
+                        continue;
+                    }
+                    for (let i = 0; i < results.length; i++) {
+                        const group = results[i];
+                        const key = this.options.hidePathInfo
+                            ? hashFilename(group.key, outputOptions)
+                            : group.key;
+                        let name = chunk.name ? chunk.name + automaticNameDelimiter + key : null;
+                        if (name && name.length > 100) {
+                            name =
+                                name.slice(0, 100) + automaticNameDelimiter + hashFilename(name, outputOptions);
+                        }
+                        if (i !== results.length - 1) {
+                            const newPart = compilation.addChunk(name);
+                            chunk.split(newPart);
+                            newPart.chunkReason = chunk.chunkReason;
+                            // Add all modules to the new chunk
+                            for (const module of group.items) {
+                                if (!module.chunkCondition(newPart, compilation)) {
+                                    continue;
+                                }
+                                // Add module to new chunk
+                                chunkGraph.connectChunkAndModule(newPart, module);
+                                // Remove module from used chunks
+                                chunkGraph.disconnectChunkAndModule(chunk, module);
+                            }
+                        }
+                        else {
+                            // change the chunk to be a part
+                            chunk.name = name;
+                        }
+                    }
+                }
+                logger.timeEnd('maxSize');
+            });
+        });
+    }
+}
+exports.default = SplitChunksPlugin;