update packages

1 files changed, 833 insertions, 479 deletions

diff --git a/node_modules/webpack/lib/Chunk.js b/node_modules/webpack/lib/Chunk.js
index 48ca2d1a3..f0bb2ea72 100644
--- a/node_modules/webpack/lib/Chunk.js
+++ b/node_modules/webpack/lib/Chunk.js
@@ -1,479 +1,833 @@
-/*

-	MIT License http://www.opensource.org/licenses/mit-license.php

-	Author Tobias Koppers @sokra

-*/

-"use strict";

-

-const util = require("util");

-const compareLocations = require("./compareLocations");

-const SortableSet = require("./util/SortableSet");

-let debugId = 1000;

-

-const sortById = (a, b) => {

-	if(a.id < b.id) return -1;

-	if(b.id < a.id) return 1;

-	return 0;

-};

-

-const sortByIdentifier = (a, b) => {

-	if(a.identifier() > b.identifier()) return 1;

-	if(a.identifier() < b.identifier()) return -1;

-	return 0;

-};

-

-class Chunk {

-

-	constructor(name, module, loc) {

-		this.id = null;

-		this.ids = null;

-		this.debugId = debugId++;

-		this.name = name;

-		this._modules = new SortableSet(undefined, sortByIdentifier);

-		this.entrypoints = [];

-		this.chunks = [];

-		this.parents = [];

-		this.blocks = [];

-		this.origins = [];

-		this.files = [];

-		this.rendered = false;

-		if(module) {

-			this.origins.push({

-				module,

-				loc,

-				name

-			});

-		}

-	}

-

-	get entry() {

-		throw new Error("Chunk.entry was removed. Use hasRuntime()");

-	}

-

-	set entry(data) {

-		throw new Error("Chunk.entry was removed. Use hasRuntime()");

-	}

-

-	get initial() {

-		throw new Error("Chunk.initial was removed. Use isInitial()");

-	}

-

-	set initial(data) {

-		throw new Error("Chunk.initial was removed. Use isInitial()");

-	}

-

-	hasRuntime() {

-		if(this.entrypoints.length === 0) return false;

-		return this.entrypoints[0].chunks[0] === this;

-	}

-

-	isInitial() {

-		return this.entrypoints.length > 0;

-	}

-

-	hasEntryModule() {

-		return !!this.entryModule;

-	}

-

-	addToCollection(collection, item) {

-		if(item === this) {

-			return false;

-		}

-

-		if(collection.indexOf(item) > -1) {

-			return false;

-		}

-

-		collection.push(item);

-		return true;

-	}

-

-	addChunk(chunk) {

-		return this.addToCollection(this.chunks, chunk);

-	}

-

-	addParent(parentChunk) {

-		return this.addToCollection(this.parents, parentChunk);

-	}

-

-	addModule(module) {

-		if(!this._modules.has(module)) {

-			this._modules.add(module);

-			return true;

-		}

-		return false;

-	}

-

-	addBlock(block) {

-		return this.addToCollection(this.blocks, block);

-	}

-

-	removeModule(module) {

-		if(this._modules.delete(module)) {

-			module.removeChunk(this);

-			return true;

-		}

-		return false;

-	}

-

-	removeChunk(chunk) {

-		const idx = this.chunks.indexOf(chunk);

-		if(idx >= 0) {

-			this.chunks.splice(idx, 1);

-			chunk.removeParent(this);

-			return true;

-		}

-		return false;

-	}

-

-	removeParent(chunk) {

-		const idx = this.parents.indexOf(chunk);

-		if(idx >= 0) {

-			this.parents.splice(idx, 1);

-			chunk.removeChunk(this);

-			return true;

-		}

-		return false;

-	}

-

-	addOrigin(module, loc) {

-		this.origins.push({

-			module,

-			loc,

-			name: this.name

-		});

-	}

-

-	setModules(modules) {

-		this._modules = new SortableSet(modules, sortByIdentifier);

-	}

-

-	getNumberOfModules() {

-		return this._modules.size;

-	}

-

-	get modulesIterable() {

-		return this._modules;

-	}

-

-	forEachModule(fn) {

-		this._modules.forEach(fn);

-	}

-

-	mapModules(fn) {

-		return Array.from(this._modules, fn);

-	}

-

-	compareTo(otherChunk) {

-		this._modules.sort();

-		otherChunk._modules.sort();

-		if(this._modules.size > otherChunk._modules.size) return -1;

-		if(this._modules.size < otherChunk._modules.size) return 1;

-		const a = this._modules[Symbol.iterator]();

-		const b = otherChunk._modules[Symbol.iterator]();

-		while(true) { // eslint-disable-line

-			const aItem = a.next();

-			const bItem = b.next();

-			if(aItem.done) return 0;

-			const aModuleIdentifier = aItem.value.identifier();

-			const bModuleIdentifier = bItem.value.identifier();

-			if(aModuleIdentifier > bModuleIdentifier) return -1;

-			if(aModuleIdentifier < bModuleIdentifier) return 1;

-		}

-	}

-

-	containsModule(module) {

-		return this._modules.has(module);

-	}

-

-	getModules() {

-		return Array.from(this._modules);

-	}

-

-	getModulesIdent() {

-		this._modules.sort();

-		let str = "";

-		this._modules.forEach(m => {

-			str += m.identifier() + "#";

-		});

-		return str;

-	}

-

-	remove(reason) {

-		// cleanup modules

-		// Array.from is used here to create a clone, because removeChunk modifies this._modules

-		Array.from(this._modules).forEach(module => {

-			module.removeChunk(this);

-		});

-

-		// cleanup parents

-		this.parents.forEach(parentChunk => {

-			// remove this chunk from its parents

-			const idx = parentChunk.chunks.indexOf(this);

-			if(idx >= 0) {

-				parentChunk.chunks.splice(idx, 1);

-			}

-

-			// cleanup "sub chunks"

-			this.chunks.forEach(chunk => {

-				/**

-				 * remove this chunk as "intermediary" and connect

-				 * it "sub chunks" and parents directly

-				 */

-				// add parent to each "sub chunk"

-				chunk.addParent(parentChunk);

-				// add "sub chunk" to parent

-				parentChunk.addChunk(chunk);

-			});

-		});

-

-		/**

-		 * we need to iterate again over the chunks

-		 * to remove this from the chunks parents.

-		 * This can not be done in the above loop

-		 * as it is not garuanteed that `this.parents` contains anything.

-		 */

-		this.chunks.forEach(chunk => {

-			// remove this as parent of every "sub chunk"

-			const idx = chunk.parents.indexOf(this);

-			if(idx >= 0) {

-				chunk.parents.splice(idx, 1);

-			}

-		});

-

-		// cleanup blocks

-		this.blocks.forEach(block => {

-			const idx = block.chunks.indexOf(this);

-			if(idx >= 0) {

-				block.chunks.splice(idx, 1);

-				if(block.chunks.length === 0) {

-					block.chunks = null;

-					block.chunkReason = reason;

-				}

-			}

-		});

-	}

-

-	moveModule(module, otherChunk) {

-		module.removeChunk(this);

-		module.addChunk(otherChunk);

-		otherChunk.addModule(module);

-		module.rewriteChunkInReasons(this, [otherChunk]);

-	}

-

-	replaceChunk(oldChunk, newChunk) {

-		const idx = this.chunks.indexOf(oldChunk);

-		if(idx >= 0) {

-			this.chunks.splice(idx, 1);

-		}

-		if(this !== newChunk && newChunk.addParent(this)) {

-			this.addChunk(newChunk);

-		}

-	}

-

-	replaceParentChunk(oldParentChunk, newParentChunk) {

-		const idx = this.parents.indexOf(oldParentChunk);

-		if(idx >= 0) {

-			this.parents.splice(idx, 1);

-		}

-		if(this !== newParentChunk && newParentChunk.addChunk(this)) {

-			this.addParent(newParentChunk);

-		}

-	}

-

-	integrate(otherChunk, reason) {

-		if(!this.canBeIntegrated(otherChunk)) {

-			return false;

-		}

-

-		// Array.from is used here to create a clone, because moveModule modifies otherChunk._modules

-		const otherChunkModules = Array.from(otherChunk._modules);

-		otherChunkModules.forEach(module => otherChunk.moveModule(module, this));

-		otherChunk._modules.clear();

-

-		otherChunk.parents.forEach(parentChunk => parentChunk.replaceChunk(otherChunk, this));

-		otherChunk.parents.length = 0;

-

-		otherChunk.chunks.forEach(chunk => chunk.replaceParentChunk(otherChunk, this));

-		otherChunk.chunks.length = 0;

-

-		otherChunk.blocks.forEach(b => {

-			b.chunks = b.chunks ? b.chunks.map(c => {

-				return c === otherChunk ? this : c;

-			}) : [this];

-			b.chunkReason = reason;

-			this.addBlock(b);

-		});

-		otherChunk.blocks.length = 0;

-

-		otherChunk.origins.forEach(origin => {

-			this.origins.push(origin);

-		});

-		this.blocks.forEach(b => {

-			b.chunkReason = reason;

-		});

-		this.origins.forEach(origin => {

-			if(!origin.reasons) {

-				origin.reasons = [reason];

-			} else if(origin.reasons[0] !== reason) {

-				origin.reasons.unshift(reason);

-			}

-		});

-		this.chunks = this.chunks.filter(chunk => {

-			return chunk !== otherChunk && chunk !== this;

-		});

-		this.parents = this.parents.filter(parentChunk => {

-			return parentChunk !== otherChunk && parentChunk !== this;

-		});

-		return true;

-	}

-

-	split(newChunk) {

-		this.blocks.forEach(block => {

-			newChunk.blocks.push(block);

-			block.chunks.push(newChunk);

-		});

-		this.chunks.forEach(chunk => {

-			newChunk.chunks.push(chunk);

-			chunk.parents.push(newChunk);

-		});

-		this.parents.forEach(parentChunk => {

-			parentChunk.chunks.push(newChunk);

-			newChunk.parents.push(parentChunk);

-		});

-		this.entrypoints.forEach(entrypoint => {

-			entrypoint.insertChunk(newChunk, this);

-		});

-	}

-

-	isEmpty() {

-		return this._modules.size === 0;

-	}

-

-	updateHash(hash) {

-		hash.update(`${this.id} `);

-		hash.update(this.ids ? this.ids.join(",") : "");

-		hash.update(`${this.name || ""} `);

-		this._modules.forEach(m => m.updateHash(hash));

-	}

-

-	canBeIntegrated(otherChunk) {

-		if(otherChunk.isInitial()) {

-			return false;

-		}

-		if(this.isInitial()) {

-			if(otherChunk.parents.length !== 1 || otherChunk.parents[0] !== this) {

-				return false;

-			}

-		}

-		return true;

-	}

-

-	addMultiplierAndOverhead(size, options) {

-		const overhead = typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000;

-		const multiplicator = this.isInitial() ? (options.entryChunkMultiplicator || 10) : 1;

-

-		return size * multiplicator + overhead;

-	}

-

-	modulesSize() {

-		let count = 0;

-		for(const module of this._modules) {

-			count += module.size();

-		}

-		return count;

-	}

-

-	size(options) {

-		return this.addMultiplierAndOverhead(this.modulesSize(), options);

-	}

-

-	integratedSize(otherChunk, options) {

-		// Chunk if it's possible to integrate this chunk

-		if(!this.canBeIntegrated(otherChunk)) {

-			return false;

-		}

-

-		let integratedModulesSize = this.modulesSize();

-		// only count modules that do not exist in this chunk!

-		for(const otherModule of otherChunk._modules) {

-			if(!this._modules.has(otherModule)) {

-				integratedModulesSize += otherModule.size();

-			}

-		}

-

-		return this.addMultiplierAndOverhead(integratedModulesSize, options);

-	}

-

-	getChunkMaps(includeEntries, realHash) {

-		const chunksProcessed = [];

-		const chunkHashMap = {};

-		const chunkNameMap = {};

-		(function addChunk(chunk) {

-			if(chunksProcessed.indexOf(chunk) >= 0) return;

-			chunksProcessed.push(chunk);

-			if(!chunk.hasRuntime() || includeEntries) {

-				chunkHashMap[chunk.id] = realHash ? chunk.hash : chunk.renderedHash;

-				if(chunk.name)

-					chunkNameMap[chunk.id] = chunk.name;

-			}

-			chunk.chunks.forEach(addChunk);

-		}(this));

-		return {

-			hash: chunkHashMap,

-			name: chunkNameMap

-		};

-	}

-

-	sortModules(sortByFn) {

-		this._modules.sortWith(sortByFn || sortById);

-	}

-

-	sortItems() {

-		this.sortModules();

-		this.origins.sort((a, b) => {

-			const aIdent = a.module.identifier();

-			const bIdent = b.module.identifier();

-			if(aIdent < bIdent) return -1;

-			if(aIdent > bIdent) return 1;

-			return compareLocations(a.loc, b.loc);

-		});

-		this.origins.forEach(origin => {

-			if(origin.reasons)

-				origin.reasons.sort();

-		});

-		this.parents.sort(sortById);

-		this.chunks.sort(sortById);

-	}

-

-	toString() {

-		return `Chunk[${Array.from(this._modules).join()}]`;

-	}

-

-	checkConstraints() {

-		const chunk = this;

-		chunk.chunks.forEach((child, idx) => {

-			if(chunk.chunks.indexOf(child) !== idx)

-				throw new Error(`checkConstraints: duplicate child in chunk ${chunk.debugId} ${child.debugId}`);

-			if(child.parents.indexOf(chunk) < 0)

-				throw new Error(`checkConstraints: child missing parent ${chunk.debugId} -> ${child.debugId}`);

-		});

-		chunk.parents.forEach((parentChunk, idx) => {

-			if(chunk.parents.indexOf(parentChunk) !== idx)

-				throw new Error(`checkConstraints: duplicate parent in chunk ${chunk.debugId} ${parentChunk.debugId}`);

-			if(parentChunk.chunks.indexOf(chunk) < 0)

-				throw new Error(`checkConstraints: parent missing child ${parentChunk.debugId} <- ${chunk.debugId}`);

-		});

-	}

-}

-

-Object.defineProperty(Chunk.prototype, "modules", {

-	configurable: false,

-	get: util.deprecate(function() {

-		return Array.from(this._modules);

-	}, "Chunk.modules is deprecated. Use Chunk.getNumberOfModules/mapModules/forEachModule/containsModule instead."),

-	set: util.deprecate(function(value) {

-		this.setModules(value);

-	}, "Chunk.modules is deprecated. Use Chunk.addModule/removeModule instead.")

-});

-

-module.exports = Chunk;

+/*
+MIT License http://www.opensource.org/licenses/mit-license.php
+Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const util = require("util");
+const SortableSet = require("./util/SortableSet");
+const intersect = require("./util/SetHelpers").intersect;
+const GraphHelpers = require("./GraphHelpers");
+const Entrypoint = require("./Entrypoint");
+let debugId = 1000;
+const ERR_CHUNK_ENTRY = "Chunk.entry was removed. Use hasRuntime()";
+const ERR_CHUNK_INITIAL =
+	"Chunk.initial was removed. Use canBeInitial/isOnlyInitial()";
+
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./ModuleReason")} ModuleReason */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./util/createHash").Hash} Hash */
+
+/**
+ *  @typedef {Object} WithId an object who has an id property *
+ *  @property {string | number} id the id of the object
+ */
+
+/**
+ * Compare two Modules based on their ids for sorting
+ * @param {Module} a module
+ * @param {Module} b module
+ * @returns {-1|0|1} sort value
+ */
+
+// TODO use @callback
+/** @typedef {(a: Module, b: Module) => -1|0|1} ModuleSortPredicate */
+/** @typedef {(m: Module) => boolean} ModuleFilterPredicate */
+/** @typedef {(c: Chunk) => boolean} ChunkFilterPredicate */
+
+const sortModuleById = (a, b) => {
+	if (a.id < b.id) return -1;
+	if (b.id < a.id) return 1;
+	return 0;
+};
+
+/**
+ * Compare two ChunkGroups based on their ids for sorting
+ * @param {ChunkGroup} a chunk group
+ * @param {ChunkGroup} b chunk group
+ * @returns {-1|0|1} sort value
+ */
+const sortChunkGroupById = (a, b) => {
+	if (a.id < b.id) return -1;
+	if (b.id < a.id) return 1;
+	return 0;
+};
+
+/**
+ * Compare two Identifiables , based on their ids for sorting
+ * @param {Module} a first object with ident fn
+ * @param {Module} b second object with ident fn
+ * @returns {-1|0|1} The order number of the sort
+ */
+const sortByIdentifier = (a, b) => {
+	if (a.identifier() > b.identifier()) return 1;
+	if (a.identifier() < b.identifier()) return -1;
+	return 0;
+};
+
+/**
+ * @returns {string} a concatenation of module identifiers sorted
+ * @param {SortableSet} set to pull module identifiers from
+ */
+const getModulesIdent = set => {
+	set.sort();
+	let str = "";
+	for (const m of set) {
+		str += m.identifier() + "#";
+	}
+	return str;
+};
+
+/**
+ * @template T
+ * @param {SortableSet<T>} set the sortable set to convert to array
+ * @returns {Array<T>} the array returned from Array.from(set)
+ */
+const getArray = set => Array.from(set);
+
+/**
+ * @param {SortableSet<Module>} set the sortable Set to get the count/size of
+ * @returns {number} the size of the modules
+ */
+const getModulesSize = set => {
+	let size = 0;
+	for (const module of set) {
+		size += module.size();
+	}
+	return size;
+};
+
+/**
+ * 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)
+	 */
+	constructor(name) {
+		/** @type {number | null} */
+		this.id = null;
+		/** @type {number[] | null} */
+		this.ids = null;
+		/** @type {number} */
+		this.debugId = debugId++;
+		/** @type {string} */
+		this.name = name;
+		/** @type {boolean} */
+		this.preventIntegration = false;
+		/** @type {Module=} */
+		this.entryModule = undefined;
+		/** @private @type {SortableSet<Module>} */
+		this._modules = new SortableSet(undefined, sortByIdentifier);
+		/** @type {string?} */
+		this.filenameTemplate = undefined;
+		/** @private @type {SortableSet<ChunkGroup>} */
+		this._groups = new SortableSet(undefined, sortChunkGroupById);
+		/** @type {string[]} */
+		this.files = [];
+		/** @type {boolean} */
+		this.rendered = false;
+		/** @type {string=} */
+		this.hash = undefined;
+		/** @type {Object} */
+		this.contentHash = Object.create(null);
+		/** @type {string=} */
+		this.renderedHash = undefined;
+		/** @type {string=} */
+		this.chunkReason = undefined;
+		/** @type {boolean} */
+		this.extraAsync = false;
+		this.removedModules = undefined;
+	}
+
+	/**
+	 * @deprecated Chunk.entry has been deprecated. Please use .hasRuntime() instead
+	 * @returns {never} Throws an error trying to access this property
+	 */
+	get entry() {
+		throw new Error(ERR_CHUNK_ENTRY);
+	}
+
+	/**
+	 * @deprecated .entry has been deprecated. Please use .hasRuntime() instead
+	 * @param {never} data The data that was attempting to be set
+	 * @returns {never} Throws an error trying to access this property
+	 */
+	set entry(data) {
+		throw new Error(ERR_CHUNK_ENTRY);
+	}
+
+	/**
+	 * @deprecated Chunk.initial was removed. Use canBeInitial/isOnlyInitial()
+	 * @returns {never} Throws an error trying to access this property
+	 */
+	get initial() {
+		throw new Error(ERR_CHUNK_INITIAL);
+	}
+
+	/**
+	 * @deprecated Chunk.initial was removed. Use canBeInitial/isOnlyInitial()
+	 * @param {never} data The data attempting to be set
+	 * @returns {never} Throws an error trying to access this property
+	 */
+	set initial(data) {
+		throw new Error(ERR_CHUNK_INITIAL);
+	}
+
+	/**
+	 * @returns {boolean} whether or not the Chunk will have a runtime
+	 */
+	hasRuntime() {
+		for (const chunkGroup of this._groups) {
+			// We only need to check the first one
+			return (
+				chunkGroup.isInitial() &&
+				chunkGroup instanceof Entrypoint &&
+				chunkGroup.getRuntimeChunk() === this
+			);
+		}
+		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 {boolean} if this chunk contains the entry module
+	 */
+	hasEntryModule() {
+		return !!this.entryModule;
+	}
+
+	/**
+	 * @param {Module} module the module that will be added to this chunk.
+	 * @returns {boolean} returns true if the chunk doesn't have the module and it was added
+	 */
+	addModule(module) {
+		if (!this._modules.has(module)) {
+			this._modules.add(module);
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * @param {Module} module the module that will be removed from this chunk
+	 * @returns {boolean} returns true if chunk exists and is successfully deleted
+	 */
+	removeModule(module) {
+		if (this._modules.delete(module)) {
+			module.removeChunk(this);
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * @param {Module[]} modules the new modules to be set
+	 * @returns {void} set new modules to this chunk and return nothing
+	 */
+	setModules(modules) {
+		this._modules = new SortableSet(modules, sortByIdentifier);
+	}
+
+	/**
+	 * @returns {number} the amount of modules in chunk
+	 */
+	getNumberOfModules() {
+		return this._modules.size;
+	}
+
+	/**
+	 * @returns {SortableSet} return the modules SortableSet for this chunk
+	 */
+	get modulesIterable() {
+		return this._modules;
+	}
+
+	/**
+	 * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being added
+	 * @returns {boolean} returns true if chunk is not apart of chunkGroup and is added successfully
+	 */
+	addGroup(chunkGroup) {
+		if (this._groups.has(chunkGroup)) return false;
+		this._groups.add(chunkGroup);
+		return true;
+	}
+
+	/**
+	 * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being removed from
+	 * @returns {boolean} returns true if chunk does exist in chunkGroup and is removed
+	 */
+	removeGroup(chunkGroup) {
+		if (!this._groups.has(chunkGroup)) return false;
+		this._groups.delete(chunkGroup);
+		return true;
+	}
+
+	/**
+	 * @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 said chunk is in
+	 */
+	getNumberOfGroups() {
+		return this._groups.size;
+	}
+
+	/**
+	 * @returns {SortableSet<ChunkGroup>} the chunkGroups that said chunk is referenced in
+	 */
+	get groupsIterable() {
+		return this._groups;
+	}
+
+	/**
+	 * @param {Chunk} otherChunk the chunk to compare itself with
+	 * @returns {-1|0|1} this is a comparitor function like sort and returns -1, 0, or 1 based on sort order
+	 */
+	compareTo(otherChunk) {
+		if (this._modules.size > otherChunk._modules.size) return -1;
+		if (this._modules.size < otherChunk._modules.size) return 1;
+		this._modules.sort();
+		otherChunk._modules.sort();
+		const a = this._modules[Symbol.iterator]();
+		const b = otherChunk._modules[Symbol.iterator]();
+		// eslint-disable-next-line no-constant-condition
+		while (true) {
+			const aItem = a.next();
+			if (aItem.done) return 0;
+			const bItem = b.next();
+			const aModuleIdentifier = aItem.value.identifier();
+			const bModuleIdentifier = bItem.value.identifier();
+			if (aModuleIdentifier < bModuleIdentifier) return -1;
+			if (aModuleIdentifier > bModuleIdentifier) return 1;
+		}
+	}
+
+	/**
+	 * @param {Module} module Module to check
+	 * @returns {boolean} returns true if module does exist in this chunk
+	 */
+	containsModule(module) {
+		return this._modules.has(module);
+	}
+
+	getModules() {
+		return this._modules.getFromCache(getArray);
+	}
+
+	getModulesIdent() {
+		return this._modules.getFromUnorderedCache(getModulesIdent);
+	}
+
+	remove() {
+		// cleanup modules
+		// Array.from is used here to create a clone, because removeChunk modifies this._modules
+		for (const module of Array.from(this._modules)) {
+			module.removeChunk(this);
+		}
+		for (const chunkGroup of this._groups) {
+			chunkGroup.removeChunk(this);
+		}
+	}
+
+	/**
+	 *
+	 * @param {Module} module module to move
+	 * @param {Chunk} otherChunk other chunk to move it to
+	 * @returns {void}
+	 */
+	moveModule(module, otherChunk) {
+		GraphHelpers.disconnectChunkAndModule(this, module);
+		GraphHelpers.connectChunkAndModule(otherChunk, module);
+		module.rewriteChunkInReasons(this, [otherChunk]);
+	}
+
+	/**
+	 *
+	 * @param {Chunk} otherChunk the chunk to integrate with
+	 * @param {ModuleReason} reason reason why the module is being integrated
+	 * @returns {boolean} returns true or false if integration succeeds or fails
+	 */
+	integrate(otherChunk, reason) {
+		if (!this.canBeIntegrated(otherChunk)) {
+			return false;
+		}
+
+		// Array.from is used here to create a clone, because moveModule modifies otherChunk._modules
+		for (const module of Array.from(otherChunk._modules)) {
+			otherChunk.moveModule(module, this);
+		}
+		otherChunk._modules.clear();
+
+		for (const chunkGroup of otherChunk._groups) {
+			chunkGroup.replaceChunk(otherChunk, this);
+			this.addGroup(chunkGroup);
+		}
+		otherChunk._groups.clear();
+
+		if (this.name && otherChunk.name) {
+			if (this.name.length !== otherChunk.name.length) {
+				this.name =
+					this.name.length < otherChunk.name.length
+						? this.name
+						: otherChunk.name;
+			} else {
+				this.name = this.name < otherChunk.name ? this.name : otherChunk.name;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * @param {Chunk} newChunk the new chunk that will be split out of, and then chunk raphi twil=
+	 * @returns {void}
+	 */
+	split(newChunk) {
+		for (const chunkGroup of this._groups) {
+			chunkGroup.insertChunk(newChunk, this);
+			newChunk.addGroup(chunkGroup);
+		}
+	}
+
+	isEmpty() {
+		return this._modules.size === 0;
+	}
+
+	updateHash(hash) {
+		hash.update(`${this.id} `);
+		hash.update(this.ids ? this.ids.join(",") : "");
+		hash.update(`${this.name || ""} `);
+		for (const m of this._modules) {
+			hash.update(m.hash);
+		}
+	}
+
+	canBeIntegrated(otherChunk) {
+		const isAvailable = (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;
+		};
+
+		if (this.preventIntegration || otherChunk.preventIntegration) {
+			return false;
+		}
+
+		if (this.hasRuntime() !== otherChunk.hasRuntime()) {
+			if (this.hasRuntime()) {
+				return isAvailable(this, otherChunk);
+			} else if (otherChunk.hasRuntime()) {
+				return isAvailable(otherChunk, this);
+			} else {
+				return false;
+			}
+		}
+
+		if (this.hasEntryModule() || otherChunk.hasEntryModule()) {
+			return false;
+		}
+
+		return true;
+	}
+
+	/**
+	 *
+	 * @param {number} size the size
+	 * @param {Object} options the options passed in
+	 * @returns {number} the multiplier returned
+	 */
+	addMultiplierAndOverhead(size, options) {
+		const overhead =
+			typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000;
+		const multiplicator = this.canBeInitial()
+			? options.entryChunkMultiplicator || 10
+			: 1;
+
+		return size * multiplicator + overhead;
+	}
+
+	/**
+	 * @returns {number} the size of all modules
+	 */
+	modulesSize() {
+		return this._modules.getFromUnorderedCache(getModulesSize);
+	}
+
+	/**
+	 * @param {Object} options the size display options
+	 * @returns {number} the chunk size
+	 */
+	size(options) {
+		return this.addMultiplierAndOverhead(this.modulesSize(), options);
+	}
+
+	/**
+	 * @param {Chunk} otherChunk the other chunk
+	 * @param {TODO} options the options for this function
+	 * @returns {number | false} the size, or false if it can't be integrated
+	 */
+	integratedSize(otherChunk, options) {
+		// Chunk if it's possible to integrate this chunk
+		if (!this.canBeIntegrated(otherChunk)) {
+			return false;
+		}
+
+		let integratedModulesSize = this.modulesSize();
+		// only count modules that do not exist in this chunk!
+		for (const otherModule of otherChunk._modules) {
+			if (!this._modules.has(otherModule)) {
+				integratedModulesSize += otherModule.size();
+			}
+		}
+
+		return this.addMultiplierAndOverhead(integratedModulesSize, options);
+	}
+
+	/**
+	 * @param {function(Module, Module): -1|0|1=} sortByFn a predicate function used to sort modules
+	 * @returns {void}
+	 */
+	sortModules(sortByFn) {
+		this._modules.sortWith(sortByFn || sortModuleById);
+	}
+
+	sortItems() {
+		this.sortModules();
+	}
+
+	/**
+	 * @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))
+		);
+
+		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)) {
+					chunks.add(chunk);
+				}
+			}
+			for (const child of chunkGroup.childrenIterable) {
+				queue.add(child);
+			}
+		}
+
+		return chunks;
+	}
+
+	/**
+	 * @typedef {Object} ChunkMaps
+	 * @property {Record<string|number, string>} hash
+	 * @property {Record<string|number, Record<string, string>>} contentHash
+	 * @property {Record<string|number, string>} name
+	 */
+
+	/**
+	 * @param {boolean} realHash should the full hash or the rendered hash 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
+		};
+	}
+
+	/**
+	 * @returns {Record<string, Set<TODO>[]>} a record object of names to lists of child ids(?)
+	 */
+	getChildIdsByOrders() {
+		const lists = new Map();
+		for (const group of this.groupsIterable) {
+			if (group.chunks[group.chunks.length - 1] === this) {
+				for (const childGroup of group.childrenIterable) {
+					// TODO webpack 5 remove this check for options
+					if (typeof childGroup.options === "object") {
+						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) 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;
+				// TODO webpack 5 remove this check of compareTo
+				if (a.group.compareTo) {
+					return a.group.compareTo(b.group);
+				}
+				return 0;
+			});
+			result[name] = Array.from(
+				list.reduce((set, item) => {
+					for (const chunk of item.group.chunks) {
+						set.add(chunk.id);
+					}
+					return set;
+				}, new Set())
+			);
+		}
+		return result;
+	}
+
+	getChildIdsByOrdersMap(includeDirectChildren) {
+		const chunkMaps = Object.create(null);
+
+		const addChildIdsByOrdersToMap = chunk => {
+			const data = chunk.getChildIdsByOrders();
+			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) {
+			addChildIdsByOrdersToMap(this);
+		}
+
+		for (const chunk of this.getAllAsyncChunks()) {
+			addChildIdsByOrdersToMap(chunk);
+		}
+
+		return chunkMaps;
+	}
+
+	/**
+	 * @typedef {Object} ChunkModuleMaps
+	 * @property {Record<string|number, (string|number)[]>} id
+	 * @property {Record<string|number, string>} hash
+	 */
+
+	/**
+	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
+	 * @returns {ChunkModuleMaps} module map information
+	 */
+	getChunkModuleMaps(filterFn) {
+		/** @type {Record<string|number, (string|number)[]>} */
+		const chunkModuleIdMap = Object.create(null);
+		/** @type {Record<string|number, string>} */
+		const chunkModuleHashMap = Object.create(null);
+
+		for (const chunk of this.getAllAsyncChunks()) {
+			/** @type {(string|number)[]} */
+			let array;
+			for (const module of chunk.modulesIterable) {
+				if (filterFn(module)) {
+					if (array === undefined) {
+						array = [];
+						chunkModuleIdMap[chunk.id] = array;
+					}
+					array.push(module.id);
+					chunkModuleHashMap[module.id] = module.renderedHash;
+				}
+			}
+			if (array !== undefined) {
+				array.sort();
+			}
+		}
+
+		return {
+			id: chunkModuleIdMap,
+			hash: chunkModuleHashMap
+		};
+	}
+
+	/**
+	 *
+	 * @param {function(Module): boolean} filterFn predicate function used to filter modules
+	 * @param {function(Chunk): boolean} filterChunkFn predicate function used to filter chunks
+	 * @returns {boolean} return true if module exists in graph
+	 */
+	hasModuleInGraph(filterFn, filterChunkFn) {
+		const queue = new Set(this.groupsIterable);
+		const chunksProcessed = new Set();
+
+		for (const chunkGroup of queue) {
+			for (const chunk of chunkGroup.chunks) {
+				if (!chunksProcessed.has(chunk)) {
+					chunksProcessed.add(chunk);
+					if (!filterChunkFn || filterChunkFn(chunk)) {
+						for (const module of chunk.modulesIterable) {
+							if (filterFn(module)) {
+								return true;
+							}
+						}
+					}
+				}
+			}
+			for (const child of chunkGroup.childrenIterable) {
+				queue.add(child);
+			}
+		}
+		return false;
+	}
+
+	toString() {
+		return `Chunk[${Array.from(this._modules).join()}]`;
+	}
+}
+
+// TODO remove in webpack 5
+Object.defineProperty(Chunk.prototype, "forEachModule", {
+	configurable: false,
+	value: util.deprecate(
+		/**
+		 * @deprecated
+		 * @this {Chunk}
+		 * @typedef {function(any, any, Set<any>): void} ForEachModuleCallback
+		 * @param {ForEachModuleCallback} fn Callback function
+		 * @returns {void}
+		 */
+		function(fn) {
+			this._modules.forEach(fn);
+		},
+		"Chunk.forEachModule: Use for(const module of chunk.modulesIterable) instead"
+	)
+});
+
+// TODO remove in webpack 5
+Object.defineProperty(Chunk.prototype, "mapModules", {
+	configurable: false,
+	value: util.deprecate(
+		/**
+		 * @deprecated
+		 * @this {Chunk}
+		 * @typedef {function(any, number): any} MapModulesCallback
+		 * @param {MapModulesCallback} fn Callback function
+		 * @returns {TODO[]} result of mapped modules
+		 */
+		function(fn) {
+			return Array.from(this._modules, fn);
+		},
+		"Chunk.mapModules: Use Array.from(chunk.modulesIterable, fn) instead"
+	)
+});
+
+// TODO remove in webpack 5
+Object.defineProperty(Chunk.prototype, "chunks", {
+	configurable: false,
+	get() {
+		throw new Error("Chunk.chunks: Use ChunkGroup.getChildren() instead");
+	},
+	set() {
+		throw new Error("Chunk.chunks: Use ChunkGroup.add/removeChild() instead");
+	}
+});
+
+// TODO remove in webpack 5
+Object.defineProperty(Chunk.prototype, "parents", {
+	configurable: false,
+	get() {
+		throw new Error("Chunk.parents: Use ChunkGroup.getParents() instead");
+	},
+	set() {
+		throw new Error("Chunk.parents: Use ChunkGroup.add/removeParent() instead");
+	}
+});
+
+// TODO remove in webpack 5
+Object.defineProperty(Chunk.prototype, "blocks", {
+	configurable: false,
+	get() {
+		throw new Error("Chunk.blocks: Use ChunkGroup.getBlocks() instead");
+	},
+	set() {
+		throw new Error("Chunk.blocks: Use ChunkGroup.add/removeBlock() instead");
+	}
+});
+
+// TODO remove in webpack 5
+Object.defineProperty(Chunk.prototype, "entrypoints", {
+	configurable: false,
+	get() {
+		throw new Error(
+			"Chunk.entrypoints: Use Chunks.groupsIterable and filter by instanceof Entrypoint instead"
+		);
+	},
+	set() {
+		throw new Error("Chunk.entrypoints: Use Chunks.addGroup instead");
+	}
+});
+
+module.exports = Chunk;