Index: imaps-frontend/node_modules/webpack/lib/serialization/ArraySerializer.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/serialization/ArraySerializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/serialization/ArraySerializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,38 @@
+/*
+	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;
Index: imaps-frontend/node_modules/webpack/lib/serialization/BinaryMiddleware.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/serialization/BinaryMiddleware.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/serialization/BinaryMiddleware.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,1142 @@
+/*
+	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 {TODO} Context */
+
+/**
+ * @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);
+	}
+
+	/**
+	 * @param {function(): Promise<any> | any} fn lazy function
+	 * @param {TODO} context serialize function
+	 * @returns {function(): Promise<any> | any} new lazy
+	 */
+	_serializeLazy(fn, context) {
+		return SerializerMiddleware.serializeLazy(fn, data =>
+			this._serialize(data, context)
+		);
+	}
+
+	/**
+	 * @param {DeserializedType} data data
+	 * @param {TODO} 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 | null} */
+		let leftOverBuffer = null;
+		/** @type {BufferSerializableType[]} */
+		let buffers = [];
+		/** @type {Buffer | null} */
+		let currentBuffer = allocationScope ? allocationScope.leftOverBuffer : null;
+		allocationScope.leftOverBuffer = null;
+		let currentPosition = 0;
+		if (currentBuffer === null) {
+			currentBuffer = Buffer.allocUnsafe(allocationScope.allocationSize);
+		}
+		/**
+		 * @param {number} bytesNeeded bytes needed
+		 */
+		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 => {
+			/** @type {Buffer} */
+			(currentBuffer).writeUInt8(byte, currentPosition++);
+		};
+		/**
+		 * @param {number} ui32 ui32
+		 */
+		const writeU32 = ui32 => {
+			/** @type {Buffer} */
+			(currentBuffer).writeUInt32LE(ui32, currentPosition);
+			currentPosition += 4;
+		};
+		/** @type {number[]} */
+		const measureStack = [];
+		const measureStart = () => {
+			measureStack.push(buffers.length, currentPosition);
+		};
+		/**
+		 * @returns {number} size
+		 */
+		const measureEnd = () => {
+			const oldPos = /** @type {number} */ (measureStack.pop());
+			const buffersIndex = /** @type {number} */ (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;
+				}
+				default: {
+					throw new Error(
+						`Unknown typeof "${typeof thing}" in binary middleware`
+					);
+				}
+			}
+		}
+		flush();
+
+		allocationScope.leftOverBuffer = leftOverBuffer;
+
+		// avoid leaking memory
+		currentBuffer = null;
+		leftOverBuffer = null;
+		allocationScope = /** @type {EXPECTED_ANY} */ (undefined);
+		const _buffers = buffers;
+		buffers = /** @type {EXPECTED_ANY} */ (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 {TODO} context context object
+	 * @returns {DeserializedType} deserialized data
+	 */
+	_deserialize(data, context) {
+		let currentDataItem = 0;
+		/** @type {BufferSerializableType | null} */
+		let currentBuffer = data[0];
+		let currentIsBuffer = Buffer.isBuffer(currentBuffer);
+		let currentPosition = 0;
+
+		/** @type {(x: Buffer) => Buffer} */
+		const retainedBuffer = context.retainedBuffer || (x => x);
+
+		const checkOverflow = () => {
+			if (currentPosition >= /** @type {Buffer} */ (currentBuffer).length) {
+				currentPosition = 0;
+				currentDataItem++;
+				currentBuffer =
+					currentDataItem < data.length ? data[currentDataItem] : null;
+				currentIsBuffer = Buffer.isBuffer(currentBuffer);
+			}
+		};
+		/**
+		 * @param {number} n n
+		 * @returns {boolean} true when in current buffer, otherwise false
+		 */
+		const isInCurrentBuffer = n =>
+			currentIsBuffer &&
+			n + currentPosition <= /** @type {Buffer} */ (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 =
+				/** @type {Buffer} */ (currentBuffer).length - currentPosition;
+			if (rem < n) {
+				const buffers = [read(rem)];
+				n -= rem;
+				ensureBuffer();
+				while (/** @type {Buffer} */ (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 =
+				/** @type {Buffer} */
+				(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 = () => read(I32_SIZE).readUInt32LE(0);
+		/**
+		 * @param {number} data data
+		 * @param {number} n n
+		 */
+		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(
+								/** @type {Buffer} */
+								(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(
+								/** @type {Buffer} */
+								(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 =
+								/** @type {Buffer} */
+								(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(
+									/** @type {Buffer} */
+									(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));
+								}
+							}
+						};
+					}
+					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
+		// eslint-disable-next-line prefer-const
+		let _result = result;
+		result = /** @type {EXPECTED_ANY} */ (undefined);
+		return _result;
+	}
+}
+
+module.exports = BinaryMiddleware;
+
+module.exports.MEASURE_START_OPERATION = MEASURE_START_OPERATION;
+module.exports.MEASURE_END_OPERATION = MEASURE_END_OPERATION;
Index: imaps-frontend/node_modules/webpack/lib/serialization/DateObjectSerializer.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/serialization/DateObjectSerializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/serialization/DateObjectSerializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,28 @@
+/*
+	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;
Index: imaps-frontend/node_modules/webpack/lib/serialization/ErrorObjectSerializer.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/serialization/ErrorObjectSerializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/serialization/ErrorObjectSerializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,44 @@
+/*
+	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;
Index: imaps-frontend/node_modules/webpack/lib/serialization/FileMiddleware.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/serialization/FileMiddleware.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/serialization/FileMiddleware.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,731 @@
+/*
+	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").IStats} IStats */
+/** @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;
+
+/** @type {function(Buffer, number, number): void} */
+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);
+		};
+
+/** @type {function(Buffer, number): void} */
+const readUInt64LE = Buffer.prototype.readBigUInt64LE
+	? (buf, offset) => 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<any>=} 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[] | undefined} */
+	let lastBuffers;
+	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 {{ filename: string, extension?: string }} FileMiddlewareContext */
+
+/**
+ * @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();
+				/**
+				 * @param {string | false} name name
+				 * @param {Buffer[]} content content
+				 * @param {number} size size
+				 * @returns {Promise<void>}
+				 */
+				const writeFile = async (name, content, size) => {
+					const file = name
+						? join(this.fs, filename, `../${name}${extension}`)
+						: filename;
+					await new Promise(
+						/**
+						 * @param {(value?: undefined) => void} resolve resolve
+						 * @param {(reason?: Error | null) => void} reject reject
+						 */
+						(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
+							/** @type {TODO[]} */
+							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;
+							/**
+							 * @param {(Error | null)=} err err
+							 */
+							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(
+								/**
+								 * @param {(value?: undefined) => void} resolve resolve
+								 */
+								resolve => {
+									this.fs.rename(filename, `${filename}.old`, err => {
+										resolve();
+									});
+								}
+							);
+
+							// update all written files
+							await Promise.all(
+								Array.from(
+									allWrittenFiles,
+									file =>
+										new Promise(
+											/**
+											 * @param {(value?: undefined) => void} resolve resolve
+											 * @param {(reason?: Error | null) => void} reject reject
+											 * @returns {void}
+											 */
+											(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(
+								/**
+								 * @param {(value?: undefined) => void} resolve resolve
+								 * @returns {void}
+								 */
+								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;
+		/**
+		 * @param {string | boolean} name name
+		 * @returns {Promise<TODO>} result
+		 */
+		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 {IStats} */ (stats).size;
+					/** @type {Buffer | undefined} */
+					let currentBuffer;
+					/** @type {number | undefined} */
+					let currentBufferUsed;
+					/** @type {any[]} */
+					const buf = [];
+					/** @type {import("zlib").Zlib & import("stream").Transform | undefined} */
+					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;
+						let 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 fd = /** @type {number} */ (_fd);
+						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 = /** @type {number} */ (currentBufferUsed);
+							let readLength =
+								currentBuffer.length -
+								/** @type {number} */ (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;
+									}
+									/** @type {number} */
+									(currentBufferUsed) += bytesRead;
+									remaining -= bytesRead;
+									if (
+										currentBufferUsed ===
+										/** @type {Buffer} */ (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;
Index: imaps-frontend/node_modules/webpack/lib/serialization/MapObjectSerializer.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/serialization/MapObjectSerializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/serialization/MapObjectSerializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,48 @@
+/*
+	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} */
+		const 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;
Index: imaps-frontend/node_modules/webpack/lib/serialization/NullPrototypeObjectSerializer.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/serialization/NullPrototypeObjectSerializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/serialization/NullPrototypeObjectSerializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,51 @@
+/*
+	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[/** @type {keyof T} */ (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[/** @type {keyof T} */ (key)] = context.read();
+		}
+		return obj;
+	}
+}
+
+module.exports = NullPrototypeObjectSerializer;
Index: imaps-frontend/node_modules/webpack/lib/serialization/ObjectMiddleware.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/serialization/ObjectMiddleware.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/serialization/ObjectMiddleware.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,778 @@
+/*
+	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)=} writeLazy
+ * @property {(function(any, object=): (() => Promise<any> | any))=} writeSeparate
+ * @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.
+// eslint-disable-next-line n/exports-style
+if (exports.constructor !== Object) {
+	// eslint-disable-next-line jsdoc/check-types, n/exports-style
+	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 {string} name name
+	 * @returns {ObjectSerializer | undefined} 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();
+		/**
+		 * @param {Buffer} buf buffer
+		 * @returns {Buffer} deduped buffer
+		 */
+		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;
+				}
+				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;
+				}
+				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;
+				}
+				return found;
+			}
+			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 (_err) {
+						// 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 (err) {
+						return `(${err.message})`;
+					}
+				})
+				.join(" -> ");
+		};
+		/** @type {WeakSet<Error>} */
+		let hasDebugInfoAttached;
+		let ctx = {
+			write(value, key) {
+				try {
+					process(value);
+				} catch (err) {
+					if (err !== NOT_SERIALIZABLE) {
+						if (hasDebugInfoAttached === undefined)
+							hasDebugInfoAttached = new WeakSet();
+						if (!hasDebugInfoAttached.has(/** @type {Error} */ (err))) {
+							/** @type {Error} */
+							(err).message += `\nwhile serializing ${stackToString(value)}`;
+							hasDebugInfoAttached.add(/** @type {Error} */ (err));
+						}
+					}
+					throw err;
+				}
+			},
+			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 (err) {
+			if (err === NOT_SERIALIZABLE) return null;
+
+			throw err;
+		} 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 =
+					/** @type {EXPECTED_ANY} */
+					(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) {
+					// Nothing
+				} 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 = /** @type {string} */ (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) && 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;
+						/** @type {Error} */
+						(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 =
+					/** @type {EXPECTED_ANY} */
+					(undefined);
+		}
+	}
+}
+
+module.exports = ObjectMiddleware;
+module.exports.NOT_SERIALIZABLE = NOT_SERIALIZABLE;
Index: imaps-frontend/node_modules/webpack/lib/serialization/PlainObjectSerializer.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/serialization/PlainObjectSerializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/serialization/PlainObjectSerializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,117 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+/** @typedef {(arg0?: any) => void} CacheAssoc */
+
+/**
+ * @template T
+ * @typedef {WeakMap<CacheAssoc, ObjectStructure<T>>}
+ */
+const cache = new WeakMap();
+
+/**
+ * @template T
+ */
+class ObjectStructure {
+	constructor() {
+		this.keys = undefined;
+		this.children = undefined;
+	}
+
+	/**
+	 * @param {keyof T[]} keys keys
+	 * @returns {keyof T[]} keys
+	 */
+	getKeys(keys) {
+		if (this.keys === undefined) this.keys = keys;
+		return this.keys;
+	}
+
+	/**
+	 * @param {keyof T} key key
+	 * @returns {ObjectStructure<T>} object structure
+	 */
+	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;
+	}
+}
+
+/**
+ * @template T
+ * @param {(keyof T)[]} keys keys
+ * @param {CacheAssoc} cacheAssoc cache assoc fn
+ * @returns {(keyof T)[]} keys
+ */
+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 {
+	/**
+	 * @template {object} T
+	 * @param {T} obj plain object
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(obj, context) {
+		const keys = /** @type {(keyof T)[]} */ (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);
+		}
+	}
+
+	/**
+	 * @template {object} T
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {T} plain object
+	 */
+	deserialize(context) {
+		const keys = context.read();
+		const obj = /** @type {T} */ ({});
+		if (Array.isArray(keys)) {
+			for (const key of keys) {
+				obj[/** @type {keyof T} */ (key)] = context.read();
+			}
+		} else if (keys !== null) {
+			obj[/** @type {keyof T} */ (keys)] = context.read();
+		}
+		return obj;
+	}
+}
+
+module.exports = PlainObjectSerializer;
Index: imaps-frontend/node_modules/webpack/lib/serialization/RegExpObjectSerializer.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/serialization/RegExpObjectSerializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/serialization/RegExpObjectSerializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,29 @@
+/*
+	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;
Index: imaps-frontend/node_modules/webpack/lib/serialization/Serializer.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/serialization/Serializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/serialization/Serializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,64 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+/**
+ * @template T, K
+ * @typedef {import("./SerializerMiddleware")<T, K>} SerializerMiddleware
+ */
+
+class Serializer {
+	/**
+	 * @param {SerializerMiddleware<any, any>[]} middlewares serializer middlewares
+	 * @param {TODO=} context context
+	 */
+	constructor(middlewares, context) {
+		this.serializeMiddlewares = middlewares.slice();
+		this.deserializeMiddlewares = middlewares.slice().reverse();
+		this.context = context;
+	}
+
+	/**
+	 * @param {any} obj object
+	 * @param {TODO} context content
+	 * @returns {Promise<any>} result
+	 */
+	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;
+	}
+
+	/**
+	 * @param {any} value value
+	 * @param {TODO} context context
+	 * @returns {Promise<any>} result
+	 */
+	deserialize(value, context) {
+		const ctx = { ...context, ...this.context };
+		/** @type {any} */
+		let current = value;
+		for (const middleware of this.deserializeMiddlewares) {
+			current =
+				current && typeof current.then === "function"
+					? current.then(data => middleware.deserialize(data, ctx))
+					: middleware.deserialize(current, ctx);
+		}
+		return current;
+	}
+}
+
+module.exports = Serializer;
Index: imaps-frontend/node_modules/webpack/lib/serialization/SerializerMiddleware.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/serialization/SerializerMiddleware.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/serialization/SerializerMiddleware.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,154 @@
+/*
+	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 = undefined) {
+		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 : Boolean(t);
+	}
+
+	/**
+	 * @param {function(): Promise<any> | any} fn lazy function
+	 * @returns {object | undefined} options
+	 */
+	static getLazyOptions(fn) {
+		if (typeof fn !== "function") return;
+		return /** @type {any} */ (fn).options;
+	}
+
+	/**
+	 * @param {function(): Promise<any> | any} fn lazy function
+	 * @returns {any | undefined} serialized value
+	 */
+	static getLazySerializedValue(fn) {
+		if (typeof fn !== "function") return;
+		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;
+	}
+
+	/**
+	 * @template T
+	 * @param {function(): Promise<any> | any} lazy lazy function
+	 * @param {function(T): Promise<T> | T} deserialize deserialize function
+	 * @returns {function(): Promise<T> | T} 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;
Index: imaps-frontend/node_modules/webpack/lib/serialization/SetObjectSerializer.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/serialization/SetObjectSerializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/serialization/SetObjectSerializer.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,40 @@
+/*
+	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} */
+		const 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;
Index: imaps-frontend/node_modules/webpack/lib/serialization/SingleItemMiddleware.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/serialization/SingleItemMiddleware.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/serialization/SingleItemMiddleware.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,34 @@
+/*
+	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;
Index: imaps-frontend/node_modules/webpack/lib/serialization/types.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/serialization/types.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/serialization/types.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,13 @@
+/*
+	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 = {};
