webpack 4.14.0 → 4.16.1

package/lib/node/NodeMainTemplateAsync.runtime.js

@@ -37,7 +37,7 @@ module.exports = function() {
 		});
 	}
 
-	//eslint-disable-next-line no-unused-vars
+	// eslint-disable-next-line no-unused-vars
 	function hotDisposeChunk(chunkId) {
 		delete installedChunks[chunkId];
 	}

package/lib/node/NodeMainTemplatePlugin.js

@@ -305,8 +305,8 @@ module.exports = class NodeMainTemplatePlugin {
 				);
 				return Template.getFunctionContent(
 					asyncChunkLoading
-						? require("./NodeMainTemplateAsync.runtime.js")
-						: require("./NodeMainTemplate.runtime.js")
+						? require("./NodeMainTemplateAsync.runtime")
+						: require("./NodeMainTemplate.runtime")
 				)
 					.replace(/\$require\$/g, mainTemplate.requireFn)
 					.replace(/\$hotMainFilename\$/g, currentHotUpdateMainFilename)

package/lib/node/NodeOutputFileSystem.js

@@ -1,22 +1,22 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const mkdirp = require("mkdirp");
-
-class NodeOutputFileSystem {
-	constructor() {
-		this.mkdirp = mkdirp;
-		this.mkdir = fs.mkdir.bind(fs);
-		this.rmdir = fs.rmdir.bind(fs);
-		this.unlink = fs.unlink.bind(fs);
-		this.writeFile = fs.writeFile.bind(fs);
-		this.join = path.join.bind(path);
-	}
-}
-
-module.exports = NodeOutputFileSystem;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const mkdirp = require("mkdirp");
+
+class NodeOutputFileSystem {
+	constructor() {
+		this.mkdirp = mkdirp;
+		this.mkdir = fs.mkdir.bind(fs);
+		this.rmdir = fs.rmdir.bind(fs);
+		this.unlink = fs.unlink.bind(fs);
+		this.writeFile = fs.writeFile.bind(fs);
+		this.join = path.join.bind(path);
+	}
+}
+
+module.exports = NodeOutputFileSystem;

package/lib/node/NodeSourcePlugin.js

@@ -71,7 +71,7 @@ module.exports = class NodeSourcePlugin {
 							.tap("NodeSourcePlugin", () => {
 								const retrieveGlobalModule = ParserHelpers.requireFileAsExpression(
 									parser.state.module.context,
-									require.resolve("../../buildin/global.js")
+									require.resolve("../../buildin/global")
 								);
 								return ParserHelpers.addParsedVariableToModule(
 									parser,

package/lib/optimize/ConcatenatedModule.js

@@ -639,6 +639,7 @@ class ConcatenatedModule extends Module {
 
 		// Must use full identifier in our cache here to ensure that the source
 		// is updated should our dependencies list change.
+		// TODO webpack 5 refactor
 		innerDependencyTemplates.set(
 			"hash",
 			innerDependencyTemplates.get("hash") + this.identifier()

package/lib/optimize/NaturalChunkOrderPlugin.js

@@ -0,0 +1,41 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class NaturalChunkOrderPlugin {
+	/**
+	 * @param {Compiler} compiler webpack compiler
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("NaturalChunkOrderPlugin", compilation => {
+			compilation.hooks.optimizeChunkOrder.tap(
+				"NaturalChunkOrderPlugin",
+				chunks => {
+					chunks.sort((chunkA, chunkB) => {
+						const a = chunkA.modulesIterable[Symbol.iterator]();
+						const b = chunkB.modulesIterable[Symbol.iterator]();
+						// eslint-disable-next-line no-constant-condition
+						while (true) {
+							const aItem = a.next();
+							const bItem = b.next();
+							if (aItem.done && bItem.done) return 0;
+							if (aItem.done) return -1;
+							if (bItem.done) return 1;
+							const aModuleId = aItem.value.id;
+							const bModuleId = bItem.value.id;
+							if (aModuleId < bModuleId) return -1;
+							if (aModuleId > bModuleId) return 1;
+						}
+					});
+				}
+			);
+		});
+	}
+}
+
+module.exports = NaturalChunkOrderPlugin;

package/lib/optimize/OccurrenceChunkOrderPlugin.js

@@ -0,0 +1,61 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const validateOptions = require("schema-utils");
+const schema = require("../../schemas/plugins/optimize/OccurrenceOrderChunkIdsPlugin.json");
+
+class OccurrenceOrderChunkIdsPlugin {
+	constructor(options = {}) {
+		validateOptions(schema, options, "Occurrence Order Chunk Ids Plugin");
+		this.options = options;
+	}
+
+	apply(compiler) {
+		const prioritiseInitial = this.options.prioritiseInitial;
+		compiler.hooks.compilation.tap(
+			"OccurrenceOrderChunkIdsPlugin",
+			compilation => {
+				compilation.hooks.optimizeChunkOrder.tap(
+					"OccurrenceOrderChunkIdsPlugin",
+					chunks => {
+						const occursInInitialChunksMap = new Map();
+						const originalOrder = new Map();
+
+						let i = 0;
+						for (const c of chunks) {
+							let occurs = 0;
+							for (const chunkGroup of c.groupsIterable) {
+								for (const parent of chunkGroup.parentsIterable) {
+									if (parent.isInitial()) occurs++;
+								}
+							}
+							occursInInitialChunksMap.set(c, occurs);
+							originalOrder.set(c, i++);
+						}
+
+						chunks.sort((a, b) => {
+							if (prioritiseInitial) {
+								const aEntryOccurs = occursInInitialChunksMap.get(a);
+								const bEntryOccurs = occursInInitialChunksMap.get(b);
+								if (aEntryOccurs > bEntryOccurs) return -1;
+								if (aEntryOccurs < bEntryOccurs) return 1;
+							}
+							const aOccurs = a.getNumberOfGroups();
+							const bOccurs = b.getNumberOfGroups();
+							if (aOccurs > bOccurs) return -1;
+							if (aOccurs < bOccurs) return 1;
+							const orgA = originalOrder.get(a);
+							const orgB = originalOrder.get(b);
+							return orgA - orgB;
+						});
+					}
+				);
+			}
+		);
+	}
+}
+
+module.exports = OccurrenceOrderChunkIdsPlugin;

package/lib/optimize/OccurrenceModuleOrderPlugin.js

@@ -0,0 +1,103 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const validateOptions = require("schema-utils");
+const schema = require("../../schemas/plugins/optimize/OccurrenceOrderModuleIdsPlugin.json");
+
+class OccurrenceOrderModuleIdsPlugin {
+	constructor(options = {}) {
+		validateOptions(schema, options, "Occurrence Order Module Ids Plugin");
+		this.options = options;
+	}
+
+	apply(compiler) {
+		const prioritiseInitial = this.options.prioritiseInitial;
+		compiler.hooks.compilation.tap(
+			"OccurrenceOrderModuleIdsPlugin",
+			compilation => {
+				compilation.hooks.optimizeModuleOrder.tap(
+					"OccurrenceOrderModuleIdsPlugin",
+					modules => {
+						const occursInInitialChunksMap = new Map();
+						const occursInAllChunksMap = new Map();
+
+						const initialChunkChunkMap = new Map();
+						const entryCountMap = new Map();
+						for (const m of modules) {
+							let initial = 0;
+							let entry = 0;
+							for (const c of m.chunksIterable) {
+								if (c.canBeInitial()) initial++;
+								if (c.entryModule === m) entry++;
+							}
+							initialChunkChunkMap.set(m, initial);
+							entryCountMap.set(m, entry);
+						}
+
+						const countOccursInEntry = (sum, r) => {
+							if (!r.module) {
+								return sum;
+							}
+							return sum + initialChunkChunkMap.get(r.module);
+						};
+						const countOccurs = (sum, r) => {
+							if (!r.module) {
+								return sum;
+							}
+							let factor = 1;
+							if (typeof r.dependency.getNumberOfIdOccurrences === "function") {
+								factor = r.dependency.getNumberOfIdOccurrences();
+							}
+							if (factor === 0) {
+								return sum;
+							}
+							return sum + factor * r.module.getNumberOfChunks();
+						};
+
+						if (prioritiseInitial) {
+							for (const m of modules) {
+								const result =
+									m.reasons.reduce(countOccursInEntry, 0) +
+									initialChunkChunkMap.get(m) +
+									entryCountMap.get(m);
+								occursInInitialChunksMap.set(m, result);
+							}
+						}
+
+						const originalOrder = new Map();
+						let i = 0;
+						for (const m of modules) {
+							const result =
+								m.reasons.reduce(countOccurs, 0) +
+								m.getNumberOfChunks() +
+								entryCountMap.get(m);
+							occursInAllChunksMap.set(m, result);
+							originalOrder.set(m, i++);
+						}
+
+						modules.sort((a, b) => {
+							if (prioritiseInitial) {
+								const aEntryOccurs = occursInInitialChunksMap.get(a);
+								const bEntryOccurs = occursInInitialChunksMap.get(b);
+								if (aEntryOccurs > bEntryOccurs) return -1;
+								if (aEntryOccurs < bEntryOccurs) return 1;
+							}
+							const aOccurs = occursInAllChunksMap.get(a);
+							const bOccurs = occursInAllChunksMap.get(b);
+							if (aOccurs > bOccurs) return -1;
+							if (aOccurs < bOccurs) return 1;
+							const orgA = originalOrder.get(a);
+							const orgB = originalOrder.get(b);
+							return orgA - orgB;
+						});
+					}
+				);
+			}
+		);
+	}
+}
+
+module.exports = OccurrenceOrderModuleIdsPlugin;

package/lib/optimize/OccurrenceOrderPlugin.js

@@ -4,6 +4,8 @@
 */
 "use strict";
 
+// TODO webpack 5 remove this plugin
+// It has been splitted into separate plugins for modules and chunks
 class OccurrenceOrderPlugin {
 	constructor(preferEntry) {
 		if (preferEntry !== undefined && typeof preferEntry !== "boolean") {
@@ -89,7 +91,7 @@ class OccurrenceOrderPlugin {
 						if (aOccurs < bOccurs) return 1;
 						const orgA = originalOrder.get(a);
 						const orgB = originalOrder.get(b);
-						return orgB - orgA;
+						return orgA - orgB;
 					});
 				}
 			);
@@ -122,7 +124,7 @@ class OccurrenceOrderPlugin {
 						if (aOccurs < bOccurs) return 1;
 						const orgA = originalOrder.get(a);
 						const orgB = originalOrder.get(b);
-						return orgB - orgA;
+						return orgA - orgB;
 					});
 				}
 			);

package/lib/optimize/SplitChunksPlugin.js

@@ -8,9 +8,16 @@ const crypto = require("crypto");
 const SortableSet = require("../util/SortableSet");
 const GraphHelpers = require("../GraphHelpers");
 const { isSubset } = require("../util/SetHelpers");
+const deterministicGrouping = require("../util/deterministicGrouping");
+const contextify = require("../util/identifier").contextify;
 
+/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
+/** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
+
+const deterministicGroupingForModules = /** @type {function(DeterministicGroupingOptionsForModule): DeterministicGroupingGroupedItemsForModule[]} */ (deterministicGrouping);
 
 const hashFilename = name => {
 	return crypto
@@ -104,25 +111,29 @@ module.exports = class SplitChunksPlugin {
 				options.chunks || "all"
 			),
 			minSize: options.minSize || 0,
+			maxSize: options.maxSize || 0,
 			minChunks: options.minChunks || 1,
 			maxAsyncRequests: options.maxAsyncRequests || 1,
 			maxInitialRequests: options.maxInitialRequests || 1,
-			getName:
-				SplitChunksPlugin.normalizeName({
-					name: options.name,
-					automaticNameDelimiter: options.automaticNameDelimiter
-				}) || (() => {}),
+			hidePathInfo: options.hidePathInfo || false,
 			filename: options.filename || undefined,
 			getCacheGroups: SplitChunksPlugin.normalizeCacheGroups({
 				cacheGroups: options.cacheGroups,
+				name: options.name,
 				automaticNameDelimiter: options.automaticNameDelimiter
-			})
+			}),
+			automaticNameDelimiter: options.automaticNameDelimiter,
+			fallbackCacheGroup: SplitChunksPlugin.normalizeFallbackCacheGroup(
+				options.fallbackCacheGroup || {},
+				options
+			)
 		};
 	}
 
-	static normalizeName({ name, automaticNameDelimiter }) {
+	static normalizeName({ name, automaticNameDelimiter, automaticNamePrefix }) {
 		if (name === true) {
-			const cache = new Map();
+			/** @type {WeakMap<Chunk[], Record<string, string>>} */
+			const cache = new WeakMap();
 			const fn = (module, chunks, cacheGroup) => {
 				let cacheEntry = cache.get(chunks);
 				if (cacheEntry === undefined) {
@@ -137,10 +148,12 @@ module.exports = class SplitChunksPlugin {
 					return;
 				}
 				names.sort();
-				let name =
-					(cacheGroup && cacheGroup !== "default"
-						? cacheGroup + automaticNameDelimiter
-						: "") + names.join(automaticNameDelimiter);
+				const prefix =
+					typeof automaticNamePrefix === "string"
+						? automaticNamePrefix
+						: cacheGroup;
+				const namePrefix = prefix ? prefix + automaticNameDelimiter : "";
+				let name = namePrefix + names.join(automaticNameDelimiter);
 				// Filenames and paths can't be too long otherwise an
 				// ENAMETOOLONG error is raised. If the generated name if too
 				// long, it is truncated and a hash is appended. The limit has
@@ -177,7 +190,27 @@ module.exports = class SplitChunksPlugin {
 		if (typeof chunks === "function") return chunks;
 	}
 
-	static normalizeCacheGroups({ cacheGroups, automaticNameDelimiter }) {
+	static normalizeFallbackCacheGroup(
+		{
+			minSize = undefined,
+			maxSize = undefined,
+			automaticNameDelimiter = undefined
+		},
+		{
+			minSize: defaultMinSize = undefined,
+			maxSize: defaultMaxSize = undefined,
+			automaticNameDelimiter: defaultAutomaticNameDelimiter = undefined
+		}
+	) {
+		return {
+			minSize: typeof minSize === "number" ? minSize : defaultMinSize || 0,
+			maxSize: typeof maxSize === "number" ? maxSize : defaultMaxSize || 0,
+			automaticNameDelimiter:
+				automaticNameDelimiter || defaultAutomaticNameDelimiter || "~"
+		};
+	}
+
+	static normalizeCacheGroups({ cacheGroups, name, automaticNameDelimiter }) {
 		if (typeof cacheGroups === "function") {
 			// TODO webpack 5 remove this
 			if (cacheGroups.length !== 1) {
@@ -216,15 +249,21 @@ module.exports = class SplitChunksPlugin {
 						results.push({
 							key: key,
 							priority: option.priority,
-							getName: SplitChunksPlugin.normalizeName({
-								name: option.name,
-								automaticNameDelimiter
-							}),
+							getName:
+								SplitChunksPlugin.normalizeName({
+									name: option.name || name,
+									automaticNameDelimiter:
+										typeof option.automaticNameDelimiter === "string"
+											? option.automaticNameDelimiter
+											: automaticNameDelimiter,
+									automaticNamePrefix: option.automaticNamePrefix
+								}) || (() => {}),
 							chunksFilter: SplitChunksPlugin.normalizeChunksFilter(
 								option.chunks
 							),
 							enforce: option.enforce,
 							minSize: option.minSize,
+							maxSize: option.maxSize,
 							minChunks: option.minChunks,
 							maxAsyncRequests: option.maxAsyncRequests,
 							maxInitialRequests: option.maxInitialRequests,
@@ -278,6 +317,10 @@ module.exports = class SplitChunksPlugin {
 		return false;
 	}
 
+	/**
+	 * @param {Compiler} compiler webpack compiler
+	 * @returns {void}
+	 */
 	apply(compiler) {
 		compiler.hooks.thisCompilation.tap("SplitChunksPlugin", compilation => {
 			let alreadyOptimized = false;
@@ -447,6 +490,12 @@ module.exports = class SplitChunksPlugin {
 									chunksKeys: new Set()
 								})
 							);
+						} else {
+							if (info.cacheGroup !== cacheGroup) {
+								if (info.cacheGroup.priority < cacheGroup.priority) {
+									info.cacheGroup = cacheGroup;
+								}
+							}
 						}
 						info.modules.add(module);
 						info.size += module.size();
@@ -486,6 +535,12 @@ module.exports = class SplitChunksPlugin {
 										: cacheGroupSource.enforce
 											? 0
 											: this.options.minSize,
+								maxSize:
+									cacheGroupSource.maxSize !== undefined
+										? cacheGroupSource.maxSize
+										: cacheGroupSource.enforce
+											? 0
+											: this.options.maxSize,
 								minChunks:
 									cacheGroupSource.minChunks !== undefined
 										? cacheGroupSource.minChunks
@@ -512,6 +567,10 @@ module.exports = class SplitChunksPlugin {
 									cacheGroupSource.filename !== undefined
 										? cacheGroupSource.filename
 										: this.options.filename,
+								automaticNameDelimiter:
+									cacheGroupSource.automaticNameDelimiter !== undefined
+										? cacheGroupSource.automaticNameDelimiter
+										: this.options.automaticNameDelimiter,
 								reuseExistingChunk: cacheGroupSource.reuseExistingChunk
 							};
 							// For all combination of chunk selection
@@ -537,6 +596,9 @@ module.exports = class SplitChunksPlugin {
 						}
 					}
 
+					/** @type {Map<Chunk, {minSize: number, maxSize: number, automaticNameDelimiter: string}>} */
+					const maxSizeQueueMap = new Map();
+
 					while (chunksInfoMap.size > 0) {
 						// Find best matching entry
 						let bestEntryKey;
@@ -563,6 +625,7 @@ module.exports = class SplitChunksPlugin {
 
 						let chunkName = item.name;
 						// Variable for the new chunk (lazy created)
+						/** @type {Chunk} */
 						let newChunk;
 						// When no chunk name, check if we can reuse a chunk instead of creating a new one
 						let isReused = false;
@@ -591,7 +654,7 @@ module.exports = class SplitChunksPlugin {
 								isReused = true;
 							}
 						}
-						// Check if maxRequests condition can be fullfilled
+						// Check if maxRequests condition can be fulfilled
 
 						const usedChunks = Array.from(item.chunks).filter(chunk => {
 							// skip if we address ourself
@@ -689,6 +752,22 @@ module.exports = class SplitChunksPlugin {
 								}
 							}
 						}
+
+						if (item.cacheGroup.maxSize > 0) {
+							const oldMaxSizeSettings = maxSizeQueueMap.get(newChunk);
+							maxSizeQueueMap.set(newChunk, {
+								minSize: Math.max(
+									oldMaxSizeSettings ? oldMaxSizeSettings.minSize : 0,
+									item.cacheGroup.minSize
+								),
+								maxSize: Math.min(
+									oldMaxSizeSettings ? oldMaxSizeSettings.maxSize : Infinity,
+									item.cacheGroup.maxSize
+								),
+								automaticNameDelimiter: item.cacheGroup.automaticNameDelimiter
+							});
+						}
+
 						// remove all modules from other entries and update size
 						for (const [key, info] of chunksInfoMap) {
 							if (isOverlap(info.chunks, item.chunks)) {
@@ -709,6 +788,77 @@ module.exports = class SplitChunksPlugin {
 							}
 						}
 					}
+
+					// Make sure that maxSize is fulfilled
+					for (const chunk of compilation.chunks.slice()) {
+						const { minSize, maxSize, automaticNameDelimiter } =
+							maxSizeQueueMap.get(chunk) || this.options.fallbackCacheGroup;
+						if (!maxSize) continue;
+						const results = deterministicGroupingForModules({
+							maxSize,
+							minSize,
+							items: chunk.modulesIterable,
+							getKey(module) {
+								const ident = contextify(
+									compilation.options.context,
+									module.identifier()
+								);
+								const name = module.nameForCondition
+									? contextify(
+											compilation.options.context,
+											module.nameForCondition()
+									  )
+									: ident.replace(/^.*!|\?[^?!]*$/g, "");
+								const fullKey =
+									name + automaticNameDelimiter + hashFilename(ident);
+								return fullKey.replace(/[\\/?]/g, "_");
+							},
+							getSize(module) {
+								return module.size();
+							}
+						});
+						results.sort((a, b) => {
+							if (a.key < b.key) return -1;
+							if (a.key > b.key) return 1;
+							return 0;
+						});
+						for (let i = 0; i < results.length; i++) {
+							const group = results[i];
+							const key = this.options.hidePathInfo
+								? hashFilename(group.key)
+								: group.key;
+							let name = chunk.name
+								? chunk.name + automaticNameDelimiter + key
+								: null;
+							if (name && name.length > 100) {
+								name =
+									name.slice(0, 100) +
+									automaticNameDelimiter +
+									hashFilename(name);
+							}
+							let newPart;
+							if (i !== results.length - 1) {
+								newPart = compilation.addChunk(name);
+								chunk.split(newPart);
+								newPart.chunkReason = chunk.chunkReason;
+								// Add all modules to the new chunk
+								for (const module of group.items) {
+									if (typeof module.chunkCondition === "function") {
+										if (!module.chunkCondition(newPart)) continue;
+									}
+									// Add module to new chunk
+									GraphHelpers.connectChunkAndModule(newPart, module);
+									// Remove module from used chunks
+									chunk.removeModule(module);
+									module.rewriteChunkInReasons(chunk, [newPart]);
+								}
+							} else {
+								// change the chunk to be a part
+								newPart = chunk;
+								chunk.name = name;
+							}
+						}
+					}
 				}
 			);
 		});

package/lib/util/Semaphore.js

@@ -5,12 +5,24 @@
 "use strict";
 
 class Semaphore {
+	/**
+	 * Creates an instance of Semaphore.
+	 *
+	 * @param {number} available the amount available number of "tasks"
+	 * in the Semaphore
+	 */
 	constructor(available) {
 		this.available = available;
+		/** @type {(function(): void)[]} */
 		this.waiters = [];
+		/** @private */
 		this._continue = this._continue.bind(this);
 	}
 
+	/**
+	 * @param {function(): void} callback function block to capture and run
+	 * @returns {void}
+	 */
 	acquire(callback) {
 		if (this.available > 0) {
 			this.available--;

package/lib/util/SetHelpers.js

@@ -5,7 +5,7 @@
  * @param {Set[]} sets an array of sets being checked for shared elements
  * @returns {Set<TODO>} returns a new Set containing the intersecting items
  */
-function intersect(sets) {
+const intersect = sets => {
 	if (sets.length === 0) return new Set();
 	if (sets.length === 1) return new Set(sets[0]);
 	let minSize = Infinity;
@@ -28,7 +28,7 @@ function intersect(sets) {
 		}
 	}
 	return current;
-}
+};
 
 /**
  * Checks if a set is the subset of another set
@@ -36,13 +36,13 @@ function intersect(sets) {
  * @param {Set<TODO>} smallSet the set whos elements might be contained inside of bigSet
  * @returns {boolean} returns true if smallSet contains all elements inside of the bigSet
  */
-function isSubset(bigSet, smallSet) {
+const isSubset = (bigSet, smallSet) => {
 	if (bigSet.size < smallSet.size) return false;
 	for (const item of smallSet) {
 		if (!bigSet.has(item)) return false;
 	}
 	return true;
-}
+};
 
 exports.intersect = intersect;
 exports.isSubset = isSubset;

package/lib/util/SortableSet.js

@@ -7,7 +7,7 @@
 class SortableSet extends Set {
 	/**
 	 * Create a new sortable set
-	 * @param {Array<T>=} initialIterable The initial iterable value
+	 * @param {Iterable<T>=} initialIterable The initial iterable value
 	 * @typedef {function(T, T): number} SortFunction
 	 * @param {SortFunction=} defaultSort Default sorting function
 	 */