FM / webpack

/opt/canhelp/node_modules/next/dist/compiled/webpack/

/opt/canhelp/node_modules/next/dist/compiled/webpack

Name	Size	Mode	Actions
BasicEvaluatedExpression.js	66	0644	edit dl rm
bundle5.js	2582639	0644	edit dl rm
ExternalsPlugin.js	57	0644	edit dl rm
FetchCompileAsyncWasmPlugin.js	69	0644	edit dl rm
FetchCompileWasmPlugin.js	64	0644	edit dl rm
FetchCompileWasmTemplatePlugin.js	72	0644	edit dl rm
GraphHelpers.js	54	0644	edit dl rm
HotModuleReplacement.runtime.js	10229	0644	edit dl rm
JavascriptHotModuleReplacement.runtime.js	13235	0644	edit dl rm
lazy-compilation-node.js	1187	0644	edit dl rm
lazy-compilation-web.js	2052	0644	edit dl rm
LibraryTemplatePlugin.js	63	0644	edit dl rm
LICENSE	1071	0644	edit dl rm
LimitChunkCountPlugin.js	63	0644	edit dl rm
ModuleFilenameHelpers.js	63	0644	edit dl rm
NodeEnvironmentPlugin.js	63	0644	edit dl rm
NodeTargetPlugin.js	58	0644	edit dl rm
NodeTemplatePlugin.js	60	0644	edit dl rm
NormalModule.js	54	0644	edit dl rm
package.js	49	0644	edit dl rm
package.json	88	0644	edit dl rm
SingleEntryPlugin.js	59	0644	edit dl rm
SourceMapDevToolModuleOptionsPlugin.js	77	0644	edit dl rm
sources.js	49	0644	edit dl rm
webpack-lib.js	49	0644	edit dl rm
webpack.d.ts	441	0644	edit dl rm
webpack.js	2408	0644	edit dl rm
WebWorkerTemplatePlugin.js	65	0644	edit dl rm

Edit: /opt/canhelp/node_modules/next/dist/compiled/webpack/HotModuleReplacement.runtime.js (10229B)

// @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$ = {};

// 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 trackBlockingPromise(promise) {
		switch (currentStatus) {
			case "ready":
				setStatus("prepare");
			/* fallthrough */
			case "prepare":
				blockingPromises++;
				promise.then(unblock, unblock);
				return promise;
			default:
				return promise;
		}
	}

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 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;
		};

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;
			});
		});
	}

cmd: