Deployed the page to Github Pages.

node_modules/webpack/lib/node/NodeEnvironmentPlugin.js

@@ -0,0 +1,66 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const CachedInputFileSystem = require("enhanced-resolve").CachedInputFileSystem;
+const fs = require("graceful-fs");
+const createConsoleLogger = require("../logging/createConsoleLogger");
+const NodeWatchFileSystem = require("./NodeWatchFileSystem");
+const nodeConsole = require("./nodeConsole");
+
+/** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+
+class NodeEnvironmentPlugin {
+	/**
+	 * @param {object} options options
+	 * @param {InfrastructureLogging} options.infrastructureLogging infrastructure logging options
+	 */
+	constructor(options) {
+		this.options = options;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const { infrastructureLogging } = this.options;
+		compiler.infrastructureLogger = createConsoleLogger({
+			level: infrastructureLogging.level || "info",
+			debug: infrastructureLogging.debug || false,
+			console:
+				infrastructureLogging.console ||
+				nodeConsole({
+					colors: infrastructureLogging.colors,
+					appendOnly: infrastructureLogging.appendOnly,
+					stream:
+						/** @type {NodeJS.WritableStream} */
+						(infrastructureLogging.stream)
+				})
+		});
+		compiler.inputFileSystem = new CachedInputFileSystem(fs, 60000);
+		const inputFileSystem =
+			/** @type {InputFileSystem} */
+			(compiler.inputFileSystem);
+		compiler.outputFileSystem = fs;
+		compiler.intermediateFileSystem = fs;
+		compiler.watchFileSystem = new NodeWatchFileSystem(inputFileSystem);
+		compiler.hooks.beforeRun.tap("NodeEnvironmentPlugin", compiler => {
+			if (
+				compiler.inputFileSystem === inputFileSystem &&
+				inputFileSystem.purge
+			) {
+				compiler.fsStartTime = Date.now();
+				inputFileSystem.purge();
+			}
+		});
+	}
+}
+
+module.exports = NodeEnvironmentPlugin;

node_modules/webpack/lib/node/NodeSourcePlugin.js

@@ -0,0 +1,19 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class NodeSourcePlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {}
+}
+
+module.exports = NodeSourcePlugin;

node_modules/webpack/lib/node/NodeTargetPlugin.js

@@ -0,0 +1,85 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const ExternalsPlugin = require("../ExternalsPlugin");
+
+/** @typedef {import("../Compiler")} Compiler */
+
+const builtins = [
+	"assert",
+	"assert/strict",
+	"async_hooks",
+	"buffer",
+	"child_process",
+	"cluster",
+	"console",
+	"constants",
+	"crypto",
+	"dgram",
+	"diagnostics_channel",
+	"dns",
+	"dns/promises",
+	"domain",
+	"events",
+	"fs",
+	"fs/promises",
+	"http",
+	"http2",
+	"https",
+	"inspector",
+	"inspector/promises",
+	"module",
+	"net",
+	"os",
+	"path",
+	"path/posix",
+	"path/win32",
+	"perf_hooks",
+	"process",
+	"punycode",
+	"querystring",
+	"readline",
+	"readline/promises",
+	"repl",
+	"stream",
+	"stream/consumers",
+	"stream/promises",
+	"stream/web",
+	"string_decoder",
+	"sys",
+	"timers",
+	"timers/promises",
+	"tls",
+	"trace_events",
+	"tty",
+	"url",
+	"util",
+	"util/types",
+	"v8",
+	"vm",
+	"wasi",
+	"worker_threads",
+	"zlib",
+	/^node:/,
+
+	// cspell:word pnpapi
+	// Yarn PnP adds pnpapi as "builtin"
+	"pnpapi"
+];
+
+class NodeTargetPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		new ExternalsPlugin("node-commonjs", builtins).apply(compiler);
+	}
+}
+
+module.exports = NodeTargetPlugin;

node_modules/webpack/lib/node/NodeTemplatePlugin.js

@@ -0,0 +1,41 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const CommonJsChunkFormatPlugin = require("../javascript/CommonJsChunkFormatPlugin");
+const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin");
+
+/** @typedef {import("../Compiler")} Compiler */
+
+/**
+ * @typedef {object} NodeTemplatePluginOptions
+ * @property {boolean} [asyncChunkLoading] enable async chunk loading
+ */
+
+class NodeTemplatePlugin {
+	/**
+	 * @param {NodeTemplatePluginOptions} [options] options object
+	 */
+	constructor(options = {}) {
+		this._options = options;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const chunkLoading = this._options.asyncChunkLoading
+			? "async-node"
+			: "require";
+		compiler.options.output.chunkLoading = chunkLoading;
+		new CommonJsChunkFormatPlugin().apply(compiler);
+		new EnableChunkLoadingPlugin(chunkLoading).apply(compiler);
+	}
+}
+
+module.exports = NodeTemplatePlugin;

node_modules/webpack/lib/node/NodeWatchFileSystem.js

@@ -0,0 +1,190 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const util = require("util");
+const Watchpack = require("watchpack");
+
+/** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
+/** @typedef {import("../FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("../util/fs").WatchMethod} WatchMethod */
+
+class NodeWatchFileSystem {
+	/**
+	 * @param {InputFileSystem} inputFileSystem input filesystem
+	 */
+	constructor(inputFileSystem) {
+		this.inputFileSystem = inputFileSystem;
+		this.watcherOptions = {
+			aggregateTimeout: 0
+		};
+		this.watcher = new Watchpack(this.watcherOptions);
+	}
+
+	/** @type {WatchMethod} */
+	watch(
+		files,
+		directories,
+		missing,
+		startTime,
+		options,
+		callback,
+		callbackUndelayed
+	) {
+		if (!files || typeof files[Symbol.iterator] !== "function") {
+			throw new Error("Invalid arguments: 'files'");
+		}
+		if (!directories || typeof directories[Symbol.iterator] !== "function") {
+			throw new Error("Invalid arguments: 'directories'");
+		}
+		if (!missing || typeof missing[Symbol.iterator] !== "function") {
+			throw new Error("Invalid arguments: 'missing'");
+		}
+		if (typeof callback !== "function") {
+			throw new Error("Invalid arguments: 'callback'");
+		}
+		if (typeof startTime !== "number" && startTime) {
+			throw new Error("Invalid arguments: 'startTime'");
+		}
+		if (typeof options !== "object") {
+			throw new Error("Invalid arguments: 'options'");
+		}
+		if (typeof callbackUndelayed !== "function" && callbackUndelayed) {
+			throw new Error("Invalid arguments: 'callbackUndelayed'");
+		}
+		const oldWatcher = this.watcher;
+		this.watcher = new Watchpack(options);
+
+		if (callbackUndelayed) {
+			this.watcher.once("change", callbackUndelayed);
+		}
+
+		const fetchTimeInfo = () => {
+			const fileTimeInfoEntries = new Map();
+			const contextTimeInfoEntries = new Map();
+			if (this.watcher) {
+				this.watcher.collectTimeInfoEntries(
+					fileTimeInfoEntries,
+					contextTimeInfoEntries
+				);
+			}
+			return { fileTimeInfoEntries, contextTimeInfoEntries };
+		};
+		this.watcher.once(
+			"aggregated",
+			/**
+			 * @param {Set<string>} changes changes
+			 * @param {Set<string>} removals removals
+			 */
+			(changes, removals) => {
+				// pause emitting events (avoids clearing aggregated changes and removals on timeout)
+				this.watcher.pause();
+
+				const fs = this.inputFileSystem;
+				if (fs && fs.purge) {
+					for (const item of changes) {
+						fs.purge(item);
+					}
+					for (const item of removals) {
+						fs.purge(item);
+					}
+				}
+				const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
+				callback(
+					null,
+					fileTimeInfoEntries,
+					contextTimeInfoEntries,
+					changes,
+					removals
+				);
+			}
+		);
+
+		this.watcher.watch({ files, directories, missing, startTime });
+
+		if (oldWatcher) {
+			oldWatcher.close();
+		}
+		return {
+			close: () => {
+				if (this.watcher) {
+					this.watcher.close();
+					this.watcher = null;
+				}
+			},
+			pause: () => {
+				if (this.watcher) {
+					this.watcher.pause();
+				}
+			},
+			getAggregatedRemovals: util.deprecate(
+				() => {
+					const items = this.watcher && this.watcher.aggregatedRemovals;
+					const fs = this.inputFileSystem;
+					if (items && fs && fs.purge) {
+						for (const item of items) {
+							fs.purge(item);
+						}
+					}
+					return items;
+				},
+				"Watcher.getAggregatedRemovals is deprecated in favor of Watcher.getInfo since that's more performant.",
+				"DEP_WEBPACK_WATCHER_GET_AGGREGATED_REMOVALS"
+			),
+			getAggregatedChanges: util.deprecate(
+				() => {
+					const items = this.watcher && this.watcher.aggregatedChanges;
+					const fs = this.inputFileSystem;
+					if (items && fs && fs.purge) {
+						for (const item of items) {
+							fs.purge(item);
+						}
+					}
+					return items;
+				},
+				"Watcher.getAggregatedChanges is deprecated in favor of Watcher.getInfo since that's more performant.",
+				"DEP_WEBPACK_WATCHER_GET_AGGREGATED_CHANGES"
+			),
+			getFileTimeInfoEntries: util.deprecate(
+				() => fetchTimeInfo().fileTimeInfoEntries,
+				"Watcher.getFileTimeInfoEntries is deprecated in favor of Watcher.getInfo since that's more performant.",
+				"DEP_WEBPACK_WATCHER_FILE_TIME_INFO_ENTRIES"
+			),
+			getContextTimeInfoEntries: util.deprecate(
+				() => fetchTimeInfo().contextTimeInfoEntries,
+				"Watcher.getContextTimeInfoEntries is deprecated in favor of Watcher.getInfo since that's more performant.",
+				"DEP_WEBPACK_WATCHER_CONTEXT_TIME_INFO_ENTRIES"
+			),
+			getInfo: () => {
+				const removals = this.watcher && this.watcher.aggregatedRemovals;
+				const changes = this.watcher && this.watcher.aggregatedChanges;
+				const fs = this.inputFileSystem;
+				if (fs && fs.purge) {
+					if (removals) {
+						for (const item of removals) {
+							fs.purge(item);
+						}
+					}
+					if (changes) {
+						for (const item of changes) {
+							fs.purge(item);
+						}
+					}
+				}
+				const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
+				return {
+					changes,
+					removals,
+					fileTimeInfoEntries,
+					contextTimeInfoEntries
+				};
+			}
+		};
+	}
+}
+
+module.exports = NodeWatchFileSystem;

node_modules/webpack/lib/node/nodeConsole.js

@@ -0,0 +1,160 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const util = require("util");
+const truncateArgs = require("../logging/truncateArgs");
+
+/** @typedef {import("../logging/createConsoleLogger").LoggerConsole} LoggerConsole */
+
+/**
+ * @param {object} options options
+ * @param {boolean=} options.colors colors
+ * @param {boolean=} options.appendOnly append only
+ * @param {NodeJS.WritableStream} options.stream stream
+ * @returns {LoggerConsole} logger function
+ */
+module.exports = ({ colors, appendOnly, stream }) => {
+	/** @type {string[] | undefined} */
+	let currentStatusMessage;
+	let hasStatusMessage = false;
+	let currentIndent = "";
+	let currentCollapsed = 0;
+
+	/**
+	 * @param {string} str string
+	 * @param {string} prefix prefix
+	 * @param {string} colorPrefix color prefix
+	 * @param {string} colorSuffix color suffix
+	 * @returns {string} indented string
+	 */
+	const indent = (str, prefix, colorPrefix, colorSuffix) => {
+		if (str === "") return str;
+		prefix = currentIndent + prefix;
+		if (colors) {
+			return (
+				prefix +
+				colorPrefix +
+				str.replace(/\n/g, `${colorSuffix}\n${prefix}${colorPrefix}`) +
+				colorSuffix
+			);
+		}
+
+		return prefix + str.replace(/\n/g, `\n${prefix}`);
+	};
+
+	const clearStatusMessage = () => {
+		if (hasStatusMessage) {
+			stream.write("\u001B[2K\r");
+			hasStatusMessage = false;
+		}
+	};
+
+	const writeStatusMessage = () => {
+		if (!currentStatusMessage) return;
+		const l = /** @type {TODO} */ (stream).columns || 40;
+		const args = truncateArgs(currentStatusMessage, l - 1);
+		const str = args.join(" ");
+		const coloredStr = `\u001B[1m${str}\u001B[39m\u001B[22m`;
+		stream.write(`\u001B[2K\r${coloredStr}`);
+		hasStatusMessage = true;
+	};
+
+	/**
+	 * @param {string} prefix prefix
+	 * @param {string} colorPrefix color prefix
+	 * @param {string} colorSuffix color suffix
+	 * @returns {(function(...any[]): void)} function to write with colors
+	 */
+	const writeColored =
+		(prefix, colorPrefix, colorSuffix) =>
+		(...args) => {
+			if (currentCollapsed > 0) return;
+			clearStatusMessage();
+			const str = indent(
+				util.format(...args),
+				prefix,
+				colorPrefix,
+				colorSuffix
+			);
+			stream.write(`${str}\n`);
+			writeStatusMessage();
+		};
+
+	const writeGroupMessage = writeColored(
+		"<-> ",
+		"\u001B[1m\u001B[36m",
+		"\u001B[39m\u001B[22m"
+	);
+
+	const writeGroupCollapsedMessage = writeColored(
+		"<+> ",
+		"\u001B[1m\u001B[36m",
+		"\u001B[39m\u001B[22m"
+	);
+
+	return {
+		log: writeColored("    ", "\u001B[1m", "\u001B[22m"),
+		debug: writeColored("    ", "", ""),
+		trace: writeColored("    ", "", ""),
+		info: writeColored("<i> ", "\u001B[1m\u001B[32m", "\u001B[39m\u001B[22m"),
+		warn: writeColored("<w> ", "\u001B[1m\u001B[33m", "\u001B[39m\u001B[22m"),
+		error: writeColored("<e> ", "\u001B[1m\u001B[31m", "\u001B[39m\u001B[22m"),
+		logTime: writeColored(
+			"<t> ",
+			"\u001B[1m\u001B[35m",
+			"\u001B[39m\u001B[22m"
+		),
+		group: (...args) => {
+			writeGroupMessage(...args);
+			if (currentCollapsed > 0) {
+				currentCollapsed++;
+			} else {
+				currentIndent += "  ";
+			}
+		},
+		groupCollapsed: (...args) => {
+			writeGroupCollapsedMessage(...args);
+			currentCollapsed++;
+		},
+		groupEnd: () => {
+			if (currentCollapsed > 0) currentCollapsed--;
+			else if (currentIndent.length >= 2)
+				currentIndent = currentIndent.slice(0, -2);
+		},
+		profile: console.profile && (name => console.profile(name)),
+		profileEnd: console.profileEnd && (name => console.profileEnd(name)),
+		clear:
+			!appendOnly &&
+			console.clear &&
+			(() => {
+				clearStatusMessage();
+				console.clear();
+				writeStatusMessage();
+			}),
+		status: appendOnly
+			? writeColored("<s> ", "", "")
+			: (name, ...args) => {
+					args = args.filter(Boolean);
+					if (name === undefined && args.length === 0) {
+						clearStatusMessage();
+						currentStatusMessage = undefined;
+					} else if (
+						typeof name === "string" &&
+						name.startsWith("[webpack.Progress] ")
+					) {
+						currentStatusMessage = [name.slice(19), ...args];
+						writeStatusMessage();
+					} else if (name === "[webpack.Progress]") {
+						currentStatusMessage = [...args];
+						writeStatusMessage();
+					} else {
+						currentStatusMessage = [name, ...args];
+						writeStatusMessage();
+					}
+				}
+	};
+};