webpack 5.18.0 → 5.20.2

package/lib/async-modules/AwaitDependenciesInitFragment.js

@@ -7,6 +7,7 @@
 
 const InitFragment = require("../InitFragment");
 const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
@@ -45,11 +46,20 @@ class AwaitDependenciesInitFragment extends InitFragment {
 		}
 		if (promises.size === 1) {
 			for (const p of promises) {
-				return `${p} = await Promise.resolve(${p});\n`;
+				return Template.asString([
+					`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${p}]);`,
+					`${p} = (__webpack_async_dependencies__.then ? await __webpack_async_dependencies__ : __webpack_async_dependencies__)[0];`,
+					""
+				]);
 			}
 		}
 		const sepPromises = Array.from(promises).join(", ");
-		return `([${sepPromises}] = await Promise.all([${sepPromises}]));\n`;
+		// TODO check if destructuring is supported
+		return Template.asString([
+			`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${sepPromises}]);`,
+			`([${sepPromises}] = __webpack_async_dependencies__.then ? await __webpack_async_dependencies__ : __webpack_async_dependencies__);`,
+			""
+		]);
 	}
 }
 

package/lib/cache/IdleFileCachePlugin.js

@@ -127,9 +127,15 @@ class IdleFileCachePlugin {
 					});
 					return;
 				}
-				currentIdlePromise = currentIdlePromise.then(() =>
-					strategy.afterAllStored()
-				);
+				currentIdlePromise = currentIdlePromise
+					.then(() => strategy.afterAllStored())
+					.catch(err => {
+						const logger = compiler.getInfrastructureLogger(
+							"IdleFileCachePlugin"
+						);
+						logger.warn(`Background tasks during idle failed: ${err.message}`);
+						logger.debug(err.stack);
+					});
 				isInitialStore = false;
 			}
 		};

package/lib/config/defaults.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const fs = require("fs");
 const path = require("path");
 const Template = require("../Template");
 const { cleverMerge } = require("../util/cleverMerge");
@@ -262,9 +263,19 @@ const applyCacheDefaults = (cache, { name, mode }) => {
 			F(cache, "name", () => name + "-" + mode);
 			D(cache, "version", "");
 			F(cache, "cacheDirectory", () => {
-				const pkgDir = require("pkg-dir");
 				const cwd = process.cwd();
-				const dir = pkgDir.sync(cwd);
+				let dir = cwd;
+				for (;;) {
+					try {
+						if (fs.statSync(path.join(dir, "package.json")).isFile()) break;
+						// eslint-disable-next-line no-empty
+					} catch (e) {}
+					const parent = path.dirname(dir);
+					if (dir === parent) {
+						dir = undefined;
+						break;
+					}
+				}
 				if (!dir) {
 					return path.resolve(cwd, ".cache/webpack");
 				} else if (process.versions.pnp === "1") {

package/lib/config/normalization.js

@@ -277,6 +277,7 @@ const getNormalizedWebpackOptions = config => {
 				chunkLoading: output.chunkLoading,
 				chunkLoadingGlobal: output.chunkLoadingGlobal,
 				chunkLoadTimeout: output.chunkLoadTimeout,
+				clean: output.clean,
 				compareBeforeEmit: output.compareBeforeEmit,
 				crossOriginLoading: output.crossOriginLoading,
 				devtoolFallbackModuleFilenameTemplate:

package/lib/container/ContainerEntryModule.js

@@ -31,6 +31,7 @@ const ContainerExposedDependency = require("./ContainerExposedDependency");
 /**
  * @typedef {Object} ExposeOptions
  * @property {string[]} import requests to exposed modules (last one is exported)
+ * @property {string} name custom chunk name for the exposed module
  */
 
 const SOURCE_TYPES = new Set(["javascript"]);
@@ -107,7 +108,9 @@ class ContainerEntryModule extends Module {
 
 		for (const [name, options] of this._exposes) {
 			const block = new AsyncDependenciesBlock(
-				undefined,
+				{
+					name: options.name
+				},
 				{ name },
 				options.import[options.import.length - 1]
 			);

package/lib/container/ContainerPlugin.js

@@ -35,10 +35,12 @@ class ContainerPlugin {
 			exposes: parseOptions(
 				options.exposes,
 				item => ({
-					import: Array.isArray(item) ? item : [item]
+					import: Array.isArray(item) ? item : [item],
+					name: undefined
 				}),
 				item => ({
-					import: Array.isArray(item.import) ? item.import : [item.import]
+					import: Array.isArray(item.import) ? item.import : [item.import],
+					name: item.name || undefined
 				})
 			)
 		};

package/lib/dependencies/HarmonyCompatibilityDependency.js

@@ -70,15 +70,16 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 		}
 		if (moduleGraph.isAsync(module)) {
 			runtimeRequirements.add(RuntimeGlobals.module);
-			const used = exportsInfo.isUsed(runtime);
-			if (used) runtimeRequirements.add(RuntimeGlobals.exports);
+			runtimeRequirements.add(RuntimeGlobals.asyncModule);
 			initFragments.push(
 				new InitFragment(
-					`${module.moduleArgument}.exports = (async () => {\n`,
+					`${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async (__webpack_handle_async_dependencies__) => {\n`,
 					InitFragment.STAGE_ASYNC_BOUNDARY,
 					0,
 					undefined,
-					used ? `\nreturn ${module.exportsArgument};\n})();` : "\n})();"
+					module.buildMeta.async
+						? `\n__webpack_handle_async_dependencies__();\n}, 1);`
+						: "\n});"
 				)
 			);
 		}

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -361,7 +361,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
 	 */
 	getCondition(moduleGraph) {
 		return (connection, runtime) => {

package/lib/dependencies/HarmonyImportSideEffectDependency.js

@@ -30,7 +30,7 @@ class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
 	 */
 	getCondition(moduleGraph) {
 		return connection => {

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -6,7 +6,9 @@
 "use strict";
 
 const Dependency = require("../Dependency");
-const { isDependencyUsedByExports } = require("../optimize/InnerGraph");
+const {
+	getDependencyUsedByExportsCondition
+} = require("../optimize/InnerGraph");
 const makeSerializable = require("../util/makeSerializable");
 const propertyAccess = require("../util/propertyAccess");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
@@ -66,7 +68,10 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	 * @returns {string[]} the imported ids
 	 */
 	getIds(moduleGraph) {
-		return moduleGraph.getMeta(this)[idsSymbol] || this.ids;
+		const meta = moduleGraph.getMetaIfExisting(this);
+		if (meta === undefined) return this.ids;
+		const ids = meta[idsSymbol];
+		return ids !== undefined ? ids : this.ids;
 	}
 
 	/**
@@ -80,11 +85,14 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
 	 */
 	getCondition(moduleGraph) {
-		return (connection, runtime) =>
-			isDependencyUsedByExports(this, this.usedByExports, moduleGraph, runtime);
+		return getDependencyUsedByExportsCondition(
+			this,
+			this.usedByExports,
+			moduleGraph
+		);
 	}
 
 	/**

package/lib/dependencies/URLDependency.js

@@ -6,7 +6,9 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
-const { isDependencyUsedByExports } = require("../optimize/InnerGraph");
+const {
+	getDependencyUsedByExportsCondition
+} = require("../optimize/InnerGraph");
 const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
@@ -45,11 +47,14 @@ class URLDependency extends ModuleDependency {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
 	 */
 	getCondition(moduleGraph) {
-		return (connection, runtime) =>
-			isDependencyUsedByExports(this, this.usedByExports, moduleGraph, runtime);
+		return getDependencyUsedByExportsCondition(
+			this,
+			this.usedByExports,
+			moduleGraph
+		);
 	}
 
 	serialize(context) {

package/lib/hmr/LazyCompilationPlugin.js

@@ -32,6 +32,27 @@ const { registerNotSerializable } = require("../util/serialization");
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
+/**
+ * @param {undefined|string|RegExp|Function} test test option
+ * @param {Module} module the module
+ * @returns {boolean} true, if the module should be selected
+ */
+const checkTest = (test, module) => {
+	if (test === undefined) return true;
+	if (typeof test === "function") {
+		return test(module);
+	}
+	if (typeof test === "string") {
+		const name = module.nameForCondition();
+		return name && name.startsWith(test);
+	}
+	if (test instanceof RegExp) {
+		const name = module.nameForCondition();
+		return name && test.test(name);
+	}
+	return false;
+};
+
 const TYPES = new Set(["javascript"]);
 
 class LazyCompilationDependency extends Dependency {
@@ -272,11 +293,15 @@ class LazyCompilationPlugin {
 	 * @param {(function(Compiler, string, function(Error?, any?): void): void) | function(Compiler, string): Promise<any>} options.backend the backend
 	 * @param {string} options.client the client reference
 	 * @param {boolean} options.entries true, when entries are lazy compiled
+	 * @param {boolean} options.imports true, when import() modules are lazy compiled
+	 * @param {RegExp | string | (function(Module): boolean)} options.test additional filter for lazy compiled entrypoint modules
 	 */
-	constructor({ backend, client, entries }) {
+	constructor({ backend, client, entries, imports, test }) {
 		this.backend = backend;
 		this.client = client;
 		this.entries = entries;
+		this.imports = imports;
+		this.test = test;
 	}
 	/**
 	 * Apply the plugin
@@ -311,12 +336,13 @@ class LazyCompilationPlugin {
 						if (
 							resolveData.dependencies.every(
 								dep =>
-									dep.type === "import()" ||
+									(this.imports && dep.type === "import()") ||
 									(this.entries && dep.type === "entry")
 							) &&
 							!/webpack[/\\]hot[/\\]|webpack-dev-server[/\\]client/.test(
 								resolveData.request
-							)
+							) &&
+							checkTest(this.test, originalModule)
 						) {
 							const moduleInfo = backend.module(originalModule);
 							if (!moduleInfo) return;

package/lib/hmr/lazyCompilationBackend.js

@@ -19,6 +19,7 @@ module.exports = (compiler, client, callback) => {
 	const logger = compiler.getInfrastructureLogger("LazyCompilationBackend");
 	const activeModules = new Map();
 	const prefix = "/lazy-compilation-using-";
+
 	const server = http.createServer((req, res) => {
 		const keys = req.url.slice(prefix.length).split("@");
 		req.socket.on("close", () => {
@@ -74,9 +75,7 @@ module.exports = (compiler, client, callback) => {
 				).replace(/%(2F|3A|24|26|2B|2C|3B|3D|3A)/g, decodeURIComponent)}`;
 				const active = activeModules.get(key) > 0;
 				return {
-					client: `webpack/hot/lazy-compilation-${
-						compiler.options.externalsPresets.node ? "node" : "web"
-					}.js?${encodeURIComponent(urlBase + prefix)}`,
+					client: `${client}?${encodeURIComponent(urlBase + prefix)}`,
 					data: key,
 					active
 				};

package/lib/index.js

@@ -10,6 +10,7 @@ const memoize = require("./util/memoize");
 
 /** @typedef {import("../declarations/WebpackOptions").Entry} Entry */
 /** @typedef {import("../declarations/WebpackOptions").EntryNormalized} EntryNormalized */
+/** @typedef {import("../declarations/WebpackOptions").EntryObject} EntryObject */
 /** @typedef {import("../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../declarations/WebpackOptions").ModuleOptions} ModuleOptions */
 /** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
@@ -109,6 +110,9 @@ module.exports = mergeExports(fn, {
 	get ChunkGraph() {
 		return require("./ChunkGraph");
 	},
+	get CleanPlugin() {
+		return require("./CleanPlugin");
+	},
 	get Compilation() {
 		return require("./Compilation");
 	},

package/lib/javascript/JavascriptModulesPlugin.js

@@ -965,7 +965,7 @@ class JavascriptModulesPlugin {
 				buf.push(
 					"// the startup function",
 					"// It's empty as no entry modules are in this chunk",
-					`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()}`,
+					`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`,
 					""
 				);
 			}
@@ -978,7 +978,7 @@ class JavascriptModulesPlugin {
 			buf.push(
 				"// the startup function",
 				"// It's empty as some runtime module handles the default behavior",
-				`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()}`
+				`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
 			);
 			startup.push("// run startup");
 			startup.push(`${maybeReturn}${RuntimeGlobals.startup}();`);

package/lib/optimize/InnerGraph.js

@@ -10,6 +10,8 @@ const { UsageState } = require("../ExportsInfo");
 /** @typedef {import("estree").Node} AnyNode */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
@@ -286,6 +288,32 @@ exports.isDependencyUsedByExports = (
 	return true;
 };
 
+/**
+ * @param {Dependency} dependency the dependency
+ * @param {Set<string> | boolean} usedByExports usedByExports info
+ * @param {ModuleGraph} moduleGraph moduleGraph
+ * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+ */
+exports.getDependencyUsedByExportsCondition = (
+	dependency,
+	usedByExports,
+	moduleGraph
+) => {
+	if (usedByExports === false) return false;
+	if (usedByExports !== true && usedByExports !== undefined) {
+		const selfModule = moduleGraph.getParentModule(dependency);
+		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
+		return (connections, runtime) => {
+			for (const exportName of usedByExports) {
+				if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused)
+					return true;
+			}
+			return false;
+		};
+	}
+	return null;
+};
+
 class TopLevelSymbol {
 	/**
 	 * @param {string} name name of the variable

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -0,0 +1,137 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+class AsyncModuleRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("async module");
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.asyncModule;
+		return Template.asString([
+			'var webpackThen = typeof Symbol === "function" ? Symbol("webpack then") : "__webpack_then__";',
+			'var webpackExports = typeof Symbol === "function" ? Symbol("webpack exports") : "__webpack_exports__";',
+			`var completeQueue = ${runtimeTemplate.basicFunction("queue", [
+				"if(queue) {",
+				Template.indent(
+					runtimeTemplate.supportsArrowFunction()
+						? [
+								"queue.forEach(fn => fn.r--);",
+								"queue.forEach(fn => fn.r-- ? fn.r++ : fn());"
+						  ]
+						: [
+								"queue.forEach(function(fn) { fn.r--; });",
+								"queue.forEach(function(fn) { fn.r-- ? fn.r++ : fn(); });"
+						  ]
+				),
+				"}"
+			])}`,
+			`var completeFunction = ${
+				runtimeTemplate.supportsArrowFunction()
+					? "fn => !--fn.r && fn()"
+					: "function(fn) { !--fn.r && fn(); }"
+			};`,
+			`var queueFunction = ${
+				runtimeTemplate.supportsArrowFunction()
+					? "(queue, fn) => queue ? queue.push(fn) : completeFunction(fn)"
+					: "function(queue, fn) { queue ? queue.push(fn) : completeFunction(fn); }"
+			};`,
+			`var wrapDeps = ${runtimeTemplate.returningFunction(
+				`deps.map(${runtimeTemplate.basicFunction("dep", [
+					'if(dep !== null && typeof dep === "object") {',
+					Template.indent([
+						"if(dep[webpackThen]) return dep;",
+						"if(dep.then) {",
+						Template.indent([
+							"var queue = [], result;",
+							`dep.then(${runtimeTemplate.basicFunction("r", [
+								"obj[webpackExports] = r;",
+								"completeQueue(queue);",
+								"queue = 0;"
+							])});`,
+							"var obj = { [webpackThen]: (fn, reject) => { queueFunction(queue, fn); dep.catch(reject); } };",
+							"return obj;"
+						]),
+						"}"
+					]),
+					"}",
+					"return { [webpackThen]: (fn) => { completeFunction(fn); }, [webpackExports]: dep };"
+				])})`,
+				"deps"
+			)};`,
+			`${fn} = ${runtimeTemplate.basicFunction("module, body, hasAwait", [
+				"var queue = hasAwait && [];",
+				"var exports = module.exports;",
+				"var currentDeps;",
+				"var outerResolve;",
+				"var reject;",
+				"var isEvaluating = true;",
+				"var nested = false;",
+				`var whenAll = ${runtimeTemplate.basicFunction(
+					"deps, onResolve, onReject",
+					[
+						"if (nested) return;",
+						"nested = true;",
+						"onResolve.r += deps.length;",
+						`deps.map(${runtimeTemplate.basicFunction("dep, i", [
+							"dep[webpackThen](onResolve, onReject);"
+						])});`,
+						"nested = false;"
+					]
+				)};`,
+				`var promise = new Promise(${runtimeTemplate.basicFunction(
+					"resolve, rej",
+					[
+						"reject = rej;",
+						`outerResolve = ${runtimeTemplate.basicFunction("", [
+							"resolve(exports);",
+							"completeQueue(queue);",
+							"queue = 0;"
+						])};`
+					]
+				)});`,
+				"promise[webpackExports] = exports;",
+				`promise[webpackThen] = ${runtimeTemplate.basicFunction(
+					"fn, rejectFn",
+					[
+						"if (isEvaluating) { return completeFunction(fn); }",
+						"if (currentDeps) whenAll(currentDeps, fn, rejectFn);",
+						"queueFunction(queue, fn);",
+						"promise.catch(rejectFn);"
+					]
+				)};`,
+				"module.exports = promise;",
+				`body(${runtimeTemplate.basicFunction("deps", [
+					"if(!deps) return outerResolve();",
+					"currentDeps = wrapDeps(deps);",
+					"var fn, result;",
+					`var promise = new Promise(${runtimeTemplate.basicFunction(
+						"resolve, reject",
+						[
+							`fn = ${runtimeTemplate.returningFunction(
+								"resolve(result = currentDeps.map(d => d[webpackExports]))"
+							)}`,
+							"fn.r = 0;",
+							"whenAll(currentDeps, fn, reject);"
+						]
+					)});`,
+					"return fn.r ? promise : result;"
+				])}).then(outerResolve, reject);`,
+				"isEvaluating = false;"
+			])};`
+		]);
+	}
+}
+
+module.exports = AsyncModuleRuntimeModule;

package/lib/serialization/BinaryMiddleware.js

@@ -379,13 +379,21 @@ class BinaryMiddleware extends SerializerMiddleware {
 							writeU8(BOOLEANS_HEADER);
 							writeU8((1 << count) | lastByte);
 						} else if (count <= 133) {
-							allocate(HEADER_SIZE + I8_SIZE * bytes.length + I8_SIZE);
+							allocate(
+								HEADER_SIZE + I8_SIZE + I8_SIZE * bytes.length + I8_SIZE
+							);
 							writeU8(BOOLEANS_HEADER);
 							writeU8(0x80 | (count - 7));
 							for (const byte of bytes) writeU8(byte);
 							writeU8(lastByte);
 						} else {
-							allocate(HEADER_SIZE + I8_SIZE * bytes.length + I8_SIZE);
+							allocate(
+								HEADER_SIZE +
+									I8_SIZE +
+									I32_SIZE +
+									I8_SIZE * bytes.length +
+									I8_SIZE
+							);
 							writeU8(BOOLEANS_HEADER);
 							writeU8(0xff);
 							writeU32(count);

package/lib/sharing/ShareRuntimeModule.js

@@ -78,7 +78,7 @@ class ShareRuntimeModule extends RuntimeModule {
 					"// runs all init snippets from all modules reachable",
 					`var scope = ${RuntimeGlobals.shareScopeMap}[name];`,
 					`var warn = ${runtimeTemplate.returningFunction(
-						'typeof console !== "undefined" && console.warn && console.warn(msg);',
+						'typeof console !== "undefined" && console.warn && console.warn(msg)',
 						"msg"
 					)};`,
 					`var uniqueName = ${JSON.stringify(uniqueName || undefined)};`,

package/lib/util/ArrayQueue.js

@@ -0,0 +1,103 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/**
+ * @template T
+ */
+class ArrayQueue {
+	/**
+	 * @param {Iterable<T>=} items The initial elements.
+	 */
+	constructor(items) {
+		/** @private @type {T[]} */
+		this._list = items ? Array.from(items) : [];
+		/** @private @type {T[]} */
+		this._listReversed = [];
+	}
+
+	/**
+	 * Returns the number of elements in this queue.
+	 * @returns {number} The number of elements in this queue.
+	 */
+	get length() {
+		return this._list.length + this._listReversed.length;
+	}
+
+	/**
+	 * Appends the specified element to this queue.
+	 * @param {T} item The element to add.
+	 * @returns {void}
+	 */
+	enqueue(item) {
+		this._list.push(item);
+	}
+
+	/**
+	 * Retrieves and removes the head of this queue.
+	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
+	 */
+	dequeue() {
+		if (this._listReversed.length === 0) {
+			if (this._list.length === 0) return undefined;
+			if (this._list.length === 1) return this._list.pop();
+			if (this._list.length < 16) return this._list.shift();
+			const temp = this._listReversed;
+			this._listReversed = this._list;
+			this._listReversed.reverse();
+			this._list = temp;
+		}
+		return this._listReversed.pop();
+	}
+
+	/**
+	 * Finds and removes an item
+	 * @param {T} item the item
+	 * @returns {void}
+	 */
+	delete(item) {
+		const i = this._list.indexOf(item);
+		if (i >= 0) {
+			this._list.splice(i, 1);
+		} else {
+			const i = this._listReversed.indexOf(item);
+			if (i >= 0) this._listReversed.splice(i, 1);
+		}
+	}
+
+	[Symbol.iterator]() {
+		let i = -1;
+		let reversed = false;
+		return {
+			next: () => {
+				if (!reversed) {
+					i++;
+					if (i < this._list.length) {
+						return {
+							done: false,
+							value: this._list[i]
+						};
+					}
+					reversed = true;
+					i = this._listReversed.length;
+				}
+				i--;
+				if (i < 0) {
+					return {
+						done: true,
+						value: undefined
+					};
+				}
+				return {
+					done: false,
+					value: this._listReversed[i]
+				};
+			}
+		};
+	}
+}
+
+module.exports = ArrayQueue;