xhs-mp-pack 1.1.0-beta.0

package/dist/chunk/Chunk.js

@@ -0,0 +1,445 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ChunkGraph_1 = __importDefault(require("@/chunk/ChunkGraph"));
+const SetHelpers_1 = require("@/base/SetHelpers");
+const SortableSet_1 = __importDefault(require("@/base/SortableSet"));
+const StringXor_1 = __importDefault(require("@/base/StringXor"));
+const comparators_1 = require("@/base/comparators");
+const deprecation_1 = require("@/base/deprecation");
+const RuntimeHelpers_1 = require("@/module/RuntimeHelpers");
+const Entrypoint_1 = __importDefault(require("./Entrypoint"));
+const ChunkFilesSet = (0, deprecation_1.createArrayToSetDeprecationSet)('chunk.files');
+let debugId = 1000;
+/**
+ * A Chunk is a unit of encapsulation for Modules.
+ * Chunks are "rendered" into bundles that get emitted when the build completes.
+ */
+class Chunk {
+    constructor(name, backCompat = true) {
+        this.id = null;
+        this.ids = null;
+        this.debugId = debugId++;
+        this.name = name;
+        this.idNameHints = new SortableSet_1.default();
+        this.preventIntegration = false;
+        this.filenameTemplate = undefined;
+        this.cssFilenameTemplate = undefined;
+        this._groups = new SortableSet_1.default(undefined, comparators_1.compareChunkGroupsByIndex);
+        this.runtime = undefined;
+        this.files = backCompat ? new ChunkFilesSet() : new Set();
+        this.auxiliaryFiles = new Set();
+        this.rendered = false;
+        this.hash = undefined;
+        this.contentHash = Object.create(null);
+        this.renderedHash = undefined;
+        this.chunkReason = undefined;
+        this.extraAsync = false;
+    }
+    // TODO remove in webpack 6
+    // BACKWARD-COMPAT START
+    get entryModule() {
+        const entryModules = Array.from(ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.entryModule', 'DEP_WEBPACK_CHUNK_ENTRY_MODULE').getChunkEntryModulesIterable(this));
+        if (entryModules.length === 0) {
+            return undefined;
+        }
+        if (entryModules.length === 1) {
+            return entryModules[0];
+        }
+        throw new Error('Module.entryModule: Multiple entry modules are not supported by the deprecated API (Use the new ChunkGroup API)');
+    }
+    hasEntryModule() {
+        return (ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.hasEntryModule', 'DEP_WEBPACK_CHUNK_HAS_ENTRY_MODULE').getNumberOfEntryModules(this) > 0);
+    }
+    addModule(module) {
+        const chunkGraph = ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.addModule', 'DEP_WEBPACK_CHUNK_ADD_MODULE');
+        if (chunkGraph.isModuleInChunk(module, this))
+            return false;
+        chunkGraph.connectChunkAndModule(this, module);
+        return true;
+    }
+    removeModule(module) {
+        ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.removeModule', 'DEP_WEBPACK_CHUNK_REMOVE_MODULE').disconnectChunkAndModule(this, module);
+    }
+    getNumberOfModules() {
+        return ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.getNumberOfModules', 'DEP_WEBPACK_CHUNK_GET_NUMBER_OF_MODULES').getNumberOfChunkModules(this);
+    }
+    get modulesIterable() {
+        const chunkGraph = ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.modulesIterable', 'DEP_WEBPACK_CHUNK_MODULES_ITERABLE');
+        return chunkGraph.getOrderedChunkModulesIterable(this, comparators_1.compareModulesByIdentifier);
+    }
+    compareTo(otherChunk) {
+        const chunkGraph = ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.compareTo', 'DEP_WEBPACK_CHUNK_COMPARE_TO');
+        return chunkGraph.compareChunks(this, otherChunk);
+    }
+    containsModule(module) {
+        return ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.containsModule', 'DEP_WEBPACK_CHUNK_CONTAINS_MODULE').isModuleInChunk(module, this);
+    }
+    getModules() {
+        return ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.getModules', 'DEP_WEBPACK_CHUNK_GET_MODULES').getChunkModules(this);
+    }
+    remove() {
+        const chunkGraph = ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.remove', 'DEP_WEBPACK_CHUNK_REMOVE');
+        chunkGraph.disconnectChunk(this);
+        this.disconnectFromGroups();
+    }
+    moveModule(module, otherChunk) {
+        const chunkGraph = ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.moveModule', 'DEP_WEBPACK_CHUNK_MOVE_MODULE');
+        chunkGraph.disconnectChunkAndModule(this, module);
+        chunkGraph.connectChunkAndModule(otherChunk, module);
+    }
+    integrate(otherChunk) {
+        const chunkGraph = ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.integrate', 'DEP_WEBPACK_CHUNK_INTEGRATE');
+        if (chunkGraph.canChunksBeIntegrated(this, otherChunk)) {
+            chunkGraph.integrateChunks(this, otherChunk);
+            return true;
+        }
+        return false;
+    }
+    canBeIntegrated(otherChunk) {
+        const chunkGraph = ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.canBeIntegrated', 'DEP_WEBPACK_CHUNK_CAN_BE_INTEGRATED');
+        return chunkGraph.canChunksBeIntegrated(this, otherChunk);
+    }
+    isEmpty() {
+        const chunkGraph = ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.isEmpty', 'DEP_WEBPACK_CHUNK_IS_EMPTY');
+        return chunkGraph.getNumberOfChunkModules(this) === 0;
+    }
+    modulesSize() {
+        const chunkGraph = ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.modulesSize', 'DEP_WEBPACK_CHUNK_MODULES_SIZE');
+        return chunkGraph.getChunkModulesSize(this);
+    }
+    size(options = {}) {
+        const chunkGraph = ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.size', 'DEP_WEBPACK_CHUNK_SIZE');
+        return chunkGraph.getChunkSize(this, options);
+    }
+    integratedSize(otherChunk, options) {
+        const chunkGraph = ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.integratedSize', 'DEP_WEBPACK_CHUNK_INTEGRATED_SIZE');
+        return chunkGraph.getIntegratedChunksSize(this, otherChunk, options);
+    }
+    getChunkModuleMaps(filterFn) {
+        const chunkGraph = ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.getChunkModuleMaps', 'DEP_WEBPACK_CHUNK_GET_CHUNK_MODULE_MAPS');
+        const chunkModuleIdMap = Object.create(null);
+        const chunkModuleHashMap = Object.create(null);
+        for (const asyncChunk of this.getAllAsyncChunks()) {
+            let array;
+            for (const module of chunkGraph.getOrderedChunkModulesIterable(asyncChunk, (0, comparators_1.compareModulesById)(chunkGraph))) {
+                if (filterFn(module)) {
+                    if (array === undefined) {
+                        array = [];
+                        chunkModuleIdMap[asyncChunk.id] = array;
+                    }
+                    const moduleId = chunkGraph.getModuleId(module);
+                    array.push(moduleId);
+                    chunkModuleHashMap[moduleId] = chunkGraph.getRenderedModuleHash(module, undefined);
+                }
+            }
+        }
+        return {
+            id: chunkModuleIdMap,
+            hash: chunkModuleHashMap,
+        };
+    }
+    hasModuleInGraph(filterFn, filterChunkFn) {
+        const chunkGraph = ChunkGraph_1.default.getChunkGraphForChunk(this, 'Chunk.hasModuleInGraph', 'DEP_WEBPACK_CHUNK_HAS_MODULE_IN_GRAPH');
+        return chunkGraph.hasModuleInGraph(this, filterFn, filterChunkFn);
+    }
+    getChunkMaps(realHash) {
+        const chunkHashMap = Object.create(null);
+        const chunkContentHashMap = Object.create(null);
+        const chunkNameMap = Object.create(null);
+        for (const chunk of this.getAllAsyncChunks()) {
+            const id = chunk.id;
+            chunkHashMap[id] = realHash ? chunk.hash : chunk.renderedHash;
+            for (const key of Object.keys(chunk.contentHash)) {
+                if (!chunkContentHashMap[key]) {
+                    chunkContentHashMap[key] = Object.create(null);
+                }
+                chunkContentHashMap[key][id] = chunk.contentHash[key];
+            }
+            if (chunk.name) {
+                chunkNameMap[id] = chunk.name;
+            }
+        }
+        return {
+            hash: chunkHashMap,
+            contentHash: chunkContentHashMap,
+            name: chunkNameMap,
+        };
+    }
+    // BACKWARD-COMPAT END
+    hasRuntime() {
+        for (const chunkGroup of this._groups) {
+            if (chunkGroup instanceof Entrypoint_1.default && chunkGroup.getRuntimeChunk() === this) {
+                return true;
+            }
+        }
+        return false;
+    }
+    canBeInitial() {
+        for (const chunkGroup of this._groups) {
+            if (chunkGroup.isInitial())
+                return true;
+        }
+        return false;
+    }
+    isOnlyInitial() {
+        if (this._groups.size <= 0)
+            return false;
+        for (const chunkGroup of this._groups) {
+            if (!chunkGroup.isInitial())
+                return false;
+        }
+        return true;
+    }
+    getEntryOptions() {
+        for (const chunkGroup of this._groups) {
+            if (chunkGroup instanceof Entrypoint_1.default) {
+                return chunkGroup.options;
+            }
+        }
+        return undefined;
+    }
+    addGroup(chunkGroup) {
+        this._groups.add(chunkGroup);
+    }
+    removeGroup(chunkGroup) {
+        this._groups.delete(chunkGroup);
+    }
+    isInGroup(chunkGroup) {
+        return this._groups.has(chunkGroup);
+    }
+    getNumberOfGroups() {
+        return this._groups.size;
+    }
+    get groupsIterable() {
+        this._groups.sort();
+        return this._groups;
+    }
+    disconnectFromGroups() {
+        for (const chunkGroup of this._groups) {
+            chunkGroup.removeChunk(this);
+        }
+    }
+    split(newChunk) {
+        for (const chunkGroup of this._groups) {
+            chunkGroup.insertChunk(newChunk, this);
+            newChunk.addGroup(chunkGroup);
+        }
+        for (const idHint of this.idNameHints) {
+            newChunk.idNameHints.add(idHint);
+        }
+        newChunk.runtime = (0, RuntimeHelpers_1.mergeRuntime)(newChunk.runtime, this.runtime);
+    }
+    updateHash(hash, chunkGraph) {
+        hash.update(`${this.id} ${this.ids ? this.ids.join() : ''} ${this.name || ''} `);
+        const xor = new StringXor_1.default();
+        for (const m of chunkGraph.getChunkModulesIterable(this)) {
+            xor.add(chunkGraph.getModuleHash(m, this.runtime));
+        }
+        xor.updateHash(hash);
+        const entryModules = chunkGraph.getChunkEntryModulesWithChunkGroupIterable(this);
+        for (const [m, chunkGroup] of entryModules) {
+            hash.update(`entry${chunkGraph.getModuleId(m)}${chunkGroup.id}`);
+        }
+    }
+    getAllAsyncChunks() {
+        const queue = new Set();
+        const chunks = new Set();
+        const initialChunks = (0, SetHelpers_1.intersect)(Array.from(this.groupsIterable, g => new Set(g.chunks)));
+        const initialQueue = new Set(this.groupsIterable);
+        for (const chunkGroup of initialQueue) {
+            for (const child of chunkGroup.childrenIterable) {
+                if (child instanceof Entrypoint_1.default) {
+                    initialQueue.add(child);
+                }
+                else {
+                    queue.add(child);
+                }
+            }
+        }
+        for (const chunkGroup of queue) {
+            for (const chunk of chunkGroup.chunks) {
+                if (!initialChunks.has(chunk)) {
+                    chunks.add(chunk);
+                }
+            }
+            for (const child of chunkGroup.childrenIterable) {
+                queue.add(child);
+            }
+        }
+        return chunks;
+    }
+    getAllInitialChunks() {
+        const chunks = new Set();
+        const queue = new Set(this.groupsIterable);
+        for (const group of queue) {
+            if (group.isInitial()) {
+                for (const c of group.chunks)
+                    chunks.add(c);
+                for (const g of group.childrenIterable)
+                    queue.add(g);
+            }
+        }
+        return chunks;
+    }
+    getAllReferencedChunks() {
+        const queue = new Set(this.groupsIterable);
+        const chunks = new Set();
+        for (const chunkGroup of queue) {
+            for (const chunk of chunkGroup.chunks) {
+                chunks.add(chunk);
+            }
+            for (const child of chunkGroup.childrenIterable) {
+                queue.add(child);
+            }
+        }
+        return chunks;
+    }
+    getAllReferencedAsyncEntrypoints() {
+        const queue = new Set(this.groupsIterable);
+        const entrypoints = new Set();
+        for (const chunkGroup of queue) {
+            for (const entrypoint of chunkGroup.asyncEntrypointsIterable) {
+                entrypoints.add(entrypoint);
+            }
+            for (const child of chunkGroup.childrenIterable) {
+                queue.add(child);
+            }
+        }
+        return entrypoints;
+    }
+    hasAsyncChunks() {
+        const queue = new Set();
+        const initialChunks = (0, SetHelpers_1.intersect)(Array.from(this.groupsIterable, g => new Set(g.chunks)));
+        for (const chunkGroup of this.groupsIterable) {
+            for (const child of chunkGroup.childrenIterable) {
+                queue.add(child);
+            }
+        }
+        for (const chunkGroup of queue) {
+            for (const chunk of chunkGroup.chunks) {
+                if (!initialChunks.has(chunk)) {
+                    return true;
+                }
+            }
+            for (const child of chunkGroup.childrenIterable) {
+                queue.add(child);
+            }
+        }
+        return false;
+    }
+    getChildIdsByOrders(chunkGraph, filterFn) {
+        const lists = new Map();
+        for (const group of this.groupsIterable) {
+            if (group.chunks[group.chunks.length - 1] === this) {
+                for (const childGroup of group.childrenIterable) {
+                    for (const key of Object.keys(childGroup.options)) {
+                        if (key.endsWith('Order')) {
+                            const name = key.slice(0, key.length - 'Order'.length);
+                            let list = lists.get(name);
+                            if (list === undefined) {
+                                list = [];
+                                lists.set(name, list);
+                            }
+                            list.push({
+                                order: childGroup.options[key],
+                                group: childGroup,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        const result = Object.create(null);
+        for (const [name, list] of lists) {
+            list.sort((a, b) => {
+                const cmp = b.order - a.order;
+                if (cmp !== 0)
+                    return cmp;
+                return a.group.compareTo(chunkGraph, b.group);
+            });
+            const chunkIdSet = new Set();
+            for (const item of list) {
+                for (const chunk of item.group.chunks) {
+                    if (filterFn && !filterFn(chunk, chunkGraph))
+                        continue;
+                    chunkIdSet.add(chunk.id);
+                }
+            }
+            if (chunkIdSet.size > 0) {
+                result[name] = Array.from(chunkIdSet);
+            }
+        }
+        return result;
+    }
+    getChildrenOfTypeInOrder(chunkGraph, type) {
+        const list = [];
+        for (const group of this.groupsIterable) {
+            for (const childGroup of group.childrenIterable) {
+                const order = childGroup.options[type];
+                if (order === undefined)
+                    continue;
+                list.push({
+                    order,
+                    group,
+                    childGroup,
+                });
+            }
+        }
+        if (list.length === 0)
+            return undefined;
+        list.sort((a, b) => {
+            const cmp = a.order;
+            if (cmp !== 0)
+                return cmp;
+            return a.group.compareTo(chunkGraph, b.group);
+        });
+        const result = [];
+        let lastEntry;
+        for (const { group, childGroup } of list) {
+            if (lastEntry && lastEntry.onChunks === group.chunks) {
+                for (const chunk of childGroup.chunks) {
+                    lastEntry.chunks.add(chunk);
+                }
+            }
+            else {
+                result.push((lastEntry = {
+                    onChunks: group.chunks,
+                    chunks: new Set(childGroup.chunks),
+                }));
+            }
+        }
+        return result;
+    }
+    getChildIdsByOrdersMap(chunkGraph, includeDirectChildren, filterFn) {
+        const chunkMaps = Object.create(null);
+        const addChildIdsByOrdersToMap = chunk => {
+            const data = chunk.getChildIdsByOrders(chunkGraph, filterFn);
+            for (const key of Object.keys(data)) {
+                let chunkMap = chunkMaps[key];
+                if (chunkMap === undefined) {
+                    chunkMaps[key] = chunkMap = Object.create(null);
+                }
+                chunkMap[chunk.id] = data[key];
+            }
+        };
+        if (includeDirectChildren) {
+            const chunks = new Set();
+            for (const chunkGroup of this.groupsIterable) {
+                for (const chunk of chunkGroup.chunks) {
+                    chunks.add(chunk);
+                }
+            }
+            for (const chunk of chunks) {
+                addChildIdsByOrdersToMap(chunk);
+            }
+        }
+        for (const chunk of this.getAllAsyncChunks()) {
+            addChildIdsByOrdersToMap(chunk);
+        }
+        return chunkMaps;
+    }
+}
+exports.default = Chunk;

package/dist/chunk/ChunkGraph.d.ts

@@ -0,0 +1,102 @@
+declare class ChunkGraph {
+    _modules: WeakMap<any, any>;
+    _chunks: WeakMap<any, any>;
+    _blockChunkGroups: WeakMap<any, any>;
+    _runtimeIds: Map<any, any>;
+    moduleGraph: any;
+    _hashFunction: string;
+    constructor(moduleGraph: any, hashFunction?: string);
+    _getChunkGraphModule(module: any): any;
+    _getChunkGraphChunk(chunk: any): any;
+    _getGraphRoots(set: any): unknown[];
+    connectChunkAndModule(chunk: any, module: any): void;
+    disconnectChunkAndModule(chunk: any, module: any): void;
+    disconnectChunk(chunk: any): void;
+    attachModules(chunk: any, modules: any): void;
+    attachRuntimeModules(chunk: any, modules: any): void;
+    attachFullHashModules(chunk: any, modules: any): void;
+    attachDependentHashModules(chunk: any, modules: any): void;
+    replaceModule(oldModule: any, newModule: any): void;
+    isModuleInChunk(module: any, chunk: any): any;
+    isModuleInChunkGroup(module: any, chunkGroup: any): boolean;
+    isEntryModule(module: any): boolean;
+    getModuleChunksIterable(module: any): any;
+    getOrderedModuleChunksIterable(module: any, sortFn: any): any;
+    getModuleChunks(module: any): any;
+    getNumberOfModuleChunks(module: any): any;
+    getModuleRuntimes(module: any): any;
+    getNumberOfChunkModules(chunk: any): any;
+    getNumberOfChunkFullHashModules(chunk: any): any;
+    getChunkModulesIterable(chunk: any): any;
+    getChunkModulesIterableBySourceType(chunk: any, sourceType: any): any;
+    setChunkModuleSourceTypes(chunk: any, module: any, sourceTypes: any): void;
+    getChunkModuleSourceTypes(chunk: any, module: any): any;
+    getModuleSourceTypes(module: any): any;
+    _getOverwrittenModuleSourceTypes(module: any): any;
+    getOrderedChunkModulesIterable(chunk: any, comparator: any): any;
+    getOrderedChunkModulesIterableBySourceType(chunk: any, sourceType: any, comparator: any): any;
+    getChunkModules(chunk: any): any;
+    getOrderedChunkModules(chunk: any, comparator: any): any;
+    getChunkModuleIdMap(chunk: any, filterFn: any, includeAllChunks?: boolean): any;
+    getChunkModuleRenderedHashMap(chunk: any, filterFn: any, hashLength?: number, includeAllChunks?: boolean): any;
+    getChunkConditionMap(chunk: any, filterFn: any): any;
+    hasModuleInGraph(chunk: any, filterFn: any, filterChunkFn: any): boolean;
+    compareChunks(chunkA: any, chunkB: any): any;
+    getChunkModulesSize(chunk: any): any;
+    getChunkModulesSizes(chunk: any): any;
+    getChunkRootModules(chunk: any): any;
+    getChunkSize(chunk: any, options?: any): any;
+    getIntegratedChunksSize(chunkA: any, chunkB: any, options?: any): any;
+    canChunksBeIntegrated(chunkA: any, chunkB: any): boolean;
+    integrateChunks(chunkA: any, chunkB: any): void;
+    upgradeDependentToFullHashModules(chunk: any): void;
+    isEntryModuleInChunk(module: any, chunk: any): any;
+    connectChunkAndEntryModule(chunk: any, module: any, entrypoint?: any): void;
+    connectChunkAndRuntimeModule(chunk: any, module: any): void;
+    addFullHashModuleToChunk(chunk: any, module: any): void;
+    addDependentHashModuleToChunk(chunk: any, module: any): void;
+    disconnectChunkAndEntryModule(chunk: any, module: any): void;
+    disconnectChunkAndRuntimeModule(chunk: any, module: any): void;
+    disconnectEntryModule(module: any): void;
+    disconnectEntries(chunk: any): void;
+    getNumberOfEntryModules(chunk: any): any;
+    getNumberOfRuntimeModules(chunk: any): any;
+    getChunkEntryModulesIterable(chunk: any): any;
+    getChunkEntryDependentChunksIterable(chunk: any): Set<unknown>;
+    hasChunkEntryDependentChunks(chunk: any): boolean;
+    getChunkRuntimeModulesIterable(chunk: any): any;
+    getChunkRuntimeModulesInOrder(chunk: any): unknown[];
+    getChunkFullHashModulesIterable(chunk: any): any;
+    getChunkFullHashModulesSet(chunk: any): any;
+    getChunkDependentHashModulesIterable(chunk: any): any;
+    getChunkEntryModulesWithChunkGroupIterable(chunk: any): any;
+    getBlockChunkGroup(depBlock: any): any;
+    connectBlockAndChunkGroup(depBlock: any, chunkGroup: any): void;
+    disconnectChunkGroup(chunkGroup: any): void;
+    getModuleId(module: any): any;
+    setModuleId(module: any, id: any): void;
+    getRuntimeId(runtime: any): any;
+    setRuntimeId(runtime: any, id: any): void;
+    _getModuleHashInfo(module: any, hashes: any, runtime: any): any;
+    hasModuleHashes(module: any, runtime: any): any;
+    getModuleHash(module: any, runtime: any): any;
+    getRenderedModuleHash(module: any, runtime: any): any;
+    setModuleHashes(module: any, runtime: any, hash: any, renderedHash: any): void;
+    addModuleRuntimeRequirements(module: any, runtime: any, items: any, transferOwnership?: boolean): void;
+    addChunkRuntimeRequirements(chunk: any, items: any): void;
+    addTreeRuntimeRequirements(chunk: any, items: any): void;
+    getModuleRuntimeRequirements(module: any, runtime: any): any;
+    getChunkRuntimeRequirements(chunk: any): any;
+    getModuleGraphHash(module: any, runtime: any, withConnections?: boolean): any;
+    getModuleGraphHashBigInt(module: any, runtime: any, withConnections?: boolean): any;
+    _getModuleGraphHashBigInt(cgm: any, module: any, runtime: any): any;
+    _getModuleGraphHashWithConnections(cgm: any, module: any, runtime: any): any;
+    getTreeRuntimeRequirements(chunk: any): any;
+    static getChunkGraphForModule(module: any, deprecateMessage: string, deprecationCode: string): any;
+    static setChunkGraphForModule(module: any, chunkGraph: any): void;
+    static clearChunkGraphForModule(module: any): void;
+    static getChunkGraphForChunk(chunk: any, deprecateMessage: any, deprecationCode: any): any;
+    static setChunkGraphForChunk(chunk: any, chunkGraph: any): void;
+    static clearChunkGraphForChunk(chunk: any): void;
+}
+export default ChunkGraph;