@utrecht/web-component-library-stencil 1.0.0-alpha.159 → 1.0.0-alpha.162

package/dist/collection/node_modules/@storybook/manager-webpack5/node_modules/webpack/lib/Chunk.js

@@ -1,818 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-"use strict";
-
-const ChunkGraph = require("./ChunkGraph");
-const Entrypoint = require("./Entrypoint");
-const { intersect } = require("./util/SetHelpers");
-const SortableSet = require("./util/SortableSet");
-const StringXor = require("./util/StringXor");
-const {
-	compareModulesByIdentifier,
-	compareChunkGroupsByIndex,
-	compareModulesById
-} = require("./util/comparators");
-const { createArrayToSetDeprecationSet } = require("./util/deprecation");
-const { mergeRuntime } = require("./util/runtime");
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./ChunkGraph").ChunkFilterPredicate} ChunkFilterPredicate */
-/** @typedef {import("./ChunkGraph").ChunkSizeOptions} ChunkSizeOptions */
-/** @typedef {import("./ChunkGraph").ModuleFilterPredicate} ModuleFilterPredicate */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./Compilation").PathData} PathData */
-/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
-
-const ChunkFilesSet = createArrayToSetDeprecationSet("chunk.files");
-
-/**
- * @typedef {Object} WithId an object who has an id property *
- * @property {string | number} id the id of the object
- */
-
-/**
- * @deprecated
- * @typedef {Object} ChunkMaps
- * @property {Record<string|number, string>} hash
- * @property {Record<string|number, Record<string, string>>} contentHash
- * @property {Record<string|number, string>} name
- */
-
-/**
- * @deprecated
- * @typedef {Object} ChunkModuleMaps
- * @property {Record<string|number, (string|number)[]>} id
- * @property {Record<string|number, string>} hash
- */
-
-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 {
-	/**
-	 * @param {string=} name of chunk being created, is optional (for subclasses)
-	 * @param {boolean} backCompat enable backward-compatibility
-	 */
-	constructor(name, backCompat = true) {
-		/** @type {number | string | null} */
-		this.id = null;
-		/** @type {(number|string)[] | null} */
-		this.ids = null;
-		/** @type {number} */
-		this.debugId = debugId++;
-		/** @type {string} */
-		this.name = name;
-		/** @type {SortableSet<string>} */
-		this.idNameHints = new SortableSet();
-		/** @type {boolean} */
-		this.preventIntegration = false;
-		/** @type {(string | function(PathData, AssetInfo=): string)?} */
-		this.filenameTemplate = undefined;
-		/** @private @type {SortableSet<ChunkGroup>} */
-		this._groups = new SortableSet(undefined, compareChunkGroupsByIndex);
-		/** @type {RuntimeSpec} */
-		this.runtime = undefined;
-		/** @type {Set<string>} */
-		this.files = backCompat ? new ChunkFilesSet() : new Set();
-		/** @type {Set<string>} */
-		this.auxiliaryFiles = new Set();
-		/** @type {boolean} */
-		this.rendered = false;
-		/** @type {string=} */
-		this.hash = undefined;
-		/** @type {Record<string, string>} */
-		this.contentHash = Object.create(null);
-		/** @type {string=} */
-		this.renderedHash = undefined;
-		/** @type {string=} */
-		this.chunkReason = undefined;
-		/** @type {boolean} */
-		this.extraAsync = false;
-	}
-
-	// TODO remove in webpack 6
-	// BACKWARD-COMPAT START
-	get entryModule() {
-		const entryModules = Array.from(
-			ChunkGraph.getChunkGraphForChunk(
-				this,
-				"Chunk.entryModule",
-				"DEP_WEBPACK_CHUNK_ENTRY_MODULE"
-			).getChunkEntryModulesIterable(this)
-		);
-		if (entryModules.length === 0) {
-			return undefined;
-		} else if (entryModules.length === 1) {
-			return entryModules[0];
-		} else {
-			throw new Error(
-				"Module.entryModule: Multiple entry modules are not supported by the deprecated API (Use the new ChunkGroup API)"
-			);
-		}
-	}
-
-	/**
-	 * @returns {boolean} true, if the chunk contains an entry module
-	 */
-	hasEntryModule() {
-		return (
-			ChunkGraph.getChunkGraphForChunk(
-				this,
-				"Chunk.hasEntryModule",
-				"DEP_WEBPACK_CHUNK_HAS_ENTRY_MODULE"
-			).getNumberOfEntryModules(this) > 0
-		);
-	}
-
-	/**
-	 * @param {Module} module the module
-	 * @returns {boolean} true, if the chunk could be added
-	 */
-	addModule(module) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.addModule",
-			"DEP_WEBPACK_CHUNK_ADD_MODULE"
-		);
-		if (chunkGraph.isModuleInChunk(module, this)) return false;
-		chunkGraph.connectChunkAndModule(this, module);
-		return true;
-	}
-
-	/**
-	 * @param {Module} module the module
-	 * @returns {void}
-	 */
-	removeModule(module) {
-		ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.removeModule",
-			"DEP_WEBPACK_CHUNK_REMOVE_MODULE"
-		).disconnectChunkAndModule(this, module);
-	}
-
-	/**
-	 * @returns {number} the number of module which are contained in this chunk
-	 */
-	getNumberOfModules() {
-		return ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.getNumberOfModules",
-			"DEP_WEBPACK_CHUNK_GET_NUMBER_OF_MODULES"
-		).getNumberOfChunkModules(this);
-	}
-
-	get modulesIterable() {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.modulesIterable",
-			"DEP_WEBPACK_CHUNK_MODULES_ITERABLE"
-		);
-		return chunkGraph.getOrderedChunkModulesIterable(
-			this,
-			compareModulesByIdentifier
-		);
-	}
-
-	/**
-	 * @param {Chunk} otherChunk the chunk to compare with
-	 * @returns {-1|0|1} the comparison result
-	 */
-	compareTo(otherChunk) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.compareTo",
-			"DEP_WEBPACK_CHUNK_COMPARE_TO"
-		);
-		return chunkGraph.compareChunks(this, otherChunk);
-	}
-
-	/**
-	 * @param {Module} module the module
-	 * @returns {boolean} true, if the chunk contains the module
-	 */
-	containsModule(module) {
-		return ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.containsModule",
-			"DEP_WEBPACK_CHUNK_CONTAINS_MODULE"
-		).isModuleInChunk(module, this);
-	}
-
-	/**
-	 * @returns {Module[]} the modules for this chunk
-	 */
-	getModules() {
-		return ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.getModules",
-			"DEP_WEBPACK_CHUNK_GET_MODULES"
-		).getChunkModules(this);
-	}
-
-	/**
-	 * @returns {void}
-	 */
-	remove() {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.remove",
-			"DEP_WEBPACK_CHUNK_REMOVE"
-		);
-		chunkGraph.disconnectChunk(this);
-		this.disconnectFromGroups();
-	}
-
-	/**
-	 * @param {Module} module the module
-	 * @param {Chunk} otherChunk the target chunk
-	 * @returns {void}
-	 */
-	moveModule(module, otherChunk) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.moveModule",
-			"DEP_WEBPACK_CHUNK_MOVE_MODULE"
-		);
-		chunkGraph.disconnectChunkAndModule(this, module);
-		chunkGraph.connectChunkAndModule(otherChunk, module);
-	}
-
-	/**
-	 * @param {Chunk} otherChunk the other chunk
-	 * @returns {boolean} true, if the specified chunk has been integrated
-	 */
-	integrate(otherChunk) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.integrate",
-			"DEP_WEBPACK_CHUNK_INTEGRATE"
-		);
-		if (chunkGraph.canChunksBeIntegrated(this, otherChunk)) {
-			chunkGraph.integrateChunks(this, otherChunk);
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	/**
-	 * @param {Chunk} otherChunk the other chunk
-	 * @returns {boolean} true, if chunks could be integrated
-	 */
-	canBeIntegrated(otherChunk) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.canBeIntegrated",
-			"DEP_WEBPACK_CHUNK_CAN_BE_INTEGRATED"
-		);
-		return chunkGraph.canChunksBeIntegrated(this, otherChunk);
-	}
-
-	/**
-	 * @returns {boolean} true, if this chunk contains no module
-	 */
-	isEmpty() {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.isEmpty",
-			"DEP_WEBPACK_CHUNK_IS_EMPTY"
-		);
-		return chunkGraph.getNumberOfChunkModules(this) === 0;
-	}
-
-	/**
-	 * @returns {number} total size of all modules in this chunk
-	 */
-	modulesSize() {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.modulesSize",
-			"DEP_WEBPACK_CHUNK_MODULES_SIZE"
-		);
-		return chunkGraph.getChunkModulesSize(this);
-	}
-
-	/**
-	 * @param {ChunkSizeOptions} options options object
-	 * @returns {number} total size of this chunk
-	 */
-	size(options = {}) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.size",
-			"DEP_WEBPACK_CHUNK_SIZE"
-		);
-		return chunkGraph.getChunkSize(this, options);
-	}
-
-	/**
-	 * @param {Chunk} otherChunk the other chunk
-	 * @param {ChunkSizeOptions} options options object
-	 * @returns {number} total size of the chunk or false if the chunk can't be integrated
-	 */
-	integratedSize(otherChunk, options) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.integratedSize",
-			"DEP_WEBPACK_CHUNK_INTEGRATED_SIZE"
-		);
-		return chunkGraph.getIntegratedChunksSize(this, otherChunk, options);
-	}
-
-	/**
-	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
-	 * @returns {ChunkModuleMaps} module map information
-	 */
-	getChunkModuleMaps(filterFn) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.getChunkModuleMaps",
-			"DEP_WEBPACK_CHUNK_GET_CHUNK_MODULE_MAPS"
-		);
-		/** @type {Record<string|number, (string|number)[]>} */
-		const chunkModuleIdMap = Object.create(null);
-		/** @type {Record<string|number, string>} */
-		const chunkModuleHashMap = Object.create(null);
-
-		for (const asyncChunk of this.getAllAsyncChunks()) {
-			/** @type {(string|number)[]} */
-			let array;
-			for (const module of chunkGraph.getOrderedChunkModulesIterable(
-				asyncChunk,
-				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
-		};
-	}
-
-	/**
-	 * @param {ModuleFilterPredicate} filterFn predicate function used to filter modules
-	 * @param {ChunkFilterPredicate=} filterChunkFn predicate function used to filter chunks
-	 * @returns {boolean} return true if module exists in graph
-	 */
-	hasModuleInGraph(filterFn, filterChunkFn) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.hasModuleInGraph",
-			"DEP_WEBPACK_CHUNK_HAS_MODULE_IN_GRAPH"
-		);
-		return chunkGraph.hasModuleInGraph(this, filterFn, filterChunkFn);
-	}
-
-	/**
-	 * @deprecated
-	 * @param {boolean} realHash whether the full hash or the rendered hash is to be used
-	 * @returns {ChunkMaps} the chunk map information
-	 */
-	getChunkMaps(realHash) {
-		/** @type {Record<string|number, string>} */
-		const chunkHashMap = Object.create(null);
-		/** @type {Record<string|number, Record<string, string>>} */
-		const chunkContentHashMap = Object.create(null);
-		/** @type {Record<string|number, string>} */
-		const chunkNameMap = Object.create(null);
-
-		for (const chunk of this.getAllAsyncChunks()) {
-			chunkHashMap[chunk.id] = realHash ? chunk.hash : chunk.renderedHash;
-			for (const key of Object.keys(chunk.contentHash)) {
-				if (!chunkContentHashMap[key]) {
-					chunkContentHashMap[key] = Object.create(null);
-				}
-				chunkContentHashMap[key][chunk.id] = chunk.contentHash[key];
-			}
-			if (chunk.name) {
-				chunkNameMap[chunk.id] = chunk.name;
-			}
-		}
-
-		return {
-			hash: chunkHashMap,
-			contentHash: chunkContentHashMap,
-			name: chunkNameMap
-		};
-	}
-	// BACKWARD-COMPAT END
-
-	/**
-	 * @returns {boolean} whether or not the Chunk will have a runtime
-	 */
-	hasRuntime() {
-		for (const chunkGroup of this._groups) {
-			if (
-				chunkGroup instanceof Entrypoint &&
-				chunkGroup.getRuntimeChunk() === this
-			) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	/**
-	 * @returns {boolean} whether or not this chunk can be an initial chunk
-	 */
-	canBeInitial() {
-		for (const chunkGroup of this._groups) {
-			if (chunkGroup.isInitial()) return true;
-		}
-		return false;
-	}
-
-	/**
-	 * @returns {boolean} whether this chunk can only be an initial chunk
-	 */
-	isOnlyInitial() {
-		if (this._groups.size <= 0) return false;
-		for (const chunkGroup of this._groups) {
-			if (!chunkGroup.isInitial()) return false;
-		}
-		return true;
-	}
-
-	/**
-	 * @returns {EntryOptions | undefined} the entry options for this chunk
-	 */
-	getEntryOptions() {
-		for (const chunkGroup of this._groups) {
-			if (chunkGroup instanceof Entrypoint) {
-				return chunkGroup.options;
-			}
-		}
-		return undefined;
-	}
-
-	/**
-	 * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being added
-	 * @returns {void}
-	 */
-	addGroup(chunkGroup) {
-		this._groups.add(chunkGroup);
-	}
-
-	/**
-	 * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being removed from
-	 * @returns {void}
-	 */
-	removeGroup(chunkGroup) {
-		this._groups.delete(chunkGroup);
-	}
-
-	/**
-	 * @param {ChunkGroup} chunkGroup the chunkGroup to check
-	 * @returns {boolean} returns true if chunk has chunkGroup reference and exists in chunkGroup
-	 */
-	isInGroup(chunkGroup) {
-		return this._groups.has(chunkGroup);
-	}
-
-	/**
-	 * @returns {number} the amount of groups that the said chunk is in
-	 */
-	getNumberOfGroups() {
-		return this._groups.size;
-	}
-
-	/**
-	 * @returns {Iterable<ChunkGroup>} the chunkGroups that the said chunk is referenced in
-	 */
-	get groupsIterable() {
-		this._groups.sort();
-		return this._groups;
-	}
-
-	/**
-	 * @returns {void}
-	 */
-	disconnectFromGroups() {
-		for (const chunkGroup of this._groups) {
-			chunkGroup.removeChunk(this);
-		}
-	}
-
-	/**
-	 * @param {Chunk} newChunk the new chunk that will be split out of
-	 * @returns {void}
-	 */
-	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 = mergeRuntime(newChunk.runtime, this.runtime);
-	}
-
-	/**
-	 * @param {Hash} hash hash (will be modified)
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {void}
-	 */
-	updateHash(hash, chunkGraph) {
-		hash.update(
-			`${this.id} ${this.ids ? this.ids.join() : ""} ${this.name || ""} `
-		);
-		const xor = new StringXor();
-		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}`);
-		}
-	}
-
-	/**
-	 * @returns {Set<Chunk>} a set of all the async chunks
-	 */
-	getAllAsyncChunks() {
-		const queue = new Set();
-		const chunks = new Set();
-
-		const initialChunks = 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) {
-					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;
-	}
-
-	/**
-	 * @returns {Set<Chunk>} a set of all the initial chunks (including itself)
-	 */
-	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;
-	}
-
-	/**
-	 * @returns {Set<Chunk>} a set of all the referenced chunks (including itself)
-	 */
-	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;
-	}
-
-	/**
-	 * @returns {Set<Entrypoint>} a set of all the referenced entrypoints
-	 */
-	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;
-	}
-
-	/**
-	 * @returns {boolean} true, if the chunk references async chunks
-	 */
-	hasAsyncChunks() {
-		const queue = new Set();
-
-		const initialChunks = 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;
-	}
-
-	/**
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {ChunkFilterPredicate=} filterFn function used to filter chunks
-	 * @returns {Record<string, (string | number)[]>} a record object of names to lists of child ids(?)
-	 */
-	getChildIdsByOrders(chunkGraph, filterFn) {
-		/** @type {Map<string, {order: number, group: ChunkGroup}[]>} */
-		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.substr(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
-							});
-						}
-					}
-				}
-			}
-		}
-		/** @type {Record<string, (string | number)[]>} */
-		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);
-			});
-			/** @type {Set<string | number>} */
-			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;
-	}
-
-	/**
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {string} type option name
-	 * @returns {{ onChunks: Chunk[], chunks: Set<Chunk> }[]} referenced chunks for a specific type
-	 */
-	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 = b.order - 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;
-	}
-
-	/**
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {boolean=} includeDirectChildren include direct children (by default only children of async children are included)
-	 * @param {ChunkFilterPredicate=} filterFn function used to filter chunks
-	 * @returns {Record<string|number, Record<string, (string | number)[]>>} a record object of names to lists of child ids(?) by chunk id
-	 */
-	getChildIdsByOrdersMap(chunkGraph, includeDirectChildren, filterFn) {
-		/** @type {Record<string|number, Record<string, (string | number)[]>>} */
-		const chunkMaps = Object.create(null);
-
-		/**
-		 * @param {Chunk} chunk a chunk
-		 * @returns {void}
-		 */
-		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) {
-			/** @type {Set<Chunk>} */
-			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;
-	}
-}
-
-module.exports = Chunk;