xhs-mp-pack 1.1.0-beta.0

package/dist/plugins/optimize/ModuleInfoHeaderPlugin.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_sources_1 = require("webpack-sources");
+const ExportsInfo_1 = require("@/module/ExportsInfo");
+const Template_1 = require("@/template/Template");
+const JavascriptModulesPlugin_1 = require("../../module/javascript/JavascriptModulesPlugin");
+const joinIterableWithComma = iterable => {
+    // This is more performant than Array.from().join(", ")
+    // as it doesn't create an array
+    let str = '';
+    let first = true;
+    for (const item of iterable) {
+        if (first) {
+            first = false;
+        }
+        else {
+            str += ', ';
+        }
+        str += item;
+    }
+    return str;
+};
+const printExportsInfoToSource = (source, indent, exportsInfo, moduleGraph, requestShortener, alreadyPrinted = new Set()) => {
+    const otherExportsInfo = exportsInfo.otherExportsInfo;
+    let alreadyPrintedExports = 0;
+    // determine exports to print
+    const printedExports = [];
+    for (const exportInfo of exportsInfo.orderedExports) {
+        if (!alreadyPrinted.has(exportInfo)) {
+            alreadyPrinted.add(exportInfo);
+            printedExports.push(exportInfo);
+        }
+        else {
+            alreadyPrintedExports++;
+        }
+    }
+    let showOtherExports = false;
+    if (!alreadyPrinted.has(otherExportsInfo)) {
+        alreadyPrinted.add(otherExportsInfo);
+        showOtherExports = true;
+    }
+    else {
+        alreadyPrintedExports++;
+    }
+    // print the exports
+    for (const exportInfo of printedExports) {
+        const target = exportInfo.getTarget(moduleGraph);
+        source.add(`${Template_1.Template.toComment(`${indent}export ${JSON.stringify(exportInfo.name).slice(1, -1)} [${exportInfo.getProvidedInfo()}] [${exportInfo.getUsedInfo()}] [${exportInfo.getRenameInfo()}]${target
+            ? ` -> ${target.module.readableIdentifier(requestShortener)}${target.export
+                ? ` .${target.export.map(e => JSON.stringify(e).slice(1, -1)).join('.')}`
+                : ''}`
+            : ''}`)}\n`);
+        if (exportInfo.exportsInfo) {
+            printExportsInfoToSource(source, `${indent}  `, exportInfo.exportsInfo, moduleGraph, requestShortener, alreadyPrinted);
+        }
+    }
+    if (alreadyPrintedExports) {
+        source.add(`${Template_1.Template.toComment(`${indent}... (${alreadyPrintedExports} already listed exports)`)}\n`);
+    }
+    if (showOtherExports) {
+        const target = otherExportsInfo.getTarget(moduleGraph);
+        if (target ||
+            otherExportsInfo.provided !== false ||
+            otherExportsInfo.getUsed(undefined) !== ExportsInfo_1.UsageState.Unused) {
+            const title = printedExports.length > 0 || alreadyPrintedExports > 0 ? 'other exports' : 'exports';
+            source.add(`${Template_1.Template.toComment(`${indent}${title} [${otherExportsInfo.getProvidedInfo()}] [${otherExportsInfo.getUsedInfo()}]${target ? ` -> ${target.module.readableIdentifier(requestShortener)}` : ''}`)}\n`);
+        }
+    }
+};
+const caches = new WeakMap();
+class ModuleInfoHeaderPlugin {
+    constructor(verbose = true) {
+        this._verbose = verbose;
+    }
+    apply(compiler) {
+        const { _verbose: verbose } = this;
+        compiler.hooks.compilation.tap('ModuleInfoHeaderPlugin', compilation => {
+            const hooks = JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation);
+            hooks.renderModulePackage.tap('ModuleInfoHeaderPlugin', (moduleSource, module, { chunk, chunkGraph, moduleGraph, runtimeTemplate }) => {
+                const { requestShortener } = runtimeTemplate;
+                let cacheEntry;
+                let cache = caches.get(requestShortener);
+                if (cache === undefined) {
+                    caches.set(requestShortener, (cache = new WeakMap()));
+                    cache.set(module, (cacheEntry = { header: undefined, full: new WeakMap() }));
+                }
+                else {
+                    cacheEntry = cache.get(module);
+                    if (cacheEntry === undefined) {
+                        cache.set(module, (cacheEntry = { header: undefined, full: new WeakMap() }));
+                    }
+                    else if (!verbose) {
+                        const cachedSource = cacheEntry.full.get(moduleSource);
+                        if (cachedSource !== undefined)
+                            return cachedSource;
+                    }
+                }
+                const source = new webpack_sources_1.ConcatSource();
+                let header = cacheEntry.header;
+                if (header === undefined) {
+                    const req = module.readableIdentifier(requestShortener);
+                    const reqStr = req.replace(/\*\//g, '*_/');
+                    const reqStrStar = '*'.repeat(reqStr.length);
+                    const headerStr = `/*!****${reqStrStar}****!*\\\n  !*** ${reqStr} ***!\n  \\****${reqStrStar}****/\n`;
+                    header = new webpack_sources_1.RawSource(headerStr);
+                    cacheEntry.header = header;
+                }
+                source.add(header);
+                if (verbose) {
+                    const exportsType = module.buildMeta.exportsType;
+                    source.add(`${Template_1.Template.toComment(exportsType ? `${exportsType} exports` : 'unknown exports (runtime-defined)')}\n`);
+                    if (exportsType) {
+                        const exportsInfo = moduleGraph.getExportsInfo(module);
+                        printExportsInfoToSource(source, '', exportsInfo, moduleGraph, requestShortener);
+                    }
+                    source.add(`${Template_1.Template.toComment(`runtime requirements: ${joinIterableWithComma(chunkGraph.getModuleRuntimeRequirements(module, chunk.runtime))}`)}\n`);
+                    const optimizationBailout = moduleGraph.getOptimizationBailout(module);
+                    if (optimizationBailout) {
+                        for (const text of optimizationBailout) {
+                            let code;
+                            if (typeof text === 'function') {
+                                code = text(requestShortener);
+                            }
+                            else {
+                                code = text;
+                            }
+                            source.add(`${Template_1.Template.toComment(`${code}`)}\n`);
+                        }
+                    }
+                    source.add(moduleSource);
+                    return source;
+                }
+                source.add(moduleSource);
+                const cachedSource = new webpack_sources_1.CachedSource(source);
+                cacheEntry.full.set(moduleSource, cachedSource);
+                return cachedSource;
+            });
+            hooks.chunkHash.tap('ModuleInfoHeaderPlugin', (chunk, hash) => {
+                hash.update('ModuleInfoHeaderPlugin');
+                hash.update('1');
+            });
+        });
+    }
+}
+exports.default = ModuleInfoHeaderPlugin;

package/dist/plugins/optimize/NoEmitOnErrorsPlugin.d.ts

@@ -0,0 +1,4 @@
+declare class NoEmitOnErrorsPlugin {
+    apply(compiler: any): void;
+}
+export default NoEmitOnErrorsPlugin;

package/dist/plugins/optimize/NoEmitOnErrorsPlugin.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class NoEmitOnErrorsPlugin {
+    apply(compiler) {
+        compiler.hooks.shouldEmit.tap('NoEmitOnErrorsPlugin', compilation => {
+            if (compilation.getStats().hasErrors())
+                return false;
+        });
+        compiler.hooks.compilation.tap('NoEmitOnErrorsPlugin', compilation => {
+            compilation.hooks.shouldRecord.tap('NoEmitOnErrorsPlugin', () => {
+                if (compilation.getStats().hasErrors())
+                    return false;
+            });
+        });
+    }
+}
+exports.default = NoEmitOnErrorsPlugin;

package/dist/plugins/optimize/OptimizationStages.d.ts

@@ -0,0 +1,4 @@
+declare const STAGE_BASIC = -10;
+declare const STAGE_DEFAULT = 0;
+declare const STAGE_ADVANCED = 10;
+export { STAGE_BASIC, STAGE_DEFAULT, STAGE_ADVANCED };

package/dist/plugins/optimize/OptimizationStages.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STAGE_ADVANCED = exports.STAGE_DEFAULT = exports.STAGE_BASIC = void 0;
+const STAGE_BASIC = -10;
+exports.STAGE_BASIC = STAGE_BASIC;
+const STAGE_DEFAULT = 0;
+exports.STAGE_DEFAULT = STAGE_DEFAULT;
+const STAGE_ADVANCED = 10;
+exports.STAGE_ADVANCED = STAGE_ADVANCED;

package/dist/plugins/optimize/RealContentHashPlugin.d.ts

@@ -0,0 +1,11 @@
+declare class RealContentHashPlugin {
+    _hashFunction: any;
+    _hashDigest: any;
+    static getCompilationHooks(compilation: any): any;
+    constructor({ hashFunction, hashDigest }: {
+        hashFunction: any;
+        hashDigest: any;
+    });
+    apply(compiler: any): void;
+}
+export default RealContentHashPlugin;

package/dist/plugins/optimize/RealContentHashPlugin.js

@@ -0,0 +1,295 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tapable_1 = require("tapable");
+const webpack_sources_1 = require("webpack-sources");
+const Compilation_1 = __importDefault(require("@/Compilation"));
+const BaseError_1 = __importDefault(require("@/base/errors/BaseError"));
+const comparators_1 = require("@/base/comparators");
+const createHash_1 = __importDefault(require("@/base/createHash"));
+const EMPTY_SET = new Set();
+const addToList = (itemOrItems, list) => {
+    if (Array.isArray(itemOrItems)) {
+        for (const item of itemOrItems) {
+            list.add(item);
+        }
+    }
+    else if (itemOrItems) {
+        list.add(itemOrItems);
+    }
+};
+const mapAndDeduplicateBuffers = (input, fn) => {
+    // Buffer.equals compares size first so this should be efficient enough
+    // If it becomes a performance problem we can use a map and group by size
+    // instead of looping over all assets.
+    const result = [];
+    outer: for (const value of input) {
+        const buf = fn(value);
+        for (const other of result) {
+            if (buf.equals(other))
+                continue outer;
+        }
+        result.push(buf);
+    }
+    return result;
+};
+const quoteMeta = (str) => str.replace(/[-[\]\\/{}()*+?.^$|]/g, '\\$&');
+const cachedSourceMap = new WeakMap();
+const toCachedSource = source => {
+    if (source instanceof webpack_sources_1.CachedSource) {
+        return source;
+    }
+    const entry = cachedSourceMap.get(source);
+    if (entry !== undefined)
+        return entry;
+    const newSource = new webpack_sources_1.CachedSource(webpack_sources_1.CompatSource.from(source));
+    cachedSourceMap.set(source, newSource);
+    return newSource;
+};
+const compilationHooksMap = new WeakMap();
+class RealContentHashPlugin {
+    static getCompilationHooks(compilation) {
+        if (!(compilation instanceof Compilation_1.default)) {
+            throw new TypeError("The 'compilation' argument must be an instance of Compilation");
+        }
+        let hooks = compilationHooksMap.get(compilation);
+        if (hooks === undefined) {
+            hooks = {
+                updateHash: new tapable_1.SyncBailHook(['content', 'oldHash']),
+            };
+            compilationHooksMap.set(compilation, hooks);
+        }
+        return hooks;
+    }
+    constructor({ hashFunction, hashDigest }) {
+        this._hashFunction = hashFunction;
+        this._hashDigest = hashDigest;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap('RealContentHashPlugin', compilation => {
+            const cacheAnalyse = compilation.getCache('RealContentHashPlugin|analyse');
+            const cacheGenerate = compilation.getCache('RealContentHashPlugin|generate');
+            const hooks = RealContentHashPlugin.getCompilationHooks(compilation);
+            compilation.hooks.processAssets.tapPromise({
+                name: 'RealContentHashPlugin',
+                stage: Compilation_1.default.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH,
+            }, () => __awaiter(this, void 0, void 0, function* () {
+                const assets = compilation.getAssets();
+                const assetsWithInfo = [];
+                const hashToAssets = new Map();
+                for (const { source, info, name } of assets) {
+                    const cachedSource = toCachedSource(source);
+                    const content = cachedSource.source();
+                    const hashes = new Set();
+                    addToList(info.contenthash, hashes);
+                    const data = {
+                        name,
+                        info,
+                        source: cachedSource,
+                        newSource: undefined,
+                        newSourceWithoutOwn: undefined,
+                        content,
+                        ownHashes: undefined,
+                        contentComputePromise: undefined,
+                        contentComputeWithoutOwnPromise: undefined,
+                        referencedHashes: undefined,
+                        hashes,
+                    };
+                    assetsWithInfo.push(data);
+                    for (const hash of hashes) {
+                        const list = hashToAssets.get(hash);
+                        if (list === undefined) {
+                            hashToAssets.set(hash, [data]);
+                        }
+                        else {
+                            list.push(data);
+                        }
+                    }
+                }
+                if (hashToAssets.size === 0)
+                    return;
+                const hashRegExp = new RegExp(Array.from(hashToAssets.keys(), quoteMeta).join('|'), 'g');
+                yield Promise.all(assetsWithInfo.map((asset) => __awaiter(this, void 0, void 0, function* () {
+                    const { name, source, content, hashes } = asset;
+                    if (Buffer.isBuffer(content)) {
+                        asset.referencedHashes = EMPTY_SET;
+                        asset.ownHashes = EMPTY_SET;
+                        return;
+                    }
+                    const etag = cacheAnalyse.mergeEtags(cacheAnalyse.getLazyHashedEtag(source), Array.from(hashes).join('|'));
+                    [asset.referencedHashes, asset.ownHashes] = yield cacheAnalyse.providePromise(name, etag, () => {
+                        const referencedHashes = new Set();
+                        const ownHashes = new Set();
+                        const inContent = content.match(hashRegExp);
+                        if (inContent) {
+                            for (const hash of inContent) {
+                                if (hashes.has(hash)) {
+                                    ownHashes.add(hash);
+                                    continue;
+                                }
+                                referencedHashes.add(hash);
+                            }
+                        }
+                        return [referencedHashes, ownHashes];
+                    });
+                })));
+                const getDependencies = hash => {
+                    const assets = hashToAssets.get(hash);
+                    if (!assets) {
+                        const referencingAssets = assetsWithInfo.filter(asset => asset.referencedHashes.has(hash));
+                        const err = new BaseError_1.default(`RealContentHashPlugin
+Some kind of unexpected caching problem occurred.
+An asset was cached with a reference to another asset (${hash}) that's not in the compilation anymore.
+Either the asset was incorrectly cached, or the referenced asset should also be restored from cache.
+Referenced by:
+${referencingAssets
+                            .map((a) => {
+                            const match = new RegExp(`.{0,20}${quoteMeta(hash)}.{0,20}`).exec(a.content);
+                            return ` - ${a.name}: ...${match ? match[0] : '???'}...`;
+                        })
+                            .join('\n')}`);
+                        compilation.errors.push(err);
+                        return undefined;
+                    }
+                    const hashes = new Set();
+                    for (const { referencedHashes, ownHashes } of assets) {
+                        if (!ownHashes.has(hash)) {
+                            for (const hash of ownHashes) {
+                                hashes.add(hash);
+                            }
+                        }
+                        for (const hash of referencedHashes) {
+                            hashes.add(hash);
+                        }
+                    }
+                    return hashes;
+                };
+                const hashInfo = hash => {
+                    const assets = hashToAssets.get(hash);
+                    return `${hash} (${Array.from(assets, (a) => a.name)})`;
+                };
+                const hashesInOrder = new Set();
+                for (const hash of hashToAssets.keys()) {
+                    const add = (hash, stack) => {
+                        const deps = getDependencies(hash);
+                        if (!deps)
+                            return;
+                        stack.add(hash);
+                        for (const dep of deps) {
+                            if (hashesInOrder.has(dep))
+                                continue;
+                            if (stack.has(dep)) {
+                                throw new Error(`Circular hash dependency ${Array.from(stack, hashInfo).join(' -> ')} -> ${hashInfo(dep)}`);
+                            }
+                            add(dep, stack);
+                        }
+                        hashesInOrder.add(hash);
+                        stack.delete(hash);
+                    };
+                    if (hashesInOrder.has(hash))
+                        continue;
+                    add(hash, new Set());
+                }
+                const hashToNewHash = new Map();
+                const getEtag = asset => cacheGenerate.mergeEtags(cacheGenerate.getLazyHashedEtag(asset.source), Array.from(asset.referencedHashes, hash => hashToNewHash.get(hash)).join('|'));
+                const computeNewContent = asset => {
+                    if (asset.contentComputePromise)
+                        return asset.contentComputePromise;
+                    asset.contentComputePromise = (() => __awaiter(this, void 0, void 0, function* () {
+                        if (asset.ownHashes.size > 0 ||
+                            Array.from(asset.referencedHashes).some(hash => hashToNewHash.get(hash) !== hash)) {
+                            const identifier = asset.name;
+                            const etag = getEtag(asset);
+                            asset.newSource = yield cacheGenerate.providePromise(identifier, etag, () => {
+                                const newContent = asset.content.replace(hashRegExp, hash => hashToNewHash.get(hash));
+                                return new webpack_sources_1.RawSource(newContent);
+                            });
+                        }
+                    }))();
+                    return asset.contentComputePromise;
+                };
+                const computeNewContentWithoutOwn = asset => {
+                    if (asset.contentComputeWithoutOwnPromise)
+                        return asset.contentComputeWithoutOwnPromise;
+                    (asset.contentComputeWithoutOwnPromise = (() => __awaiter(this, void 0, void 0, function* () {
+                        if (asset.ownHashes.size > 0 ||
+                            Array.from(asset.referencedHashes).some(hash => hashToNewHash.get(hash) !== hash)) {
+                            const identifier = `${asset.name}|without-own`;
+                            const etag = getEtag(asset);
+                            asset.newSourceWithoutOwn = yield cacheGenerate.providePromise(identifier, etag, () => {
+                                const newContent = asset.content.replace(hashRegExp, hash => {
+                                    if (asset.ownHashes.has(hash)) {
+                                        return '';
+                                    }
+                                    return hashToNewHash.get(hash);
+                                });
+                                return new webpack_sources_1.RawSource(newContent);
+                            });
+                        }
+                    }))());
+                    return asset.contentComputeWithoutOwnPromise;
+                };
+                const comparator = (0, comparators_1.compareSelect)(a => a.name, comparators_1.compareStrings);
+                for (const oldHash of hashesInOrder) {
+                    const assets = hashToAssets.get(oldHash);
+                    assets.sort(comparator);
+                    yield Promise.all(assets.map(asset => asset.ownHashes.has(oldHash)
+                        ? computeNewContentWithoutOwn(asset)
+                        : computeNewContent(asset)));
+                    const assetsContent = mapAndDeduplicateBuffers(assets, asset => {
+                        if (asset.ownHashes.has(oldHash)) {
+                            return asset.newSourceWithoutOwn
+                                ? asset.newSourceWithoutOwn.buffer()
+                                : asset.source.buffer();
+                        }
+                        return asset.newSource ? asset.newSource.buffer() : asset.source.buffer();
+                    });
+                    let newHash = hooks.updateHash.call(assetsContent, oldHash);
+                    if (!newHash) {
+                        const hash = (0, createHash_1.default)(this._hashFunction);
+                        if (compilation.outputOptions.hashSalt) {
+                            hash.update(compilation.outputOptions.hashSalt);
+                        }
+                        for (const content of assetsContent) {
+                            hash.update(content);
+                        }
+                        const digest = hash.digest(this._hashDigest);
+                        // @ts-ignore
+                        newHash = digest.slice(0, oldHash.length);
+                    }
+                    hashToNewHash.set(oldHash, newHash);
+                }
+                yield Promise.all(assetsWithInfo.map((asset) => __awaiter(this, void 0, void 0, function* () {
+                    yield computeNewContent(asset);
+                    const newName = asset.name.replace(hashRegExp, hash => hashToNewHash.get(hash));
+                    const infoUpdate = {};
+                    const hash = asset.info.contenthash;
+                    infoUpdate.contenthash = Array.isArray(hash)
+                        ? hash.map(hash => hashToNewHash.get(hash))
+                        : hashToNewHash.get(hash);
+                    if (asset.newSource !== undefined) {
+                        compilation.updateAsset(asset.name, asset.newSource, infoUpdate);
+                    }
+                    else {
+                        compilation.updateAsset(asset.name, asset.source, infoUpdate);
+                    }
+                    if (asset.name !== newName) {
+                        compilation.renameAsset(asset.name, newName);
+                    }
+                })));
+            }));
+        });
+    }
+}
+exports.default = RealContentHashPlugin;

package/dist/plugins/optimize/RemoveEmptyChunksPlugin.d.ts

@@ -0,0 +1,4 @@
+declare class RemoveEmptyChunksPlugin {
+    apply(compiler: any): void;
+}
+export default RemoveEmptyChunksPlugin;

package/dist/plugins/optimize/RemoveEmptyChunksPlugin.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const OptimizationStages_1 = require("@/plugins/optimize/OptimizationStages");
+class RemoveEmptyChunksPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap('RemoveEmptyChunksPlugin', compilation => {
+            const handler = chunks => {
+                const chunkGraph = compilation.chunkGraph;
+                for (const chunk of chunks) {
+                    if (chunkGraph.getNumberOfChunkModules(chunk) === 0 &&
+                        !chunk.hasRuntime() &&
+                        chunkGraph.getNumberOfEntryModules(chunk) === 0) {
+                        compilation.chunkGraph.disconnectChunk(chunk);
+                        compilation.chunks.delete(chunk);
+                    }
+                }
+            };
+            // TODO do it once
+            compilation.hooks.optimizeChunks.tap({
+                name: 'RemoveEmptyChunksPlugin',
+                stage: OptimizationStages_1.STAGE_BASIC,
+            }, handler);
+            compilation.hooks.optimizeChunks.tap({
+                name: 'RemoveEmptyChunksPlugin',
+                stage: OptimizationStages_1.STAGE_ADVANCED,
+            }, handler);
+        });
+    }
+}
+exports.default = RemoveEmptyChunksPlugin;

package/dist/plugins/optimize/RemoveParentModulesPlugin.d.ts

@@ -0,0 +1,4 @@
+declare class RemoveParentModulesPlugin {
+    apply(compiler: any): void;
+}
+export default RemoveParentModulesPlugin;

package/dist/plugins/optimize/RemoveParentModulesPlugin.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const OptimizationStages_1 = require("@/plugins/optimize/OptimizationStages");
+const Queue_1 = __importDefault(require("@/base/Queue"));
+const SetHelpers_1 = require("@/base/SetHelpers");
+class RemoveParentModulesPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap('RemoveParentModulesPlugin', compilation => {
+            const handler = (chunks, chunkGroups) => {
+                const chunkGraph = compilation.chunkGraph;
+                const queue = new Queue_1.default();
+                const availableModulesMap = new WeakMap();
+                for (const chunkGroup of compilation.entrypoints.values()) {
+                    // initialize available modules for chunks without parents
+                    availableModulesMap.set(chunkGroup, new Set());
+                    for (const child of chunkGroup.childrenIterable) {
+                        queue.enqueue(child);
+                    }
+                }
+                for (const chunkGroup of compilation.asyncEntrypoints) {
+                    // initialize available modules for chunks without parents
+                    availableModulesMap.set(chunkGroup, new Set());
+                    for (const child of chunkGroup.childrenIterable) {
+                        queue.enqueue(child);
+                    }
+                }
+                while (queue.length > 0) {
+                    const chunkGroup = queue.dequeue();
+                    let availableModules = availableModulesMap.get(chunkGroup);
+                    let changed = false;
+                    for (const parent of chunkGroup.parentsIterable) {
+                        const availableModulesInParent = availableModulesMap.get(parent);
+                        if (availableModulesInParent !== undefined) {
+                            // If we know the available modules in parent: process these
+                            if (availableModules === undefined) {
+                                // if we have not own info yet: create new entry
+                                availableModules = new Set(availableModulesInParent);
+                                for (const chunk of parent.chunks) {
+                                    for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
+                                        availableModules.add(m);
+                                    }
+                                }
+                                availableModulesMap.set(chunkGroup, availableModules);
+                                changed = true;
+                            }
+                            else {
+                                for (const m of availableModules) {
+                                    if (!chunkGraph.isModuleInChunkGroup(m, parent) &&
+                                        !availableModulesInParent.has(m)) {
+                                        availableModules.delete(m);
+                                        changed = true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (changed) {
+                        // if something changed: enqueue our children
+                        for (const child of chunkGroup.childrenIterable) {
+                            queue.enqueue(child);
+                        }
+                    }
+                }
+                // now we have available modules for every chunk
+                for (const chunk of chunks) {
+                    const availableModulesSets = Array.from(chunk.groupsIterable, chunkGroup => availableModulesMap.get(chunkGroup));
+                    if (availableModulesSets.some(s => s === undefined))
+                        continue; // No info about this chunk group
+                    const availableModules = availableModulesSets.length === 1
+                        ? availableModulesSets[0]
+                        : (0, SetHelpers_1.intersect)(availableModulesSets);
+                    const numberOfModules = chunkGraph.getNumberOfChunkModules(chunk);
+                    const toRemove = new Set();
+                    if (numberOfModules < availableModules.size) {
+                        for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
+                            if (availableModules.has(m)) {
+                                toRemove.add(m);
+                            }
+                        }
+                    }
+                    else {
+                        for (const m of availableModules) {
+                            if (chunkGraph.isModuleInChunk(m, chunk)) {
+                                toRemove.add(m);
+                            }
+                        }
+                    }
+                    for (const module of toRemove) {
+                        chunkGraph.disconnectChunkAndModule(chunk, module);
+                    }
+                }
+            };
+            compilation.hooks.optimizeChunks.tap({
+                name: 'RemoveParentModulesPlugin',
+                stage: OptimizationStages_1.STAGE_BASIC,
+            }, handler);
+        });
+    }
+}
+exports.default = RemoveParentModulesPlugin;

package/dist/plugins/optimize/RuntimeChunkPlugin.d.ts

@@ -0,0 +1,6 @@
+declare class RuntimeChunkPlugin {
+    options: any;
+    constructor(options: any);
+    apply(compiler: any): void;
+}
+export default RuntimeChunkPlugin;