Project files

receipeServer/frontend_old/node_modules/webpack-dev-server/client/clients/SockJSClient.js

@@ -0,0 +1,68 @@
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+import SockJS from "../modules/sockjs-client/index.js";
+import { log } from "../utils/log.js";
+
+var SockJSClient = /*#__PURE__*/function () {
+  /**
+   * @param {string} url
+   */
+  function SockJSClient(url) {
+    _classCallCheck(this, SockJSClient);
+
+    // SockJS requires `http` and `https` protocols
+    this.sock = new SockJS(url.replace(/^ws:/i, "http:").replace(/^wss:/i, "https:"));
+
+    this.sock.onerror =
+    /**
+     * @param {Error} error
+     */
+    function (error) {
+      log.error(error);
+    };
+  }
+  /**
+   * @param {(...args: any[]) => void} f
+   */
+
+
+  _createClass(SockJSClient, [{
+    key: "onOpen",
+    value: function onOpen(f) {
+      this.sock.onopen = f;
+    }
+    /**
+     * @param {(...args: any[]) => void} f
+     */
+
+  }, {
+    key: "onClose",
+    value: function onClose(f) {
+      this.sock.onclose = f;
+    } // call f with the message string as the first argument
+
+    /**
+     * @param {(...args: any[]) => void} f
+     */
+
+  }, {
+    key: "onMessage",
+    value: function onMessage(f) {
+      this.sock.onmessage =
+      /**
+       * @param {Error & { data: string }} e
+       */
+      function (e) {
+        f(e.data);
+      };
+    }
+  }]);
+
+  return SockJSClient;
+}();
+
+export { SockJSClient as default };

receipeServer/frontend_old/node_modules/webpack-dev-server/client/clients/WebSocketClient.js

@@ -0,0 +1,58 @@
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+import { log } from "../utils/log.js";
+
+var WebSocketClient = /*#__PURE__*/function () {
+  /**
+   * @param {string} url
+   */
+  function WebSocketClient(url) {
+    _classCallCheck(this, WebSocketClient);
+
+    this.client = new WebSocket(url);
+
+    this.client.onerror = function (error) {
+      log.error(error);
+    };
+  }
+  /**
+   * @param {(...args: any[]) => void} f
+   */
+
+
+  _createClass(WebSocketClient, [{
+    key: "onOpen",
+    value: function onOpen(f) {
+      this.client.onopen = f;
+    }
+    /**
+     * @param {(...args: any[]) => void} f
+     */
+
+  }, {
+    key: "onClose",
+    value: function onClose(f) {
+      this.client.onclose = f;
+    } // call f with the message string as the first argument
+
+    /**
+     * @param {(...args: any[]) => void} f
+     */
+
+  }, {
+    key: "onMessage",
+    value: function onMessage(f) {
+      this.client.onmessage = function (e) {
+        f(e.data);
+      };
+    }
+  }]);
+
+  return WebSocketClient;
+}();
+
+export { WebSocketClient as default };

receipeServer/frontend_old/node_modules/webpack-dev-server/client/index.js

@@ -0,0 +1,273 @@
+/* global __resourceQuery, __webpack_hash__ */
+/// <reference types="webpack/module" />
+import webpackHotLog from "webpack/hot/log.js";
+import stripAnsi from "./utils/stripAnsi.js";
+import parseURL from "./utils/parseURL.js";
+import socket from "./socket.js";
+import { formatProblem, show, hide } from "./overlay.js";
+import { log, setLogLevel } from "./utils/log.js";
+import sendMessage from "./utils/sendMessage.js";
+import reloadApp from "./utils/reloadApp.js";
+import createSocketURL from "./utils/createSocketURL.js";
+/**
+ * @typedef {Object} Options
+ * @property {boolean} hot
+ * @property {boolean} liveReload
+ * @property {boolean} progress
+ * @property {boolean | { warnings?: boolean, errors?: boolean }} overlay
+ * @property {string} [logging]
+ * @property {number} [reconnect]
+ */
+
+/**
+ * @typedef {Object} Status
+ * @property {boolean} isUnloading
+ * @property {string} currentHash
+ * @property {string} [previousHash]
+ */
+
+/**
+ * @type {Status}
+ */
+
+var status = {
+  isUnloading: false,
+  // TODO Workaround for webpack v4, `__webpack_hash__` is not replaced without HotModuleReplacement
+  // eslint-disable-next-line camelcase
+  currentHash: typeof __webpack_hash__ !== "undefined" ? __webpack_hash__ : ""
+};
+/** @type {Options} */
+
+var options = {
+  hot: false,
+  liveReload: false,
+  progress: false,
+  overlay: false
+};
+var parsedResourceQuery = parseURL(__resourceQuery);
+
+if (parsedResourceQuery.hot === "true") {
+  options.hot = true;
+  log.info("Hot Module Replacement enabled.");
+}
+
+if (parsedResourceQuery["live-reload"] === "true") {
+  options.liveReload = true;
+  log.info("Live Reloading enabled.");
+}
+
+if (parsedResourceQuery.logging) {
+  options.logging = parsedResourceQuery.logging;
+}
+
+if (typeof parsedResourceQuery.reconnect !== "undefined") {
+  options.reconnect = Number(parsedResourceQuery.reconnect);
+}
+/**
+ * @param {string} level
+ */
+
+
+function setAllLogLevel(level) {
+  // This is needed because the HMR logger operate separately from dev server logger
+  webpackHotLog.setLogLevel(level === "verbose" || level === "log" ? "info" : level);
+  setLogLevel(level);
+}
+
+if (options.logging) {
+  setAllLogLevel(options.logging);
+}
+
+self.addEventListener("beforeunload", function () {
+  status.isUnloading = true;
+});
+var onSocketMessage = {
+  hot: function hot() {
+    if (parsedResourceQuery.hot === "false") {
+      return;
+    }
+
+    options.hot = true;
+    log.info("Hot Module Replacement enabled.");
+  },
+  liveReload: function liveReload() {
+    if (parsedResourceQuery["live-reload"] === "false") {
+      return;
+    }
+
+    options.liveReload = true;
+    log.info("Live Reloading enabled.");
+  },
+  invalid: function invalid() {
+    log.info("App updated. Recompiling..."); // Fixes #1042. overlay doesn't clear if errors are fixed but warnings remain.
+
+    if (options.overlay) {
+      hide();
+    }
+
+    sendMessage("Invalid");
+  },
+
+  /**
+   * @param {string} hash
+   */
+  hash: function hash(_hash) {
+    status.previousHash = status.currentHash;
+    status.currentHash = _hash;
+  },
+  logging: setAllLogLevel,
+
+  /**
+   * @param {boolean} value
+   */
+  overlay: function overlay(value) {
+    if (typeof document === "undefined") {
+      return;
+    }
+
+    options.overlay = value;
+  },
+
+  /**
+   * @param {number} value
+   */
+  reconnect: function reconnect(value) {
+    if (parsedResourceQuery.reconnect === "false") {
+      return;
+    }
+
+    options.reconnect = value;
+  },
+
+  /**
+   * @param {boolean} value
+   */
+  progress: function progress(value) {
+    options.progress = value;
+  },
+
+  /**
+   * @param {{ pluginName?: string, percent: number, msg: string }} data
+   */
+  "progress-update": function progressUpdate(data) {
+    if (options.progress) {
+      log.info("".concat(data.pluginName ? "[".concat(data.pluginName, "] ") : "").concat(data.percent, "% - ").concat(data.msg, "."));
+    }
+
+    sendMessage("Progress", data);
+  },
+  "still-ok": function stillOk() {
+    log.info("Nothing changed.");
+
+    if (options.overlay) {
+      hide();
+    }
+
+    sendMessage("StillOk");
+  },
+  ok: function ok() {
+    sendMessage("Ok");
+
+    if (options.overlay) {
+      hide();
+    }
+
+    reloadApp(options, status);
+  },
+  // TODO: remove in v5 in favor of 'static-changed'
+
+  /**
+   * @param {string} file
+   */
+  "content-changed": function contentChanged(file) {
+    log.info("".concat(file ? "\"".concat(file, "\"") : "Content", " from static directory was changed. Reloading..."));
+    self.location.reload();
+  },
+
+  /**
+   * @param {string} file
+   */
+  "static-changed": function staticChanged(file) {
+    log.info("".concat(file ? "\"".concat(file, "\"") : "Content", " from static directory was changed. Reloading..."));
+    self.location.reload();
+  },
+
+  /**
+   * @param {Error[]} warnings
+   * @param {any} params
+   */
+  warnings: function warnings(_warnings, params) {
+    log.warn("Warnings while compiling.");
+
+    var printableWarnings = _warnings.map(function (error) {
+      var _formatProblem = formatProblem("warning", error),
+          header = _formatProblem.header,
+          body = _formatProblem.body;
+
+      return "".concat(header, "\n").concat(stripAnsi(body));
+    });
+
+    sendMessage("Warnings", printableWarnings);
+
+    for (var i = 0; i < printableWarnings.length; i++) {
+      log.warn(printableWarnings[i]);
+    }
+
+    var needShowOverlayForWarnings = typeof options.overlay === "boolean" ? options.overlay : options.overlay && options.overlay.warnings;
+
+    if (needShowOverlayForWarnings) {
+      show("warning", _warnings);
+    }
+
+    if (params && params.preventReloading) {
+      return;
+    }
+
+    reloadApp(options, status);
+  },
+
+  /**
+   * @param {Error[]} errors
+   */
+  errors: function errors(_errors) {
+    log.error("Errors while compiling. Reload prevented.");
+
+    var printableErrors = _errors.map(function (error) {
+      var _formatProblem2 = formatProblem("error", error),
+          header = _formatProblem2.header,
+          body = _formatProblem2.body;
+
+      return "".concat(header, "\n").concat(stripAnsi(body));
+    });
+
+    sendMessage("Errors", printableErrors);
+
+    for (var i = 0; i < printableErrors.length; i++) {
+      log.error(printableErrors[i]);
+    }
+
+    var needShowOverlayForErrors = typeof options.overlay === "boolean" ? options.overlay : options.overlay && options.overlay.errors;
+
+    if (needShowOverlayForErrors) {
+      show("error", _errors);
+    }
+  },
+
+  /**
+   * @param {Error} error
+   */
+  error: function error(_error) {
+    log.error(_error);
+  },
+  close: function close() {
+    log.info("Disconnected!");
+
+    if (options.overlay) {
+      hide();
+    }
+
+    sendMessage("Close");
+  }
+};
+var socketURL = createSocketURL(parsedResourceQuery);
+socket(socketURL, onSocketMessage, options.reconnect);

receipeServer/frontend_old/node_modules/webpack-dev-server/client/modules/logger/index.js

@@ -0,0 +1,828 @@
+/******/ (function() { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "./client-src/modules/logger/SyncBailHookFake.js":
+/*!*******************************************************!*\
+  !*** ./client-src/modules/logger/SyncBailHookFake.js ***!
+  \*******************************************************/
+/***/ (function(module) {
+
+
+/**
+ * Client stub for tapable SyncBailHook
+ */
+
+module.exports = function clientTapableSyncBailHook() {
+  return {
+    call: function call() {}
+  };
+};
+
+/***/ }),
+
+/***/ "./node_modules/webpack/lib/logging/Logger.js":
+/*!****************************************************!*\
+  !*** ./node_modules/webpack/lib/logging/Logger.js ***!
+  \****************************************************/
+/***/ (function(__unused_webpack_module, exports) {
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _iterableToArray(iter) {
+  if (typeof (typeof Symbol !== "undefined" ? Symbol : function (i) { return i; }) !== "undefined" && iter[(typeof Symbol !== "undefined" ? Symbol : function (i) { return i; }).iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) {
+    arr2[i] = arr[i];
+  }
+
+  return arr2;
+}
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+var LogType = Object.freeze({
+  error:
+  /** @type {"error"} */
+  "error",
+  // message, c style arguments
+  warn:
+  /** @type {"warn"} */
+  "warn",
+  // message, c style arguments
+  info:
+  /** @type {"info"} */
+  "info",
+  // message, c style arguments
+  log:
+  /** @type {"log"} */
+  "log",
+  // message, c style arguments
+  debug:
+  /** @type {"debug"} */
+  "debug",
+  // message, c style arguments
+  trace:
+  /** @type {"trace"} */
+  "trace",
+  // no arguments
+  group:
+  /** @type {"group"} */
+  "group",
+  // [label]
+  groupCollapsed:
+  /** @type {"groupCollapsed"} */
+  "groupCollapsed",
+  // [label]
+  groupEnd:
+  /** @type {"groupEnd"} */
+  "groupEnd",
+  // [label]
+  profile:
+  /** @type {"profile"} */
+  "profile",
+  // [profileName]
+  profileEnd:
+  /** @type {"profileEnd"} */
+  "profileEnd",
+  // [profileName]
+  time:
+  /** @type {"time"} */
+  "time",
+  // name, time as [seconds, nanoseconds]
+  clear:
+  /** @type {"clear"} */
+  "clear",
+  // no arguments
+  status:
+  /** @type {"status"} */
+  "status" // message, arguments
+
+});
+exports.LogType = LogType;
+/** @typedef {typeof LogType[keyof typeof LogType]} LogTypeEnum */
+
+var LOG_SYMBOL = (typeof Symbol !== "undefined" ? Symbol : function (i) { return i; })("webpack logger raw log method");
+var TIMERS_SYMBOL = (typeof Symbol !== "undefined" ? Symbol : function (i) { return i; })("webpack logger times");
+var TIMERS_AGGREGATES_SYMBOL = (typeof Symbol !== "undefined" ? Symbol : function (i) { return i; })("webpack logger aggregated times");
+
+var WebpackLogger = /*#__PURE__*/function () {
+  /**
+   * @param {function(LogTypeEnum, any[]=): void} log log function
+   * @param {function(string | function(): string): WebpackLogger} getChildLogger function to create child logger
+   */
+  function WebpackLogger(log, getChildLogger) {
+    _classCallCheck(this, WebpackLogger);
+
+    this[LOG_SYMBOL] = log;
+    this.getChildLogger = getChildLogger;
+  }
+
+  _createClass(WebpackLogger, [{
+    key: "error",
+    value: function error() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      this[LOG_SYMBOL](LogType.error, args);
+    }
+  }, {
+    key: "warn",
+    value: function warn() {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+
+      this[LOG_SYMBOL](LogType.warn, args);
+    }
+  }, {
+    key: "info",
+    value: function info() {
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+
+      this[LOG_SYMBOL](LogType.info, args);
+    }
+  }, {
+    key: "log",
+    value: function log() {
+      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+        args[_key4] = arguments[_key4];
+      }
+
+      this[LOG_SYMBOL](LogType.log, args);
+    }
+  }, {
+    key: "debug",
+    value: function debug() {
+      for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+        args[_key5] = arguments[_key5];
+      }
+
+      this[LOG_SYMBOL](LogType.debug, args);
+    }
+  }, {
+    key: "assert",
+    value: function assert(assertion) {
+      if (!assertion) {
+        for (var _len6 = arguments.length, args = new Array(_len6 > 1 ? _len6 - 1 : 0), _key6 = 1; _key6 < _len6; _key6++) {
+          args[_key6 - 1] = arguments[_key6];
+        }
+
+        this[LOG_SYMBOL](LogType.error, args);
+      }
+    }
+  }, {
+    key: "trace",
+    value: function trace() {
+      this[LOG_SYMBOL](LogType.trace, ["Trace"]);
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this[LOG_SYMBOL](LogType.clear);
+    }
+  }, {
+    key: "status",
+    value: function status() {
+      for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
+        args[_key7] = arguments[_key7];
+      }
+
+      this[LOG_SYMBOL](LogType.status, args);
+    }
+  }, {
+    key: "group",
+    value: function group() {
+      for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
+        args[_key8] = arguments[_key8];
+      }
+
+      this[LOG_SYMBOL](LogType.group, args);
+    }
+  }, {
+    key: "groupCollapsed",
+    value: function groupCollapsed() {
+      for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
+        args[_key9] = arguments[_key9];
+      }
+
+      this[LOG_SYMBOL](LogType.groupCollapsed, args);
+    }
+  }, {
+    key: "groupEnd",
+    value: function groupEnd() {
+      for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {
+        args[_key10] = arguments[_key10];
+      }
+
+      this[LOG_SYMBOL](LogType.groupEnd, args);
+    }
+  }, {
+    key: "profile",
+    value: function profile(label) {
+      this[LOG_SYMBOL](LogType.profile, [label]);
+    }
+  }, {
+    key: "profileEnd",
+    value: function profileEnd(label) {
+      this[LOG_SYMBOL](LogType.profileEnd, [label]);
+    }
+  }, {
+    key: "time",
+    value: function time(label) {
+      this[TIMERS_SYMBOL] = this[TIMERS_SYMBOL] || new Map();
+      this[TIMERS_SYMBOL].set(label, process.hrtime());
+    }
+  }, {
+    key: "timeLog",
+    value: function timeLog(label) {
+      var prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
+
+      if (!prev) {
+        throw new Error("No such label '".concat(label, "' for WebpackLogger.timeLog()"));
+      }
+
+      var time = process.hrtime(prev);
+      this[LOG_SYMBOL](LogType.time, [label].concat(_toConsumableArray(time)));
+    }
+  }, {
+    key: "timeEnd",
+    value: function timeEnd(label) {
+      var prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
+
+      if (!prev) {
+        throw new Error("No such label '".concat(label, "' for WebpackLogger.timeEnd()"));
+      }
+
+      var time = process.hrtime(prev);
+      this[TIMERS_SYMBOL].delete(label);
+      this[LOG_SYMBOL](LogType.time, [label].concat(_toConsumableArray(time)));
+    }
+  }, {
+    key: "timeAggregate",
+    value: function timeAggregate(label) {
+      var prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
+
+      if (!prev) {
+        throw new Error("No such label '".concat(label, "' for WebpackLogger.timeAggregate()"));
+      }
+
+      var time = process.hrtime(prev);
+      this[TIMERS_SYMBOL].delete(label);
+      this[TIMERS_AGGREGATES_SYMBOL] = this[TIMERS_AGGREGATES_SYMBOL] || new Map();
+      var current = this[TIMERS_AGGREGATES_SYMBOL].get(label);
+
+      if (current !== undefined) {
+        if (time[1] + current[1] > 1e9) {
+          time[0] += current[0] + 1;
+          time[1] = time[1] - 1e9 + current[1];
+        } else {
+          time[0] += current[0];
+          time[1] += current[1];
+        }
+      }
+
+      this[TIMERS_AGGREGATES_SYMBOL].set(label, time);
+    }
+  }, {
+    key: "timeAggregateEnd",
+    value: function timeAggregateEnd(label) {
+      if (this[TIMERS_AGGREGATES_SYMBOL] === undefined) return;
+      var time = this[TIMERS_AGGREGATES_SYMBOL].get(label);
+      if (time === undefined) return;
+      this[TIMERS_AGGREGATES_SYMBOL].delete(label);
+      this[LOG_SYMBOL](LogType.time, [label].concat(_toConsumableArray(time)));
+    }
+  }]);
+
+  return WebpackLogger;
+}();
+
+exports.Logger = WebpackLogger;
+
+/***/ }),
+
+/***/ "./node_modules/webpack/lib/logging/createConsoleLogger.js":
+/*!*****************************************************************!*\
+  !*** ./node_modules/webpack/lib/logging/createConsoleLogger.js ***!
+  \*****************************************************************/
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _iterableToArray(iter) {
+  if (typeof (typeof Symbol !== "undefined" ? Symbol : function (i) { return i; }) !== "undefined" && iter[(typeof Symbol !== "undefined" ? Symbol : function (i) { return i; }).iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) {
+    arr2[i] = arr[i];
+  }
+
+  return arr2;
+}
+
+var _require = __webpack_require__(/*! ./Logger */ "./node_modules/webpack/lib/logging/Logger.js"),
+    LogType = _require.LogType;
+/** @typedef {import("../../declarations/WebpackOptions").FilterItemTypes} FilterItemTypes */
+
+/** @typedef {import("../../declarations/WebpackOptions").FilterTypes} FilterTypes */
+
+/** @typedef {import("./Logger").LogTypeEnum} LogTypeEnum */
+
+/** @typedef {function(string): boolean} FilterFunction */
+
+/**
+ * @typedef {Object} LoggerConsole
+ * @property {function(): void} clear
+ * @property {function(): void} trace
+ * @property {(...args: any[]) => void} info
+ * @property {(...args: any[]) => void} log
+ * @property {(...args: any[]) => void} warn
+ * @property {(...args: any[]) => void} error
+ * @property {(...args: any[]) => void=} debug
+ * @property {(...args: any[]) => void=} group
+ * @property {(...args: any[]) => void=} groupCollapsed
+ * @property {(...args: any[]) => void=} groupEnd
+ * @property {(...args: any[]) => void=} status
+ * @property {(...args: any[]) => void=} profile
+ * @property {(...args: any[]) => void=} profileEnd
+ * @property {(...args: any[]) => void=} logTime
+ */
+
+/**
+ * @typedef {Object} LoggerOptions
+ * @property {false|true|"none"|"error"|"warn"|"info"|"log"|"verbose"} level loglevel
+ * @property {FilterTypes|boolean} debug filter for debug logging
+ * @property {LoggerConsole} console the console to log to
+ */
+
+/**
+ * @param {FilterItemTypes} item an input item
+ * @returns {FilterFunction} filter function
+ */
+
+
+var filterToFunction = function filterToFunction(item) {
+  if (typeof item === "string") {
+    var regExp = new RegExp("[\\\\/]".concat(item.replace( // eslint-disable-next-line no-useless-escape
+    /[-[\]{}()*+?.\\^$|]/g, "\\$&"), "([\\\\/]|$|!|\\?)"));
+    return function (ident) {
+      return regExp.test(ident);
+    };
+  }
+
+  if (item && typeof item === "object" && typeof item.test === "function") {
+    return function (ident) {
+      return item.test(ident);
+    };
+  }
+
+  if (typeof item === "function") {
+    return item;
+  }
+
+  if (typeof item === "boolean") {
+    return function () {
+      return item;
+    };
+  }
+};
+/**
+ * @enum {number}
+ */
+
+
+var LogLevel = {
+  none: 6,
+  false: 6,
+  error: 5,
+  warn: 4,
+  info: 3,
+  log: 2,
+  true: 2,
+  verbose: 1
+};
+/**
+ * @param {LoggerOptions} options options object
+ * @returns {function(string, LogTypeEnum, any[]): void} logging function
+ */
+
+module.exports = function (_ref) {
+  var _ref$level = _ref.level,
+      level = _ref$level === void 0 ? "info" : _ref$level,
+      _ref$debug = _ref.debug,
+      debug = _ref$debug === void 0 ? false : _ref$debug,
+      console = _ref.console;
+  var debugFilters = typeof debug === "boolean" ? [function () {
+    return debug;
+  }] :
+  /** @type {FilterItemTypes[]} */
+  [].concat(debug).map(filterToFunction);
+  /** @type {number} */
+
+  var loglevel = LogLevel["".concat(level)] || 0;
+  /**
+   * @param {string} name name of the logger
+   * @param {LogTypeEnum} type type of the log entry
+   * @param {any[]} args arguments of the log entry
+   * @returns {void}
+   */
+
+  var logger = function logger(name, type, args) {
+    var labeledArgs = function labeledArgs() {
+      if (Array.isArray(args)) {
+        if (args.length > 0 && typeof args[0] === "string") {
+          return ["[".concat(name, "] ").concat(args[0])].concat(_toConsumableArray(args.slice(1)));
+        } else {
+          return ["[".concat(name, "]")].concat(_toConsumableArray(args));
+        }
+      } else {
+        return [];
+      }
+    };
+
+    var debug = debugFilters.some(function (f) {
+      return f(name);
+    });
+
+    switch (type) {
+      case LogType.debug:
+        if (!debug) return; // eslint-disable-next-line node/no-unsupported-features/node-builtins
+
+        if (typeof console.debug === "function") {
+          // eslint-disable-next-line node/no-unsupported-features/node-builtins
+          console.debug.apply(console, _toConsumableArray(labeledArgs()));
+        } else {
+          console.log.apply(console, _toConsumableArray(labeledArgs()));
+        }
+
+        break;
+
+      case LogType.log:
+        if (!debug && loglevel > LogLevel.log) return;
+        console.log.apply(console, _toConsumableArray(labeledArgs()));
+        break;
+
+      case LogType.info:
+        if (!debug && loglevel > LogLevel.info) return;
+        console.info.apply(console, _toConsumableArray(labeledArgs()));
+        break;
+
+      case LogType.warn:
+        if (!debug && loglevel > LogLevel.warn) return;
+        console.warn.apply(console, _toConsumableArray(labeledArgs()));
+        break;
+
+      case LogType.error:
+        if (!debug && loglevel > LogLevel.error) return;
+        console.error.apply(console, _toConsumableArray(labeledArgs()));
+        break;
+
+      case LogType.trace:
+        if (!debug) return;
+        console.trace();
+        break;
+
+      case LogType.groupCollapsed:
+        if (!debug && loglevel > LogLevel.log) return;
+
+        if (!debug && loglevel > LogLevel.verbose) {
+          // eslint-disable-next-line node/no-unsupported-features/node-builtins
+          if (typeof console.groupCollapsed === "function") {
+            // eslint-disable-next-line node/no-unsupported-features/node-builtins
+            console.groupCollapsed.apply(console, _toConsumableArray(labeledArgs()));
+          } else {
+            console.log.apply(console, _toConsumableArray(labeledArgs()));
+          }
+
+          break;
+        }
+
+      // falls through
+
+      case LogType.group:
+        if (!debug && loglevel > LogLevel.log) return; // eslint-disable-next-line node/no-unsupported-features/node-builtins
+
+        if (typeof console.group === "function") {
+          // eslint-disable-next-line node/no-unsupported-features/node-builtins
+          console.group.apply(console, _toConsumableArray(labeledArgs()));
+        } else {
+          console.log.apply(console, _toConsumableArray(labeledArgs()));
+        }
+
+        break;
+
+      case LogType.groupEnd:
+        if (!debug && loglevel > LogLevel.log) return; // eslint-disable-next-line node/no-unsupported-features/node-builtins
+
+        if (typeof console.groupEnd === "function") {
+          // eslint-disable-next-line node/no-unsupported-features/node-builtins
+          console.groupEnd();
+        }
+
+        break;
+
+      case LogType.time:
+        {
+          if (!debug && loglevel > LogLevel.log) return;
+          var ms = args[1] * 1000 + args[2] / 1000000;
+          var msg = "[".concat(name, "] ").concat(args[0], ": ").concat(ms, " ms");
+
+          if (typeof console.logTime === "function") {
+            console.logTime(msg);
+          } else {
+            console.log(msg);
+          }
+
+          break;
+        }
+
+      case LogType.profile:
+        // eslint-disable-next-line node/no-unsupported-features/node-builtins
+        if (typeof console.profile === "function") {
+          // eslint-disable-next-line node/no-unsupported-features/node-builtins
+          console.profile.apply(console, _toConsumableArray(labeledArgs()));
+        }
+
+        break;
+
+      case LogType.profileEnd:
+        // eslint-disable-next-line node/no-unsupported-features/node-builtins
+        if (typeof console.profileEnd === "function") {
+          // eslint-disable-next-line node/no-unsupported-features/node-builtins
+          console.profileEnd.apply(console, _toConsumableArray(labeledArgs()));
+        }
+
+        break;
+
+      case LogType.clear:
+        if (!debug && loglevel > LogLevel.log) return; // eslint-disable-next-line node/no-unsupported-features/node-builtins
+
+        if (typeof console.clear === "function") {
+          // eslint-disable-next-line node/no-unsupported-features/node-builtins
+          console.clear();
+        }
+
+        break;
+
+      case LogType.status:
+        if (!debug && loglevel > LogLevel.info) return;
+
+        if (typeof console.status === "function") {
+          if (args.length === 0) {
+            console.status();
+          } else {
+            console.status.apply(console, _toConsumableArray(labeledArgs()));
+          }
+        } else {
+          if (args.length !== 0) {
+            console.info.apply(console, _toConsumableArray(labeledArgs()));
+          }
+        }
+
+        break;
+
+      default:
+        throw new Error("Unexpected LogType ".concat(type));
+    }
+  };
+
+  return logger;
+};
+
+/***/ }),
+
+/***/ "./node_modules/webpack/lib/logging/runtime.js":
+/*!*****************************************************!*\
+  !*** ./node_modules/webpack/lib/logging/runtime.js ***!
+  \*****************************************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+var SyncBailHook = __webpack_require__(/*! tapable/lib/SyncBailHook */ "./client-src/modules/logger/SyncBailHookFake.js");
+
+var _require = __webpack_require__(/*! ./Logger */ "./node_modules/webpack/lib/logging/Logger.js"),
+    Logger = _require.Logger;
+
+var createConsoleLogger = __webpack_require__(/*! ./createConsoleLogger */ "./node_modules/webpack/lib/logging/createConsoleLogger.js");
+/** @type {createConsoleLogger.LoggerOptions} */
+
+
+var currentDefaultLoggerOptions = {
+  level: "info",
+  debug: false,
+  console: console
+};
+var currentDefaultLogger = createConsoleLogger(currentDefaultLoggerOptions);
+/**
+ * @param {string} name name of the logger
+ * @returns {Logger} a logger
+ */
+
+exports.getLogger = function (name) {
+  return new Logger(function (type, args) {
+    if (exports.hooks.log.call(name, type, args) === undefined) {
+      currentDefaultLogger(name, type, args);
+    }
+  }, function (childName) {
+    return exports.getLogger("".concat(name, "/").concat(childName));
+  });
+};
+/**
+ * @param {createConsoleLogger.LoggerOptions} options new options, merge with old options
+ * @returns {void}
+ */
+
+
+exports.configureDefaultLogger = function (options) {
+  _extends(currentDefaultLoggerOptions, options);
+
+  currentDefaultLogger = createConsoleLogger(currentDefaultLoggerOptions);
+};
+
+exports.hooks = {
+  log: new SyncBailHook(["origin", "type", "args"])
+};
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	!function() {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = function(exports, definition) {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	!function() {
+/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	!function() {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = function(exports) {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+!function() {
+/*!********************************************!*\
+  !*** ./client-src/modules/logger/index.js ***!
+  \********************************************/
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": function() { return /* reexport default export from named module */ webpack_lib_logging_runtime_js__WEBPACK_IMPORTED_MODULE_0__; }
+/* harmony export */ });
+/* harmony import */ var webpack_lib_logging_runtime_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! webpack/lib/logging/runtime.js */ "./node_modules/webpack/lib/logging/runtime.js");
+
+}();
+var __webpack_export_target__ = exports;
+for(var i in __webpack_exports__) __webpack_export_target__[i] = __webpack_exports__[i];
+if(__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, "__esModule", { value: true });
+/******/ })()
+;

receipeServer/frontend_old/node_modules/webpack-dev-server/client/overlay.js

@@ -0,0 +1,197 @@
+// The error overlay is inspired (and mostly copied) from Create React App (https://github.com/facebookincubator/create-react-app)
+// They, in turn, got inspired by webpack-hot-middleware (https://github.com/glenjamin/webpack-hot-middleware).
+import ansiHTML from "ansi-html-community";
+import { encode } from "html-entities";
+var colors = {
+  reset: ["transparent", "transparent"],
+  black: "181818",
+  red: "E36049",
+  green: "B3CB74",
+  yellow: "FFD080",
+  blue: "7CAFC2",
+  magenta: "7FACCA",
+  cyan: "C3C2EF",
+  lightgrey: "EBE7E3",
+  darkgrey: "6D7891"
+};
+/** @type {HTMLIFrameElement | null | undefined} */
+
+var iframeContainerElement;
+/** @type {HTMLDivElement | null | undefined} */
+
+var containerElement;
+/** @type {Array<(element: HTMLDivElement) => void>} */
+
+var onLoadQueue = [];
+ansiHTML.setColors(colors);
+
+function createContainer() {
+  iframeContainerElement = document.createElement("iframe");
+  iframeContainerElement.id = "webpack-dev-server-client-overlay";
+  iframeContainerElement.src = "about:blank";
+  iframeContainerElement.style.position = "fixed";
+  iframeContainerElement.style.left = 0;
+  iframeContainerElement.style.top = 0;
+  iframeContainerElement.style.right = 0;
+  iframeContainerElement.style.bottom = 0;
+  iframeContainerElement.style.width = "100vw";
+  iframeContainerElement.style.height = "100vh";
+  iframeContainerElement.style.border = "none";
+  iframeContainerElement.style.zIndex = 9999999999;
+
+  iframeContainerElement.onload = function () {
+    containerElement =
+    /** @type {Document} */
+
+    /** @type {HTMLIFrameElement} */
+    iframeContainerElement.contentDocument.createElement("div");
+    containerElement.id = "webpack-dev-server-client-overlay-div";
+    containerElement.style.position = "fixed";
+    containerElement.style.boxSizing = "border-box";
+    containerElement.style.left = 0;
+    containerElement.style.top = 0;
+    containerElement.style.right = 0;
+    containerElement.style.bottom = 0;
+    containerElement.style.width = "100vw";
+    containerElement.style.height = "100vh";
+    containerElement.style.backgroundColor = "rgba(0, 0, 0, 0.85)";
+    containerElement.style.color = "#E8E8E8";
+    containerElement.style.fontFamily = "Menlo, Consolas, monospace";
+    containerElement.style.fontSize = "large";
+    containerElement.style.padding = "2rem";
+    containerElement.style.lineHeight = "1.2";
+    containerElement.style.whiteSpace = "pre-wrap";
+    containerElement.style.overflow = "auto";
+    var headerElement = document.createElement("span");
+    headerElement.innerText = "Compiled with problems:";
+    var closeButtonElement = document.createElement("button");
+    closeButtonElement.innerText = "X";
+    closeButtonElement.style.background = "transparent";
+    closeButtonElement.style.border = "none";
+    closeButtonElement.style.fontSize = "20px";
+    closeButtonElement.style.fontWeight = "bold";
+    closeButtonElement.style.color = "white";
+    closeButtonElement.style.cursor = "pointer";
+    closeButtonElement.style.cssFloat = "right"; // @ts-ignore
+
+    closeButtonElement.style.styleFloat = "right";
+    closeButtonElement.addEventListener("click", function () {
+      hide();
+    });
+    containerElement.appendChild(headerElement);
+    containerElement.appendChild(closeButtonElement);
+    containerElement.appendChild(document.createElement("br"));
+    containerElement.appendChild(document.createElement("br"));
+    /** @type {Document} */
+
+    /** @type {HTMLIFrameElement} */
+    iframeContainerElement.contentDocument.body.appendChild(containerElement);
+    onLoadQueue.forEach(function (onLoad) {
+      onLoad(
+      /** @type {HTMLDivElement} */
+      containerElement);
+    });
+    onLoadQueue = [];
+    /** @type {HTMLIFrameElement} */
+
+    iframeContainerElement.onload = null;
+  };
+
+  document.body.appendChild(iframeContainerElement);
+}
+/**
+ * @param {(element: HTMLDivElement) => void} callback
+ */
+
+
+function ensureOverlayExists(callback) {
+  if (containerElement) {
+    // Everything is ready, call the callback right away.
+    callback(containerElement);
+    return;
+  }
+
+  onLoadQueue.push(callback);
+
+  if (iframeContainerElement) {
+    return;
+  }
+
+  createContainer();
+} // Successful compilation.
+
+
+function hide() {
+  if (!iframeContainerElement) {
+    return;
+  } // Clean up and reset internal state.
+
+
+  document.body.removeChild(iframeContainerElement);
+  iframeContainerElement = null;
+  containerElement = null;
+}
+/**
+ * @param {string} type
+ * @param {string  | { file?: string, moduleName?: string, loc?: string, message?: string }} item
+ * @returns {{ header: string, body: string }}
+ */
+
+
+function formatProblem(type, item) {
+  var header = type === "warning" ? "WARNING" : "ERROR";
+  var body = "";
+
+  if (typeof item === "string") {
+    body += item;
+  } else {
+    var file = item.file || ""; // eslint-disable-next-line no-nested-ternary
+
+    var moduleName = item.moduleName ? item.moduleName.indexOf("!") !== -1 ? "".concat(item.moduleName.replace(/^(\s|\S)*!/, ""), " (").concat(item.moduleName, ")") : "".concat(item.moduleName) : "";
+    var loc = item.loc;
+    header += "".concat(moduleName || file ? " in ".concat(moduleName ? "".concat(moduleName).concat(file ? " (".concat(file, ")") : "") : file).concat(loc ? " ".concat(loc) : "") : "");
+    body += item.message || "";
+  }
+
+  return {
+    header: header,
+    body: body
+  };
+} // Compilation with errors (e.g. syntax error or missing modules).
+
+/**
+ * @param {string} type
+ * @param {Array<string  | { file?: string, moduleName?: string, loc?: string, message?: string }>} messages
+ */
+
+
+function show(type, messages) {
+  ensureOverlayExists(function () {
+    messages.forEach(function (message) {
+      var entryElement = document.createElement("div");
+      var typeElement = document.createElement("span");
+
+      var _formatProblem = formatProblem(type, message),
+          header = _formatProblem.header,
+          body = _formatProblem.body;
+
+      typeElement.innerText = header;
+      typeElement.style.color = "#".concat(colors.red); // Make it look similar to our terminal.
+
+      var text = ansiHTML(encode(body));
+      var messageTextNode = document.createElement("div");
+      messageTextNode.innerHTML = text;
+      entryElement.appendChild(typeElement);
+      entryElement.appendChild(document.createElement("br"));
+      entryElement.appendChild(document.createElement("br"));
+      entryElement.appendChild(messageTextNode);
+      entryElement.appendChild(document.createElement("br"));
+      entryElement.appendChild(document.createElement("br"));
+      /** @type {HTMLDivElement} */
+
+      containerElement.appendChild(entryElement);
+    });
+  });
+}
+
+export { formatProblem, show, hide };

receipeServer/frontend_old/node_modules/webpack-dev-server/client/socket.js

@@ -0,0 +1,65 @@
+/* global __webpack_dev_server_client__ */
+import WebSocketClient from "./clients/WebSocketClient.js";
+import { log } from "./utils/log.js"; // this WebsocketClient is here as a default fallback, in case the client is not injected
+
+/* eslint-disable camelcase */
+
+var Client = // eslint-disable-next-line no-nested-ternary
+typeof __webpack_dev_server_client__ !== "undefined" ? typeof __webpack_dev_server_client__.default !== "undefined" ? __webpack_dev_server_client__.default : __webpack_dev_server_client__ : WebSocketClient;
+/* eslint-enable camelcase */
+
+var retries = 0;
+var maxRetries = 10; // Initialized client is exported so external consumers can utilize the same instance
+// It is mutable to enforce singleton
+// eslint-disable-next-line import/no-mutable-exports
+
+export var client = null;
+/**
+ * @param {string} url
+ * @param {{ [handler: string]: (data?: any, params?: any) => any }} handlers
+ * @param {number} [reconnect]
+ */
+
+var socket = function initSocket(url, handlers, reconnect) {
+  client = new Client(url);
+  client.onOpen(function () {
+    retries = 0;
+
+    if (typeof reconnect !== "undefined") {
+      maxRetries = reconnect;
+    }
+  });
+  client.onClose(function () {
+    if (retries === 0) {
+      handlers.close();
+    } // Try to reconnect.
+
+
+    client = null; // After 10 retries stop trying, to prevent logspam.
+
+    if (retries < maxRetries) {
+      // Exponentially increase timeout to reconnect.
+      // Respectfully copied from the package `got`.
+      // eslint-disable-next-line no-restricted-properties
+      var retryInMs = 1000 * Math.pow(2, retries) + Math.random() * 100;
+      retries += 1;
+      log.info("Trying to reconnect...");
+      setTimeout(function () {
+        socket(url, handlers, reconnect);
+      }, retryInMs);
+    }
+  });
+  client.onMessage(
+  /**
+   * @param {any} data
+   */
+  function (data) {
+    var message = JSON.parse(data);
+
+    if (handlers[message.type]) {
+      handlers[message.type](message.data, message.params);
+    }
+  });
+};
+
+export default socket;

receipeServer/frontend_old/node_modules/webpack-dev-server/client/utils/createSocketURL.js

@@ -0,0 +1,137 @@
+/**
+ * @param {{ protocol?: string, auth?: string, hostname?: string, port?: string, pathname?: string, search?: string, hash?: string, slashes?: boolean }} objURL
+ * @returns {string}
+ */
+function format(objURL) {
+  var protocol = objURL.protocol || "";
+
+  if (protocol && !protocol.endsWith(":")) {
+    protocol += ":";
+  }
+
+  var auth = objURL.auth || "";
+
+  if (auth) {
+    auth = encodeURIComponent(auth);
+    auth = auth.replace(/%3A/i, ":");
+    auth += "@";
+  }
+
+  var host = "";
+
+  if (objURL.hostname) {
+    host = auth + (objURL.hostname.indexOf(":") === -1 ? objURL.hostname : "[".concat(objURL.hostname, "]"));
+
+    if (objURL.port) {
+      host += ":".concat(objURL.port);
+    }
+  }
+
+  var pathname = objURL.pathname || "";
+
+  if (objURL.slashes) {
+    host = "//".concat(host || "");
+
+    if (pathname && pathname.charAt(0) !== "/") {
+      pathname = "/".concat(pathname);
+    }
+  } else if (!host) {
+    host = "";
+  }
+
+  var search = objURL.search || "";
+
+  if (search && search.charAt(0) !== "?") {
+    search = "?".concat(search);
+  }
+
+  var hash = objURL.hash || "";
+
+  if (hash && hash.charAt(0) !== "#") {
+    hash = "#".concat(hash);
+  }
+
+  pathname = pathname.replace(/[?#]/g,
+  /**
+   * @param {string} match
+   * @returns {string}
+   */
+  function (match) {
+    return encodeURIComponent(match);
+  });
+  search = search.replace("#", "%23");
+  return "".concat(protocol).concat(host).concat(pathname).concat(search).concat(hash);
+}
+/**
+ * @param {URL & { fromCurrentScript?: boolean }} parsedURL
+ * @returns {string}
+ */
+
+
+function createSocketURL(parsedURL) {
+  var hostname = parsedURL.hostname; // Node.js module parses it as `::`
+  // `new URL(urlString, [baseURLString])` parses it as '[::]'
+
+  var isInAddrAny = hostname === "0.0.0.0" || hostname === "::" || hostname === "[::]"; // why do we need this check?
+  // hostname n/a for file protocol (example, when using electron, ionic)
+  // see: https://github.com/webpack/webpack-dev-server/pull/384
+
+  if (isInAddrAny && self.location.hostname && self.location.protocol.indexOf("http") === 0) {
+    hostname = self.location.hostname;
+  }
+
+  var socketURLProtocol = parsedURL.protocol || self.location.protocol; // When https is used in the app, secure web sockets are always necessary because the browser doesn't accept non-secure web sockets.
+
+  if (socketURLProtocol === "auto:" || hostname && isInAddrAny && self.location.protocol === "https:") {
+    socketURLProtocol = self.location.protocol;
+  }
+
+  socketURLProtocol = socketURLProtocol.replace(/^(?:http|.+-extension|file)/i, "ws");
+  var socketURLAuth = ""; // `new URL(urlString, [baseURLstring])` doesn't have `auth` property
+  // Parse authentication credentials in case we need them
+
+  if (parsedURL.username) {
+    socketURLAuth = parsedURL.username; // Since HTTP basic authentication does not allow empty username,
+    // we only include password if the username is not empty.
+
+    if (parsedURL.password) {
+      // Result: <username>:<password>
+      socketURLAuth = socketURLAuth.concat(":", parsedURL.password);
+    }
+  } // In case the host is a raw IPv6 address, it can be enclosed in
+  // the brackets as the brackets are needed in the final URL string.
+  // Need to remove those as url.format blindly adds its own set of brackets
+  // if the host string contains colons. That would lead to non-working
+  // double brackets (e.g. [[::]]) host
+  //
+  // All of these web socket url params are optionally passed in through resourceQuery,
+  // so we need to fall back to the default if they are not provided
+
+
+  var socketURLHostname = (hostname || self.location.hostname || "localhost").replace(/^\[(.*)\]$/, "$1");
+  var socketURLPort = parsedURL.port;
+
+  if (!socketURLPort || socketURLPort === "0") {
+    socketURLPort = self.location.port;
+  } // If path is provided it'll be passed in via the resourceQuery as a
+  // query param so it has to be parsed out of the querystring in order for the
+  // client to open the socket to the correct location.
+
+
+  var socketURLPathname = "/ws";
+
+  if (parsedURL.pathname && !parsedURL.fromCurrentScript) {
+    socketURLPathname = parsedURL.pathname;
+  }
+
+  return format({
+    protocol: socketURLProtocol,
+    auth: socketURLAuth,
+    hostname: socketURLHostname,
+    port: socketURLPort,
+    pathname: socketURLPathname,
+    slashes: true
+  });
+}
+
+export default createSocketURL;

receipeServer/frontend_old/node_modules/webpack-dev-server/client/utils/getCurrentScriptSource.js

@@ -0,0 +1,26 @@
+/**
+ * @returns {string}
+ */
+function getCurrentScriptSource() {
+  // `document.currentScript` is the most accurate way to find the current script,
+  // but is not supported in all browsers.
+  if (document.currentScript) {
+    return document.currentScript.getAttribute("src");
+  } // Fallback to getting all scripts running in the document.
+
+
+  var scriptElements = document.scripts || [];
+  var scriptElementsWithSrc = Array.prototype.filter.call(scriptElements, function (element) {
+    return element.getAttribute("src");
+  });
+
+  if (scriptElementsWithSrc.length > 0) {
+    var currentScript = scriptElementsWithSrc[scriptElementsWithSrc.length - 1];
+    return currentScript.getAttribute("src");
+  } // Fail as there was no script to use.
+
+
+  throw new Error("[webpack-dev-server] Failed to get current script source.");
+}
+
+export default getCurrentScriptSource;

receipeServer/frontend_old/node_modules/webpack-dev-server/client/utils/log.js

@@ -0,0 +1,20 @@
+import logger from "../modules/logger/index.js";
+var name = "webpack-dev-server"; // default level is set on the client side, so it does not need
+// to be set by the CLI or API
+
+var defaultLevel = "info"; // options new options, merge with old options
+
+/**
+ * @param {false | true | "none" | "error" | "warn" | "info" | "log" | "verbose"} level
+ * @returns {void}
+ */
+
+function setLogLevel(level) {
+  logger.configureDefaultLogger({
+    level: level
+  });
+}
+
+setLogLevel(defaultLevel);
+var log = logger.getLogger(name);
+export { log, setLogLevel };

receipeServer/frontend_old/node_modules/webpack-dev-server/client/utils/parseURL.js

@@ -0,0 +1,41 @@
+import getCurrentScriptSource from "./getCurrentScriptSource.js";
+/**
+ * @param {string} resourceQuery
+ * @returns {{ [key: string]: string | boolean }}
+ */
+
+function parseURL(resourceQuery) {
+  /** @type {{ [key: string]: string }} */
+  var options = {};
+
+  if (typeof resourceQuery === "string" && resourceQuery !== "") {
+    var searchParams = resourceQuery.slice(1).split("&");
+
+    for (var i = 0; i < searchParams.length; i++) {
+      var pair = searchParams[i].split("=");
+      options[pair[0]] = decodeURIComponent(pair[1]);
+    }
+  } else {
+    // Else, get the url from the <script> this file was called with.
+    var scriptSource = getCurrentScriptSource();
+    var scriptSourceURL;
+
+    try {
+      // The placeholder `baseURL` with `window.location.href`,
+      // is to allow parsing of path-relative or protocol-relative URLs,
+      // and will have no effect if `scriptSource` is a fully valid URL.
+      scriptSourceURL = new URL(scriptSource, self.location.href);
+    } catch (error) {// URL parsing failed, do nothing.
+      // We will still proceed to see if we can recover using `resourceQuery`
+    }
+
+    if (scriptSourceURL) {
+      options = scriptSourceURL;
+      options.fromCurrentScript = true;
+    }
+  }
+
+  return options;
+}
+
+export default parseURL;

receipeServer/frontend_old/node_modules/webpack-dev-server/client/utils/reloadApp.js

@@ -0,0 +1,72 @@
+import hotEmitter from "webpack/hot/emitter.js";
+import { log } from "./log.js";
+/** @typedef {import("../index").Options} Options
+/** @typedef {import("../index").Status} Status
+
+/**
+ * @param {Options} options
+ * @param {Status} status
+ */
+
+function reloadApp(_ref, status) {
+  var hot = _ref.hot,
+      liveReload = _ref.liveReload;
+
+  if (status.isUnloading) {
+    return;
+  }
+
+  var currentHash = status.currentHash,
+      previousHash = status.previousHash;
+  var isInitial = currentHash.indexOf(
+  /** @type {string} */
+  previousHash) >= 0;
+
+  if (isInitial) {
+    return;
+  }
+  /**
+   * @param {Window} rootWindow
+   * @param {number} intervalId
+   */
+
+
+  function applyReload(rootWindow, intervalId) {
+    clearInterval(intervalId);
+    log.info("App updated. Reloading...");
+    rootWindow.location.reload();
+  }
+
+  var search = self.location.search.toLowerCase();
+  var allowToHot = search.indexOf("webpack-dev-server-hot=false") === -1;
+  var allowToLiveReload = search.indexOf("webpack-dev-server-live-reload=false") === -1;
+
+  if (hot && allowToHot) {
+    log.info("App hot update...");
+    hotEmitter.emit("webpackHotUpdate", status.currentHash);
+
+    if (typeof self !== "undefined" && self.window) {
+      // broadcast update to window
+      self.postMessage("webpackHotUpdate".concat(status.currentHash), "*");
+    }
+  } // allow refreshing the page only if liveReload isn't disabled
+  else if (liveReload && allowToLiveReload) {
+    var rootWindow = self; // use parent window for reload (in case we're in an iframe with no valid src)
+
+    var intervalId = self.setInterval(function () {
+      if (rootWindow.location.protocol !== "about:") {
+        // reload immediately if protocol is valid
+        applyReload(rootWindow, intervalId);
+      } else {
+        rootWindow = rootWindow.parent;
+
+        if (rootWindow.parent === rootWindow) {
+          // if parent equals current window we've reached the root which would continue forever, so trigger a reload anyways
+          applyReload(rootWindow, intervalId);
+        }
+      }
+    });
+  }
+}
+
+export default reloadApp;

receipeServer/frontend_old/node_modules/webpack-dev-server/client/utils/sendMessage.js

@@ -0,0 +1,17 @@
+/* global __resourceQuery WorkerGlobalScope */
+// Send messages to the outside, so plugins can consume it.
+
+/**
+ * @param {string} type
+ * @param {any} [data]
+ */
+function sendMsg(type, data) {
+  if (typeof self !== "undefined" && (typeof WorkerGlobalScope === "undefined" || !(self instanceof WorkerGlobalScope))) {
+    self.postMessage({
+      type: "webpack".concat(type),
+      data: data
+    }, "*");
+  }
+}
+
+export default sendMsg;

receipeServer/frontend_old/node_modules/webpack-dev-server/client/utils/stripAnsi.js

@@ -0,0 +1,20 @@
+var ansiRegex = new RegExp(["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)", "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"].join("|"), "g");
+/**
+ *
+ * Strip [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) from a string.
+ * Adapted from code originally released by Sindre Sorhus
+ * Licensed the MIT License
+ *
+ * @param {string} string
+ * @return {string}
+ */
+
+function stripAnsi(string) {
+  if (typeof string !== "string") {
+    throw new TypeError("Expected a `string`, got `".concat(typeof string, "`"));
+  }
+
+  return string.replace(ansiRegex, "");
+}
+
+export default stripAnsi;