Index: imaps-frontend/node_modules/webpack/lib/hmr/HotModuleReplacement.runtime.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/hmr/HotModuleReplacement.runtime.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/hmr/HotModuleReplacement.runtime.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,407 @@
+// @ts-nocheck
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+var $interceptModuleExecution$ = undefined;
+var $moduleCache$ = undefined;
+// eslint-disable-next-line no-unused-vars
+var $hmrModuleData$ = undefined;
+/** @type {() => Promise}  */
+var $hmrDownloadManifest$ = undefined;
+var $hmrDownloadUpdateHandlers$ = undefined;
+var $hmrInvalidateModuleHandlers$ = undefined;
+var __webpack_require__ = undefined;
+
+module.exports = function () {
+	var currentModuleData = {};
+	var installedModules = $moduleCache$;
+
+	// module and require creation
+	var currentChildModule;
+	var currentParents = [];
+
+	// status
+	var registeredStatusHandlers = [];
+	var currentStatus = "idle";
+
+	// while downloading
+	var blockingPromises = 0;
+	var blockingPromisesWaiting = [];
+
+	// The update info
+	var currentUpdateApplyHandlers;
+	var queuedInvalidatedModules;
+
+	$hmrModuleData$ = currentModuleData;
+
+	$interceptModuleExecution$.push(function (options) {
+		var module = options.module;
+		var require = createRequire(options.require, options.id);
+		module.hot = createModuleHotObject(options.id, module);
+		module.parents = currentParents;
+		module.children = [];
+		currentParents = [];
+		options.require = require;
+	});
+
+	$hmrDownloadUpdateHandlers$ = {};
+	$hmrInvalidateModuleHandlers$ = {};
+
+	function createRequire(require, moduleId) {
+		var me = installedModules[moduleId];
+		if (!me) return require;
+		var fn = function (request) {
+			if (me.hot.active) {
+				if (installedModules[request]) {
+					var parents = installedModules[request].parents;
+					if (parents.indexOf(moduleId) === -1) {
+						parents.push(moduleId);
+					}
+				} else {
+					currentParents = [moduleId];
+					currentChildModule = request;
+				}
+				if (me.children.indexOf(request) === -1) {
+					me.children.push(request);
+				}
+			} else {
+				console.warn(
+					"[HMR] unexpected require(" +
+						request +
+						") from disposed module " +
+						moduleId
+				);
+				currentParents = [];
+			}
+			return require(request);
+		};
+		var createPropertyDescriptor = function (name) {
+			return {
+				configurable: true,
+				enumerable: true,
+				get: function () {
+					return require[name];
+				},
+				set: function (value) {
+					require[name] = value;
+				}
+			};
+		};
+		for (var name in require) {
+			if (Object.prototype.hasOwnProperty.call(require, name) && name !== "e") {
+				Object.defineProperty(fn, name, createPropertyDescriptor(name));
+			}
+		}
+		fn.e = function (chunkId, fetchPriority) {
+			return trackBlockingPromise(require.e(chunkId, fetchPriority));
+		};
+		return fn;
+	}
+
+	function createModuleHotObject(moduleId, me) {
+		var _main = currentChildModule !== moduleId;
+		var hot = {
+			// private stuff
+			_acceptedDependencies: {},
+			_acceptedErrorHandlers: {},
+			_declinedDependencies: {},
+			_selfAccepted: false,
+			_selfDeclined: false,
+			_selfInvalidated: false,
+			_disposeHandlers: [],
+			_main: _main,
+			_requireSelf: function () {
+				currentParents = me.parents.slice();
+				currentChildModule = _main ? undefined : moduleId;
+				__webpack_require__(moduleId);
+			},
+
+			// Module API
+			active: true,
+			accept: function (dep, callback, errorHandler) {
+				if (dep === undefined) hot._selfAccepted = true;
+				else if (typeof dep === "function") hot._selfAccepted = dep;
+				else if (typeof dep === "object" && dep !== null) {
+					for (var i = 0; i < dep.length; i++) {
+						hot._acceptedDependencies[dep[i]] = callback || function () {};
+						hot._acceptedErrorHandlers[dep[i]] = errorHandler;
+					}
+				} else {
+					hot._acceptedDependencies[dep] = callback || function () {};
+					hot._acceptedErrorHandlers[dep] = errorHandler;
+				}
+			},
+			decline: function (dep) {
+				if (dep === undefined) hot._selfDeclined = true;
+				else if (typeof dep === "object" && dep !== null)
+					for (var i = 0; i < dep.length; i++)
+						hot._declinedDependencies[dep[i]] = true;
+				else hot._declinedDependencies[dep] = true;
+			},
+			dispose: function (callback) {
+				hot._disposeHandlers.push(callback);
+			},
+			addDisposeHandler: function (callback) {
+				hot._disposeHandlers.push(callback);
+			},
+			removeDisposeHandler: function (callback) {
+				var idx = hot._disposeHandlers.indexOf(callback);
+				if (idx >= 0) hot._disposeHandlers.splice(idx, 1);
+			},
+			invalidate: function () {
+				this._selfInvalidated = true;
+				switch (currentStatus) {
+					case "idle":
+						currentUpdateApplyHandlers = [];
+						Object.keys($hmrInvalidateModuleHandlers$).forEach(function (key) {
+							$hmrInvalidateModuleHandlers$[key](
+								moduleId,
+								currentUpdateApplyHandlers
+							);
+						});
+						setStatus("ready");
+						break;
+					case "ready":
+						Object.keys($hmrInvalidateModuleHandlers$).forEach(function (key) {
+							$hmrInvalidateModuleHandlers$[key](
+								moduleId,
+								currentUpdateApplyHandlers
+							);
+						});
+						break;
+					case "prepare":
+					case "check":
+					case "dispose":
+					case "apply":
+						(queuedInvalidatedModules = queuedInvalidatedModules || []).push(
+							moduleId
+						);
+						break;
+					default:
+						// ignore requests in error states
+						break;
+				}
+			},
+
+			// Management API
+			check: hotCheck,
+			apply: hotApply,
+			status: function (l) {
+				if (!l) return currentStatus;
+				registeredStatusHandlers.push(l);
+			},
+			addStatusHandler: function (l) {
+				registeredStatusHandlers.push(l);
+			},
+			removeStatusHandler: function (l) {
+				var idx = registeredStatusHandlers.indexOf(l);
+				if (idx >= 0) registeredStatusHandlers.splice(idx, 1);
+			},
+
+			// inherit from previous dispose call
+			data: currentModuleData[moduleId]
+		};
+		currentChildModule = undefined;
+		return hot;
+	}
+
+	function setStatus(newStatus) {
+		currentStatus = newStatus;
+		var results = [];
+
+		for (var i = 0; i < registeredStatusHandlers.length; i++)
+			results[i] = registeredStatusHandlers[i].call(null, newStatus);
+
+		return Promise.all(results).then(function () {});
+	}
+
+	function unblock() {
+		if (--blockingPromises === 0) {
+			setStatus("ready").then(function () {
+				if (blockingPromises === 0) {
+					var list = blockingPromisesWaiting;
+					blockingPromisesWaiting = [];
+					for (var i = 0; i < list.length; i++) {
+						list[i]();
+					}
+				}
+			});
+		}
+	}
+
+	function trackBlockingPromise(promise) {
+		switch (currentStatus) {
+			case "ready":
+				setStatus("prepare");
+			/* fallthrough */
+			case "prepare":
+				blockingPromises++;
+				promise.then(unblock, unblock);
+				return promise;
+			default:
+				return promise;
+		}
+	}
+
+	function waitForBlockingPromises(fn) {
+		if (blockingPromises === 0) return fn();
+		return new Promise(function (resolve) {
+			blockingPromisesWaiting.push(function () {
+				resolve(fn());
+			});
+		});
+	}
+
+	function hotCheck(applyOnUpdate) {
+		if (currentStatus !== "idle") {
+			throw new Error("check() is only allowed in idle status");
+		}
+		return setStatus("check")
+			.then($hmrDownloadManifest$)
+			.then(function (update) {
+				if (!update) {
+					return setStatus(applyInvalidatedModules() ? "ready" : "idle").then(
+						function () {
+							return null;
+						}
+					);
+				}
+
+				return setStatus("prepare").then(function () {
+					var updatedModules = [];
+					currentUpdateApplyHandlers = [];
+
+					return Promise.all(
+						Object.keys($hmrDownloadUpdateHandlers$).reduce(function (
+							promises,
+							key
+						) {
+							$hmrDownloadUpdateHandlers$[key](
+								update.c,
+								update.r,
+								update.m,
+								promises,
+								currentUpdateApplyHandlers,
+								updatedModules
+							);
+							return promises;
+						}, [])
+					).then(function () {
+						return waitForBlockingPromises(function () {
+							if (applyOnUpdate) {
+								return internalApply(applyOnUpdate);
+							}
+							return setStatus("ready").then(function () {
+								return updatedModules;
+							});
+						});
+					});
+				});
+			});
+	}
+
+	function hotApply(options) {
+		if (currentStatus !== "ready") {
+			return Promise.resolve().then(function () {
+				throw new Error(
+					"apply() is only allowed in ready status (state: " +
+						currentStatus +
+						")"
+				);
+			});
+		}
+		return internalApply(options);
+	}
+
+	function internalApply(options) {
+		options = options || {};
+
+		applyInvalidatedModules();
+
+		var results = currentUpdateApplyHandlers.map(function (handler) {
+			return handler(options);
+		});
+		currentUpdateApplyHandlers = undefined;
+
+		var errors = results
+			.map(function (r) {
+				return r.error;
+			})
+			.filter(Boolean);
+
+		if (errors.length > 0) {
+			return setStatus("abort").then(function () {
+				throw errors[0];
+			});
+		}
+
+		// Now in "dispose" phase
+		var disposePromise = setStatus("dispose");
+
+		results.forEach(function (result) {
+			if (result.dispose) result.dispose();
+		});
+
+		// Now in "apply" phase
+		var applyPromise = setStatus("apply");
+
+		var error;
+		var reportError = function (err) {
+			if (!error) error = err;
+		};
+
+		var outdatedModules = [];
+		results.forEach(function (result) {
+			if (result.apply) {
+				var modules = result.apply(reportError);
+				if (modules) {
+					for (var i = 0; i < modules.length; i++) {
+						outdatedModules.push(modules[i]);
+					}
+				}
+			}
+		});
+
+		return Promise.all([disposePromise, applyPromise]).then(function () {
+			// handle errors in accept handlers and self accepted module load
+			if (error) {
+				return setStatus("fail").then(function () {
+					throw error;
+				});
+			}
+
+			if (queuedInvalidatedModules) {
+				return internalApply(options).then(function (list) {
+					outdatedModules.forEach(function (moduleId) {
+						if (list.indexOf(moduleId) < 0) list.push(moduleId);
+					});
+					return list;
+				});
+			}
+
+			return setStatus("idle").then(function () {
+				return outdatedModules;
+			});
+		});
+	}
+
+	function applyInvalidatedModules() {
+		if (queuedInvalidatedModules) {
+			if (!currentUpdateApplyHandlers) currentUpdateApplyHandlers = [];
+			Object.keys($hmrInvalidateModuleHandlers$).forEach(function (key) {
+				queuedInvalidatedModules.forEach(function (moduleId) {
+					$hmrInvalidateModuleHandlers$[key](
+						moduleId,
+						currentUpdateApplyHandlers
+					);
+				});
+			});
+			queuedInvalidatedModules = undefined;
+			return true;
+		}
+	}
+};
Index: imaps-frontend/node_modules/webpack/lib/hmr/HotModuleReplacementRuntimeModule.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/hmr/HotModuleReplacementRuntimeModule.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/hmr/HotModuleReplacementRuntimeModule.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,42 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+
+class HotModuleReplacementRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("hot module replacement", RuntimeModule.STAGE_BASIC);
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		return Template.getFunctionContent(
+			require("./HotModuleReplacement.runtime.js")
+		)
+			.replace(
+				/\$interceptModuleExecution\$/g,
+				RuntimeGlobals.interceptModuleExecution
+			)
+			.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
+			.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
+			.replace(/\$hmrDownloadManifest\$/g, RuntimeGlobals.hmrDownloadManifest)
+			.replace(
+				/\$hmrInvalidateModuleHandlers\$/g,
+				RuntimeGlobals.hmrInvalidateModuleHandlers
+			)
+			.replace(
+				/\$hmrDownloadUpdateHandlers\$/g,
+				RuntimeGlobals.hmrDownloadUpdateHandlers
+			);
+	}
+}
+
+module.exports = HotModuleReplacementRuntimeModule;
Index: imaps-frontend/node_modules/webpack/lib/hmr/JavascriptHotModuleReplacement.runtime.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/hmr/JavascriptHotModuleReplacement.runtime.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/hmr/JavascriptHotModuleReplacement.runtime.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,461 @@
+// @ts-nocheck
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+var $installedChunks$ = undefined;
+var $loadUpdateChunk$ = undefined;
+var $moduleCache$ = undefined;
+var $moduleFactories$ = undefined;
+var $ensureChunkHandlers$ = undefined;
+var $hasOwnProperty$ = undefined;
+var $hmrModuleData$ = undefined;
+var $hmrDownloadUpdateHandlers$ = undefined;
+var $hmrInvalidateModuleHandlers$ = undefined;
+var __webpack_require__ = undefined;
+
+module.exports = function () {
+	var currentUpdateChunks;
+	var currentUpdate;
+	var currentUpdateRemovedChunks;
+	var currentUpdateRuntime;
+	function applyHandler(options) {
+		if ($ensureChunkHandlers$) delete $ensureChunkHandlers$.$key$Hmr;
+		currentUpdateChunks = undefined;
+		function getAffectedModuleEffects(updateModuleId) {
+			var outdatedModules = [updateModuleId];
+			var outdatedDependencies = {};
+
+			var queue = outdatedModules.map(function (id) {
+				return {
+					chain: [id],
+					id: id
+				};
+			});
+			while (queue.length > 0) {
+				var queueItem = queue.pop();
+				var moduleId = queueItem.id;
+				var chain = queueItem.chain;
+				var module = $moduleCache$[moduleId];
+				if (
+					!module ||
+					(module.hot._selfAccepted && !module.hot._selfInvalidated)
+				)
+					continue;
+				if (module.hot._selfDeclined) {
+					return {
+						type: "self-declined",
+						chain: chain,
+						moduleId: moduleId
+					};
+				}
+				if (module.hot._main) {
+					return {
+						type: "unaccepted",
+						chain: chain,
+						moduleId: moduleId
+					};
+				}
+				for (var i = 0; i < module.parents.length; i++) {
+					var parentId = module.parents[i];
+					var parent = $moduleCache$[parentId];
+					if (!parent) continue;
+					if (parent.hot._declinedDependencies[moduleId]) {
+						return {
+							type: "declined",
+							chain: chain.concat([parentId]),
+							moduleId: moduleId,
+							parentId: parentId
+						};
+					}
+					if (outdatedModules.indexOf(parentId) !== -1) continue;
+					if (parent.hot._acceptedDependencies[moduleId]) {
+						if (!outdatedDependencies[parentId])
+							outdatedDependencies[parentId] = [];
+						addAllToSet(outdatedDependencies[parentId], [moduleId]);
+						continue;
+					}
+					delete outdatedDependencies[parentId];
+					outdatedModules.push(parentId);
+					queue.push({
+						chain: chain.concat([parentId]),
+						id: parentId
+					});
+				}
+			}
+
+			return {
+				type: "accepted",
+				moduleId: updateModuleId,
+				outdatedModules: outdatedModules,
+				outdatedDependencies: outdatedDependencies
+			};
+		}
+
+		function addAllToSet(a, b) {
+			for (var i = 0; i < b.length; i++) {
+				var item = b[i];
+				if (a.indexOf(item) === -1) a.push(item);
+			}
+		}
+
+		// at begin all updates modules are outdated
+		// the "outdated" status can propagate to parents if they don't accept the children
+		var outdatedDependencies = {};
+		var outdatedModules = [];
+		var appliedUpdate = {};
+
+		var warnUnexpectedRequire = function warnUnexpectedRequire(module) {
+			console.warn(
+				"[HMR] unexpected require(" + module.id + ") to disposed module"
+			);
+		};
+
+		for (var moduleId in currentUpdate) {
+			if ($hasOwnProperty$(currentUpdate, moduleId)) {
+				var newModuleFactory = currentUpdate[moduleId];
+				/** @type {TODO} */
+				var result = newModuleFactory
+					? getAffectedModuleEffects(moduleId)
+					: {
+							type: "disposed",
+							moduleId: moduleId
+						};
+				/** @type {Error|false} */
+				var abortError = false;
+				var doApply = false;
+				var doDispose = false;
+				var chainInfo = "";
+				if (result.chain) {
+					chainInfo = "\nUpdate propagation: " + result.chain.join(" -> ");
+				}
+				switch (result.type) {
+					case "self-declined":
+						if (options.onDeclined) options.onDeclined(result);
+						if (!options.ignoreDeclined)
+							abortError = new Error(
+								"Aborted because of self decline: " +
+									result.moduleId +
+									chainInfo
+							);
+						break;
+					case "declined":
+						if (options.onDeclined) options.onDeclined(result);
+						if (!options.ignoreDeclined)
+							abortError = new Error(
+								"Aborted because of declined dependency: " +
+									result.moduleId +
+									" in " +
+									result.parentId +
+									chainInfo
+							);
+						break;
+					case "unaccepted":
+						if (options.onUnaccepted) options.onUnaccepted(result);
+						if (!options.ignoreUnaccepted)
+							abortError = new Error(
+								"Aborted because " + moduleId + " is not accepted" + chainInfo
+							);
+						break;
+					case "accepted":
+						if (options.onAccepted) options.onAccepted(result);
+						doApply = true;
+						break;
+					case "disposed":
+						if (options.onDisposed) options.onDisposed(result);
+						doDispose = true;
+						break;
+					default:
+						throw new Error("Unexception type " + result.type);
+				}
+				if (abortError) {
+					return {
+						error: abortError
+					};
+				}
+				if (doApply) {
+					appliedUpdate[moduleId] = newModuleFactory;
+					addAllToSet(outdatedModules, result.outdatedModules);
+					for (moduleId in result.outdatedDependencies) {
+						if ($hasOwnProperty$(result.outdatedDependencies, moduleId)) {
+							if (!outdatedDependencies[moduleId])
+								outdatedDependencies[moduleId] = [];
+							addAllToSet(
+								outdatedDependencies[moduleId],
+								result.outdatedDependencies[moduleId]
+							);
+						}
+					}
+				}
+				if (doDispose) {
+					addAllToSet(outdatedModules, [result.moduleId]);
+					appliedUpdate[moduleId] = warnUnexpectedRequire;
+				}
+			}
+		}
+		currentUpdate = undefined;
+
+		// Store self accepted outdated modules to require them later by the module system
+		var outdatedSelfAcceptedModules = [];
+		for (var j = 0; j < outdatedModules.length; j++) {
+			var outdatedModuleId = outdatedModules[j];
+			var module = $moduleCache$[outdatedModuleId];
+			if (
+				module &&
+				(module.hot._selfAccepted || module.hot._main) &&
+				// removed self-accepted modules should not be required
+				appliedUpdate[outdatedModuleId] !== warnUnexpectedRequire &&
+				// when called invalidate self-accepting is not possible
+				!module.hot._selfInvalidated
+			) {
+				outdatedSelfAcceptedModules.push({
+					module: outdatedModuleId,
+					require: module.hot._requireSelf,
+					errorHandler: module.hot._selfAccepted
+				});
+			}
+		}
+
+		var moduleOutdatedDependencies;
+
+		return {
+			dispose: function () {
+				currentUpdateRemovedChunks.forEach(function (chunkId) {
+					delete $installedChunks$[chunkId];
+				});
+				currentUpdateRemovedChunks = undefined;
+
+				var idx;
+				var queue = outdatedModules.slice();
+				while (queue.length > 0) {
+					var moduleId = queue.pop();
+					var module = $moduleCache$[moduleId];
+					if (!module) continue;
+
+					var data = {};
+
+					// Call dispose handlers
+					var disposeHandlers = module.hot._disposeHandlers;
+					for (j = 0; j < disposeHandlers.length; j++) {
+						disposeHandlers[j].call(null, data);
+					}
+					$hmrModuleData$[moduleId] = data;
+
+					// disable module (this disables requires from this module)
+					module.hot.active = false;
+
+					// remove module from cache
+					delete $moduleCache$[moduleId];
+
+					// when disposing there is no need to call dispose handler
+					delete outdatedDependencies[moduleId];
+
+					// remove "parents" references from all children
+					for (j = 0; j < module.children.length; j++) {
+						var child = $moduleCache$[module.children[j]];
+						if (!child) continue;
+						idx = child.parents.indexOf(moduleId);
+						if (idx >= 0) {
+							child.parents.splice(idx, 1);
+						}
+					}
+				}
+
+				// remove outdated dependency from module children
+				var dependency;
+				for (var outdatedModuleId in outdatedDependencies) {
+					if ($hasOwnProperty$(outdatedDependencies, outdatedModuleId)) {
+						module = $moduleCache$[outdatedModuleId];
+						if (module) {
+							moduleOutdatedDependencies =
+								outdatedDependencies[outdatedModuleId];
+							for (j = 0; j < moduleOutdatedDependencies.length; j++) {
+								dependency = moduleOutdatedDependencies[j];
+								idx = module.children.indexOf(dependency);
+								if (idx >= 0) module.children.splice(idx, 1);
+							}
+						}
+					}
+				}
+			},
+			apply: function (reportError) {
+				// insert new code
+				for (var updateModuleId in appliedUpdate) {
+					if ($hasOwnProperty$(appliedUpdate, updateModuleId)) {
+						$moduleFactories$[updateModuleId] = appliedUpdate[updateModuleId];
+					}
+				}
+
+				// run new runtime modules
+				for (var i = 0; i < currentUpdateRuntime.length; i++) {
+					currentUpdateRuntime[i](__webpack_require__);
+				}
+
+				// call accept handlers
+				for (var outdatedModuleId in outdatedDependencies) {
+					if ($hasOwnProperty$(outdatedDependencies, outdatedModuleId)) {
+						var module = $moduleCache$[outdatedModuleId];
+						if (module) {
+							moduleOutdatedDependencies =
+								outdatedDependencies[outdatedModuleId];
+							var callbacks = [];
+							var errorHandlers = [];
+							var dependenciesForCallbacks = [];
+							for (var j = 0; j < moduleOutdatedDependencies.length; j++) {
+								var dependency = moduleOutdatedDependencies[j];
+								var acceptCallback =
+									module.hot._acceptedDependencies[dependency];
+								var errorHandler =
+									module.hot._acceptedErrorHandlers[dependency];
+								if (acceptCallback) {
+									if (callbacks.indexOf(acceptCallback) !== -1) continue;
+									callbacks.push(acceptCallback);
+									errorHandlers.push(errorHandler);
+									dependenciesForCallbacks.push(dependency);
+								}
+							}
+							for (var k = 0; k < callbacks.length; k++) {
+								try {
+									callbacks[k].call(null, moduleOutdatedDependencies);
+								} catch (err) {
+									if (typeof errorHandlers[k] === "function") {
+										try {
+											errorHandlers[k](err, {
+												moduleId: outdatedModuleId,
+												dependencyId: dependenciesForCallbacks[k]
+											});
+										} catch (err2) {
+											if (options.onErrored) {
+												options.onErrored({
+													type: "accept-error-handler-errored",
+													moduleId: outdatedModuleId,
+													dependencyId: dependenciesForCallbacks[k],
+													error: err2,
+													originalError: err
+												});
+											}
+											if (!options.ignoreErrored) {
+												reportError(err2);
+												reportError(err);
+											}
+										}
+									} else {
+										if (options.onErrored) {
+											options.onErrored({
+												type: "accept-errored",
+												moduleId: outdatedModuleId,
+												dependencyId: dependenciesForCallbacks[k],
+												error: err
+											});
+										}
+										if (!options.ignoreErrored) {
+											reportError(err);
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+
+				// Load self accepted modules
+				for (var o = 0; o < outdatedSelfAcceptedModules.length; o++) {
+					var item = outdatedSelfAcceptedModules[o];
+					var moduleId = item.module;
+					try {
+						item.require(moduleId);
+					} catch (err) {
+						if (typeof item.errorHandler === "function") {
+							try {
+								item.errorHandler(err, {
+									moduleId: moduleId,
+									module: $moduleCache$[moduleId]
+								});
+							} catch (err1) {
+								if (options.onErrored) {
+									options.onErrored({
+										type: "self-accept-error-handler-errored",
+										moduleId: moduleId,
+										error: err1,
+										originalError: err
+									});
+								}
+								if (!options.ignoreErrored) {
+									reportError(err1);
+									reportError(err);
+								}
+							}
+						} else {
+							if (options.onErrored) {
+								options.onErrored({
+									type: "self-accept-errored",
+									moduleId: moduleId,
+									error: err
+								});
+							}
+							if (!options.ignoreErrored) {
+								reportError(err);
+							}
+						}
+					}
+				}
+
+				return outdatedModules;
+			}
+		};
+	}
+	$hmrInvalidateModuleHandlers$.$key$ = function (moduleId, applyHandlers) {
+		if (!currentUpdate) {
+			currentUpdate = {};
+			currentUpdateRuntime = [];
+			currentUpdateRemovedChunks = [];
+			applyHandlers.push(applyHandler);
+		}
+		if (!$hasOwnProperty$(currentUpdate, moduleId)) {
+			currentUpdate[moduleId] = $moduleFactories$[moduleId];
+		}
+	};
+	$hmrDownloadUpdateHandlers$.$key$ = function (
+		chunkIds,
+		removedChunks,
+		removedModules,
+		promises,
+		applyHandlers,
+		updatedModulesList
+	) {
+		applyHandlers.push(applyHandler);
+		currentUpdateChunks = {};
+		currentUpdateRemovedChunks = removedChunks;
+		currentUpdate = removedModules.reduce(function (obj, key) {
+			obj[key] = false;
+			return obj;
+		}, {});
+		currentUpdateRuntime = [];
+		chunkIds.forEach(function (chunkId) {
+			if (
+				$hasOwnProperty$($installedChunks$, chunkId) &&
+				$installedChunks$[chunkId] !== undefined
+			) {
+				promises.push($loadUpdateChunk$(chunkId, updatedModulesList));
+				currentUpdateChunks[chunkId] = true;
+			} else {
+				currentUpdateChunks[chunkId] = false;
+			}
+		});
+		if ($ensureChunkHandlers$) {
+			$ensureChunkHandlers$.$key$Hmr = function (chunkId, promises) {
+				if (
+					currentUpdateChunks &&
+					$hasOwnProperty$(currentUpdateChunks, chunkId) &&
+					!currentUpdateChunks[chunkId]
+				) {
+					promises.push($loadUpdateChunk$(chunkId));
+					currentUpdateChunks[chunkId] = true;
+				}
+			};
+		}
+	};
+};
Index: imaps-frontend/node_modules/webpack/lib/hmr/LazyCompilationPlugin.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/hmr/LazyCompilationPlugin.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/hmr/LazyCompilationPlugin.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,455 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { RawSource } = require("webpack-sources");
+const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
+const Dependency = require("../Dependency");
+const Module = require("../Module");
+const ModuleFactory = require("../ModuleFactory");
+const { JS_TYPES } = require("../ModuleSourceTypesConstants");
+const {
+	WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY
+} = require("../ModuleTypeConstants");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const CommonJsRequireDependency = require("../dependencies/CommonJsRequireDependency");
+const { registerNotSerializable } = require("../util/serialization");
+
+/** @typedef {import("../../declarations/WebpackOptions")} WebpackOptions */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../dependencies/HarmonyImportDependency")} HarmonyImportDependency */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+
+/** @typedef {{ client: string, data: string, active: boolean }} ModuleResult */
+
+/**
+ * @typedef {object} BackendApi
+ * @property {function(function((Error | null)=) : void): void} dispose
+ * @property {function(Module): ModuleResult} module
+ */
+
+const HMR_DEPENDENCY_TYPES = new Set([
+	"import.meta.webpackHot.accept",
+	"import.meta.webpackHot.decline",
+	"module.hot.accept",
+	"module.hot.decline"
+]);
+
+/**
+ * @param {undefined|string|RegExp|Function} test test option
+ * @param {Module} module the module
+ * @returns {boolean | null | string} true, if the module should be selected
+ */
+const checkTest = (test, module) => {
+	if (test === undefined) return true;
+	if (typeof test === "function") {
+		return test(module);
+	}
+	if (typeof test === "string") {
+		const name = module.nameForCondition();
+		return name && name.startsWith(test);
+	}
+	if (test instanceof RegExp) {
+		const name = module.nameForCondition();
+		return name && test.test(name);
+	}
+	return false;
+};
+
+class LazyCompilationDependency extends Dependency {
+	/**
+	 * @param {LazyCompilationProxyModule} proxyModule proxy module
+	 */
+	constructor(proxyModule) {
+		super();
+		this.proxyModule = proxyModule;
+	}
+
+	get category() {
+		return "esm";
+	}
+
+	get type() {
+		return "lazy import()";
+	}
+
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return this.proxyModule.originalModule.identifier();
+	}
+}
+
+registerNotSerializable(LazyCompilationDependency);
+
+class LazyCompilationProxyModule extends Module {
+	/**
+	 * @param {string} context context
+	 * @param {Module} originalModule an original module
+	 * @param {string} request request
+	 * @param {ModuleResult["client"]} client client
+	 * @param {ModuleResult["data"]} data data
+	 * @param {ModuleResult["active"]} active true when active, otherwise false
+	 */
+	constructor(context, originalModule, request, client, data, active) {
+		super(
+			WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY,
+			context,
+			originalModule.layer
+		);
+		this.originalModule = originalModule;
+		this.request = request;
+		this.client = client;
+		this.data = data;
+		this.active = active;
+	}
+
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return `${WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY}|${this.originalModule.identifier()}`;
+	}
+
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return `${WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY} ${this.originalModule.readableIdentifier(
+			requestShortener
+		)}`;
+	}
+
+	/**
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
+	 */
+	updateCacheModule(module) {
+		super.updateCacheModule(module);
+		const m = /** @type {LazyCompilationProxyModule} */ (module);
+		this.originalModule = m.originalModule;
+		this.request = m.request;
+		this.client = m.client;
+		this.data = m.data;
+		this.active = m.active;
+	}
+
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return `${this.originalModule.libIdent(
+			options
+		)}!${WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY}`;
+	}
+
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		callback(null, !this.buildInfo || this.buildInfo.active !== this.active);
+	}
+
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildInfo = {
+			active: this.active
+		};
+		/** @type {BuildMeta} */
+		this.buildMeta = {};
+		this.clearDependenciesAndBlocks();
+		const dep = new CommonJsRequireDependency(this.client);
+		this.addDependency(dep);
+		if (this.active) {
+			const dep = new LazyCompilationDependency(this);
+			const block = new AsyncDependenciesBlock({});
+			block.addDependency(dep);
+			this.addBlock(block);
+		}
+		callback();
+	}
+
+	/**
+	 * @returns {SourceTypes} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return JS_TYPES;
+	}
+
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return 200;
+	}
+
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({ runtimeTemplate, chunkGraph, moduleGraph }) {
+		const sources = new Map();
+		const runtimeRequirements = new Set();
+		runtimeRequirements.add(RuntimeGlobals.module);
+		const clientDep = /** @type {CommonJsRequireDependency} */ (
+			this.dependencies[0]
+		);
+		const clientModule = moduleGraph.getModule(clientDep);
+		const block = this.blocks[0];
+		const client = Template.asString([
+			`var client = ${runtimeTemplate.moduleExports({
+				module: clientModule,
+				chunkGraph,
+				request: clientDep.userRequest,
+				runtimeRequirements
+			})}`,
+			`var data = ${JSON.stringify(this.data)};`
+		]);
+		const keepActive = Template.asString([
+			`var dispose = client.keepAlive({ data: data, active: ${JSON.stringify(
+				Boolean(block)
+			)}, module: module, onError: onError });`
+		]);
+		let source;
+		if (block) {
+			const dep = block.dependencies[0];
+			const module = /** @type {Module} */ (moduleGraph.getModule(dep));
+			source = Template.asString([
+				client,
+				`module.exports = ${runtimeTemplate.moduleNamespacePromise({
+					chunkGraph,
+					block,
+					module,
+					request: this.request,
+					strict: false, // TODO this should be inherited from the original module
+					message: "import()",
+					runtimeRequirements
+				})};`,
+				"if (module.hot) {",
+				Template.indent([
+					"module.hot.accept();",
+					`module.hot.accept(${JSON.stringify(
+						chunkGraph.getModuleId(module)
+					)}, function() { module.hot.invalidate(); });`,
+					"module.hot.dispose(function(data) { delete data.resolveSelf; dispose(data); });",
+					"if (module.hot.data && module.hot.data.resolveSelf) module.hot.data.resolveSelf(module.exports);"
+				]),
+				"}",
+				"function onError() { /* ignore */ }",
+				keepActive
+			]);
+		} else {
+			source = Template.asString([
+				client,
+				"var resolveSelf, onError;",
+				"module.exports = new Promise(function(resolve, reject) { resolveSelf = resolve; onError = reject; });",
+				"if (module.hot) {",
+				Template.indent([
+					"module.hot.accept();",
+					"if (module.hot.data && module.hot.data.resolveSelf) module.hot.data.resolveSelf(module.exports);",
+					"module.hot.dispose(function(data) { data.resolveSelf = resolveSelf; dispose(data); });"
+				]),
+				"}",
+				keepActive
+			]);
+		}
+		sources.set("javascript", new RawSource(source));
+		return {
+			sources,
+			runtimeRequirements
+		};
+	}
+
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		super.updateHash(hash, context);
+		hash.update(this.active ? "active" : "");
+		hash.update(JSON.stringify(this.data));
+	}
+}
+
+registerNotSerializable(LazyCompilationProxyModule);
+
+class LazyCompilationDependencyFactory extends ModuleFactory {
+	constructor() {
+		super();
+	}
+
+	/**
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
+	 * @returns {void}
+	 */
+	create(data, callback) {
+		const dependency = /** @type {LazyCompilationDependency} */ (
+			data.dependencies[0]
+		);
+		callback(null, {
+			module: dependency.proxyModule.originalModule
+		});
+	}
+}
+
+/**
+ * @callback BackendHandler
+ * @param {Compiler} compiler compiler
+ * @param {function(Error | null, BackendApi=): void} callback callback
+ * @returns {void}
+ */
+
+/**
+ * @callback PromiseBackendHandler
+ * @param {Compiler} compiler compiler
+ * @returns {Promise<BackendApi>} backend
+ */
+
+class LazyCompilationPlugin {
+	/**
+	 * @param {object} options options
+	 * @param {BackendHandler | PromiseBackendHandler} options.backend the backend
+	 * @param {boolean} options.entries true, when entries are lazy compiled
+	 * @param {boolean} options.imports true, when import() modules are lazy compiled
+	 * @param {RegExp | string | (function(Module): boolean) | undefined} options.test additional filter for lazy compiled entrypoint modules
+	 */
+	constructor({ backend, entries, imports, test }) {
+		this.backend = backend;
+		this.entries = entries;
+		this.imports = imports;
+		this.test = test;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		/** @type {BackendApi} */
+		let backend;
+		compiler.hooks.beforeCompile.tapAsync(
+			"LazyCompilationPlugin",
+			(params, callback) => {
+				if (backend !== undefined) return callback();
+				const promise = this.backend(compiler, (err, result) => {
+					if (err) return callback(err);
+					backend = /** @type {BackendApi} */ (result);
+					callback();
+				});
+				if (promise && promise.then) {
+					promise.then(b => {
+						backend = b;
+						callback();
+					}, callback);
+				}
+			}
+		);
+		compiler.hooks.thisCompilation.tap(
+			"LazyCompilationPlugin",
+			(compilation, { normalModuleFactory }) => {
+				normalModuleFactory.hooks.module.tap(
+					"LazyCompilationPlugin",
+					(originalModule, createData, resolveData) => {
+						if (
+							resolveData.dependencies.every(dep =>
+								HMR_DEPENDENCY_TYPES.has(dep.type)
+							)
+						) {
+							// for HMR only resolving, try to determine if the HMR accept/decline refers to
+							// an import() or not
+							const hmrDep = resolveData.dependencies[0];
+							const originModule =
+								/** @type {Module} */
+								(compilation.moduleGraph.getParentModule(hmrDep));
+							const isReferringToDynamicImport = originModule.blocks.some(
+								block =>
+									block.dependencies.some(
+										dep =>
+											dep.type === "import()" &&
+											/** @type {HarmonyImportDependency} */ (dep).request ===
+												hmrDep.request
+									)
+							);
+							if (!isReferringToDynamicImport) return;
+						} else if (
+							!resolveData.dependencies.every(
+								dep =>
+									HMR_DEPENDENCY_TYPES.has(dep.type) ||
+									(this.imports &&
+										(dep.type === "import()" ||
+											dep.type === "import() context element")) ||
+									(this.entries && dep.type === "entry")
+							)
+						)
+							return;
+						if (
+							/webpack[/\\]hot[/\\]|webpack-dev-server[/\\]client|webpack-hot-middleware[/\\]client/.test(
+								resolveData.request
+							) ||
+							!checkTest(this.test, originalModule)
+						)
+							return;
+						const moduleInfo = backend.module(originalModule);
+						if (!moduleInfo) return;
+						const { client, data, active } = moduleInfo;
+
+						return new LazyCompilationProxyModule(
+							compiler.context,
+							originalModule,
+							resolveData.request,
+							client,
+							data,
+							active
+						);
+					}
+				);
+				compilation.dependencyFactories.set(
+					LazyCompilationDependency,
+					new LazyCompilationDependencyFactory()
+				);
+			}
+		);
+		compiler.hooks.shutdown.tapAsync("LazyCompilationPlugin", callback => {
+			backend.dispose(callback);
+		});
+	}
+}
+
+module.exports = LazyCompilationPlugin;
Index: imaps-frontend/node_modules/webpack/lib/hmr/lazyCompilationBackend.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/hmr/lazyCompilationBackend.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/hmr/lazyCompilationBackend.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,161 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("http").IncomingMessage} IncomingMessage */
+/** @typedef {import("http").RequestListener} RequestListener */
+/** @typedef {import("http").ServerOptions} HttpServerOptions */
+/** @typedef {import("http").ServerResponse} ServerResponse */
+/** @typedef {import("https").ServerOptions} HttpsServerOptions */
+/** @typedef {import("net").AddressInfo} AddressInfo */
+/** @typedef {import("net").Server} Server */
+/** @typedef {import("../../declarations/WebpackOptions").LazyCompilationDefaultBackendOptions} LazyCompilationDefaultBackendOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("./LazyCompilationPlugin").BackendApi} BackendApi */
+/** @typedef {import("./LazyCompilationPlugin").BackendHandler} BackendHandler */
+
+/**
+ * @param {Omit<LazyCompilationDefaultBackendOptions, "client"> & { client: NonNullable<LazyCompilationDefaultBackendOptions["client"]>}} options additional options for the backend
+ * @returns {BackendHandler} backend
+ */
+module.exports = options => (compiler, callback) => {
+	const logger = compiler.getInfrastructureLogger("LazyCompilationBackend");
+	const activeModules = new Map();
+	const prefix = "/lazy-compilation-using-";
+
+	const isHttps =
+		options.protocol === "https" ||
+		(typeof options.server === "object" &&
+			("key" in options.server || "pfx" in options.server));
+
+	const createServer =
+		typeof options.server === "function"
+			? options.server
+			: (() => {
+					const http = isHttps ? require("https") : require("http");
+					return http.createServer.bind(
+						http,
+						/** @type {HttpServerOptions | HttpsServerOptions} */
+						(options.server)
+					);
+				})();
+	/** @type {function(Server): void} */
+	const listen =
+		typeof options.listen === "function"
+			? options.listen
+			: server => {
+					let listen = options.listen;
+					if (typeof listen === "object" && !("port" in listen))
+						listen = { ...listen, port: undefined };
+					server.listen(listen);
+				};
+
+	const protocol = options.protocol || (isHttps ? "https" : "http");
+
+	/** @type {RequestListener} */
+	const requestListener = (req, res) => {
+		if (req.url === undefined) return;
+		const keys = req.url.slice(prefix.length).split("@");
+		req.socket.on("close", () => {
+			setTimeout(() => {
+				for (const key of keys) {
+					const oldValue = activeModules.get(key) || 0;
+					activeModules.set(key, oldValue - 1);
+					if (oldValue === 1) {
+						logger.log(
+							`${key} is no longer in use. Next compilation will skip this module.`
+						);
+					}
+				}
+			}, 120000);
+		});
+		req.socket.setNoDelay(true);
+		res.writeHead(200, {
+			"content-type": "text/event-stream",
+			"Access-Control-Allow-Origin": "*",
+			"Access-Control-Allow-Methods": "*",
+			"Access-Control-Allow-Headers": "*"
+		});
+		res.write("\n");
+		let moduleActivated = false;
+		for (const key of keys) {
+			const oldValue = activeModules.get(key) || 0;
+			activeModules.set(key, oldValue + 1);
+			if (oldValue === 0) {
+				logger.log(`${key} is now in use and will be compiled.`);
+				moduleActivated = true;
+			}
+		}
+		if (moduleActivated && compiler.watching) compiler.watching.invalidate();
+	};
+
+	const server = /** @type {Server} */ (createServer());
+	server.on("request", requestListener);
+
+	let isClosing = false;
+	/** @type {Set<import("net").Socket>} */
+	const sockets = new Set();
+	server.on("connection", socket => {
+		sockets.add(socket);
+		socket.on("close", () => {
+			sockets.delete(socket);
+		});
+		if (isClosing) socket.destroy();
+	});
+	server.on("clientError", e => {
+		if (e.message !== "Server is disposing") logger.warn(e);
+	});
+
+	server.on(
+		"listening",
+		/**
+		 * @param {Error} err error
+		 * @returns {void}
+		 */
+		err => {
+			if (err) return callback(err);
+			const _addr = server.address();
+			if (typeof _addr === "string")
+				throw new Error("addr must not be a string");
+			const addr = /** @type {AddressInfo} */ (_addr);
+			const urlBase =
+				addr.address === "::" || addr.address === "0.0.0.0"
+					? `${protocol}://localhost:${addr.port}`
+					: addr.family === "IPv6"
+						? `${protocol}://[${addr.address}]:${addr.port}`
+						: `${protocol}://${addr.address}:${addr.port}`;
+			logger.log(
+				`Server-Sent-Events server for lazy compilation open at ${urlBase}.`
+			);
+			callback(null, {
+				dispose(callback) {
+					isClosing = true;
+					// Removing the listener is a workaround for a memory leak in node.js
+					server.off("request", requestListener);
+					server.close(err => {
+						callback(err);
+					});
+					for (const socket of sockets) {
+						socket.destroy(new Error("Server is disposing"));
+					}
+				},
+				module(originalModule) {
+					const key = `${encodeURIComponent(
+						originalModule.identifier().replace(/\\/g, "/").replace(/@/g, "_")
+					).replace(/%(2F|3A|24|26|2B|2C|3B|3D)/g, decodeURIComponent)}`;
+					const active = activeModules.get(key) > 0;
+					return {
+						client: `${options.client}?${encodeURIComponent(urlBase + prefix)}`,
+						data: key,
+						active
+					};
+				}
+			});
+		}
+	);
+	listen(server);
+};
