xhs-mp-pack 1.1.0-beta.0

package/dist/chunk/ChunkGraph.js

@@ -0,0 +1,1037 @@
+"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 ModuleGraphConnection_1 = require("@/module/ModuleGraphConnection");
+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 findGraphRoots_1 = __importDefault(require("@/base/findGraphRoots"));
+const RuntimeHelpers_1 = require("@/module/RuntimeHelpers");
+const Entrypoint_1 = __importDefault(require("./Entrypoint"));
+const EMPTY_SET = new Set();
+const ZERO_BIG_INT = BigInt(0);
+const compareModuleIterables = (0, comparators_1.compareIterables)(comparators_1.compareModulesByIdentifier);
+class ModuleHashInfo {
+    constructor(hash, renderedHash) {
+        this.hash = hash;
+        this.renderedHash = renderedHash;
+    }
+}
+const getArray = set => Array.from(set);
+const getModuleRuntimes = chunks => {
+    const runtimes = new RuntimeHelpers_1.RuntimeSpecSet();
+    for (const chunk of chunks) {
+        runtimes.add(chunk.runtime);
+    }
+    return runtimes;
+};
+const modulesBySourceType = sourceTypesByModule => set => {
+    const map = new Map();
+    for (const module of set) {
+        const sourceTypes = (sourceTypesByModule === null || sourceTypesByModule === void 0 ? void 0 : sourceTypesByModule.get(module)) || module.getSourceTypes();
+        for (const sourceType of sourceTypes) {
+            let innerSet = map.get(sourceType);
+            if (innerSet === undefined) {
+                innerSet = new SortableSet_1.default();
+                map.set(sourceType, innerSet);
+            }
+            innerSet.add(module);
+        }
+    }
+    for (const [key, innerSet] of map) {
+        // When all modules have the source type, we reuse the original SortableSet
+        // to benefit from the shared cache (especially for sorting)
+        if (innerSet.size === set.size) {
+            map.set(key, set);
+        }
+    }
+    return map;
+};
+const defaultModulesBySourceType = modulesBySourceType(undefined);
+const createOrderedArrayFunctionMap = new WeakMap();
+const createOrderedArrayFunction = comparator => {
+    let fn = createOrderedArrayFunctionMap.get(comparator);
+    if (fn !== undefined)
+        return fn;
+    fn = set => {
+        set.sortWith(comparator);
+        return Array.from(set);
+    };
+    createOrderedArrayFunctionMap.set(comparator, fn);
+    return fn;
+};
+const getModulesSize = modules => {
+    let size = 0;
+    for (const module of modules) {
+        for (const type of module.getSourceTypes()) {
+            size += module.size(type);
+        }
+    }
+    return size;
+};
+const getModulesSizes = modules => {
+    const sizes = Object.create(null);
+    for (const module of modules) {
+        for (const type of module.getSourceTypes()) {
+            sizes[type] = (sizes[type] || 0) + module.size(type);
+        }
+    }
+    return sizes;
+};
+const isAvailableChunk = (a, b) => {
+    const queue = new Set(b.groupsIterable);
+    for (const chunkGroup of queue) {
+        if (a.isInGroup(chunkGroup))
+            continue;
+        if (chunkGroup.isInitial())
+            return false;
+        for (const parent of chunkGroup.parentsIterable) {
+            queue.add(parent);
+        }
+    }
+    return true;
+};
+class ChunkGraphModule {
+    constructor() {
+        this.chunks = new SortableSet_1.default();
+        this.entryInChunks = undefined;
+        this.runtimeInChunks = undefined;
+        this.hashes = undefined;
+        this.id = null;
+        this.runtimeRequirements = undefined;
+        this.graphHashes = undefined;
+        this.graphHashesWithConnections = undefined;
+    }
+}
+class ChunkGraphChunk {
+    constructor() {
+        this.modules = new SortableSet_1.default();
+        this.sourceTypesByModule = undefined;
+        this.entryModules = new Map();
+        this.runtimeModules = new SortableSet_1.default();
+        this.fullHashModules = undefined;
+        this.dependentHashModules = undefined;
+        this.runtimeRequirements = undefined;
+        this.runtimeRequirementsInTree = new Set();
+        this._modulesBySourceType = defaultModulesBySourceType;
+    }
+}
+class ChunkGraph {
+    constructor(moduleGraph, hashFunction = 'md4') {
+        this._modules = new WeakMap();
+        this._chunks = new WeakMap();
+        this._blockChunkGroups = new WeakMap();
+        this._runtimeIds = new Map();
+        this.moduleGraph = moduleGraph;
+        this._hashFunction = hashFunction;
+        this._getGraphRoots = this._getGraphRoots.bind(this);
+    }
+    _getChunkGraphModule(module) {
+        let cgm = this._modules.get(module);
+        if (cgm === undefined) {
+            cgm = new ChunkGraphModule();
+            this._modules.set(module, cgm);
+        }
+        return cgm;
+    }
+    _getChunkGraphChunk(chunk) {
+        let cgc = this._chunks.get(chunk);
+        if (cgc === undefined) {
+            cgc = new ChunkGraphChunk();
+            this._chunks.set(chunk, cgc);
+        }
+        return cgc;
+    }
+    _getGraphRoots(set) {
+        const { moduleGraph } = this;
+        return Array.from((0, findGraphRoots_1.default)(set, module => {
+            const set = new Set();
+            const addDependencies = module => {
+                for (const connection of moduleGraph.getOutgoingConnections(module)) {
+                    if (!connection.module)
+                        continue;
+                    const activeState = connection.getActiveState(undefined);
+                    if (activeState === false)
+                        continue;
+                    if (activeState === ModuleGraphConnection_1.TRANSITIVE_ONLY) {
+                        addDependencies(connection.module);
+                        continue;
+                    }
+                    set.add(connection.module);
+                }
+            };
+            addDependencies(module);
+            return set;
+        })).sort(comparators_1.compareModulesByIdentifier);
+    }
+    connectChunkAndModule(chunk, module) {
+        const cgm = this._getChunkGraphModule(module);
+        const cgc = this._getChunkGraphChunk(chunk);
+        cgm.chunks.add(chunk);
+        cgc.modules.add(module);
+    }
+    disconnectChunkAndModule(chunk, module) {
+        const cgm = this._getChunkGraphModule(module);
+        const cgc = this._getChunkGraphChunk(chunk);
+        cgc.modules.delete(module);
+        // No need to invalidate cgc._modulesBySourceType because we modified cgc.modules anyway
+        if (cgc.sourceTypesByModule)
+            cgc.sourceTypesByModule.delete(module);
+        cgm.chunks.delete(chunk);
+    }
+    disconnectChunk(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        for (const module of cgc.modules) {
+            const cgm = this._getChunkGraphModule(module);
+            cgm.chunks.delete(chunk);
+        }
+        cgc.modules.clear();
+        chunk.disconnectFromGroups();
+        ChunkGraph.clearChunkGraphForChunk(chunk);
+    }
+    attachModules(chunk, modules) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        for (const module of modules) {
+            cgc.modules.add(module);
+        }
+    }
+    attachRuntimeModules(chunk, modules) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        for (const module of modules) {
+            cgc.runtimeModules.add(module);
+        }
+    }
+    attachFullHashModules(chunk, modules) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        if (cgc.fullHashModules === undefined)
+            cgc.fullHashModules = new Set();
+        for (const module of modules) {
+            cgc.fullHashModules.add(module);
+        }
+    }
+    attachDependentHashModules(chunk, modules) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        if (cgc.dependentHashModules === undefined)
+            cgc.dependentHashModules = new Set();
+        for (const module of modules) {
+            cgc.dependentHashModules.add(module);
+        }
+    }
+    replaceModule(oldModule, newModule) {
+        var _a, _b;
+        const oldCgm = this._getChunkGraphModule(oldModule);
+        const newCgm = this._getChunkGraphModule(newModule);
+        for (const chunk of oldCgm.chunks) {
+            const cgc = this._getChunkGraphChunk(chunk);
+            cgc.modules.delete(oldModule);
+            cgc.modules.add(newModule);
+            newCgm.chunks.add(chunk);
+        }
+        oldCgm.chunks.clear();
+        if (oldCgm.entryInChunks !== undefined) {
+            if (newCgm.entryInChunks === undefined) {
+                newCgm.entryInChunks = new Set();
+            }
+            for (const chunk of oldCgm.entryInChunks) {
+                const cgc = this._getChunkGraphChunk(chunk);
+                const old = cgc.entryModules.get(oldModule);
+                const newEntryModules = new Map();
+                for (const [m, cg] of cgc.entryModules) {
+                    if (m === oldModule) {
+                        newEntryModules.set(newModule, old);
+                    }
+                    else {
+                        newEntryModules.set(m, cg);
+                    }
+                }
+                cgc.entryModules = newEntryModules;
+                newCgm.entryInChunks.add(chunk);
+            }
+            oldCgm.entryInChunks = undefined;
+        }
+        if (oldCgm.runtimeInChunks !== undefined) {
+            if (newCgm.runtimeInChunks === undefined) {
+                newCgm.runtimeInChunks = new Set();
+            }
+            for (const chunk of oldCgm.runtimeInChunks) {
+                const cgc = this._getChunkGraphChunk(chunk);
+                cgc.runtimeModules.delete(oldModule);
+                cgc.runtimeModules.add(newModule);
+                newCgm.runtimeInChunks.add(chunk);
+                if ((_a = cgc.fullHashModules) === null || _a === void 0 ? void 0 : _a.has(oldModule)) {
+                    cgc.fullHashModules.delete(oldModule);
+                    cgc.fullHashModules.add(newModule);
+                }
+                if ((_b = cgc.dependentHashModules) === null || _b === void 0 ? void 0 : _b.has(oldModule)) {
+                    cgc.dependentHashModules.delete(oldModule);
+                    cgc.dependentHashModules.add(newModule);
+                }
+            }
+            oldCgm.runtimeInChunks = undefined;
+        }
+    }
+    isModuleInChunk(module, chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.modules.has(module);
+    }
+    isModuleInChunkGroup(module, chunkGroup) {
+        for (const chunk of chunkGroup.chunks) {
+            if (this.isModuleInChunk(module, chunk))
+                return true;
+        }
+        return false;
+    }
+    isEntryModule(module) {
+        const cgm = this._getChunkGraphModule(module);
+        return cgm.entryInChunks !== undefined;
+    }
+    getModuleChunksIterable(module) {
+        const cgm = this._getChunkGraphModule(module);
+        return cgm.chunks;
+    }
+    getOrderedModuleChunksIterable(module, sortFn) {
+        const cgm = this._getChunkGraphModule(module);
+        cgm.chunks.sortWith(sortFn);
+        return cgm.chunks;
+    }
+    getModuleChunks(module) {
+        const cgm = this._getChunkGraphModule(module);
+        return cgm.chunks.getFromCache(getArray);
+    }
+    getNumberOfModuleChunks(module) {
+        const cgm = this._getChunkGraphModule(module);
+        return cgm.chunks.size;
+    }
+    getModuleRuntimes(module) {
+        const cgm = this._getChunkGraphModule(module);
+        return cgm.chunks.getFromUnorderedCache(getModuleRuntimes);
+    }
+    getNumberOfChunkModules(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.modules.size;
+    }
+    getNumberOfChunkFullHashModules(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.fullHashModules === undefined ? 0 : cgc.fullHashModules.size;
+    }
+    getChunkModulesIterable(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.modules;
+    }
+    getChunkModulesIterableBySourceType(chunk, sourceType) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        const modulesWithSourceType = cgc.modules
+            .getFromUnorderedCache(cgc._modulesBySourceType)
+            .get(sourceType);
+        return modulesWithSourceType;
+    }
+    setChunkModuleSourceTypes(chunk, module, sourceTypes) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        if (cgc.sourceTypesByModule === undefined) {
+            cgc.sourceTypesByModule = new WeakMap();
+        }
+        cgc.sourceTypesByModule.set(module, sourceTypes);
+        // Update cgc._modulesBySourceType to invalidate the cache
+        cgc._modulesBySourceType = modulesBySourceType(cgc.sourceTypesByModule);
+    }
+    getChunkModuleSourceTypes(chunk, module) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        if (cgc.sourceTypesByModule === undefined) {
+            return module.getSourceTypes();
+        }
+        return cgc.sourceTypesByModule.get(module) || module.getSourceTypes();
+    }
+    getModuleSourceTypes(module) {
+        return this._getOverwrittenModuleSourceTypes(module) || module.getSourceTypes();
+    }
+    _getOverwrittenModuleSourceTypes(module) {
+        let newSet = false;
+        let sourceTypes;
+        for (const chunk of this.getModuleChunksIterable(module)) {
+            const cgc = this._getChunkGraphChunk(chunk);
+            if (cgc.sourceTypesByModule === undefined)
+                return;
+            const st = cgc.sourceTypesByModule.get(module);
+            if (st === undefined)
+                return;
+            if (!sourceTypes) {
+                sourceTypes = st;
+                continue;
+            }
+            else if (!newSet) {
+                for (const type of st) {
+                    if (!newSet) {
+                        if (!sourceTypes.has(type)) {
+                            newSet = true;
+                            sourceTypes = new Set(sourceTypes);
+                            sourceTypes.add(type);
+                        }
+                    }
+                    else {
+                        sourceTypes.add(type);
+                    }
+                }
+            }
+            else {
+                for (const type of st)
+                    sourceTypes.add(type);
+            }
+        }
+        return sourceTypes;
+    }
+    getOrderedChunkModulesIterable(chunk, comparator) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        cgc.modules.sortWith(comparator);
+        return cgc.modules;
+    }
+    getOrderedChunkModulesIterableBySourceType(chunk, sourceType, comparator) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        const modulesWithSourceType = cgc.modules
+            .getFromUnorderedCache(cgc._modulesBySourceType)
+            .get(sourceType);
+        if (modulesWithSourceType === undefined)
+            return undefined;
+        modulesWithSourceType.sortWith(comparator);
+        return modulesWithSourceType;
+    }
+    getChunkModules(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.modules.getFromUnorderedCache(getArray);
+    }
+    getOrderedChunkModules(chunk, comparator) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        const arrayFunction = createOrderedArrayFunction(comparator);
+        return cgc.modules.getFromUnorderedCache(arrayFunction);
+    }
+    getChunkModuleIdMap(chunk, filterFn, includeAllChunks = false) {
+        const chunkModuleIdMap = Object.create(null);
+        for (const asyncChunk of includeAllChunks
+            ? chunk.getAllReferencedChunks()
+            : chunk.getAllAsyncChunks()) {
+            let array;
+            for (const module of this.getOrderedChunkModulesIterable(asyncChunk, (0, comparators_1.compareModulesById)(this))) {
+                if (filterFn(module)) {
+                    if (array === undefined) {
+                        array = [];
+                        chunkModuleIdMap[asyncChunk.id] = array;
+                    }
+                    const moduleId = this.getModuleId(module);
+                    array.push(moduleId);
+                }
+            }
+        }
+        return chunkModuleIdMap;
+    }
+    getChunkModuleRenderedHashMap(chunk, filterFn, hashLength = 0, includeAllChunks = false) {
+        const chunkModuleHashMap = Object.create(null);
+        for (const asyncChunk of includeAllChunks
+            ? chunk.getAllReferencedChunks()
+            : chunk.getAllAsyncChunks()) {
+            let idToHashMap;
+            for (const module of this.getOrderedChunkModulesIterable(asyncChunk, (0, comparators_1.compareModulesById)(this))) {
+                if (filterFn(module)) {
+                    if (idToHashMap === undefined) {
+                        idToHashMap = Object.create(null);
+                        chunkModuleHashMap[asyncChunk.id] = idToHashMap;
+                    }
+                    const moduleId = this.getModuleId(module);
+                    const hash = this.getRenderedModuleHash(module, asyncChunk.runtime);
+                    idToHashMap[moduleId] = hashLength ? hash.slice(0, hashLength) : hash;
+                }
+            }
+        }
+        return chunkModuleHashMap;
+    }
+    getChunkConditionMap(chunk, filterFn) {
+        const map = Object.create(null);
+        for (const c of chunk.getAllReferencedChunks()) {
+            map[c.id] = filterFn(c, this);
+        }
+        return map;
+    }
+    hasModuleInGraph(chunk, filterFn, filterChunkFn) {
+        const queue = new Set(chunk.groupsIterable);
+        const chunksProcessed = new Set();
+        for (const chunkGroup of queue) {
+            for (const innerChunk of chunkGroup.chunks) {
+                if (!chunksProcessed.has(innerChunk)) {
+                    chunksProcessed.add(innerChunk);
+                    if (!filterChunkFn || filterChunkFn(innerChunk, this)) {
+                        for (const module of this.getChunkModulesIterable(innerChunk)) {
+                            if (filterFn(module)) {
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+            for (const child of chunkGroup.childrenIterable) {
+                queue.add(child);
+            }
+        }
+        return false;
+    }
+    compareChunks(chunkA, chunkB) {
+        const cgcA = this._getChunkGraphChunk(chunkA);
+        const cgcB = this._getChunkGraphChunk(chunkB);
+        if (cgcA.modules.size > cgcB.modules.size)
+            return -1;
+        if (cgcA.modules.size < cgcB.modules.size)
+            return 1;
+        cgcA.modules.sortWith(comparators_1.compareModulesByIdentifier);
+        cgcB.modules.sortWith(comparators_1.compareModulesByIdentifier);
+        return compareModuleIterables(cgcA.modules, cgcB.modules);
+    }
+    getChunkModulesSize(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.modules.getFromUnorderedCache(getModulesSize);
+    }
+    getChunkModulesSizes(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.modules.getFromUnorderedCache(getModulesSizes);
+    }
+    getChunkRootModules(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.modules.getFromUnorderedCache(this._getGraphRoots);
+    }
+    getChunkSize(chunk, options = {}) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        const modulesSize = cgc.modules.getFromUnorderedCache(getModulesSize);
+        const chunkOverhead = typeof options.chunkOverhead === 'number' ? options.chunkOverhead : 10000;
+        const entryChunkMultiplicator = typeof options.entryChunkMultiplicator === 'number' ? options.entryChunkMultiplicator : 10;
+        return chunkOverhead + modulesSize * (chunk.canBeInitial() ? entryChunkMultiplicator : 1);
+    }
+    getIntegratedChunksSize(chunkA, chunkB, options = {}) {
+        const cgcA = this._getChunkGraphChunk(chunkA);
+        const cgcB = this._getChunkGraphChunk(chunkB);
+        const allModules = new Set(cgcA.modules);
+        for (const m of cgcB.modules)
+            allModules.add(m);
+        const modulesSize = getModulesSize(allModules);
+        const chunkOverhead = typeof options.chunkOverhead === 'number' ? options.chunkOverhead : 10000;
+        const entryChunkMultiplicator = typeof options.entryChunkMultiplicator === 'number' ? options.entryChunkMultiplicator : 10;
+        return (chunkOverhead +
+            modulesSize * (chunkA.canBeInitial() || chunkB.canBeInitial() ? entryChunkMultiplicator : 1));
+    }
+    canChunksBeIntegrated(chunkA, chunkB) {
+        if (chunkA.preventIntegration || chunkB.preventIntegration) {
+            return false;
+        }
+        const hasRuntimeA = chunkA.hasRuntime();
+        const hasRuntimeB = chunkB.hasRuntime();
+        if (hasRuntimeA !== hasRuntimeB) {
+            if (hasRuntimeA) {
+                return isAvailableChunk(chunkA, chunkB);
+            }
+            if (hasRuntimeB) {
+                return isAvailableChunk(chunkB, chunkA);
+            }
+            return false;
+        }
+        if (this.getNumberOfEntryModules(chunkA) > 0 || this.getNumberOfEntryModules(chunkB) > 0) {
+            return false;
+        }
+        return true;
+    }
+    integrateChunks(chunkA, chunkB) {
+        // Decide for one name (deterministic)
+        if (chunkA.name && chunkB.name) {
+            if (this.getNumberOfEntryModules(chunkA) > 0 === this.getNumberOfEntryModules(chunkB) > 0) {
+                // When both chunks have entry modules or none have one, use
+                // shortest name
+                if (chunkA.name.length !== chunkB.name.length) {
+                    chunkA.name = chunkA.name.length < chunkB.name.length ? chunkA.name : chunkB.name;
+                }
+                else {
+                    chunkA.name = chunkA.name < chunkB.name ? chunkA.name : chunkB.name;
+                }
+            }
+            else if (this.getNumberOfEntryModules(chunkB) > 0) {
+                // Pick the name of the chunk with the entry module
+                chunkA.name = chunkB.name;
+            }
+        }
+        else if (chunkB.name) {
+            chunkA.name = chunkB.name;
+        }
+        // Merge id name hints
+        for (const hint of chunkB.idNameHints) {
+            chunkA.idNameHints.add(hint);
+        }
+        // Merge runtime
+        chunkA.runtime = (0, RuntimeHelpers_1.mergeRuntime)(chunkA.runtime, chunkB.runtime);
+        // getChunkModules is used here to create a clone, because disconnectChunkAndModule modifies
+        for (const module of this.getChunkModules(chunkB)) {
+            this.disconnectChunkAndModule(chunkB, module);
+            this.connectChunkAndModule(chunkA, module);
+        }
+        for (const [module, chunkGroup] of Array.from(this.getChunkEntryModulesWithChunkGroupIterable(chunkB))) {
+            this.disconnectChunkAndEntryModule(chunkB, module);
+            this.connectChunkAndEntryModule(chunkA, module, chunkGroup);
+        }
+        for (const chunkGroup of chunkB.groupsIterable) {
+            chunkGroup.replaceChunk(chunkB, chunkA);
+            chunkA.addGroup(chunkGroup);
+            chunkB.removeGroup(chunkGroup);
+        }
+        ChunkGraph.clearChunkGraphForChunk(chunkB);
+    }
+    upgradeDependentToFullHashModules(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        if (cgc.dependentHashModules === undefined)
+            return;
+        if (cgc.fullHashModules === undefined) {
+            cgc.fullHashModules = cgc.dependentHashModules;
+        }
+        else {
+            for (const m of cgc.dependentHashModules) {
+                cgc.fullHashModules.add(m);
+            }
+            cgc.dependentHashModules = undefined;
+        }
+    }
+    isEntryModuleInChunk(module, chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.entryModules.has(module);
+    }
+    connectChunkAndEntryModule(chunk, module, entrypoint) {
+        const cgm = this._getChunkGraphModule(module);
+        const cgc = this._getChunkGraphChunk(chunk);
+        if (cgm.entryInChunks === undefined) {
+            cgm.entryInChunks = new Set();
+        }
+        cgm.entryInChunks.add(chunk);
+        cgc.entryModules.set(module, entrypoint);
+    }
+    connectChunkAndRuntimeModule(chunk, module) {
+        const cgm = this._getChunkGraphModule(module);
+        const cgc = this._getChunkGraphChunk(chunk);
+        if (cgm.runtimeInChunks === undefined) {
+            cgm.runtimeInChunks = new Set();
+        }
+        cgm.runtimeInChunks.add(chunk);
+        cgc.runtimeModules.add(module);
+    }
+    addFullHashModuleToChunk(chunk, module) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        if (cgc.fullHashModules === undefined)
+            cgc.fullHashModules = new Set();
+        cgc.fullHashModules.add(module);
+    }
+    addDependentHashModuleToChunk(chunk, module) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        if (cgc.dependentHashModules === undefined)
+            cgc.dependentHashModules = new Set();
+        cgc.dependentHashModules.add(module);
+    }
+    disconnectChunkAndEntryModule(chunk, module) {
+        const cgm = this._getChunkGraphModule(module);
+        const cgc = this._getChunkGraphChunk(chunk);
+        cgm.entryInChunks.delete(chunk);
+        if (cgm.entryInChunks.size === 0) {
+            cgm.entryInChunks = undefined;
+        }
+        cgc.entryModules.delete(module);
+    }
+    disconnectChunkAndRuntimeModule(chunk, module) {
+        const cgm = this._getChunkGraphModule(module);
+        const cgc = this._getChunkGraphChunk(chunk);
+        cgm.runtimeInChunks.delete(chunk);
+        if (cgm.runtimeInChunks.size === 0) {
+            cgm.runtimeInChunks = undefined;
+        }
+        cgc.runtimeModules.delete(module);
+    }
+    disconnectEntryModule(module) {
+        const cgm = this._getChunkGraphModule(module);
+        for (const chunk of cgm.entryInChunks) {
+            const cgc = this._getChunkGraphChunk(chunk);
+            cgc.entryModules.delete(module);
+        }
+        cgm.entryInChunks = undefined;
+    }
+    disconnectEntries(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        for (const module of cgc.entryModules.keys()) {
+            const cgm = this._getChunkGraphModule(module);
+            cgm.entryInChunks.delete(chunk);
+            if (cgm.entryInChunks.size === 0) {
+                cgm.entryInChunks = undefined;
+            }
+        }
+        cgc.entryModules.clear();
+    }
+    getNumberOfEntryModules(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.entryModules.size;
+    }
+    getNumberOfRuntimeModules(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.runtimeModules.size;
+    }
+    getChunkEntryModulesIterable(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.entryModules.keys();
+    }
+    getChunkEntryDependentChunksIterable(chunk) {
+        const set = new Set();
+        for (const chunkGroup of chunk.groupsIterable) {
+            if (chunkGroup instanceof Entrypoint_1.default) {
+                const entrypointChunk = chunkGroup.getEntrypointChunk();
+                const cgc = this._getChunkGraphChunk(entrypointChunk);
+                for (const chunkGroup of cgc.entryModules.values()) {
+                    for (const c of chunkGroup.chunks) {
+                        if (c !== chunk && c !== entrypointChunk && !c.hasRuntime()) {
+                            set.add(c);
+                        }
+                    }
+                }
+            }
+        }
+        return set;
+    }
+    hasChunkEntryDependentChunks(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        for (const chunkGroup of cgc.entryModules.values()) {
+            for (const c of chunkGroup.chunks) {
+                if (c !== chunk) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    getChunkRuntimeModulesIterable(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.runtimeModules;
+    }
+    getChunkRuntimeModulesInOrder(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        const array = Array.from(cgc.runtimeModules);
+        array.sort((0, comparators_1.concatComparators)((0, comparators_1.compareSelect)(r => r.stage, comparators_1.compareIds), comparators_1.compareModulesByIdentifier));
+        return array;
+    }
+    getChunkFullHashModulesIterable(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.fullHashModules;
+    }
+    getChunkFullHashModulesSet(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.fullHashModules;
+    }
+    getChunkDependentHashModulesIterable(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.dependentHashModules;
+    }
+    getChunkEntryModulesWithChunkGroupIterable(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.entryModules;
+    }
+    getBlockChunkGroup(depBlock) {
+        return this._blockChunkGroups.get(depBlock);
+    }
+    connectBlockAndChunkGroup(depBlock, chunkGroup) {
+        this._blockChunkGroups.set(depBlock, chunkGroup);
+        chunkGroup.addBlock(depBlock);
+    }
+    disconnectChunkGroup(chunkGroup) {
+        for (const block of chunkGroup.blocksIterable) {
+            this._blockChunkGroups.delete(block);
+        }
+        // TODO refactor by moving blocks list into ChunkGraph
+        chunkGroup._blocks.clear();
+    }
+    getModuleId(module) {
+        const cgm = this._getChunkGraphModule(module);
+        return cgm.id;
+    }
+    setModuleId(module, id) {
+        const cgm = this._getChunkGraphModule(module);
+        cgm.id = id;
+    }
+    getRuntimeId(runtime) {
+        return this._runtimeIds.get(runtime);
+    }
+    setRuntimeId(runtime, id) {
+        this._runtimeIds.set(runtime, id);
+    }
+    _getModuleHashInfo(module, hashes, runtime) {
+        if (!hashes) {
+            throw new Error(`Module ${module.identifier()} has no hash info for runtime ${(0, RuntimeHelpers_1.runtimeToString)(runtime)} (hashes not set at all)`);
+        }
+        else if (runtime === undefined) {
+            const hashInfoItems = new Set(hashes.values());
+            if (hashInfoItems.size !== 1) {
+                throw new Error(`No unique hash info entry for unspecified runtime for ${module.identifier()} (existing runtimes: ${Array.from(hashes.keys(), r => (0, RuntimeHelpers_1.runtimeToString)(r)).join(', ')}).
+Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").`);
+            }
+            return (0, SetHelpers_1.first)(hashInfoItems);
+        }
+        else {
+            const hashInfo = hashes.get(runtime);
+            if (!hashInfo) {
+                throw new Error(`Module ${module.identifier()} has no hash info for runtime ${(0, RuntimeHelpers_1.runtimeToString)(runtime)} (available runtimes ${Array.from(hashes.keys(), RuntimeHelpers_1.runtimeToString).join(', ')})`);
+            }
+            return hashInfo;
+        }
+    }
+    hasModuleHashes(module, runtime) {
+        const cgm = this._getChunkGraphModule(module);
+        const hashes = cgm.hashes;
+        return hashes === null || hashes === void 0 ? void 0 : hashes.has(runtime);
+    }
+    getModuleHash(module, runtime) {
+        const cgm = this._getChunkGraphModule(module);
+        const hashes = cgm.hashes;
+        return this._getModuleHashInfo(module, hashes, runtime).hash;
+    }
+    getRenderedModuleHash(module, runtime) {
+        const cgm = this._getChunkGraphModule(module);
+        const hashes = cgm.hashes;
+        return this._getModuleHashInfo(module, hashes, runtime).renderedHash;
+    }
+    setModuleHashes(module, runtime, hash, renderedHash) {
+        const cgm = this._getChunkGraphModule(module);
+        if (cgm.hashes === undefined) {
+            cgm.hashes = new RuntimeHelpers_1.RuntimeSpecMap();
+        }
+        cgm.hashes.set(runtime, new ModuleHashInfo(hash, renderedHash));
+    }
+    addModuleRuntimeRequirements(module, runtime, items, transferOwnership = true) {
+        const cgm = this._getChunkGraphModule(module);
+        const runtimeRequirementsMap = cgm.runtimeRequirements;
+        if (runtimeRequirementsMap === undefined) {
+            const map = new RuntimeHelpers_1.RuntimeSpecMap();
+            // TODO avoid cloning item and track ownership instead
+            map.set(runtime, transferOwnership ? items : new Set(items));
+            cgm.runtimeRequirements = map;
+            return;
+        }
+        runtimeRequirementsMap.update(runtime, runtimeRequirements => {
+            if (runtimeRequirements === undefined) {
+                return transferOwnership ? items : new Set(items);
+            }
+            if (!transferOwnership || runtimeRequirements.size >= items.size) {
+                for (const item of items)
+                    runtimeRequirements.add(item);
+                return runtimeRequirements;
+            }
+            for (const item of runtimeRequirements)
+                items.add(item);
+            return items;
+        });
+    }
+    addChunkRuntimeRequirements(chunk, items) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        const runtimeRequirements = cgc.runtimeRequirements;
+        if (runtimeRequirements === undefined) {
+            cgc.runtimeRequirements = items;
+        }
+        else if (runtimeRequirements.size >= items.size) {
+            for (const item of items)
+                runtimeRequirements.add(item);
+        }
+        else {
+            for (const item of runtimeRequirements)
+                items.add(item);
+            cgc.runtimeRequirements = items;
+        }
+    }
+    addTreeRuntimeRequirements(chunk, items) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        const runtimeRequirements = cgc.runtimeRequirementsInTree;
+        for (const item of items)
+            runtimeRequirements.add(item);
+    }
+    getModuleRuntimeRequirements(module, runtime) {
+        var _a;
+        const cgm = this._getChunkGraphModule(module);
+        const runtimeRequirements = (_a = cgm.runtimeRequirements) === null || _a === void 0 ? void 0 : _a.get(runtime);
+        return runtimeRequirements === undefined ? EMPTY_SET : runtimeRequirements;
+    }
+    getChunkRuntimeRequirements(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        const runtimeRequirements = cgc.runtimeRequirements;
+        return runtimeRequirements === undefined ? EMPTY_SET : runtimeRequirements;
+    }
+    getModuleGraphHash(module, runtime, withConnections = true) {
+        const cgm = this._getChunkGraphModule(module);
+        return withConnections
+            ? this._getModuleGraphHashWithConnections(cgm, module, runtime)
+            : this._getModuleGraphHashBigInt(cgm, module, runtime).toString(16);
+    }
+    getModuleGraphHashBigInt(module, runtime, withConnections = true) {
+        const cgm = this._getChunkGraphModule(module);
+        return withConnections
+            ? BigInt(`0x${this._getModuleGraphHashWithConnections(cgm, module, runtime)}`)
+            : this._getModuleGraphHashBigInt(cgm, module, runtime);
+    }
+    _getModuleGraphHashBigInt(cgm, module, runtime) {
+        if (cgm.graphHashes === undefined) {
+            cgm.graphHashes = new RuntimeHelpers_1.RuntimeSpecMap();
+        }
+        const graphHash = cgm.graphHashes.provide(runtime, () => {
+            const hash = (0, createHash_1.default)(this._hashFunction);
+            hash.update(`${cgm.id}${this.moduleGraph.isAsync(module)}`);
+            const sourceTypes = this._getOverwrittenModuleSourceTypes(module);
+            if (sourceTypes !== undefined) {
+                for (const type of sourceTypes)
+                    hash.update(type);
+            }
+            this.moduleGraph.getExportsInfo(module).updateHash(hash, runtime);
+            return BigInt(`0x${hash.digest('hex')}`);
+        });
+        return graphHash;
+    }
+    _getModuleGraphHashWithConnections(cgm, module, runtime) {
+        var _a;
+        if (cgm.graphHashesWithConnections === undefined) {
+            cgm.graphHashesWithConnections = new RuntimeHelpers_1.RuntimeSpecMap();
+        }
+        const activeStateToString = state => {
+            if (state === false)
+                return 'F';
+            if (state === true)
+                return 'T';
+            if (state === ModuleGraphConnection_1.TRANSITIVE_ONLY)
+                return 'O';
+            throw new Error('Not implemented active state');
+        };
+        const strict = (_a = module.buildMeta) === null || _a === void 0 ? void 0 : _a.strictHarmonyModule;
+        return cgm.graphHashesWithConnections.provide(runtime, () => {
+            const graphHash = this._getModuleGraphHashBigInt(cgm, module, runtime).toString(16);
+            const connections = this.moduleGraph.getOutgoingConnections(module);
+            const activeNamespaceModules = new Set();
+            const connectedModules = new Map();
+            const processConnection = (connection, stateInfo) => {
+                const module = connection.module;
+                stateInfo += module.getExportsType(this.moduleGraph, strict);
+                // cspell:word Tnamespace
+                if (stateInfo === 'Tnamespace')
+                    activeNamespaceModules.add(module);
+                else {
+                    const oldModule = connectedModules.get(stateInfo);
+                    if (oldModule === undefined) {
+                        connectedModules.set(stateInfo, module);
+                    }
+                    else if (oldModule instanceof Set) {
+                        oldModule.add(module);
+                    }
+                    else if (oldModule !== module) {
+                        connectedModules.set(stateInfo, new Set([oldModule, module]));
+                    }
+                }
+            };
+            if (runtime === undefined || typeof runtime === 'string') {
+                for (const connection of connections) {
+                    const state = connection.getActiveState(runtime);
+                    if (state === false)
+                        continue;
+                    processConnection(connection, state === true ? 'T' : 'O');
+                }
+            }
+            else {
+                // cspell:word Tnamespace
+                for (const connection of connections) {
+                    const states = new Set();
+                    let stateInfo = '';
+                    (0, RuntimeHelpers_1.forEachRuntime)(runtime, runtime => {
+                        const state = connection.getActiveState(runtime);
+                        states.add(state);
+                        stateInfo += activeStateToString(state) + runtime;
+                    }, true);
+                    if (states.size === 1) {
+                        const state = (0, SetHelpers_1.first)(states);
+                        if (state === false)
+                            continue;
+                        stateInfo = activeStateToString(state);
+                    }
+                    processConnection(connection, stateInfo);
+                }
+            }
+            // cspell:word Tnamespace
+            if (activeNamespaceModules.size === 0 && connectedModules.size === 0)
+                return graphHash;
+            const connectedModulesInOrder = connectedModules.size > 1
+                ? Array.from(connectedModules).sort(([a], [b]) => (a < b ? -1 : 1))
+                : connectedModules;
+            const hash = (0, createHash_1.default)(this._hashFunction);
+            const addModuleToHash = module => {
+                hash.update(this._getModuleGraphHashBigInt(this._getChunkGraphModule(module), module, runtime).toString(16));
+            };
+            const addModulesToHash = modules => {
+                let xor = ZERO_BIG_INT;
+                for (const m of modules) {
+                    xor ^= this._getModuleGraphHashBigInt(this._getChunkGraphModule(m), m, runtime);
+                }
+                hash.update(xor.toString(16));
+            };
+            if (activeNamespaceModules.size === 1)
+                addModuleToHash(activeNamespaceModules.values().next().value);
+            else if (activeNamespaceModules.size > 1)
+                addModulesToHash(activeNamespaceModules);
+            for (const [stateInfo, modules] of connectedModulesInOrder) {
+                hash.update(stateInfo);
+                if (modules instanceof Set) {
+                    addModulesToHash(modules);
+                }
+                else {
+                    addModuleToHash(modules);
+                }
+            }
+            hash.update(graphHash);
+            return hash.digest('hex');
+        });
+    }
+    getTreeRuntimeRequirements(chunk) {
+        const cgc = this._getChunkGraphChunk(chunk);
+        return cgc.runtimeRequirementsInTree;
+    }
+    static getChunkGraphForModule(module, deprecateMessage, deprecationCode) {
+        const fn = deprecateGetChunkGraphForModuleMap.get(deprecateMessage);
+        if (fn)
+            return fn(module);
+        const newFn = util_1.default.deprecate(module => {
+            const chunkGraph = chunkGraphForModuleMap.get(module);
+            if (!chunkGraph)
+                throw new Error(`${deprecateMessage}: There was no ChunkGraph assigned to the Module for backward-compat (Use the new API)`);
+            return chunkGraph;
+        }, `${deprecateMessage}: Use new ChunkGraph API`, deprecationCode);
+        deprecateGetChunkGraphForModuleMap.set(deprecateMessage, newFn);
+        return newFn(module);
+    }
+    static setChunkGraphForModule(module, chunkGraph) {
+        chunkGraphForModuleMap.set(module, chunkGraph);
+    }
+    static clearChunkGraphForModule(module) {
+        chunkGraphForModuleMap.delete(module);
+    }
+    static getChunkGraphForChunk(chunk, deprecateMessage, deprecationCode) {
+        const fn = deprecateGetChunkGraphForChunkMap.get(deprecateMessage);
+        if (fn)
+            return fn(chunk);
+        const newFn = util_1.default.deprecate(chunk => {
+            const chunkGraph = chunkGraphForChunkMap.get(chunk);
+            if (!chunkGraph)
+                throw new Error(`${deprecateMessage}There was no ChunkGraph assigned to the Chunk for backward-compat (Use the new API)`);
+            return chunkGraph;
+        }, `${deprecateMessage}: Use new ChunkGraph API`, deprecationCode);
+        deprecateGetChunkGraphForChunkMap.set(deprecateMessage, newFn);
+        return newFn(chunk);
+    }
+    static setChunkGraphForChunk(chunk, chunkGraph) {
+        chunkGraphForChunkMap.set(chunk, chunkGraph);
+    }
+    static clearChunkGraphForChunk(chunk) {
+        chunkGraphForChunkMap.delete(chunk);
+    }
+}
+const chunkGraphForModuleMap = new WeakMap();
+const chunkGraphForChunkMap = new WeakMap();
+const deprecateGetChunkGraphForModuleMap = new Map();
+const deprecateGetChunkGraphForChunkMap = new Map();
+exports.default = ChunkGraph;