FM / hmr

/var/www/cobraambalaj/node_modules/webpack/lib/hmr/

/var/www/cobraambalaj/node_modules/webpack/lib/hmr

Name	Size	Mode	Actions
HotModuleReplacement.runtime.js	9379	0644	edit dl rm
HotModuleReplacementRuntimeModule.js	1181	0644	edit dl rm
JavascriptHotModuleReplacement.runtime.js	12373	0644	edit dl rm
lazyCompilationBackend.js	2488	0644	edit dl rm
LazyCompilationPlugin.js	11383	0644	edit dl rm

Edit: /var/www/cobraambalaj/node_modules/webpack/lib/hmr/HotModuleReplacement.runtime.js (9379B)

/*
	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;
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;

// The update info
	var currentUpdateApplyHandlers;
	var queuedInvalidatedModules;

// eslint-disable-next-line no-unused-vars
	$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) {
				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 () {};
				else hot._acceptedDependencies[dep] = callback || function () {};
			},
			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;
		for (var i = 0; i < registeredStatusHandlers.length; i++)
			registeredStatusHandlers[i].call(null, newStatus);
	}

function waitForBlockingPromises(fn) {
		if (blockingPromises.length === 0) return fn();
		var blocker = blockingPromises;
		blockingPromises = [];
		return Promise.all(blocker).then(function () {
			return waitForBlockingPromises(fn);
		});
	}

function hotCheck(applyOnUpdate) {
		if (currentStatus !== "idle") {
			throw new Error("check() is only allowed in idle status");
		}
		setStatus("check");
		return $hmrDownloadManifest$().then(function (update) {
			if (!update) {
				setStatus(applyInvalidatedModules() ? "ready" : "idle");
				return null;
			}

setStatus("prepare");

var updatedModules = [];
			blockingPromises = [];
			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);
					} else {
						setStatus("ready");

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) {
			setStatus("abort");
			return Promise.resolve().then(function () {
				throw errors[0];
			});
		}

// Now in "dispose" phase
		setStatus("dispose");

results.forEach(function (result) {
			if (result.dispose) result.dispose();
		});

// Now in "apply" phase
		setStatus("apply");

var error;
		var reportError = function (err) {
			if (!error) error = err;
		};

// handle errors in accept handlers and self accepted module load
		if (error) {
			setStatus("fail");
			return Promise.resolve().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;
			});
		}

setStatus("idle");
		return Promise.resolve(outdatedModules);
	}

cmd: