removed autoprefix hover as it will have a high chance of making hover stopped working

15 files changed, 0 insertions, 3168 deletions

diff --git a/node_modules/webpack/lib/serialization/ArraySerializer.js b/node_modules/webpack/lib/serialization/ArraySerializer.js
deleted file mode 100644
index 021c82ca..00000000
--- a/node_modules/webpack/lib/serialization/ArraySerializer.js
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-"use strict";
-
-/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-
-class ArraySerializer {
-	/**
-	 * @template T
-	 * @param {T[]} array array
-	 * @param {ObjectSerializerContext} context context
-	 */
-	serialize(array, context) {
-		context.write(array.length);
-		for (const item of array) context.write(item);
-	}
-
-	/**
-	 * @template T
-	 * @param {ObjectDeserializerContext} context context
-	 * @returns {T[]} array
-	 */
-	deserialize(context) {
-		/** @type {number} */
-		const length = context.read();
-		/** @type {T[]} */
-		const array = [];
-		for (let i = 0; i < length; i++) {
-			array.push(context.read());
-		}
-		return array;
-	}
-}
-
-module.exports = ArraySerializer;
diff --git a/node_modules/webpack/lib/serialization/BinaryMiddleware.js b/node_modules/webpack/lib/serialization/BinaryMiddleware.js
deleted file mode 100644
index c2969b16..00000000
--- a/node_modules/webpack/lib/serialization/BinaryMiddleware.js
+++ /dev/null
@@ -1,1113 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-"use strict";
-
-const memoize = require("../util/memoize");
-const SerializerMiddleware = require("./SerializerMiddleware");
-
-/** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
-/** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
-
-/*
-Format:
-
-File -> Section*
-
-Section -> NullsSection |
-					 BooleansSection |
-					 F64NumbersSection |
-					 I32NumbersSection |
-					 I8NumbersSection |
-					 ShortStringSection |
-					 BigIntSection |
-					 I32BigIntSection |
-					 I8BigIntSection
-					 StringSection |
-					 BufferSection |
-					 NopSection
-
-
-
-NullsSection ->
-	NullHeaderByte | Null2HeaderByte | Null3HeaderByte |
-	Nulls8HeaderByte 0xnn (n:count - 4) |
-	Nulls32HeaderByte n:ui32 (n:count - 260) |
-BooleansSection -> TrueHeaderByte | FalseHeaderByte | BooleansSectionHeaderByte BooleansCountAndBitsByte
-F64NumbersSection -> F64NumbersSectionHeaderByte f64*
-I32NumbersSection -> I32NumbersSectionHeaderByte i32*
-I8NumbersSection -> I8NumbersSectionHeaderByte i8*
-ShortStringSection -> ShortStringSectionHeaderByte ascii-byte*
-StringSection -> StringSectionHeaderByte i32:length utf8-byte*
-BufferSection -> BufferSectionHeaderByte i32:length byte*
-NopSection --> NopSectionHeaderByte
-BigIntSection -> BigIntSectionHeaderByte i32:length ascii-byte*
-I32BigIntSection -> I32BigIntSectionHeaderByte i32
-I8BigIntSection -> I8BigIntSectionHeaderByte i8
-
-ShortStringSectionHeaderByte -> 0b1nnn_nnnn (n:length)
-
-F64NumbersSectionHeaderByte -> 0b001n_nnnn (n:count - 1)
-I32NumbersSectionHeaderByte -> 0b010n_nnnn (n:count - 1)
-I8NumbersSectionHeaderByte -> 0b011n_nnnn (n:count - 1)
-
-NullsSectionHeaderByte -> 0b0001_nnnn (n:count - 1)
-BooleansCountAndBitsByte ->
-	0b0000_1xxx (count = 3) |
-	0b0001_xxxx (count = 4) |
-	0b001x_xxxx (count = 5) |
-	0b01xx_xxxx (count = 6) |
-	0b1nnn_nnnn (n:count - 7, 7 <= count <= 133)
-	0xff n:ui32 (n:count, 134 <= count < 2^32)
-
-StringSectionHeaderByte -> 0b0000_1110
-BufferSectionHeaderByte -> 0b0000_1111
-NopSectionHeaderByte -> 0b0000_1011
-BigIntSectionHeaderByte -> 0b0001_1010
-I32BigIntSectionHeaderByte -> 0b0001_1100
-I8BigIntSectionHeaderByte -> 0b0001_1011
-FalseHeaderByte -> 0b0000_1100
-TrueHeaderByte -> 0b0000_1101
-
-RawNumber -> n (n <= 10)
-
-*/
-
-const LAZY_HEADER = 0x0b;
-const TRUE_HEADER = 0x0c;
-const FALSE_HEADER = 0x0d;
-const BOOLEANS_HEADER = 0x0e;
-const NULL_HEADER = 0x10;
-const NULL2_HEADER = 0x11;
-const NULL3_HEADER = 0x12;
-const NULLS8_HEADER = 0x13;
-const NULLS32_HEADER = 0x14;
-const NULL_AND_I8_HEADER = 0x15;
-const NULL_AND_I32_HEADER = 0x16;
-const NULL_AND_TRUE_HEADER = 0x17;
-const NULL_AND_FALSE_HEADER = 0x18;
-const BIGINT_HEADER = 0x1a;
-const BIGINT_I8_HEADER = 0x1b;
-const BIGINT_I32_HEADER = 0x1c;
-const STRING_HEADER = 0x1e;
-const BUFFER_HEADER = 0x1f;
-const I8_HEADER = 0x60;
-const I32_HEADER = 0x40;
-const F64_HEADER = 0x20;
-const SHORT_STRING_HEADER = 0x80;
-
-/** Uplift high-order bits */
-const NUMBERS_HEADER_MASK = 0xe0; // 0b1010_0000
-const NUMBERS_COUNT_MASK = 0x1f; // 0b0001_1111
-const SHORT_STRING_LENGTH_MASK = 0x7f; // 0b0111_1111
-
-const HEADER_SIZE = 1;
-const I8_SIZE = 1;
-const I32_SIZE = 4;
-const F64_SIZE = 8;
-
-const MEASURE_START_OPERATION = Symbol("MEASURE_START_OPERATION");
-const MEASURE_END_OPERATION = Symbol("MEASURE_END_OPERATION");
-
-/** @typedef {typeof MEASURE_START_OPERATION} MEASURE_START_OPERATION_TYPE */
-/** @typedef {typeof MEASURE_END_OPERATION} MEASURE_END_OPERATION_TYPE */
-
-/**
- * @param {number} n number
- * @returns {0 | 1 | 2} type of number for serialization
- */
-const identifyNumber = n => {
-	if (n === (n | 0)) {
-		if (n <= 127 && n >= -128) return 0;
-		if (n <= 2147483647 && n >= -2147483648) return 1;
-	}
-	return 2;
-};
-
-/**
- * @param {bigint} n bigint
- * @returns {0 | 1 | 2} type of bigint for serialization
- */
-const identifyBigInt = n => {
-	if (n <= BigInt(127) && n >= BigInt(-128)) return 0;
-	if (n <= BigInt(2147483647) && n >= BigInt(-2147483648)) return 1;
-	return 2;
-};
-
-/**
- * @typedef {PrimitiveSerializableType[]} DeserializedType
- * @typedef {BufferSerializableType[]} SerializedType
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
- */
-class BinaryMiddleware extends SerializerMiddleware {
-	/**
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
-	 */
-	serialize(data, context) {
-		return this._serialize(data, context);
-	}
-
-	_serializeLazy(fn, context) {
-		return SerializerMiddleware.serializeLazy(fn, data =>
-			this._serialize(data, context)
-		);
-	}
-
-	/**
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @param {{ leftOverBuffer: Buffer | null, allocationSize: number, increaseCounter: number }} allocationScope allocation scope
-	 * @returns {SerializedType} serialized data
-	 */
-	_serialize(
-		data,
-		context,
-		allocationScope = {
-			allocationSize: 1024,
-			increaseCounter: 0,
-			leftOverBuffer: null
-		}
-	) {
-		/** @type {Buffer} */
-		let leftOverBuffer = null;
-		/** @type {BufferSerializableType[]} */
-		let buffers = [];
-		/** @type {Buffer} */
-		let currentBuffer = allocationScope ? allocationScope.leftOverBuffer : null;
-		allocationScope.leftOverBuffer = null;
-		let currentPosition = 0;
-		if (currentBuffer === null) {
-			currentBuffer = Buffer.allocUnsafe(allocationScope.allocationSize);
-		}
-		const allocate = bytesNeeded => {
-			if (currentBuffer !== null) {
-				if (currentBuffer.length - currentPosition >= bytesNeeded) return;
-				flush();
-			}
-			if (leftOverBuffer && leftOverBuffer.length >= bytesNeeded) {
-				currentBuffer = leftOverBuffer;
-				leftOverBuffer = null;
-			} else {
-				currentBuffer = Buffer.allocUnsafe(
-					Math.max(bytesNeeded, allocationScope.allocationSize)
-				);
-				if (
-					!(allocationScope.increaseCounter =
-						(allocationScope.increaseCounter + 1) % 4) &&
-					allocationScope.allocationSize < 16777216
-				) {
-					allocationScope.allocationSize = allocationScope.allocationSize << 1;
-				}
-			}
-		};
-		const flush = () => {
-			if (currentBuffer !== null) {
-				if (currentPosition > 0) {
-					buffers.push(
-						Buffer.from(
-							currentBuffer.buffer,
-							currentBuffer.byteOffset,
-							currentPosition
-						)
-					);
-				}
-				if (
-					!leftOverBuffer ||
-					leftOverBuffer.length < currentBuffer.length - currentPosition
-				) {
-					leftOverBuffer = Buffer.from(
-						currentBuffer.buffer,
-						currentBuffer.byteOffset + currentPosition,
-						currentBuffer.byteLength - currentPosition
-					);
-				}
-
-				currentBuffer = null;
-				currentPosition = 0;
-			}
-		};
-		/**
-		 * @param {number} byte byte
-		 */
-		const writeU8 = byte => {
-			currentBuffer.writeUInt8(byte, currentPosition++);
-		};
-		/**
-		 * @param {number} ui32 ui32
-		 */
-		const writeU32 = ui32 => {
-			currentBuffer.writeUInt32LE(ui32, currentPosition);
-			currentPosition += 4;
-		};
-		/** @type {number[]} */
-		const measureStack = [];
-		const measureStart = () => {
-			measureStack.push(buffers.length, currentPosition);
-		};
-		/**
-		 * @returns {number} size
-		 */
-		const measureEnd = () => {
-			const oldPos = measureStack.pop();
-			const buffersIndex = measureStack.pop();
-			let size = currentPosition - oldPos;
-			for (let i = buffersIndex; i < buffers.length; i++) {
-				size += buffers[i].length;
-			}
-			return size;
-		};
-		for (let i = 0; i < data.length; i++) {
-			const thing = data[i];
-			switch (typeof thing) {
-				case "function": {
-					if (!SerializerMiddleware.isLazy(thing))
-						throw new Error("Unexpected function " + thing);
-					/** @type {SerializedType | (() => SerializedType)} */
-					let serializedData =
-						SerializerMiddleware.getLazySerializedValue(thing);
-					if (serializedData === undefined) {
-						if (SerializerMiddleware.isLazy(thing, this)) {
-							flush();
-							allocationScope.leftOverBuffer = leftOverBuffer;
-							const result =
-								/** @type {(Exclude<PrimitiveSerializableType, Promise<PrimitiveSerializableType>>)[]} */ (
-									thing()
-								);
-							const data = this._serialize(result, context, allocationScope);
-							leftOverBuffer = allocationScope.leftOverBuffer;
-							allocationScope.leftOverBuffer = null;
-							SerializerMiddleware.setLazySerializedValue(thing, data);
-							serializedData = data;
-						} else {
-							serializedData = this._serializeLazy(thing, context);
-							flush();
-							buffers.push(serializedData);
-							break;
-						}
-					} else {
-						if (typeof serializedData === "function") {
-							flush();
-							buffers.push(serializedData);
-							break;
-						}
-					}
-					/** @type {number[]} */
-					const lengths = [];
-					for (const item of serializedData) {
-						let last;
-						if (typeof item === "function") {
-							lengths.push(0);
-						} else if (item.length === 0) {
-							// ignore
-						} else if (
-							lengths.length > 0 &&
-							(last = lengths[lengths.length - 1]) !== 0
-						) {
-							const remaining = 0xffffffff - last;
-							if (remaining >= item.length) {
-								lengths[lengths.length - 1] += item.length;
-							} else {
-								lengths.push(item.length - remaining);
-								lengths[lengths.length - 2] = 0xffffffff;
-							}
-						} else {
-							lengths.push(item.length);
-						}
-					}
-					allocate(5 + lengths.length * 4);
-					writeU8(LAZY_HEADER);
-					writeU32(lengths.length);
-					for (const l of lengths) {
-						writeU32(l);
-					}
-					flush();
-					for (const item of serializedData) {
-						buffers.push(item);
-					}
-					break;
-				}
-				case "string": {
-					const len = Buffer.byteLength(thing);
-					if (len >= 128 || len !== thing.length) {
-						allocate(len + HEADER_SIZE + I32_SIZE);
-						writeU8(STRING_HEADER);
-						writeU32(len);
-						currentBuffer.write(thing, currentPosition);
-						currentPosition += len;
-					} else if (len >= 70) {
-						allocate(len + HEADER_SIZE);
-						writeU8(SHORT_STRING_HEADER | len);
-
-						currentBuffer.write(thing, currentPosition, "latin1");
-						currentPosition += len;
-					} else {
-						allocate(len + HEADER_SIZE);
-						writeU8(SHORT_STRING_HEADER | len);
-
-						for (let i = 0; i < len; i++) {
-							currentBuffer[currentPosition++] = thing.charCodeAt(i);
-						}
-					}
-					break;
-				}
-				case "bigint": {
-					const type = identifyBigInt(thing);
-					if (type === 0 && thing >= 0 && thing <= BigInt(10)) {
-						// shortcut for very small bigints
-						allocate(HEADER_SIZE + I8_SIZE);
-						writeU8(BIGINT_I8_HEADER);
-						writeU8(Number(thing));
-						break;
-					}
-
-					switch (type) {
-						case 0: {
-							let n = 1;
-							allocate(HEADER_SIZE + I8_SIZE * n);
-							writeU8(BIGINT_I8_HEADER | (n - 1));
-							while (n > 0) {
-								currentBuffer.writeInt8(
-									Number(/** @type {bigint} */ (data[i])),
-									currentPosition
-								);
-								currentPosition += I8_SIZE;
-								n--;
-								i++;
-							}
-							i--;
-							break;
-						}
-						case 1: {
-							let n = 1;
-							allocate(HEADER_SIZE + I32_SIZE * n);
-							writeU8(BIGINT_I32_HEADER | (n - 1));
-							while (n > 0) {
-								currentBuffer.writeInt32LE(
-									Number(/** @type {bigint} */ (data[i])),
-									currentPosition
-								);
-								currentPosition += I32_SIZE;
-								n--;
-								i++;
-							}
-							i--;
-							break;
-						}
-						default: {
-							const value = thing.toString();
-							const len = Buffer.byteLength(value);
-							allocate(len + HEADER_SIZE + I32_SIZE);
-							writeU8(BIGINT_HEADER);
-							writeU32(len);
-							currentBuffer.write(value, currentPosition);
-							currentPosition += len;
-							break;
-						}
-					}
-					break;
-				}
-				case "number": {
-					const type = identifyNumber(thing);
-					if (type === 0 && thing >= 0 && thing <= 10) {
-						// shortcut for very small numbers
-						allocate(I8_SIZE);
-						writeU8(thing);
-						break;
-					}
-					/**
-					 * amount of numbers to write
-					 * @type {number}
-					 */
-					let n = 1;
-					for (; n < 32 && i + n < data.length; n++) {
-						const item = data[i + n];
-						if (typeof item !== "number") break;
-						if (identifyNumber(item) !== type) break;
-					}
-					switch (type) {
-						case 0:
-							allocate(HEADER_SIZE + I8_SIZE * n);
-							writeU8(I8_HEADER | (n - 1));
-							while (n > 0) {
-								currentBuffer.writeInt8(
-									/** @type {number} */ (data[i]),
-									currentPosition
-								);
-								currentPosition += I8_SIZE;
-								n--;
-								i++;
-							}
-							break;
-						case 1:
-							allocate(HEADER_SIZE + I32_SIZE * n);
-							writeU8(I32_HEADER | (n - 1));
-							while (n > 0) {
-								currentBuffer.writeInt32LE(
-									/** @type {number} */ (data[i]),
-									currentPosition
-								);
-								currentPosition += I32_SIZE;
-								n--;
-								i++;
-							}
-							break;
-						case 2:
-							allocate(HEADER_SIZE + F64_SIZE * n);
-							writeU8(F64_HEADER | (n - 1));
-							while (n > 0) {
-								currentBuffer.writeDoubleLE(
-									/** @type {number} */ (data[i]),
-									currentPosition
-								);
-								currentPosition += F64_SIZE;
-								n--;
-								i++;
-							}
-							break;
-					}
-
-					i--;
-					break;
-				}
-				case "boolean": {
-					let lastByte = thing === true ? 1 : 0;
-					const bytes = [];
-					let count = 1;
-					let n;
-					for (n = 1; n < 0xffffffff && i + n < data.length; n++) {
-						const item = data[i + n];
-						if (typeof item !== "boolean") break;
-						const pos = count & 0x7;
-						if (pos === 0) {
-							bytes.push(lastByte);
-							lastByte = item === true ? 1 : 0;
-						} else if (item === true) {
-							lastByte |= 1 << pos;
-						}
-						count++;
-					}
-					i += count - 1;
-					if (count === 1) {
-						allocate(HEADER_SIZE);
-						writeU8(lastByte === 1 ? TRUE_HEADER : FALSE_HEADER);
-					} else if (count === 2) {
-						allocate(HEADER_SIZE * 2);
-						writeU8(lastByte & 1 ? TRUE_HEADER : FALSE_HEADER);
-						writeU8(lastByte & 2 ? TRUE_HEADER : FALSE_HEADER);
-					} else if (count <= 6) {
-						allocate(HEADER_SIZE + I8_SIZE);
-						writeU8(BOOLEANS_HEADER);
-						writeU8((1 << count) | lastByte);
-					} else if (count <= 133) {
-						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 +
-								I32_SIZE +
-								I8_SIZE * bytes.length +
-								I8_SIZE
-						);
-						writeU8(BOOLEANS_HEADER);
-						writeU8(0xff);
-						writeU32(count);
-						for (const byte of bytes) writeU8(byte);
-						writeU8(lastByte);
-					}
-					break;
-				}
-				case "object": {
-					if (thing === null) {
-						let n;
-						for (n = 1; n < 0x100000104 && i + n < data.length; n++) {
-							const item = data[i + n];
-							if (item !== null) break;
-						}
-						i += n - 1;
-						if (n === 1) {
-							if (i + 1 < data.length) {
-								const next = data[i + 1];
-								if (next === true) {
-									allocate(HEADER_SIZE);
-									writeU8(NULL_AND_TRUE_HEADER);
-									i++;
-								} else if (next === false) {
-									allocate(HEADER_SIZE);
-									writeU8(NULL_AND_FALSE_HEADER);
-									i++;
-								} else if (typeof next === "number") {
-									const type = identifyNumber(next);
-									if (type === 0) {
-										allocate(HEADER_SIZE + I8_SIZE);
-										writeU8(NULL_AND_I8_HEADER);
-										currentBuffer.writeInt8(next, currentPosition);
-										currentPosition += I8_SIZE;
-										i++;
-									} else if (type === 1) {
-										allocate(HEADER_SIZE + I32_SIZE);
-										writeU8(NULL_AND_I32_HEADER);
-										currentBuffer.writeInt32LE(next, currentPosition);
-										currentPosition += I32_SIZE;
-										i++;
-									} else {
-										allocate(HEADER_SIZE);
-										writeU8(NULL_HEADER);
-									}
-								} else {
-									allocate(HEADER_SIZE);
-									writeU8(NULL_HEADER);
-								}
-							} else {
-								allocate(HEADER_SIZE);
-								writeU8(NULL_HEADER);
-							}
-						} else if (n === 2) {
-							allocate(HEADER_SIZE);
-							writeU8(NULL2_HEADER);
-						} else if (n === 3) {
-							allocate(HEADER_SIZE);
-							writeU8(NULL3_HEADER);
-						} else if (n < 260) {
-							allocate(HEADER_SIZE + I8_SIZE);
-							writeU8(NULLS8_HEADER);
-							writeU8(n - 4);
-						} else {
-							allocate(HEADER_SIZE + I32_SIZE);
-							writeU8(NULLS32_HEADER);
-							writeU32(n - 260);
-						}
-					} else if (Buffer.isBuffer(thing)) {
-						if (thing.length < 8192) {
-							allocate(HEADER_SIZE + I32_SIZE + thing.length);
-							writeU8(BUFFER_HEADER);
-							writeU32(thing.length);
-							thing.copy(currentBuffer, currentPosition);
-							currentPosition += thing.length;
-						} else {
-							allocate(HEADER_SIZE + I32_SIZE);
-							writeU8(BUFFER_HEADER);
-							writeU32(thing.length);
-							flush();
-							buffers.push(thing);
-						}
-					}
-					break;
-				}
-				case "symbol": {
-					if (thing === MEASURE_START_OPERATION) {
-						measureStart();
-					} else if (thing === MEASURE_END_OPERATION) {
-						const size = measureEnd();
-						allocate(HEADER_SIZE + I32_SIZE);
-						writeU8(I32_HEADER);
-						currentBuffer.writeInt32LE(size, currentPosition);
-						currentPosition += I32_SIZE;
-					}
-					break;
-				}
-			}
-		}
-		flush();
-
-		allocationScope.leftOverBuffer = leftOverBuffer;
-
-		// avoid leaking memory
-		currentBuffer = null;
-		leftOverBuffer = null;
-		allocationScope = undefined;
-		const _buffers = buffers;
-		buffers = undefined;
-		return _buffers;
-	}
-
-	/**
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
-	 */
-	deserialize(data, context) {
-		return this._deserialize(data, context);
-	}
-
-	_createLazyDeserialized(content, context) {
-		return SerializerMiddleware.createLazy(
-			memoize(() => this._deserialize(content, context)),
-			this,
-			undefined,
-			content
-		);
-	}
-
-	_deserializeLazy(fn, context) {
-		return SerializerMiddleware.deserializeLazy(fn, data =>
-			this._deserialize(data, context)
-		);
-	}
-
-	/**
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType} deserialized data
-	 */
-	_deserialize(data, context) {
-		let currentDataItem = 0;
-		let currentBuffer = data[0];
-		let currentIsBuffer = Buffer.isBuffer(currentBuffer);
-		let currentPosition = 0;
-
-		const retainedBuffer = context.retainedBuffer || (x => x);
-
-		const checkOverflow = () => {
-			if (currentPosition >= currentBuffer.length) {
-				currentPosition = 0;
-				currentDataItem++;
-				currentBuffer =
-					currentDataItem < data.length ? data[currentDataItem] : null;
-				currentIsBuffer = Buffer.isBuffer(currentBuffer);
-			}
-		};
-		const isInCurrentBuffer = n => {
-			return currentIsBuffer && n + currentPosition <= currentBuffer.length;
-		};
-		const ensureBuffer = () => {
-			if (!currentIsBuffer) {
-				throw new Error(
-					currentBuffer === null
-						? "Unexpected end of stream"
-						: "Unexpected lazy element in stream"
-				);
-			}
-		};
-		/**
-		 * Reads n bytes
-		 * @param {number} n amount of bytes to read
-		 * @returns {Buffer} buffer with bytes
-		 */
-		const read = n => {
-			ensureBuffer();
-			const rem = currentBuffer.length - currentPosition;
-			if (rem < n) {
-				const buffers = [read(rem)];
-				n -= rem;
-				ensureBuffer();
-				while (currentBuffer.length < n) {
-					const b = /** @type {Buffer} */ (currentBuffer);
-					buffers.push(b);
-					n -= b.length;
-					currentDataItem++;
-					currentBuffer =
-						currentDataItem < data.length ? data[currentDataItem] : null;
-					currentIsBuffer = Buffer.isBuffer(currentBuffer);
-					ensureBuffer();
-				}
-				buffers.push(read(n));
-				return Buffer.concat(buffers);
-			}
-			const b = /** @type {Buffer} */ (currentBuffer);
-			const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
-			currentPosition += n;
-			checkOverflow();
-			return res;
-		};
-		/**
-		 * Reads up to n bytes
-		 * @param {number} n amount of bytes to read
-		 * @returns {Buffer} buffer with bytes
-		 */
-		const readUpTo = n => {
-			ensureBuffer();
-			const rem = currentBuffer.length - currentPosition;
-			if (rem < n) {
-				n = rem;
-			}
-			const b = /** @type {Buffer} */ (currentBuffer);
-			const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
-			currentPosition += n;
-			checkOverflow();
-			return res;
-		};
-		/**
-		 * @returns {number} U8
-		 */
-		const readU8 = () => {
-			ensureBuffer();
-			/**
-			 * There is no need to check remaining buffer size here
-			 * since {@link checkOverflow} guarantees at least one byte remaining
-			 */
-			const byte = /** @type {Buffer} */ (currentBuffer).readUInt8(
-				currentPosition
-			);
-			currentPosition += I8_SIZE;
-			checkOverflow();
-			return byte;
-		};
-		/**
-		 * @returns {number} U32
-		 */
-		const readU32 = () => {
-			return read(I32_SIZE).readUInt32LE(0);
-		};
-		const readBits = (data, n) => {
-			let mask = 1;
-			while (n !== 0) {
-				result.push((data & mask) !== 0);
-				mask = mask << 1;
-				n--;
-			}
-		};
-		const dispatchTable = Array.from({ length: 256 }).map((_, header) => {
-			switch (header) {
-				case LAZY_HEADER:
-					return () => {
-						const count = readU32();
-						const lengths = Array.from({ length: count }).map(() => readU32());
-						const content = [];
-						for (let l of lengths) {
-							if (l === 0) {
-								if (typeof currentBuffer !== "function") {
-									throw new Error("Unexpected non-lazy element in stream");
-								}
-								content.push(currentBuffer);
-								currentDataItem++;
-								currentBuffer =
-									currentDataItem < data.length ? data[currentDataItem] : null;
-								currentIsBuffer = Buffer.isBuffer(currentBuffer);
-							} else {
-								do {
-									const buf = readUpTo(l);
-									l -= buf.length;
-									content.push(retainedBuffer(buf));
-								} while (l > 0);
-							}
-						}
-						result.push(this._createLazyDeserialized(content, context));
-					};
-				case BUFFER_HEADER:
-					return () => {
-						const len = readU32();
-						result.push(retainedBuffer(read(len)));
-					};
-				case TRUE_HEADER:
-					return () => result.push(true);
-				case FALSE_HEADER:
-					return () => result.push(false);
-				case NULL3_HEADER:
-					return () => result.push(null, null, null);
-				case NULL2_HEADER:
-					return () => result.push(null, null);
-				case NULL_HEADER:
-					return () => result.push(null);
-				case NULL_AND_TRUE_HEADER:
-					return () => result.push(null, true);
-				case NULL_AND_FALSE_HEADER:
-					return () => result.push(null, false);
-				case NULL_AND_I8_HEADER:
-					return () => {
-						if (currentIsBuffer) {
-							result.push(
-								null,
-								/** @type {Buffer} */ (currentBuffer).readInt8(currentPosition)
-							);
-							currentPosition += I8_SIZE;
-							checkOverflow();
-						} else {
-							result.push(null, read(I8_SIZE).readInt8(0));
-						}
-					};
-				case NULL_AND_I32_HEADER:
-					return () => {
-						result.push(null);
-						if (isInCurrentBuffer(I32_SIZE)) {
-							result.push(
-								/** @type {Buffer} */ (currentBuffer).readInt32LE(
-									currentPosition
-								)
-							);
-							currentPosition += I32_SIZE;
-							checkOverflow();
-						} else {
-							result.push(read(I32_SIZE).readInt32LE(0));
-						}
-					};
-				case NULLS8_HEADER:
-					return () => {
-						const len = readU8() + 4;
-						for (let i = 0; i < len; i++) {
-							result.push(null);
-						}
-					};
-				case NULLS32_HEADER:
-					return () => {
-						const len = readU32() + 260;
-						for (let i = 0; i < len; i++) {
-							result.push(null);
-						}
-					};
-				case BOOLEANS_HEADER:
-					return () => {
-						const innerHeader = readU8();
-						if ((innerHeader & 0xf0) === 0) {
-							readBits(innerHeader, 3);
-						} else if ((innerHeader & 0xe0) === 0) {
-							readBits(innerHeader, 4);
-						} else if ((innerHeader & 0xc0) === 0) {
-							readBits(innerHeader, 5);
-						} else if ((innerHeader & 0x80) === 0) {
-							readBits(innerHeader, 6);
-						} else if (innerHeader !== 0xff) {
-							let count = (innerHeader & 0x7f) + 7;
-							while (count > 8) {
-								readBits(readU8(), 8);
-								count -= 8;
-							}
-							readBits(readU8(), count);
-						} else {
-							let count = readU32();
-							while (count > 8) {
-								readBits(readU8(), 8);
-								count -= 8;
-							}
-							readBits(readU8(), count);
-						}
-					};
-				case STRING_HEADER:
-					return () => {
-						const len = readU32();
-						if (isInCurrentBuffer(len) && currentPosition + len < 0x7fffffff) {
-							result.push(
-								currentBuffer.toString(
-									undefined,
-									currentPosition,
-									currentPosition + len
-								)
-							);
-							currentPosition += len;
-							checkOverflow();
-						} else {
-							result.push(read(len).toString());
-						}
-					};
-				case SHORT_STRING_HEADER:
-					return () => result.push("");
-				case SHORT_STRING_HEADER | 1:
-					return () => {
-						if (currentIsBuffer && currentPosition < 0x7ffffffe) {
-							result.push(
-								currentBuffer.toString(
-									"latin1",
-									currentPosition,
-									currentPosition + 1
-								)
-							);
-							currentPosition++;
-							checkOverflow();
-						} else {
-							result.push(read(1).toString("latin1"));
-						}
-					};
-				case I8_HEADER:
-					return () => {
-						if (currentIsBuffer) {
-							result.push(
-								/** @type {Buffer} */ (currentBuffer).readInt8(currentPosition)
-							);
-							currentPosition++;
-							checkOverflow();
-						} else {
-							result.push(read(1).readInt8(0));
-						}
-					};
-				case BIGINT_I8_HEADER: {
-					const len = 1;
-					return () => {
-						const need = I8_SIZE * len;
-
-						if (isInCurrentBuffer(need)) {
-							for (let i = 0; i < len; i++) {
-								const value =
-									/** @type {Buffer} */
-									(currentBuffer).readInt8(currentPosition);
-								result.push(BigInt(value));
-								currentPosition += I8_SIZE;
-							}
-							checkOverflow();
-						} else {
-							const buf = read(need);
-							for (let i = 0; i < len; i++) {
-								const value = buf.readInt8(i * I8_SIZE);
-								result.push(BigInt(value));
-							}
-						}
-					};
-				}
-				case BIGINT_I32_HEADER: {
-					const len = 1;
-					return () => {
-						const need = I32_SIZE * len;
-						if (isInCurrentBuffer(need)) {
-							for (let i = 0; i < len; i++) {
-								const value = /** @type {Buffer} */ (currentBuffer).readInt32LE(
-									currentPosition
-								);
-								result.push(BigInt(value));
-								currentPosition += I32_SIZE;
-							}
-							checkOverflow();
-						} else {
-							const buf = read(need);
-							for (let i = 0; i < len; i++) {
-								const value = buf.readInt32LE(i * I32_SIZE);
-								result.push(BigInt(value));
-							}
-						}
-					};
-				}
-				case BIGINT_HEADER: {
-					return () => {
-						const len = readU32();
-						if (isInCurrentBuffer(len) && currentPosition + len < 0x7fffffff) {
-							const value = currentBuffer.toString(
-								undefined,
-								currentPosition,
-								currentPosition + len
-							);
-
-							result.push(BigInt(value));
-							currentPosition += len;
-							checkOverflow();
-						} else {
-							const value = read(len).toString();
-							result.push(BigInt(value));
-						}
-					};
-				}
-				default:
-					if (header <= 10) {
-						return () => result.push(header);
-					} else if ((header & SHORT_STRING_HEADER) === SHORT_STRING_HEADER) {
-						const len = header & SHORT_STRING_LENGTH_MASK;
-						return () => {
-							if (
-								isInCurrentBuffer(len) &&
-								currentPosition + len < 0x7fffffff
-							) {
-								result.push(
-									currentBuffer.toString(
-										"latin1",
-										currentPosition,
-										currentPosition + len
-									)
-								);
-								currentPosition += len;
-								checkOverflow();
-							} else {
-								result.push(read(len).toString("latin1"));
-							}
-						};
-					} else if ((header & NUMBERS_HEADER_MASK) === F64_HEADER) {
-						const len = (header & NUMBERS_COUNT_MASK) + 1;
-						return () => {
-							const need = F64_SIZE * len;
-							if (isInCurrentBuffer(need)) {
-								for (let i = 0; i < len; i++) {
-									result.push(
-										/** @type {Buffer} */ (currentBuffer).readDoubleLE(
-											currentPosition
-										)
-									);
-									currentPosition += F64_SIZE;
-								}
-								checkOverflow();
-							} else {
-								const buf = read(need);
-								for (let i = 0; i < len; i++) {
-									result.push(buf.readDoubleLE(i * F64_SIZE));
-								}
-							}
-						};
-					} else if ((header & NUMBERS_HEADER_MASK) === I32_HEADER) {
-						const len = (header & NUMBERS_COUNT_MASK) + 1;
-						return () => {
-							const need = I32_SIZE * len;
-							if (isInCurrentBuffer(need)) {
-								for (let i = 0; i < len; i++) {
-									result.push(
-										/** @type {Buffer} */ (currentBuffer).readInt32LE(
-											currentPosition
-										)
-									);
-									currentPosition += I32_SIZE;
-								}
-								checkOverflow();
-							} else {
-								const buf = read(need);
-								for (let i = 0; i < len; i++) {
-									result.push(buf.readInt32LE(i * I32_SIZE));
-								}
-							}
-						};
-					} else if ((header & NUMBERS_HEADER_MASK) === I8_HEADER) {
-						const len = (header & NUMBERS_COUNT_MASK) + 1;
-						return () => {
-							const need = I8_SIZE * len;
-							if (isInCurrentBuffer(need)) {
-								for (let i = 0; i < len; i++) {
-									result.push(
-										/** @type {Buffer} */ (currentBuffer).readInt8(
-											currentPosition
-										)
-									);
-									currentPosition += I8_SIZE;
-								}
-								checkOverflow();
-							} else {
-								const buf = read(need);
-								for (let i = 0; i < len; i++) {
-									result.push(buf.readInt8(i * I8_SIZE));
-								}
-							}
-						};
-					} else {
-						return () => {
-							throw new Error(
-								`Unexpected header byte 0x${header.toString(16)}`
-							);
-						};
-					}
-			}
-		});
-
-		/** @type {DeserializedType} */
-		let result = [];
-		while (currentBuffer !== null) {
-			if (typeof currentBuffer === "function") {
-				result.push(this._deserializeLazy(currentBuffer, context));
-				currentDataItem++;
-				currentBuffer =
-					currentDataItem < data.length ? data[currentDataItem] : null;
-				currentIsBuffer = Buffer.isBuffer(currentBuffer);
-			} else {
-				const header = readU8();
-				dispatchTable[header]();
-			}
-		}
-
-		// avoid leaking memory in context
-		let _result = result;
-		result = undefined;
-		return _result;
-	}
-}
-
-module.exports = BinaryMiddleware;
-
-module.exports.MEASURE_START_OPERATION = MEASURE_START_OPERATION;
-module.exports.MEASURE_END_OPERATION = MEASURE_END_OPERATION;
diff --git a/node_modules/webpack/lib/serialization/DateObjectSerializer.js b/node_modules/webpack/lib/serialization/DateObjectSerializer.js
deleted file mode 100644
index c8e53ccf..00000000
--- a/node_modules/webpack/lib/serialization/DateObjectSerializer.js
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-"use strict";
-
-/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-
-class DateObjectSerializer {
-	/**
-	 * @param {Date} obj date
-	 * @param {ObjectSerializerContext} context context
-	 */
-	serialize(obj, context) {
-		context.write(obj.getTime());
-	}
-	/**
-	 * @param {ObjectDeserializerContext} context context
-	 * @returns {Date} date
-	 */
-	deserialize(context) {
-		return new Date(context.read());
-	}
-}
-
-module.exports = DateObjectSerializer;
diff --git a/node_modules/webpack/lib/serialization/ErrorObjectSerializer.js b/node_modules/webpack/lib/serialization/ErrorObjectSerializer.js
deleted file mode 100644
index 40f47fc2..00000000
--- a/node_modules/webpack/lib/serialization/ErrorObjectSerializer.js
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-"use strict";
-
-/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-
-class ErrorObjectSerializer {
-	/**
-	 * @param {ErrorConstructor | EvalErrorConstructor | RangeErrorConstructor | ReferenceErrorConstructor | SyntaxErrorConstructor | TypeErrorConstructor} Type error type
-	 */
-	constructor(Type) {
-		this.Type = Type;
-	}
-	/**
-	 * @param {Error | EvalError | RangeError | ReferenceError | SyntaxError | TypeError} obj error
-	 * @param {ObjectSerializerContext} context context
-	 */
-	serialize(obj, context) {
-		context.write(obj.message);
-		context.write(obj.stack);
-		context.write(/** @type {Error & { cause: "unknown" }} */ (obj).cause);
-	}
-	/**
-	 * @param {ObjectDeserializerContext} context context
-	 * @returns {Error | EvalError | RangeError | ReferenceError | SyntaxError | TypeError} error
-	 */
-	deserialize(context) {
-		const err = new this.Type();
-
-		err.message = context.read();
-		err.stack = context.read();
-		/** @type {Error & { cause: "unknown" }} */
-		(err).cause = context.read();
-
-		return err;
-	}
-}
-
-module.exports = ErrorObjectSerializer;
diff --git a/node_modules/webpack/lib/serialization/FileMiddleware.js b/node_modules/webpack/lib/serialization/FileMiddleware.js
deleted file mode 100644
index be4b3650..00000000
--- a/node_modules/webpack/lib/serialization/FileMiddleware.js
+++ /dev/null
@@ -1,682 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-"use strict";
-
-const { constants } = require("buffer");
-const { pipeline } = require("stream");
-const {
-	createBrotliCompress,
-	createBrotliDecompress,
-	createGzip,
-	createGunzip,
-	constants: zConstants
-} = require("zlib");
-const createHash = require("../util/createHash");
-const { dirname, join, mkdirp } = require("../util/fs");
-const memoize = require("../util/memoize");
-const SerializerMiddleware = require("./SerializerMiddleware");
-
-/** @typedef {typeof import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
-/** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
-
-/*
-Format:
-
-File -> Header Section*
-
-Version -> u32
-AmountOfSections -> u32
-SectionSize -> i32 (if less than zero represents lazy value)
-
-Header -> Version AmountOfSections SectionSize*
-
-Buffer -> n bytes
-Section -> Buffer
-
-*/
-
-// "wpc" + 1 in little-endian
-const VERSION = 0x01637077;
-const WRITE_LIMIT_TOTAL = 0x7fff0000;
-const WRITE_LIMIT_CHUNK = 511 * 1024 * 1024;
-
-/**
- * @param {Buffer[]} buffers buffers
- * @param {string | Hash} hashFunction hash function to use
- * @returns {string} hash
- */
-const hashForName = (buffers, hashFunction) => {
-	const hash = createHash(hashFunction);
-	for (const buf of buffers) hash.update(buf);
-	return /** @type {string} */ (hash.digest("hex"));
-};
-
-const COMPRESSION_CHUNK_SIZE = 100 * 1024 * 1024;
-const DECOMPRESSION_CHUNK_SIZE = 100 * 1024 * 1024;
-
-const writeUInt64LE = Buffer.prototype.writeBigUInt64LE
-	? (buf, value, offset) => {
-			buf.writeBigUInt64LE(BigInt(value), offset);
-	  }
-	: (buf, value, offset) => {
-			const low = value % 0x100000000;
-			const high = (value - low) / 0x100000000;
-			buf.writeUInt32LE(low, offset);
-			buf.writeUInt32LE(high, offset + 4);
-	  };
-
-const readUInt64LE = Buffer.prototype.readBigUInt64LE
-	? (buf, offset) => {
-			return Number(buf.readBigUInt64LE(offset));
-	  }
-	: (buf, offset) => {
-			const low = buf.readUInt32LE(offset);
-			const high = buf.readUInt32LE(offset + 4);
-			return high * 0x100000000 + low;
-	  };
-
-/**
- * @typedef {Object} SerializeResult
- * @property {string | false} name
- * @property {number} size
- * @property {Promise=} backgroundJob
- */
-
-/**
- * @param {FileMiddleware} middleware this
- * @param {BufferSerializableType[] | Promise<BufferSerializableType[]>} data data to be serialized
- * @param {string | boolean} name file base name
- * @param {function(string | false, Buffer[], number): Promise<void>} writeFile writes a file
- * @param {string | Hash} hashFunction hash function to use
- * @returns {Promise<SerializeResult>} resulting file pointer and promise
- */
-const serialize = async (
-	middleware,
-	data,
-	name,
-	writeFile,
-	hashFunction = "md4"
-) => {
-	/** @type {(Buffer[] | Buffer | SerializeResult | Promise<SerializeResult>)[]} */
-	const processedData = [];
-	/** @type {WeakMap<SerializeResult, function(): any | Promise<any>>} */
-	const resultToLazy = new WeakMap();
-	/** @type {Buffer[]} */
-	let lastBuffers = undefined;
-	for (const item of await data) {
-		if (typeof item === "function") {
-			if (!SerializerMiddleware.isLazy(item))
-				throw new Error("Unexpected function");
-			if (!SerializerMiddleware.isLazy(item, middleware)) {
-				throw new Error(
-					"Unexpected lazy value with non-this target (can't pass through lazy values)"
-				);
-			}
-			lastBuffers = undefined;
-			const serializedInfo = SerializerMiddleware.getLazySerializedValue(item);
-			if (serializedInfo) {
-				if (typeof serializedInfo === "function") {
-					throw new Error(
-						"Unexpected lazy value with non-this target (can't pass through lazy values)"
-					);
-				} else {
-					processedData.push(serializedInfo);
-				}
-			} else {
-				const content = item();
-				if (content) {
-					const options = SerializerMiddleware.getLazyOptions(item);
-					processedData.push(
-						serialize(
-							middleware,
-							content,
-							(options && options.name) || true,
-							writeFile,
-							hashFunction
-						).then(result => {
-							/** @type {any} */ (item).options.size = result.size;
-							resultToLazy.set(result, item);
-							return result;
-						})
-					);
-				} else {
-					throw new Error(
-						"Unexpected falsy value returned by lazy value function"
-					);
-				}
-			}
-		} else if (item) {
-			if (lastBuffers) {
-				lastBuffers.push(item);
-			} else {
-				lastBuffers = [item];
-				processedData.push(lastBuffers);
-			}
-		} else {
-			throw new Error("Unexpected falsy value in items array");
-		}
-	}
-	/** @type {Promise<any>[]} */
-	const backgroundJobs = [];
-	const resolvedData = (
-		await Promise.all(
-			/** @type {Promise<Buffer[] | Buffer | SerializeResult>[]} */ (
-				processedData
-			)
-		)
-	).map(item => {
-		if (Array.isArray(item) || Buffer.isBuffer(item)) return item;
-
-		backgroundJobs.push(item.backgroundJob);
-		// create pointer buffer from size and name
-		const name = /** @type {string} */ (item.name);
-		const nameBuffer = Buffer.from(name);
-		const buf = Buffer.allocUnsafe(8 + nameBuffer.length);
-		writeUInt64LE(buf, item.size, 0);
-		nameBuffer.copy(buf, 8, 0);
-		const lazy = resultToLazy.get(item);
-		SerializerMiddleware.setLazySerializedValue(lazy, buf);
-		return buf;
-	});
-	/** @type {number[]} */
-	const lengths = [];
-	for (const item of resolvedData) {
-		if (Array.isArray(item)) {
-			let l = 0;
-			for (const b of item) l += b.length;
-			while (l > 0x7fffffff) {
-				lengths.push(0x7fffffff);
-				l -= 0x7fffffff;
-			}
-			lengths.push(l);
-		} else if (item) {
-			lengths.push(-item.length);
-		} else {
-			throw new Error("Unexpected falsy value in resolved data " + item);
-		}
-	}
-	const header = Buffer.allocUnsafe(8 + lengths.length * 4);
-	header.writeUInt32LE(VERSION, 0);
-	header.writeUInt32LE(lengths.length, 4);
-	for (let i = 0; i < lengths.length; i++) {
-		header.writeInt32LE(lengths[i], 8 + i * 4);
-	}
-	/** @type {Buffer[]} */
-	const buf = [header];
-	for (const item of resolvedData) {
-		if (Array.isArray(item)) {
-			for (const b of item) buf.push(b);
-		} else if (item) {
-			buf.push(item);
-		}
-	}
-	if (name === true) {
-		name = hashForName(buf, hashFunction);
-	}
-	let size = 0;
-	for (const b of buf) size += b.length;
-	backgroundJobs.push(writeFile(name, buf, size));
-	return {
-		size,
-		name,
-		backgroundJob:
-			backgroundJobs.length === 1
-				? backgroundJobs[0]
-				: Promise.all(backgroundJobs)
-	};
-};
-
-/**
- * @param {FileMiddleware} middleware this
- * @param {string | false} name filename
- * @param {function(string | false): Promise<Buffer[]>} readFile read content of a file
- * @returns {Promise<BufferSerializableType[]>} deserialized data
- */
-const deserialize = async (middleware, name, readFile) => {
-	const contents = await readFile(name);
-	if (contents.length === 0) throw new Error("Empty file " + name);
-	let contentsIndex = 0;
-	let contentItem = contents[0];
-	let contentItemLength = contentItem.length;
-	let contentPosition = 0;
-	if (contentItemLength === 0) throw new Error("Empty file " + name);
-	const nextContent = () => {
-		contentsIndex++;
-		contentItem = contents[contentsIndex];
-		contentItemLength = contentItem.length;
-		contentPosition = 0;
-	};
-	/**
-	 * @param {number} n number of bytes to ensure
-	 */
-	const ensureData = n => {
-		if (contentPosition === contentItemLength) {
-			nextContent();
-		}
-		while (contentItemLength - contentPosition < n) {
-			const remaining = contentItem.slice(contentPosition);
-			let lengthFromNext = n - remaining.length;
-			const buffers = [remaining];
-			for (let i = contentsIndex + 1; i < contents.length; i++) {
-				const l = contents[i].length;
-				if (l > lengthFromNext) {
-					buffers.push(contents[i].slice(0, lengthFromNext));
-					contents[i] = contents[i].slice(lengthFromNext);
-					lengthFromNext = 0;
-					break;
-				} else {
-					buffers.push(contents[i]);
-					contentsIndex = i;
-					lengthFromNext -= l;
-				}
-			}
-			if (lengthFromNext > 0) throw new Error("Unexpected end of data");
-			contentItem = Buffer.concat(buffers, n);
-			contentItemLength = n;
-			contentPosition = 0;
-		}
-	};
-	/**
-	 * @returns {number} value value
-	 */
-	const readUInt32LE = () => {
-		ensureData(4);
-		const value = contentItem.readUInt32LE(contentPosition);
-		contentPosition += 4;
-		return value;
-	};
-	/**
-	 * @returns {number} value value
-	 */
-	const readInt32LE = () => {
-		ensureData(4);
-		const value = contentItem.readInt32LE(contentPosition);
-		contentPosition += 4;
-		return value;
-	};
-	/**
-	 * @param {number} l length
-	 * @returns {Buffer} buffer
-	 */
-	const readSlice = l => {
-		ensureData(l);
-		if (contentPosition === 0 && contentItemLength === l) {
-			const result = contentItem;
-			if (contentsIndex + 1 < contents.length) {
-				nextContent();
-			} else {
-				contentPosition = l;
-			}
-			return result;
-		}
-		const result = contentItem.slice(contentPosition, contentPosition + l);
-		contentPosition += l;
-		// we clone the buffer here to allow the original content to be garbage collected
-		return l * 2 < contentItem.buffer.byteLength ? Buffer.from(result) : result;
-	};
-	const version = readUInt32LE();
-	if (version !== VERSION) {
-		throw new Error("Invalid file version");
-	}
-	const sectionCount = readUInt32LE();
-	const lengths = [];
-	let lastLengthPositive = false;
-	for (let i = 0; i < sectionCount; i++) {
-		const value = readInt32LE();
-		const valuePositive = value >= 0;
-		if (lastLengthPositive && valuePositive) {
-			lengths[lengths.length - 1] += value;
-		} else {
-			lengths.push(value);
-			lastLengthPositive = valuePositive;
-		}
-	}
-	const result = [];
-	for (let length of lengths) {
-		if (length < 0) {
-			const slice = readSlice(-length);
-			const size = Number(readUInt64LE(slice, 0));
-			const nameBuffer = slice.slice(8);
-			const name = nameBuffer.toString();
-			result.push(
-				SerializerMiddleware.createLazy(
-					memoize(() => deserialize(middleware, name, readFile)),
-					middleware,
-					{
-						name,
-						size
-					},
-					slice
-				)
-			);
-		} else {
-			if (contentPosition === contentItemLength) {
-				nextContent();
-			} else if (contentPosition !== 0) {
-				if (length <= contentItemLength - contentPosition) {
-					result.push(
-						Buffer.from(
-							contentItem.buffer,
-							contentItem.byteOffset + contentPosition,
-							length
-						)
-					);
-					contentPosition += length;
-					length = 0;
-				} else {
-					const l = contentItemLength - contentPosition;
-					result.push(
-						Buffer.from(
-							contentItem.buffer,
-							contentItem.byteOffset + contentPosition,
-							l
-						)
-					);
-					length -= l;
-					contentPosition = contentItemLength;
-				}
-			} else {
-				if (length >= contentItemLength) {
-					result.push(contentItem);
-					length -= contentItemLength;
-					contentPosition = contentItemLength;
-				} else {
-					result.push(
-						Buffer.from(contentItem.buffer, contentItem.byteOffset, length)
-					);
-					contentPosition += length;
-					length = 0;
-				}
-			}
-			while (length > 0) {
-				nextContent();
-				if (length >= contentItemLength) {
-					result.push(contentItem);
-					length -= contentItemLength;
-					contentPosition = contentItemLength;
-				} else {
-					result.push(
-						Buffer.from(contentItem.buffer, contentItem.byteOffset, length)
-					);
-					contentPosition += length;
-					length = 0;
-				}
-			}
-		}
-	}
-	return result;
-};
-
-/**
- * @typedef {BufferSerializableType[]} DeserializedType
- * @typedef {true} SerializedType
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
- */
-class FileMiddleware extends SerializerMiddleware {
-	/**
-	 * @param {IntermediateFileSystem} fs filesystem
-	 * @param {string | Hash} hashFunction hash function to use
-	 */
-	constructor(fs, hashFunction = "md4") {
-		super();
-		this.fs = fs;
-		this._hashFunction = hashFunction;
-	}
-	/**
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
-	 */
-	serialize(data, context) {
-		const { filename, extension = "" } = context;
-		return new Promise((resolve, reject) => {
-			mkdirp(this.fs, dirname(this.fs, filename), err => {
-				if (err) return reject(err);
-
-				// It's important that we don't touch existing files during serialization
-				// because serialize may read existing files (when deserializing)
-				const allWrittenFiles = new Set();
-				const writeFile = async (name, content, size) => {
-					const file = name
-						? join(this.fs, filename, `../${name}${extension}`)
-						: filename;
-					await new Promise((resolve, reject) => {
-						let stream = this.fs.createWriteStream(file + "_");
-						let compression;
-						if (file.endsWith(".gz")) {
-							compression = createGzip({
-								chunkSize: COMPRESSION_CHUNK_SIZE,
-								level: zConstants.Z_BEST_SPEED
-							});
-						} else if (file.endsWith(".br")) {
-							compression = createBrotliCompress({
-								chunkSize: COMPRESSION_CHUNK_SIZE,
-								params: {
-									[zConstants.BROTLI_PARAM_MODE]: zConstants.BROTLI_MODE_TEXT,
-									[zConstants.BROTLI_PARAM_QUALITY]: 2,
-									[zConstants.BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING]: true,
-									[zConstants.BROTLI_PARAM_SIZE_HINT]: size
-								}
-							});
-						}
-						if (compression) {
-							pipeline(compression, stream, reject);
-							stream = compression;
-							stream.on("finish", () => resolve());
-						} else {
-							stream.on("error", err => reject(err));
-							stream.on("finish", () => resolve());
-						}
-						// split into chunks for WRITE_LIMIT_CHUNK size
-						const chunks = [];
-						for (const b of content) {
-							if (b.length < WRITE_LIMIT_CHUNK) {
-								chunks.push(b);
-							} else {
-								for (let i = 0; i < b.length; i += WRITE_LIMIT_CHUNK) {
-									chunks.push(b.slice(i, i + WRITE_LIMIT_CHUNK));
-								}
-							}
-						}
-
-						const len = chunks.length;
-						let i = 0;
-						const batchWrite = err => {
-							// will be handled in "on" error handler
-							if (err) return;
-
-							if (i === len) {
-								stream.end();
-								return;
-							}
-
-							// queue up a batch of chunks up to the write limit
-							// end is exclusive
-							let end = i;
-							let sum = chunks[end++].length;
-							while (end < len) {
-								sum += chunks[end].length;
-								if (sum > WRITE_LIMIT_TOTAL) break;
-								end++;
-							}
-							while (i < end - 1) {
-								stream.write(chunks[i++]);
-							}
-							stream.write(chunks[i++], batchWrite);
-						};
-						batchWrite();
-					});
-					if (name) allWrittenFiles.add(file);
-				};
-
-				resolve(
-					serialize(this, data, false, writeFile, this._hashFunction).then(
-						async ({ backgroundJob }) => {
-							await backgroundJob;
-
-							// Rename the index file to disallow access during inconsistent file state
-							await new Promise(resolve =>
-								this.fs.rename(filename, filename + ".old", err => {
-									resolve();
-								})
-							);
-
-							// update all written files
-							await Promise.all(
-								Array.from(
-									allWrittenFiles,
-									file =>
-										new Promise((resolve, reject) => {
-											this.fs.rename(file + "_", file, err => {
-												if (err) return reject(err);
-												resolve();
-											});
-										})
-								)
-							);
-
-							// As final step automatically update the index file to have a consistent pack again
-							await new Promise(resolve => {
-								this.fs.rename(filename + "_", filename, err => {
-									if (err) return reject(err);
-									resolve();
-								});
-							});
-							return /** @type {true} */ (true);
-						}
-					)
-				);
-			});
-		});
-	}
-
-	/**
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
-	 */
-	deserialize(data, context) {
-		const { filename, extension = "" } = context;
-		const readFile = name =>
-			new Promise((resolve, reject) => {
-				const file = name
-					? join(this.fs, filename, `../${name}${extension}`)
-					: filename;
-				this.fs.stat(file, (err, stats) => {
-					if (err) {
-						reject(err);
-						return;
-					}
-					let remaining = /** @type {number} */ (stats.size);
-					/** @type {Buffer | undefined} */
-					let currentBuffer;
-					/** @type {number | undefined} */
-					let currentBufferUsed;
-					const buf = [];
-					let decompression;
-					if (file.endsWith(".gz")) {
-						decompression = createGunzip({
-							chunkSize: DECOMPRESSION_CHUNK_SIZE
-						});
-					} else if (file.endsWith(".br")) {
-						decompression = createBrotliDecompress({
-							chunkSize: DECOMPRESSION_CHUNK_SIZE
-						});
-					}
-					if (decompression) {
-						let newResolve, newReject;
-						resolve(
-							Promise.all([
-								new Promise((rs, rj) => {
-									newResolve = rs;
-									newReject = rj;
-								}),
-								new Promise((resolve, reject) => {
-									decompression.on("data", chunk => buf.push(chunk));
-									decompression.on("end", () => resolve());
-									decompression.on("error", err => reject(err));
-								})
-							]).then(() => buf)
-						);
-						resolve = newResolve;
-						reject = newReject;
-					}
-					this.fs.open(file, "r", (err, fd) => {
-						if (err) {
-							reject(err);
-							return;
-						}
-						const read = () => {
-							if (currentBuffer === undefined) {
-								currentBuffer = Buffer.allocUnsafeSlow(
-									Math.min(
-										constants.MAX_LENGTH,
-										remaining,
-										decompression ? DECOMPRESSION_CHUNK_SIZE : Infinity
-									)
-								);
-								currentBufferUsed = 0;
-							}
-							let readBuffer = currentBuffer;
-							let readOffset = currentBufferUsed;
-							let readLength = currentBuffer.length - currentBufferUsed;
-							// values passed to fs.read must be valid int32 values
-							if (readOffset > 0x7fffffff) {
-								readBuffer = currentBuffer.slice(readOffset);
-								readOffset = 0;
-							}
-							if (readLength > 0x7fffffff) {
-								readLength = 0x7fffffff;
-							}
-							this.fs.read(
-								fd,
-								readBuffer,
-								readOffset,
-								readLength,
-								null,
-								(err, bytesRead) => {
-									if (err) {
-										this.fs.close(fd, () => {
-											reject(err);
-										});
-										return;
-									}
-									currentBufferUsed += bytesRead;
-									remaining -= bytesRead;
-									if (currentBufferUsed === currentBuffer.length) {
-										if (decompression) {
-											decompression.write(currentBuffer);
-										} else {
-											buf.push(currentBuffer);
-										}
-										currentBuffer = undefined;
-										if (remaining === 0) {
-											if (decompression) {
-												decompression.end();
-											}
-											this.fs.close(fd, err => {
-												if (err) {
-													reject(err);
-													return;
-												}
-												resolve(buf);
-											});
-											return;
-										}
-									}
-									read();
-								}
-							);
-						};
-						read();
-					});
-				});
-			});
-		return deserialize(this, false, readFile);
-	}
-}
-
-module.exports = FileMiddleware;
diff --git a/node_modules/webpack/lib/serialization/MapObjectSerializer.js b/node_modules/webpack/lib/serialization/MapObjectSerializer.js
deleted file mode 100644
index cb5fa6b6..00000000
--- a/node_modules/webpack/lib/serialization/MapObjectSerializer.js
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-"use strict";
-
-/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-
-class MapObjectSerializer {
-	/**
-	 * @template K, V
-	 * @param {Map<K, V>} obj map
-	 * @param {ObjectSerializerContext} context context
-	 */
-	serialize(obj, context) {
-		context.write(obj.size);
-		for (const key of obj.keys()) {
-			context.write(key);
-		}
-		for (const value of obj.values()) {
-			context.write(value);
-		}
-	}
-	/**
-	 * @template K, V
-	 * @param {ObjectDeserializerContext} context context
-	 * @returns {Map<K, V>} map
-	 */
-	deserialize(context) {
-		/** @type {number} */
-		let size = context.read();
-		/** @type {Map<K, V>} */
-		const map = new Map();
-		/** @type {K[]} */
-		const keys = [];
-		for (let i = 0; i < size; i++) {
-			keys.push(context.read());
-		}
-		for (let i = 0; i < size; i++) {
-			map.set(keys[i], context.read());
-		}
-		return map;
-	}
-}
-
-module.exports = MapObjectSerializer;
diff --git a/node_modules/webpack/lib/serialization/NullPrototypeObjectSerializer.js b/node_modules/webpack/lib/serialization/NullPrototypeObjectSerializer.js
deleted file mode 100644
index f7263e33..00000000
--- a/node_modules/webpack/lib/serialization/NullPrototypeObjectSerializer.js
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-"use strict";
-
-/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-
-class NullPrototypeObjectSerializer {
-	/**
-	 * @template {Object} T
-	 * @param {T} obj null object
-	 * @param {ObjectSerializerContext} context context
-	 */
-	serialize(obj, context) {
-		/** @type {string[]} */
-		const keys = Object.keys(obj);
-		for (const key of keys) {
-			context.write(key);
-		}
-		context.write(null);
-		for (const key of keys) {
-			context.write(obj[key]);
-		}
-	}
-	/**
-	 * @template {Object} T
-	 * @param {ObjectDeserializerContext} context context
-	 * @returns {T} null object
-	 */
-	deserialize(context) {
-		/** @type {T} */
-		const obj = Object.create(null);
-		/** @type {string[]} */
-		const keys = [];
-		/** @type {string | null} */
-		let key = context.read();
-		while (key !== null) {
-			keys.push(key);
-			key = context.read();
-		}
-		for (const key of keys) {
-			obj[key] = context.read();
-		}
-		return obj;
-	}
-}
-
-module.exports = NullPrototypeObjectSerializer;
diff --git a/node_modules/webpack/lib/serialization/ObjectMiddleware.js b/node_modules/webpack/lib/serialization/ObjectMiddleware.js
deleted file mode 100644
index 31890dfe..00000000
--- a/node_modules/webpack/lib/serialization/ObjectMiddleware.js
+++ /dev/null
@@ -1,765 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-"use strict";
-
-const createHash = require("../util/createHash");
-const ArraySerializer = require("./ArraySerializer");
-const DateObjectSerializer = require("./DateObjectSerializer");
-const ErrorObjectSerializer = require("./ErrorObjectSerializer");
-const MapObjectSerializer = require("./MapObjectSerializer");
-const NullPrototypeObjectSerializer = require("./NullPrototypeObjectSerializer");
-const PlainObjectSerializer = require("./PlainObjectSerializer");
-const RegExpObjectSerializer = require("./RegExpObjectSerializer");
-const SerializerMiddleware = require("./SerializerMiddleware");
-const SetObjectSerializer = require("./SetObjectSerializer");
-
-/** @typedef {typeof import("../util/Hash")} Hash */
-/** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
-/** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
-
-/** @typedef {new (...params: any[]) => any} Constructor */
-
-/*
-
-Format:
-
-File -> Section*
-Section -> ObjectSection | ReferenceSection | EscapeSection | OtherSection
-
-ObjectSection -> ESCAPE (
-	number:relativeOffset (number > 0) |
-	string:request (string|null):export
-) Section:value* ESCAPE ESCAPE_END_OBJECT
-ReferenceSection -> ESCAPE number:relativeOffset (number < 0)
-EscapeSection -> ESCAPE ESCAPE_ESCAPE_VALUE (escaped value ESCAPE)
-EscapeSection -> ESCAPE ESCAPE_UNDEFINED (escaped value ESCAPE)
-OtherSection -> any (except ESCAPE)
-
-Why using null as escape value?
-Multiple null values can merged by the BinaryMiddleware, which makes it very efficient
-Technically any value can be used.
-
-*/
-
-/**
- * @typedef {Object} ObjectSerializerContext
- * @property {function(any): void} write
- * @property {function(any): void} setCircularReference
- */
-
-/**
- * @typedef {Object} ObjectDeserializerContext
- * @property {function(): any} read
- * @property {function(any): void} setCircularReference
- */
-
-/**
- * @typedef {Object} ObjectSerializer
- * @property {function(any, ObjectSerializerContext): void} serialize
- * @property {function(ObjectDeserializerContext): any} deserialize
- */
-
-/**
- * @template T
- * @param {Set<T>} set set
- * @param {number} size count of items to keep
- */
-const setSetSize = (set, size) => {
-	let i = 0;
-	for (const item of set) {
-		if (i++ >= size) {
-			set.delete(item);
-		}
-	}
-};
-
-/**
- * @template K, X
- * @param {Map<K, X>} map map
- * @param {number} size count of items to keep
- */
-const setMapSize = (map, size) => {
-	let i = 0;
-	for (const item of map.keys()) {
-		if (i++ >= size) {
-			map.delete(item);
-		}
-	}
-};
-
-/**
- * @param {Buffer} buffer buffer
- * @param {string | Hash} hashFunction hash function to use
- * @returns {string} hash
- */
-const toHash = (buffer, hashFunction) => {
-	const hash = createHash(hashFunction);
-	hash.update(buffer);
-	return /** @type {string} */ (hash.digest("latin1"));
-};
-
-const ESCAPE = null;
-const ESCAPE_ESCAPE_VALUE = null;
-const ESCAPE_END_OBJECT = true;
-const ESCAPE_UNDEFINED = false;
-
-const CURRENT_VERSION = 2;
-
-/** @type {Map<Constructor, { request?: string, name?: string | number | null, serializer?: ObjectSerializer }>} */
-const serializers = new Map();
-/** @type {Map<string | number, ObjectSerializer>} */
-const serializerInversed = new Map();
-
-/** @type {Set<string>} */
-const loadedRequests = new Set();
-
-const NOT_SERIALIZABLE = {};
-
-const jsTypes = new Map();
-jsTypes.set(Object, new PlainObjectSerializer());
-jsTypes.set(Array, new ArraySerializer());
-jsTypes.set(null, new NullPrototypeObjectSerializer());
-jsTypes.set(Map, new MapObjectSerializer());
-jsTypes.set(Set, new SetObjectSerializer());
-jsTypes.set(Date, new DateObjectSerializer());
-jsTypes.set(RegExp, new RegExpObjectSerializer());
-jsTypes.set(Error, new ErrorObjectSerializer(Error));
-jsTypes.set(EvalError, new ErrorObjectSerializer(EvalError));
-jsTypes.set(RangeError, new ErrorObjectSerializer(RangeError));
-jsTypes.set(ReferenceError, new ErrorObjectSerializer(ReferenceError));
-jsTypes.set(SyntaxError, new ErrorObjectSerializer(SyntaxError));
-jsTypes.set(TypeError, new ErrorObjectSerializer(TypeError));
-
-// If in a sandboxed environment (e. g. jest), this escapes the sandbox and registers
-// real Object and Array types to. These types may occur in the wild too, e. g. when
-// using Structured Clone in postMessage.
-if (exports.constructor !== Object) {
-	const Obj = /** @type {typeof Object} */ (exports.constructor);
-	const Fn = /** @type {typeof Function} */ (Obj.constructor);
-	for (const [type, config] of Array.from(jsTypes)) {
-		if (type) {
-			const Type = new Fn(`return ${type.name};`)();
-			jsTypes.set(Type, config);
-		}
-	}
-}
-
-{
-	let i = 1;
-	for (const [type, serializer] of jsTypes) {
-		serializers.set(type, {
-			request: "",
-			name: i++,
-			serializer
-		});
-	}
-}
-
-for (const { request, name, serializer } of serializers.values()) {
-	serializerInversed.set(
-		`${request}/${name}`,
-		/** @type {ObjectSerializer} */ (serializer)
-	);
-}
-
-/** @type {Map<RegExp, (request: string) => boolean>} */
-const loaders = new Map();
-
-/**
- * @typedef {ComplexSerializableType[]} DeserializedType
- * @typedef {PrimitiveSerializableType[]} SerializedType
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
- */
-class ObjectMiddleware extends SerializerMiddleware {
-	/**
-	 * @param {function(any): void} extendContext context extensions
-	 * @param {string | Hash} hashFunction hash function to use
-	 */
-	constructor(extendContext, hashFunction = "md4") {
-		super();
-		this.extendContext = extendContext;
-		this._hashFunction = hashFunction;
-	}
-	/**
-	 * @param {RegExp} regExp RegExp for which the request is tested
-	 * @param {function(string): boolean} loader loader to load the request, returns true when successful
-	 * @returns {void}
-	 */
-	static registerLoader(regExp, loader) {
-		loaders.set(regExp, loader);
-	}
-
-	/**
-	 * @param {Constructor} Constructor the constructor
-	 * @param {string} request the request which will be required when deserializing
-	 * @param {string | null} name the name to make multiple serializer unique when sharing a request
-	 * @param {ObjectSerializer} serializer the serializer
-	 * @returns {void}
-	 */
-	static register(Constructor, request, name, serializer) {
-		const key = request + "/" + name;
-
-		if (serializers.has(Constructor)) {
-			throw new Error(
-				`ObjectMiddleware.register: serializer for ${Constructor.name} is already registered`
-			);
-		}
-
-		if (serializerInversed.has(key)) {
-			throw new Error(
-				`ObjectMiddleware.register: serializer for ${key} is already registered`
-			);
-		}
-
-		serializers.set(Constructor, {
-			request,
-			name,
-			serializer
-		});
-
-		serializerInversed.set(key, serializer);
-	}
-
-	/**
-	 * @param {Constructor} Constructor the constructor
-	 * @returns {void}
-	 */
-	static registerNotSerializable(Constructor) {
-		if (serializers.has(Constructor)) {
-			throw new Error(
-				`ObjectMiddleware.registerNotSerializable: serializer for ${Constructor.name} is already registered`
-			);
-		}
-
-		serializers.set(Constructor, NOT_SERIALIZABLE);
-	}
-
-	static getSerializerFor(object) {
-		const proto = Object.getPrototypeOf(object);
-		let c;
-		if (proto === null) {
-			// Object created with Object.create(null)
-			c = null;
-		} else {
-			c = proto.constructor;
-			if (!c) {
-				throw new Error(
-					"Serialization of objects with prototype without valid constructor property not possible"
-				);
-			}
-		}
-		const config = serializers.get(c);
-
-		if (!config) throw new Error(`No serializer registered for ${c.name}`);
-		if (config === NOT_SERIALIZABLE) throw NOT_SERIALIZABLE;
-
-		return config;
-	}
-
-	/**
-	 * @param {string} request request
-	 * @param {TODO} name name
-	 * @returns {ObjectSerializer} serializer
-	 */
-	static getDeserializerFor(request, name) {
-		const key = request + "/" + name;
-		const serializer = serializerInversed.get(key);
-
-		if (serializer === undefined) {
-			throw new Error(`No deserializer registered for ${key}`);
-		}
-
-		return serializer;
-	}
-
-	/**
-	 * @param {string} request request
-	 * @param {TODO} name name
-	 * @returns {ObjectSerializer} serializer
-	 */
-	static _getDeserializerForWithoutError(request, name) {
-		const key = request + "/" + name;
-		const serializer = serializerInversed.get(key);
-		return serializer;
-	}
-
-	/**
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
-	 */
-	serialize(data, context) {
-		/** @type {any[]} */
-		let result = [CURRENT_VERSION];
-		let currentPos = 0;
-		let referenceable = new Map();
-		const addReferenceable = item => {
-			referenceable.set(item, currentPos++);
-		};
-		let bufferDedupeMap = new Map();
-		const dedupeBuffer = buf => {
-			const len = buf.length;
-			const entry = bufferDedupeMap.get(len);
-			if (entry === undefined) {
-				bufferDedupeMap.set(len, buf);
-				return buf;
-			}
-			if (Buffer.isBuffer(entry)) {
-				if (len < 32) {
-					if (buf.equals(entry)) {
-						return entry;
-					}
-					bufferDedupeMap.set(len, [entry, buf]);
-					return buf;
-				} else {
-					const hash = toHash(entry, this._hashFunction);
-					const newMap = new Map();
-					newMap.set(hash, entry);
-					bufferDedupeMap.set(len, newMap);
-					const hashBuf = toHash(buf, this._hashFunction);
-					if (hash === hashBuf) {
-						return entry;
-					}
-					return buf;
-				}
-			} else if (Array.isArray(entry)) {
-				if (entry.length < 16) {
-					for (const item of entry) {
-						if (buf.equals(item)) {
-							return item;
-						}
-					}
-					entry.push(buf);
-					return buf;
-				} else {
-					const newMap = new Map();
-					const hash = toHash(buf, this._hashFunction);
-					let found;
-					for (const item of entry) {
-						const itemHash = toHash(item, this._hashFunction);
-						newMap.set(itemHash, item);
-						if (found === undefined && itemHash === hash) found = item;
-					}
-					bufferDedupeMap.set(len, newMap);
-					if (found === undefined) {
-						newMap.set(hash, buf);
-						return buf;
-					} else {
-						return found;
-					}
-				}
-			} else {
-				const hash = toHash(buf, this._hashFunction);
-				const item = entry.get(hash);
-				if (item !== undefined) {
-					return item;
-				}
-				entry.set(hash, buf);
-				return buf;
-			}
-		};
-		let currentPosTypeLookup = 0;
-		let objectTypeLookup = new Map();
-		const cycleStack = new Set();
-		const stackToString = item => {
-			const arr = Array.from(cycleStack);
-			arr.push(item);
-			return arr
-				.map(item => {
-					if (typeof item === "string") {
-						if (item.length > 100) {
-							return `String ${JSON.stringify(item.slice(0, 100)).slice(
-								0,
-								-1
-							)}..."`;
-						}
-						return `String ${JSON.stringify(item)}`;
-					}
-					try {
-						const { request, name } = ObjectMiddleware.getSerializerFor(item);
-						if (request) {
-							return `${request}${name ? `.${name}` : ""}`;
-						}
-					} catch (e) {
-						// ignore -> fallback
-					}
-					if (typeof item === "object" && item !== null) {
-						if (item.constructor) {
-							if (item.constructor === Object)
-								return `Object { ${Object.keys(item).join(", ")} }`;
-							if (item.constructor === Map) return `Map { ${item.size} items }`;
-							if (item.constructor === Array)
-								return `Array { ${item.length} items }`;
-							if (item.constructor === Set) return `Set { ${item.size} items }`;
-							if (item.constructor === RegExp) return item.toString();
-							return `${item.constructor.name}`;
-						}
-						return `Object [null prototype] { ${Object.keys(item).join(
-							", "
-						)} }`;
-					}
-					if (typeof item === "bigint") {
-						return `BigInt ${item}n`;
-					}
-					try {
-						return `${item}`;
-					} catch (e) {
-						return `(${e.message})`;
-					}
-				})
-				.join(" -> ");
-		};
-		let hasDebugInfoAttached;
-		let ctx = {
-			write(value, key) {
-				try {
-					process(value);
-				} catch (e) {
-					if (e !== NOT_SERIALIZABLE) {
-						if (hasDebugInfoAttached === undefined)
-							hasDebugInfoAttached = new WeakSet();
-						if (!hasDebugInfoAttached.has(e)) {
-							e.message += `\nwhile serializing ${stackToString(value)}`;
-							hasDebugInfoAttached.add(e);
-						}
-					}
-					throw e;
-				}
-			},
-			setCircularReference(ref) {
-				addReferenceable(ref);
-			},
-			snapshot() {
-				return {
-					length: result.length,
-					cycleStackSize: cycleStack.size,
-					referenceableSize: referenceable.size,
-					currentPos,
-					objectTypeLookupSize: objectTypeLookup.size,
-					currentPosTypeLookup
-				};
-			},
-			rollback(snapshot) {
-				result.length = snapshot.length;
-				setSetSize(cycleStack, snapshot.cycleStackSize);
-				setMapSize(referenceable, snapshot.referenceableSize);
-				currentPos = snapshot.currentPos;
-				setMapSize(objectTypeLookup, snapshot.objectTypeLookupSize);
-				currentPosTypeLookup = snapshot.currentPosTypeLookup;
-			},
-			...context
-		};
-		this.extendContext(ctx);
-		const process = item => {
-			if (Buffer.isBuffer(item)) {
-				// check if we can emit a reference
-				const ref = referenceable.get(item);
-				if (ref !== undefined) {
-					result.push(ESCAPE, ref - currentPos);
-					return;
-				}
-				const alreadyUsedBuffer = dedupeBuffer(item);
-				if (alreadyUsedBuffer !== item) {
-					const ref = referenceable.get(alreadyUsedBuffer);
-					if (ref !== undefined) {
-						referenceable.set(item, ref);
-						result.push(ESCAPE, ref - currentPos);
-						return;
-					}
-					item = alreadyUsedBuffer;
-				}
-				addReferenceable(item);
-
-				result.push(item);
-			} else if (item === ESCAPE) {
-				result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
-			} else if (
-				typeof item === "object"
-				// We don't have to check for null as ESCAPE is null and this has been checked before
-			) {
-				// check if we can emit a reference
-				const ref = referenceable.get(item);
-				if (ref !== undefined) {
-					result.push(ESCAPE, ref - currentPos);
-					return;
-				}
-
-				if (cycleStack.has(item)) {
-					throw new Error(
-						`This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize.`
-					);
-				}
-
-				const { request, name, serializer } =
-					ObjectMiddleware.getSerializerFor(item);
-				const key = `${request}/${name}`;
-				const lastIndex = objectTypeLookup.get(key);
-
-				if (lastIndex === undefined) {
-					objectTypeLookup.set(key, currentPosTypeLookup++);
-
-					result.push(ESCAPE, request, name);
-				} else {
-					result.push(ESCAPE, currentPosTypeLookup - lastIndex);
-				}
-
-				cycleStack.add(item);
-
-				try {
-					serializer.serialize(item, ctx);
-				} finally {
-					cycleStack.delete(item);
-				}
-
-				result.push(ESCAPE, ESCAPE_END_OBJECT);
-
-				addReferenceable(item);
-			} else if (typeof item === "string") {
-				if (item.length > 1) {
-					// short strings are shorter when not emitting a reference (this saves 1 byte per empty string)
-					// check if we can emit a reference
-					const ref = referenceable.get(item);
-					if (ref !== undefined) {
-						result.push(ESCAPE, ref - currentPos);
-						return;
-					}
-					addReferenceable(item);
-				}
-
-				if (item.length > 102400 && context.logger) {
-					context.logger.warn(
-						`Serializing big strings (${Math.round(
-							item.length / 1024
-						)}kiB) impacts deserialization performance (consider using Buffer instead and decode when needed)`
-					);
-				}
-
-				result.push(item);
-			} else if (typeof item === "function") {
-				if (!SerializerMiddleware.isLazy(item))
-					throw new Error("Unexpected function " + item);
-				/** @type {SerializedType} */
-				const serializedData =
-					SerializerMiddleware.getLazySerializedValue(item);
-				if (serializedData !== undefined) {
-					if (typeof serializedData === "function") {
-						result.push(serializedData);
-					} else {
-						throw new Error("Not implemented");
-					}
-				} else if (SerializerMiddleware.isLazy(item, this)) {
-					throw new Error("Not implemented");
-				} else {
-					const data = SerializerMiddleware.serializeLazy(item, data =>
-						this.serialize([data], context)
-					);
-					SerializerMiddleware.setLazySerializedValue(item, data);
-					result.push(data);
-				}
-			} else if (item === undefined) {
-				result.push(ESCAPE, ESCAPE_UNDEFINED);
-			} else {
-				result.push(item);
-			}
-		};
-
-		try {
-			for (const item of data) {
-				process(item);
-			}
-			return result;
-		} catch (e) {
-			if (e === NOT_SERIALIZABLE) return null;
-
-			throw e;
-		} finally {
-			// Get rid of these references to avoid leaking memory
-			// This happens because the optimized code v8 generates
-			// is optimized for our "ctx.write" method so it will reference
-			// it from e. g. Dependency.prototype.serialize -(IC)-> ctx.write
-			data =
-				result =
-				referenceable =
-				bufferDedupeMap =
-				objectTypeLookup =
-				ctx =
-					undefined;
-		}
-	}
-
-	/**
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
-	 */
-	deserialize(data, context) {
-		let currentDataPos = 0;
-		const read = () => {
-			if (currentDataPos >= data.length)
-				throw new Error("Unexpected end of stream");
-
-			return data[currentDataPos++];
-		};
-
-		if (read() !== CURRENT_VERSION)
-			throw new Error("Version mismatch, serializer changed");
-
-		let currentPos = 0;
-		let referenceable = [];
-		const addReferenceable = item => {
-			referenceable.push(item);
-			currentPos++;
-		};
-		let currentPosTypeLookup = 0;
-		let objectTypeLookup = [];
-		let result = [];
-		let ctx = {
-			read() {
-				return decodeValue();
-			},
-			setCircularReference(ref) {
-				addReferenceable(ref);
-			},
-			...context
-		};
-		this.extendContext(ctx);
-		const decodeValue = () => {
-			const item = read();
-
-			if (item === ESCAPE) {
-				const nextItem = read();
-
-				if (nextItem === ESCAPE_ESCAPE_VALUE) {
-					return ESCAPE;
-				} else if (nextItem === ESCAPE_UNDEFINED) {
-					return undefined;
-				} else if (nextItem === ESCAPE_END_OBJECT) {
-					throw new Error(
-						`Unexpected end of object at position ${currentDataPos - 1}`
-					);
-				} else {
-					const request = nextItem;
-					let serializer;
-
-					if (typeof request === "number") {
-						if (request < 0) {
-							// relative reference
-							return referenceable[currentPos + request];
-						}
-						serializer = objectTypeLookup[currentPosTypeLookup - request];
-					} else {
-						if (typeof request !== "string") {
-							throw new Error(
-								`Unexpected type (${typeof request}) of request ` +
-									`at position ${currentDataPos - 1}`
-							);
-						}
-						const name = read();
-
-						serializer = ObjectMiddleware._getDeserializerForWithoutError(
-							request,
-							name
-						);
-
-						if (serializer === undefined) {
-							if (request && !loadedRequests.has(request)) {
-								let loaded = false;
-								for (const [regExp, loader] of loaders) {
-									if (regExp.test(request)) {
-										if (loader(request)) {
-											loaded = true;
-											break;
-										}
-									}
-								}
-								if (!loaded) {
-									require(request);
-								}
-
-								loadedRequests.add(request);
-							}
-
-							serializer = ObjectMiddleware.getDeserializerFor(request, name);
-						}
-
-						objectTypeLookup.push(serializer);
-						currentPosTypeLookup++;
-					}
-					try {
-						const item = serializer.deserialize(ctx);
-						const end1 = read();
-
-						if (end1 !== ESCAPE) {
-							throw new Error("Expected end of object");
-						}
-
-						const end2 = read();
-
-						if (end2 !== ESCAPE_END_OBJECT) {
-							throw new Error("Expected end of object");
-						}
-
-						addReferenceable(item);
-
-						return item;
-					} catch (err) {
-						// As this is only for error handling, we omit creating a Map for
-						// faster access to this information, as this would affect performance
-						// in the good case
-						let serializerEntry;
-						for (const entry of serializers) {
-							if (entry[1].serializer === serializer) {
-								serializerEntry = entry;
-								break;
-							}
-						}
-						const name = !serializerEntry
-							? "unknown"
-							: !serializerEntry[1].request
-							? serializerEntry[0].name
-							: serializerEntry[1].name
-							? `${serializerEntry[1].request} ${serializerEntry[1].name}`
-							: serializerEntry[1].request;
-						err.message += `\n(during deserialization of ${name})`;
-						throw err;
-					}
-				}
-			} else if (typeof item === "string") {
-				if (item.length > 1) {
-					addReferenceable(item);
-				}
-
-				return item;
-			} else if (Buffer.isBuffer(item)) {
-				addReferenceable(item);
-
-				return item;
-			} else if (typeof item === "function") {
-				return SerializerMiddleware.deserializeLazy(
-					item,
-					data => this.deserialize(data, context)[0]
-				);
-			} else {
-				return item;
-			}
-		};
-
-		try {
-			while (currentDataPos < data.length) {
-				result.push(decodeValue());
-			}
-			return result;
-		} finally {
-			// Get rid of these references to avoid leaking memory
-			// This happens because the optimized code v8 generates
-			// is optimized for our "ctx.read" method so it will reference
-			// it from e. g. Dependency.prototype.deserialize -(IC)-> ctx.read
-			result = referenceable = data = objectTypeLookup = ctx = undefined;
-		}
-	}
-}
-
-module.exports = ObjectMiddleware;
-module.exports.NOT_SERIALIZABLE = NOT_SERIALIZABLE;
diff --git a/node_modules/webpack/lib/serialization/PlainObjectSerializer.js b/node_modules/webpack/lib/serialization/PlainObjectSerializer.js
deleted file mode 100644
index b10ff555..00000000
--- a/node_modules/webpack/lib/serialization/PlainObjectSerializer.js
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-"use strict";
-
-/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-
-const cache = new WeakMap();
-
-class ObjectStructure {
-	constructor() {
-		this.keys = undefined;
-		this.children = undefined;
-	}
-
-	getKeys(keys) {
-		if (this.keys === undefined) this.keys = keys;
-		return this.keys;
-	}
-
-	key(key) {
-		if (this.children === undefined) this.children = new Map();
-		const child = this.children.get(key);
-		if (child !== undefined) return child;
-		const newChild = new ObjectStructure();
-		this.children.set(key, newChild);
-		return newChild;
-	}
-}
-
-const getCachedKeys = (keys, cacheAssoc) => {
-	let root = cache.get(cacheAssoc);
-	if (root === undefined) {
-		root = new ObjectStructure();
-		cache.set(cacheAssoc, root);
-	}
-	let current = root;
-	for (const key of keys) {
-		current = current.key(key);
-	}
-	return current.getKeys(keys);
-};
-
-class PlainObjectSerializer {
-	/**
-	 * @param {Object} obj plain object
-	 * @param {ObjectSerializerContext} context context
-	 */
-	serialize(obj, context) {
-		const keys = Object.keys(obj);
-		if (keys.length > 128) {
-			// Objects with so many keys are unlikely to share structure
-			// with other objects
-			context.write(keys);
-			for (const key of keys) {
-				context.write(obj[key]);
-			}
-		} else if (keys.length > 1) {
-			context.write(getCachedKeys(keys, context.write));
-			for (const key of keys) {
-				context.write(obj[key]);
-			}
-		} else if (keys.length === 1) {
-			const key = keys[0];
-			context.write(key);
-			context.write(obj[key]);
-		} else {
-			context.write(null);
-		}
-	}
-	/**
-	 * @param {ObjectDeserializerContext} context context
-	 * @returns {Object} plain object
-	 */
-	deserialize(context) {
-		const keys = context.read();
-		const obj = {};
-		if (Array.isArray(keys)) {
-			for (const key of keys) {
-				obj[key] = context.read();
-			}
-		} else if (keys !== null) {
-			obj[keys] = context.read();
-		}
-		return obj;
-	}
-}
-
-module.exports = PlainObjectSerializer;
diff --git a/node_modules/webpack/lib/serialization/RegExpObjectSerializer.js b/node_modules/webpack/lib/serialization/RegExpObjectSerializer.js
deleted file mode 100644
index 9338fe29..00000000
--- a/node_modules/webpack/lib/serialization/RegExpObjectSerializer.js
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-"use strict";
-
-/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-
-class RegExpObjectSerializer {
-	/**
-	 * @param {RegExp} obj regexp
-	 * @param {ObjectSerializerContext} context context
-	 */
-	serialize(obj, context) {
-		context.write(obj.source);
-		context.write(obj.flags);
-	}
-	/**
-	 * @param {ObjectDeserializerContext} context context
-	 * @returns {RegExp} regexp
-	 */
-	deserialize(context) {
-		return new RegExp(context.read(), context.read());
-	}
-}
-
-module.exports = RegExpObjectSerializer;
diff --git a/node_modules/webpack/lib/serialization/Serializer.js b/node_modules/webpack/lib/serialization/Serializer.js
deleted file mode 100644
index ba814293..00000000
--- a/node_modules/webpack/lib/serialization/Serializer.js
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-"use strict";
-
-class Serializer {
-	constructor(middlewares, context) {
-		this.serializeMiddlewares = middlewares.slice();
-		this.deserializeMiddlewares = middlewares.slice().reverse();
-		this.context = context;
-	}
-
-	serialize(obj, context) {
-		const ctx = { ...context, ...this.context };
-		let current = obj;
-		for (const middleware of this.serializeMiddlewares) {
-			if (current && typeof current.then === "function") {
-				current = current.then(data => data && middleware.serialize(data, ctx));
-			} else if (current) {
-				try {
-					current = middleware.serialize(current, ctx);
-				} catch (err) {
-					current = Promise.reject(err);
-				}
-			} else break;
-		}
-		return current;
-	}
-
-	deserialize(value, context) {
-		const ctx = { ...context, ...this.context };
-		/** @type {any} */
-		let current = value;
-		for (const middleware of this.deserializeMiddlewares) {
-			if (current && typeof current.then === "function") {
-				current = current.then(data => middleware.deserialize(data, ctx));
-			} else {
-				current = middleware.deserialize(current, ctx);
-			}
-		}
-		return current;
-	}
-}
-
-module.exports = Serializer;
diff --git a/node_modules/webpack/lib/serialization/SerializerMiddleware.js b/node_modules/webpack/lib/serialization/SerializerMiddleware.js
deleted file mode 100644
index 30d1d1dd..00000000
--- a/node_modules/webpack/lib/serialization/SerializerMiddleware.js
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-"use strict";
-
-const memoize = require("../util/memoize");
-
-const LAZY_TARGET = Symbol("lazy serialization target");
-const LAZY_SERIALIZED_VALUE = Symbol("lazy serialization data");
-
-/**
- * @template DeserializedType
- * @template SerializedType
- */
-class SerializerMiddleware {
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
-	 */
-	serialize(data, context) {
-		const AbstractMethodError = require("../AbstractMethodError");
-		throw new AbstractMethodError();
-	}
-
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
-	 */
-	deserialize(data, context) {
-		const AbstractMethodError = require("../AbstractMethodError");
-		throw new AbstractMethodError();
-	}
-
-	/**
-	 * @param {any | function(): Promise<any> | any} value contained value or function to value
-	 * @param {SerializerMiddleware<any, any>} target target middleware
-	 * @param {object=} options lazy options
-	 * @param {any=} serializedValue serialized value
-	 * @returns {function(): Promise<any> | any} lazy function
-	 */
-	static createLazy(value, target, options = {}, serializedValue) {
-		if (SerializerMiddleware.isLazy(value, target)) return value;
-		const fn = typeof value === "function" ? value : () => value;
-		fn[LAZY_TARGET] = target;
-		/** @type {any} */ (fn).options = options;
-		fn[LAZY_SERIALIZED_VALUE] = serializedValue;
-		return fn;
-	}
-
-	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @param {SerializerMiddleware<any, any>=} target target middleware
-	 * @returns {boolean} true, when fn is a lazy function (optionally of that target)
-	 */
-	static isLazy(fn, target) {
-		if (typeof fn !== "function") return false;
-		const t = fn[LAZY_TARGET];
-		return target ? t === target : !!t;
-	}
-
-	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @returns {object} options
-	 */
-	static getLazyOptions(fn) {
-		if (typeof fn !== "function") return undefined;
-		return /** @type {any} */ (fn).options;
-	}
-
-	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @returns {any} serialized value
-	 */
-	static getLazySerializedValue(fn) {
-		if (typeof fn !== "function") return undefined;
-		return fn[LAZY_SERIALIZED_VALUE];
-	}
-
-	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @param {any} value serialized value
-	 * @returns {void}
-	 */
-	static setLazySerializedValue(fn, value) {
-		fn[LAZY_SERIALIZED_VALUE] = value;
-	}
-
-	/**
-	 * @param {function(): Promise<any> | any} lazy lazy function
-	 * @param {function(any): Promise<any> | any} serialize serialize function
-	 * @returns {function(): Promise<any> | any} new lazy
-	 */
-	static serializeLazy(lazy, serialize) {
-		const fn = memoize(() => {
-			const r = lazy();
-			if (r && typeof r.then === "function") {
-				return r.then(data => data && serialize(data));
-			}
-			return serialize(r);
-		});
-		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
-		/** @type {any} */ (fn).options = /** @type {any} */ (lazy).options;
-		lazy[LAZY_SERIALIZED_VALUE] = fn;
-		return fn;
-	}
-
-	/**
-	 * @param {function(): Promise<any> | any} lazy lazy function
-	 * @param {function(any): Promise<any> | any} deserialize deserialize function
-	 * @returns {function(): Promise<any> | any} new lazy
-	 */
-	static deserializeLazy(lazy, deserialize) {
-		const fn = memoize(() => {
-			const r = lazy();
-			if (r && typeof r.then === "function") {
-				return r.then(data => deserialize(data));
-			}
-			return deserialize(r);
-		});
-		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
-		/** @type {any} */ (fn).options = /** @type {any} */ (lazy).options;
-		fn[LAZY_SERIALIZED_VALUE] = lazy;
-		return fn;
-	}
-
-	/**
-	 * @param {function(): Promise<any> | any} lazy lazy function
-	 * @returns {function(): Promise<any> | any} new lazy
-	 */
-	static unMemoizeLazy(lazy) {
-		if (!SerializerMiddleware.isLazy(lazy)) return lazy;
-		const fn = () => {
-			throw new Error(
-				"A lazy value that has been unmemorized can't be called again"
-			);
-		};
-		fn[LAZY_SERIALIZED_VALUE] = SerializerMiddleware.unMemoizeLazy(
-			lazy[LAZY_SERIALIZED_VALUE]
-		);
-		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
-		fn.options = /** @type {any} */ (lazy).options;
-		return fn;
-	}
-}
-
-module.exports = SerializerMiddleware;
diff --git a/node_modules/webpack/lib/serialization/SetObjectSerializer.js b/node_modules/webpack/lib/serialization/SetObjectSerializer.js
deleted file mode 100644
index 18cfa8ca..00000000
--- a/node_modules/webpack/lib/serialization/SetObjectSerializer.js
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-"use strict";
-
-/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-
-class SetObjectSerializer {
-	/**
-	 * @template T
-	 * @param {Set<T>} obj set
-	 * @param {ObjectSerializerContext} context context
-	 */
-	serialize(obj, context) {
-		context.write(obj.size);
-		for (const value of obj) {
-			context.write(value);
-		}
-	}
-	/**
-	 * @template T
-	 * @param {ObjectDeserializerContext} context context
-	 * @returns {Set<T>} date
-	 */
-	deserialize(context) {
-		/** @type {number} */
-		let size = context.read();
-		/** @type {Set<T>} */
-		const set = new Set();
-		for (let i = 0; i < size; i++) {
-			set.add(context.read());
-		}
-		return set;
-	}
-}
-
-module.exports = SetObjectSerializer;
diff --git a/node_modules/webpack/lib/serialization/SingleItemMiddleware.js b/node_modules/webpack/lib/serialization/SingleItemMiddleware.js
deleted file mode 100644
index bc9ea094..00000000
--- a/node_modules/webpack/lib/serialization/SingleItemMiddleware.js
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-"use strict";
-
-const SerializerMiddleware = require("./SerializerMiddleware");
-
-/**
- * @typedef {any} DeserializedType
- * @typedef {any[]} SerializedType
- * @extends {SerializerMiddleware<any, any[]>}
- */
-class SingleItemMiddleware extends SerializerMiddleware {
-	/**
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
-	 */
-	serialize(data, context) {
-		return [data];
-	}
-
-	/**
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
-	 */
-	deserialize(data, context) {
-		return data[0];
-	}
-}
-
-module.exports = SingleItemMiddleware;
diff --git a/node_modules/webpack/lib/serialization/types.js b/node_modules/webpack/lib/serialization/types.js
deleted file mode 100644
index 4d8f4ef1..00000000
--- a/node_modules/webpack/lib/serialization/types.js
+++ /dev/null
@@ -1,13 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-"use strict";
-
-/** @typedef {undefined|null|number|string|boolean|Buffer|Object|(() => ComplexSerializableType[] | Promise<ComplexSerializableType[]>)} ComplexSerializableType */
-
-/** @typedef {undefined|null|number|bigint|string|boolean|Buffer|(() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>)} PrimitiveSerializableType */
-
-/** @typedef {Buffer|(() => BufferSerializableType[] | Promise<BufferSerializableType[]>)} BufferSerializableType */
-
-module.exports = {};