Mail

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/lib/globals.js

@@ -0,0 +1,22 @@
+/**
+ * Gets current bundle's global scope identifier for React Refresh.
+ * @param {Record<string, string>} runtimeGlobals The Webpack runtime globals.
+ * @returns {string} The React Refresh global scope within the Webpack bundle.
+ */
+module.exports.getRefreshGlobalScope = (runtimeGlobals) => {
+  return `${runtimeGlobals.require || '__webpack_require__'}.$Refresh$`;
+};
+
+/**
+ * Gets current Webpack version according to features on the compiler instance.
+ * @param {import('webpack').Compiler} compiler The current Webpack compiler instance.
+ * @returns {number} The current Webpack version.
+ */
+module.exports.getWebpackVersion = (compiler) => {
+  if (!compiler.hooks) {
+    throw new Error(`[ReactRefreshPlugin] Webpack version is not supported!`);
+  }
+
+  // Webpack v5+ implements compiler caching
+  return 'cache' in compiler ? 5 : 4;
+};

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/lib/index.js

@@ -0,0 +1,367 @@
+const { validate: validateOptions } = require('schema-utils');
+const { getRefreshGlobalScope, getWebpackVersion } = require('./globals');
+const {
+  getAdditionalEntries,
+  getIntegrationEntry,
+  getRefreshGlobal,
+  getSocketIntegration,
+  injectRefreshEntry,
+  injectRefreshLoader,
+  makeRefreshRuntimeModule,
+  normalizeOptions,
+} = require('./utils');
+const schema = require('./options.json');
+
+class ReactRefreshPlugin {
+  /**
+   * @param {import('./types').ReactRefreshPluginOptions} [options] Options for react-refresh-plugin.
+   */
+  constructor(options = {}) {
+    validateOptions(schema, options, {
+      name: 'React Refresh Plugin',
+      baseDataPath: 'options',
+    });
+
+    /**
+     * @readonly
+     * @type {import('./types').NormalizedPluginOptions}
+     */
+    this.options = normalizeOptions(options);
+  }
+
+  /**
+   * Applies the plugin.
+   * @param {import('webpack').Compiler} compiler A webpack compiler object.
+   * @returns {void}
+   */
+  apply(compiler) {
+    // Skip processing in non-development mode, but allow manual force-enabling
+    if (
+      // Webpack do not set process.env.NODE_ENV, so we need to check for mode.
+      // Ref: https://github.com/webpack/webpack/issues/7074
+      (compiler.options.mode !== 'development' ||
+        // We also check for production process.env.NODE_ENV,
+        // in case it was set and mode is non-development (e.g. 'none')
+        (process.env.NODE_ENV && process.env.NODE_ENV === 'production')) &&
+      !this.options.forceEnable
+    ) {
+      return;
+    }
+
+    const webpackVersion = getWebpackVersion(compiler);
+    const logger = compiler.getInfrastructureLogger(this.constructor.name);
+
+    // Get Webpack imports from compiler instance (if available) -
+    // this allow mono-repos to use different versions of Webpack without conflicts.
+    const webpack = compiler.webpack || require('webpack');
+    const {
+      DefinePlugin,
+      EntryDependency,
+      EntryPlugin,
+      ModuleFilenameHelpers,
+      NormalModule,
+      ProvidePlugin,
+      RuntimeGlobals,
+      Template,
+    } = webpack;
+
+    // Inject react-refresh context to all Webpack entry points.
+    // This should create `EntryDependency` objects when available,
+    // and fallback to patching the `entry` object for legacy workflows.
+    const addEntries = getAdditionalEntries({
+      devServer: compiler.options.devServer,
+      options: this.options,
+    });
+    if (EntryPlugin) {
+      // Prepended entries does not care about injection order,
+      // so we can utilise EntryPlugin for simpler logic.
+      addEntries.prependEntries.forEach((entry) => {
+        new EntryPlugin(compiler.context, entry, { name: undefined }).apply(compiler);
+      });
+
+      const integrationEntry = getIntegrationEntry(this.options.overlay.sockIntegration);
+      const socketEntryData = [];
+      compiler.hooks.make.tap(
+        { name: this.constructor.name, stage: Number.POSITIVE_INFINITY },
+        (compilation) => {
+          // Exhaustively search all entries for `integrationEntry`.
+          // If found, mark those entries and the index of `integrationEntry`.
+          for (const [name, entryData] of compilation.entries.entries()) {
+            const index = entryData.dependencies.findIndex(
+              (dep) => dep.request && dep.request.includes(integrationEntry)
+            );
+            if (index !== -1) {
+              socketEntryData.push({ name, index });
+            }
+          }
+        }
+      );
+
+      // Overlay entries need to be injected AFTER integration's entry,
+      // so we will loop through everything in `finishMake` instead of `make`.
+      // This ensures we can traverse all entry points and inject stuff with the correct order.
+      addEntries.overlayEntries.forEach((entry, idx, arr) => {
+        compiler.hooks.finishMake.tapPromise(
+          { name: this.constructor.name, stage: Number.MIN_SAFE_INTEGER + (arr.length - idx - 1) },
+          (compilation) => {
+            // Only hook into the current compiler
+            if (compilation.compiler !== compiler) {
+              return Promise.resolve();
+            }
+
+            const injectData = socketEntryData.length ? socketEntryData : [{ name: undefined }];
+            return Promise.all(
+              injectData.map(({ name, index }) => {
+                return new Promise((resolve, reject) => {
+                  const options = { name };
+                  const dep = EntryPlugin.createDependency(entry, options);
+                  compilation.addEntry(compiler.context, dep, options, (err) => {
+                    if (err) return reject(err);
+
+                    // If the entry is not a global one,
+                    // and we have registered the index for integration entry,
+                    // we will reorder all entry dependencies to our desired order.
+                    // That is, to have additional entries DIRECTLY behind integration entry.
+                    if (name && typeof index !== 'undefined') {
+                      const entryData = compilation.entries.get(name);
+                      entryData.dependencies.splice(
+                        index + 1,
+                        0,
+                        entryData.dependencies.splice(entryData.dependencies.length - 1, 1)[0]
+                      );
+                    }
+
+                    resolve();
+                  });
+                });
+              })
+            ).then(() => {});
+          }
+        );
+      });
+    } else {
+      compiler.options.entry = injectRefreshEntry(compiler.options.entry, addEntries);
+    }
+
+    // Inject necessary modules and variables to bundle's global scope
+    const refreshGlobal = getRefreshGlobalScope(RuntimeGlobals || {});
+    /** @type {Record<string, string | boolean>}*/
+    const definedModules = {
+      // Mapping of react-refresh globals to Webpack runtime globals
+      $RefreshReg$: `${refreshGlobal}.register`,
+      $RefreshSig$: `${refreshGlobal}.signature`,
+      'typeof $RefreshReg$': 'function',
+      'typeof $RefreshSig$': 'function',
+
+      // Library mode
+      __react_refresh_library__: JSON.stringify(
+        Template.toIdentifier(
+          this.options.library ||
+            compiler.options.output.uniqueName ||
+            compiler.options.output.library
+        )
+      ),
+    };
+    /** @type {Record<string, string>} */
+    const providedModules = {
+      __react_refresh_utils__: require.resolve('./runtime/RefreshUtils'),
+    };
+
+    if (this.options.overlay === false) {
+      // Stub errorOverlay module so their calls can be erased
+      definedModules.__react_refresh_error_overlay__ = false;
+      definedModules.__react_refresh_polyfill_url__ = false;
+      definedModules.__react_refresh_socket__ = false;
+    } else {
+      definedModules.__react_refresh_polyfill_url__ = this.options.overlay.useURLPolyfill || false;
+
+      if (this.options.overlay.module) {
+        providedModules.__react_refresh_error_overlay__ = require.resolve(
+          this.options.overlay.module
+        );
+      }
+      if (this.options.overlay.sockIntegration) {
+        providedModules.__react_refresh_socket__ = getSocketIntegration(
+          this.options.overlay.sockIntegration
+        );
+      }
+    }
+
+    new DefinePlugin(definedModules).apply(compiler);
+    new ProvidePlugin(providedModules).apply(compiler);
+
+    const match = ModuleFilenameHelpers.matchObject.bind(undefined, this.options);
+    let loggedHotWarning = false;
+    compiler.hooks.compilation.tap(
+      this.constructor.name,
+      (compilation, { normalModuleFactory }) => {
+        // Only hook into the current compiler
+        if (compilation.compiler !== compiler) {
+          return;
+        }
+
+        // Tap into version-specific compilation hooks
+        switch (webpackVersion) {
+          case 4: {
+            const outputOptions = compilation.mainTemplate.outputOptions;
+            compilation.mainTemplate.hooks.require.tap(
+              this.constructor.name,
+              // Constructs the module template for react-refresh
+              (source, chunk, hash) => {
+                // Check for the output filename
+                // This is to ensure we are processing a JS-related chunk
+                let filename = outputOptions.filename;
+                if (typeof filename === 'function') {
+                  // Only usage of the `chunk` property is documented by Webpack.
+                  // However, some internal Webpack plugins uses other properties,
+                  // so we also pass them through to be on the safe side.
+                  filename = filename({
+                    contentHashType: 'javascript',
+                    chunk,
+                    hash,
+                  });
+                }
+
+                // Check whether the current compilation is outputting to JS,
+                // since other plugins can trigger compilations for other file types too.
+                // If we apply the transform to them, their compilation will break fatally.
+                // One prominent example of this is the HTMLWebpackPlugin.
+                // If filename is falsy, something is terribly wrong and there's nothing we can do.
+                if (!filename || !filename.includes('.js')) {
+                  return source;
+                }
+
+                // Split template source code into lines for easier processing
+                const lines = source.split('\n');
+                // Webpack generates this line when the MainTemplate is called
+                const moduleInitializationLineNumber = lines.findIndex((line) =>
+                  line.includes('modules[moduleId].call(')
+                );
+                // Unable to find call to module execution -
+                // this happens if the current module does not call MainTemplate.
+                // In this case, we will return the original source and won't mess with it.
+                if (moduleInitializationLineNumber === -1) {
+                  return source;
+                }
+
+                const moduleInterceptor = Template.asString([
+                  `${refreshGlobal}.setup(moduleId);`,
+                  'try {',
+                  Template.indent(lines[moduleInitializationLineNumber]),
+                  '} finally {',
+                  Template.indent(`${refreshGlobal}.cleanup(moduleId);`),
+                  '}',
+                ]);
+
+                return Template.asString([
+                  ...lines.slice(0, moduleInitializationLineNumber),
+                  '',
+                  outputOptions.strictModuleExceptionHandling
+                    ? Template.indent(moduleInterceptor)
+                    : moduleInterceptor,
+                  '',
+                  ...lines.slice(moduleInitializationLineNumber + 1, lines.length),
+                ]);
+              }
+            );
+
+            compilation.mainTemplate.hooks.requireExtensions.tap(
+              this.constructor.name,
+              // Setup react-refresh globals as extensions to Webpack's require function
+              (source) => {
+                return Template.asString([source, '', getRefreshGlobal(Template)]);
+              }
+            );
+
+            normalModuleFactory.hooks.afterResolve.tap(
+              this.constructor.name,
+              // Add react-refresh loader to process files that matches specified criteria
+              (data) => {
+                return injectRefreshLoader(data, {
+                  match,
+                  options: { const: false, esModule: false },
+                });
+              }
+            );
+
+            compilation.hooks.normalModuleLoader.tap(
+              // `Number.POSITIVE_INFINITY` ensures this check will run only after all other taps
+              { name: this.constructor.name, stage: Number.POSITIVE_INFINITY },
+              // Check for existence of the HMR runtime -
+              // it is the foundation to this plugin working correctly
+              (context) => {
+                if (!context.hot && !loggedHotWarning) {
+                  logger.warn(
+                    [
+                      'Hot Module Replacement (HMR) is not enabled!',
+                      'React Refresh requires HMR to function properly.',
+                    ].join(' ')
+                  );
+                  loggedHotWarning = true;
+                }
+              }
+            );
+
+            break;
+          }
+          case 5: {
+            // Set factory for EntryDependency which is used to initialise the module
+            compilation.dependencyFactories.set(EntryDependency, normalModuleFactory);
+
+            const ReactRefreshRuntimeModule = makeRefreshRuntimeModule(webpack);
+            compilation.hooks.additionalTreeRuntimeRequirements.tap(
+              this.constructor.name,
+              // Setup react-refresh globals with a Webpack runtime module
+              (chunk, runtimeRequirements) => {
+                runtimeRequirements.add(RuntimeGlobals.interceptModuleExecution);
+                runtimeRequirements.add(RuntimeGlobals.moduleCache);
+                runtimeRequirements.add(refreshGlobal);
+                compilation.addRuntimeModule(chunk, new ReactRefreshRuntimeModule());
+              }
+            );
+
+            normalModuleFactory.hooks.afterResolve.tap(
+              this.constructor.name,
+              // Add react-refresh loader to process files that matches specified criteria
+              (resolveData) => {
+                injectRefreshLoader(resolveData.createData, {
+                  match,
+                  options: {
+                    const: compilation.runtimeTemplate.supportsConst(),
+                    esModule: this.options.esModule,
+                  },
+                });
+              }
+            );
+
+            NormalModule.getCompilationHooks(compilation).loader.tap(
+              // `Infinity` ensures this check will run only after all other taps
+              { name: this.constructor.name, stage: Infinity },
+              // Check for existence of the HMR runtime -
+              // it is the foundation to this plugin working correctly
+              (context) => {
+                if (!context.hot && !loggedHotWarning) {
+                  logger.warn(
+                    [
+                      'Hot Module Replacement (HMR) is not enabled!',
+                      'React Refresh requires HMR to function properly.',
+                    ].join(' ')
+                  );
+                  loggedHotWarning = true;
+                }
+              }
+            );
+
+            break;
+          }
+          default: {
+            // Do nothing - this should be an impossible case
+          }
+        }
+      }
+    );
+  }
+}
+
+module.exports.ReactRefreshPlugin = ReactRefreshPlugin;
+module.exports = ReactRefreshPlugin;

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/lib/options.json

@@ -0,0 +1,79 @@
+{
+  "additionalProperties": false,
+  "type": "object",
+  "definitions": {
+    "Path": { "type": "string" },
+    "MatchCondition": {
+      "anyOf": [{ "instanceof": "RegExp" }, { "$ref": "#/definitions/Path" }]
+    },
+    "MatchConditions": {
+      "type": "array",
+      "items": { "$ref": "#/definitions/MatchCondition" },
+      "minItems": 1
+    },
+    "ESModuleOptions": {
+      "additionalProperties": false,
+      "type": "object",
+      "properties": {
+        "exclude": {
+          "anyOf": [
+            { "$ref": "#/definitions/MatchCondition" },
+            { "$ref": "#/definitions/MatchConditions" }
+          ]
+        },
+        "include": {
+          "anyOf": [
+            { "$ref": "#/definitions/MatchCondition" },
+            { "$ref": "#/definitions/MatchConditions" }
+          ]
+        }
+      }
+    },
+    "OverlayOptions": {
+      "additionalProperties": false,
+      "type": "object",
+      "properties": {
+        "entry": {
+          "anyOf": [{ "const": false }, { "$ref": "#/definitions/Path" }]
+        },
+        "module": {
+          "anyOf": [{ "const": false }, { "$ref": "#/definitions/Path" }]
+        },
+        "sockIntegration": {
+          "anyOf": [
+            { "const": false },
+            { "enum": ["wds", "whm", "wps"] },
+            { "$ref": "#/definitions/Path" }
+          ]
+        },
+        "sockHost": { "type": "string" },
+        "sockPath": { "type": "string" },
+        "sockPort": { "type": "number", "minimum": 0 },
+        "sockProtocol": { "enum": ["http", "https", "ws", "wss"] },
+        "useURLPolyfill": { "type": "boolean" }
+      }
+    }
+  },
+  "properties": {
+    "esModule": {
+      "anyOf": [{ "type": "boolean" }, { "$ref": "#/definitions/ESModuleOptions" }]
+    },
+    "exclude": {
+      "anyOf": [
+        { "$ref": "#/definitions/MatchCondition" },
+        { "$ref": "#/definitions/MatchConditions" }
+      ]
+    },
+    "forceEnable": { "type": "boolean" },
+    "include": {
+      "anyOf": [
+        { "$ref": "#/definitions/MatchCondition" },
+        { "$ref": "#/definitions/MatchConditions" }
+      ]
+    },
+    "library": { "type": "string" },
+    "overlay": {
+      "anyOf": [{ "type": "boolean" }, { "$ref": "#/definitions/OverlayOptions" }]
+    }
+  }
+}

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/lib/runtime/RefreshUtils.js

@@ -0,0 +1,286 @@
+/* global __webpack_require__ */
+var Refresh = require('react-refresh/runtime');
+
+/**
+ * Extracts exports from a webpack module object.
+ * @param {string} moduleId A Webpack module ID.
+ * @returns {*} An exports object from the module.
+ */
+function getModuleExports(moduleId) {
+  if (typeof moduleId === 'undefined') {
+    // `moduleId` is unavailable, which indicates that this module is not in the cache,
+    // which means we won't be able to capture any exports,
+    // and thus they cannot be refreshed safely.
+    // These are likely runtime or dynamically generated modules.
+    return {};
+  }
+
+  var maybeModule = __webpack_require__.c[moduleId];
+  if (typeof maybeModule === 'undefined') {
+    // `moduleId` is available but the module in cache is unavailable,
+    // which indicates the module is somehow corrupted (e.g. broken Webpacak `module` globals).
+    // We will warn the user (as this is likely a mistake) and assume they cannot be refreshed.
+    console.warn('[React Refresh] Failed to get exports for module: ' + moduleId + '.');
+    return {};
+  }
+
+  var exportsOrPromise = maybeModule.exports;
+  if (typeof Promise !== 'undefined' && exportsOrPromise instanceof Promise) {
+    return exportsOrPromise.then(function (exports) {
+      return exports;
+    });
+  }
+  return exportsOrPromise;
+}
+
+/**
+ * Calculates the signature of a React refresh boundary.
+ * If this signature changes, it's unsafe to accept the boundary.
+ *
+ * This implementation is based on the one in [Metro](https://github.com/facebook/metro/blob/907d6af22ac6ebe58572be418e9253a90665ecbd/packages/metro/src/lib/polyfills/require.js#L795-L816).
+ * @param {*} moduleExports A Webpack module exports object.
+ * @returns {string[]} A React refresh boundary signature array.
+ */
+function getReactRefreshBoundarySignature(moduleExports) {
+  var signature = [];
+  signature.push(Refresh.getFamilyByType(moduleExports));
+
+  if (moduleExports == null || typeof moduleExports !== 'object') {
+    // Exit if we can't iterate over exports.
+    return signature;
+  }
+
+  for (var key in moduleExports) {
+    if (key === '__esModule') {
+      continue;
+    }
+
+    signature.push(key);
+    signature.push(Refresh.getFamilyByType(moduleExports[key]));
+  }
+
+  return signature;
+}
+
+/**
+ * Creates a data object to be retained across refreshes.
+ * This object should not transtively reference previous exports,
+ * which can form infinite chain of objects across refreshes, which can pressure RAM.
+ *
+ * @param {*} moduleExports A Webpack module exports object.
+ * @returns {*} A React refresh boundary signature array.
+ */
+function getWebpackHotData(moduleExports) {
+  return {
+    signature: getReactRefreshBoundarySignature(moduleExports),
+    isReactRefreshBoundary: isReactRefreshBoundary(moduleExports),
+  };
+}
+
+/**
+ * Creates a helper that performs a delayed React refresh.
+ * @returns {function(function(): void): void} A debounced React refresh function.
+ */
+function createDebounceUpdate() {
+  /**
+   * A cached setTimeout handler.
+   * @type {number | undefined}
+   */
+  var refreshTimeout;
+
+  /**
+   * Performs react refresh on a delay and clears the error overlay.
+   * @param {function(): void} callback
+   * @returns {void}
+   */
+  function enqueueUpdate(callback) {
+    if (typeof refreshTimeout === 'undefined') {
+      refreshTimeout = setTimeout(function () {
+        refreshTimeout = undefined;
+        Refresh.performReactRefresh();
+        callback();
+      }, 30);
+    }
+  }
+
+  return enqueueUpdate;
+}
+
+/**
+ * Checks if all exports are likely a React component.
+ *
+ * This implementation is based on the one in [Metro](https://github.com/facebook/metro/blob/febdba2383113c88296c61e28e4ef6a7f4939fda/packages/metro/src/lib/polyfills/require.js#L748-L774).
+ * @param {*} moduleExports A Webpack module exports object.
+ * @returns {boolean} Whether the exports are React component like.
+ */
+function isReactRefreshBoundary(moduleExports) {
+  if (Refresh.isLikelyComponentType(moduleExports)) {
+    return true;
+  }
+  if (moduleExports === undefined || moduleExports === null || typeof moduleExports !== 'object') {
+    // Exit if we can't iterate over exports.
+    return false;
+  }
+
+  var hasExports = false;
+  var areAllExportsComponents = true;
+  for (var key in moduleExports) {
+    hasExports = true;
+
+    // This is the ES Module indicator flag
+    if (key === '__esModule') {
+      continue;
+    }
+
+    // We can (and have to) safely execute getters here,
+    // as Webpack manually assigns harmony exports to getters,
+    // without any side-effects attached.
+    // Ref: https://github.com/webpack/webpack/blob/b93048643fe74de2a6931755911da1212df55897/lib/MainTemplate.js#L281
+    var exportValue = moduleExports[key];
+    if (!Refresh.isLikelyComponentType(exportValue)) {
+      areAllExportsComponents = false;
+    }
+  }
+
+  return hasExports && areAllExportsComponents;
+}
+
+/**
+ * Checks if exports are likely a React component and registers them.
+ *
+ * This implementation is based on the one in [Metro](https://github.com/facebook/metro/blob/febdba2383113c88296c61e28e4ef6a7f4939fda/packages/metro/src/lib/polyfills/require.js#L818-L835).
+ * @param {*} moduleExports A Webpack module exports object.
+ * @param {string} moduleId A Webpack module ID.
+ * @returns {void}
+ */
+function registerExportsForReactRefresh(moduleExports, moduleId) {
+  if (Refresh.isLikelyComponentType(moduleExports)) {
+    // Register module.exports if it is likely a component
+    Refresh.register(moduleExports, moduleId + ' %exports%');
+  }
+
+  if (moduleExports === undefined || moduleExports === null || typeof moduleExports !== 'object') {
+    // Exit if we can't iterate over the exports.
+    return;
+  }
+
+  for (var key in moduleExports) {
+    // Skip registering the ES Module indicator
+    if (key === '__esModule') {
+      continue;
+    }
+
+    var exportValue = moduleExports[key];
+    if (Refresh.isLikelyComponentType(exportValue)) {
+      var typeID = moduleId + ' %exports% ' + key;
+      Refresh.register(exportValue, typeID);
+    }
+  }
+}
+
+/**
+ * Compares previous and next module objects to check for mutated boundaries.
+ *
+ * This implementation is based on the one in [Metro](https://github.com/facebook/metro/blob/907d6af22ac6ebe58572be418e9253a90665ecbd/packages/metro/src/lib/polyfills/require.js#L776-L792).
+ * @param {*} prevSignature The signature of the current Webpack module exports object.
+ * @param {*} nextSignature The signature of the next Webpack module exports object.
+ * @returns {boolean} Whether the React refresh boundary should be invalidated.
+ */
+function shouldInvalidateReactRefreshBoundary(prevSignature, nextSignature) {
+  if (prevSignature.length !== nextSignature.length) {
+    return true;
+  }
+
+  for (var i = 0; i < nextSignature.length; i += 1) {
+    if (prevSignature[i] !== nextSignature[i]) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+var enqueueUpdate = createDebounceUpdate();
+function executeRuntime(moduleExports, moduleId, webpackHot, refreshOverlay, isTest) {
+  registerExportsForReactRefresh(moduleExports, moduleId);
+
+  if (webpackHot) {
+    var isHotUpdate = !!webpackHot.data;
+    var prevData;
+    if (isHotUpdate) {
+      prevData = webpackHot.data.prevData;
+    }
+
+    if (isReactRefreshBoundary(moduleExports)) {
+      webpackHot.dispose(
+        /**
+         * A callback to performs a full refresh if React has unrecoverable errors,
+         * and also caches the to-be-disposed module.
+         * @param {*} data A hot module data object from Webpack HMR.
+         * @returns {void}
+         */
+        function hotDisposeCallback(data) {
+          // We have to mutate the data object to get data registered and cached
+          data.prevData = getWebpackHotData(moduleExports);
+        }
+      );
+      webpackHot.accept(
+        /**
+         * An error handler to allow self-recovering behaviours.
+         * @param {Error} error An error occurred during evaluation of a module.
+         * @returns {void}
+         */
+        function hotErrorHandler(error) {
+          if (typeof refreshOverlay !== 'undefined' && refreshOverlay) {
+            refreshOverlay.handleRuntimeError(error);
+          }
+
+          if (typeof isTest !== 'undefined' && isTest) {
+            if (window.onHotAcceptError) {
+              window.onHotAcceptError(error.message);
+            }
+          }
+
+          __webpack_require__.c[moduleId].hot.accept(hotErrorHandler);
+        }
+      );
+
+      if (isHotUpdate) {
+        if (
+          prevData &&
+          prevData.isReactRefreshBoundary &&
+          shouldInvalidateReactRefreshBoundary(
+            prevData.signature,
+            getReactRefreshBoundarySignature(moduleExports)
+          )
+        ) {
+          webpackHot.invalidate();
+        } else {
+          enqueueUpdate(
+            /**
+             * A function to dismiss the error overlay after performing React refresh.
+             * @returns {void}
+             */
+            function updateCallback() {
+              if (typeof refreshOverlay !== 'undefined' && refreshOverlay) {
+                refreshOverlay.clearRuntimeErrors();
+              }
+            }
+          );
+        }
+      }
+    } else {
+      if (isHotUpdate && typeof prevData !== 'undefined') {
+        webpackHot.invalidate();
+      }
+    }
+  }
+}
+
+module.exports = Object.freeze({
+  enqueueUpdate: enqueueUpdate,
+  executeRuntime: executeRuntime,
+  getModuleExports: getModuleExports,
+  isReactRefreshBoundary: isReactRefreshBoundary,
+  registerExportsForReactRefresh: registerExportsForReactRefresh,
+});

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/lib/types.js

@@ -0,0 +1,36 @@
+/**
+ * @typedef {Object} ErrorOverlayOptions
+ * @property {string | false} [entry] Path to a JS file that sets up the error overlay integration.
+ * @property {string | false} [module] The error overlay module to use.
+ * @property {string} [sockHost] The socket host to use (WDS only).
+ * @property {import('type-fest').LiteralUnion<'wds' | 'whm' | 'wps' | false, string>} [sockIntegration] Path to a JS file that sets up the Webpack socket integration.
+ * @property {string} [sockPath] The socket path to use (WDS only).
+ * @property {number} [sockPort] The socket port to use (WDS only).
+ * @property {'http' | 'https' | 'ws' | 'wss'} [sockProtocol] The socket protocol to use (WDS only).
+ * @property {boolean} [useURLPolyfill] Uses a polyfill for the DOM URL API (WDS only).
+ */
+
+/**
+ * @typedef {import('type-fest').SetRequired<ErrorOverlayOptions, 'entry' | 'module' | 'sockIntegration'>} NormalizedErrorOverlayOptions
+ */
+
+/**
+ * @typedef {Object} ReactRefreshPluginOptions
+ * @property {boolean | import('../loader/types').ESModuleOptions} [esModule] Enables strict ES Modules compatible runtime.
+ * @property {string | RegExp | Array<string | RegExp>} [exclude] Files to explicitly exclude from processing.
+ * @property {boolean} [forceEnable] Enables the plugin forcefully.
+ * @property {string | RegExp | Array<string | RegExp>} [include] Files to explicitly include for processing.
+ * @property {string} [library] Name of the library bundle.
+ * @property {boolean | ErrorOverlayOptions} [overlay] Modifies how the error overlay integration works in the plugin.
+ */
+
+/**
+ * @typedef {Object} OverlayOverrides
+ * @property {false | NormalizedErrorOverlayOptions} overlay Modifies how the error overlay integration works in the plugin.
+ */
+
+/**
+ * @typedef {import('type-fest').SetRequired<import('type-fest').Except<ReactRefreshPluginOptions, 'overlay'>, 'exclude' | 'include'> & OverlayOverrides} NormalizedPluginOptions
+ */
+
+module.exports = {};

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/lib/utils/getAdditionalEntries.js

@@ -0,0 +1,95 @@
+const querystring = require('querystring');
+
+/**
+ * @typedef {Object} AdditionalEntries
+ * @property {string[]} prependEntries
+ * @property {string[]} overlayEntries
+ */
+
+/**
+ * Creates an object that contains two entry arrays: the prependEntries and overlayEntries
+ * @param {Object} optionsContainer This is the container for the options to this function
+ * @param {import('../types').NormalizedPluginOptions} optionsContainer.options Configuration options for this plugin.
+ * @param {import('webpack').Compiler["options"]["devServer"]} [optionsContainer.devServer] The webpack devServer config
+ * @returns {AdditionalEntries} An object that contains the Webpack entries for prepending and the overlay feature
+ */
+function getAdditionalEntries({ devServer, options }) {
+  /** @type {Record<string, string | number>} */
+  let resourceQuery = {};
+
+  if (devServer) {
+    const { client, https, http2, sockHost, sockPath, sockPort } = devServer;
+    let { host, path, port } = devServer;
+
+    let protocol = https || http2 ? 'https' : 'http';
+    if (sockHost) host = sockHost;
+    if (sockPath) path = sockPath;
+    if (sockPort) port = sockPort;
+
+    if (client && client.webSocketURL != null) {
+      let parsedUrl = client.webSocketURL;
+      if (typeof parsedUrl === 'string') parsedUrl = new URL(parsedUrl);
+
+      let auth;
+      if (parsedUrl.username) {
+        auth = parsedUrl.username;
+        if (parsedUrl.password) {
+          auth += ':' + parsedUrl.password;
+        }
+      }
+
+      if (parsedUrl.hostname != null) {
+        host = [auth != null && auth, parsedUrl.hostname].filter(Boolean).join('@');
+      }
+      if (parsedUrl.pathname != null) {
+        path = parsedUrl.pathname;
+      }
+      if (parsedUrl.port != null) {
+        port = !['0', 'auto'].includes(String(parsedUrl.port)) ? parsedUrl.port : undefined;
+      }
+      if (parsedUrl.protocol != null) {
+        protocol = parsedUrl.protocol !== 'auto' ? parsedUrl.protocol.replace(':', '') : 'ws';
+      }
+    }
+
+    if (host) resourceQuery.sockHost = host;
+    if (path) resourceQuery.sockPath = path;
+    if (port) resourceQuery.sockPort = port;
+    resourceQuery.sockProtocol = protocol;
+  }
+
+  if (options.overlay) {
+    const { sockHost, sockPath, sockPort, sockProtocol } = options.overlay;
+    if (sockHost) resourceQuery.sockHost = sockHost;
+    if (sockPath) resourceQuery.sockPath = sockPath;
+    if (sockPort) resourceQuery.sockPort = sockPort;
+    if (sockProtocol) resourceQuery.sockProtocol = sockProtocol;
+  }
+
+  // We don't need to URI encode the resourceQuery as it will be parsed by Webpack
+  const queryString = querystring.stringify(resourceQuery, undefined, undefined, {
+    /**
+     * @param {string} string
+     * @returns {string}
+     */
+    encodeURIComponent(string) {
+      return string;
+    },
+  });
+
+  const prependEntries = [
+    // React-refresh runtime
+    require.resolve('../../client/ReactRefreshEntry'),
+  ];
+
+  const overlayEntries = [
+    // Error overlay runtime
+    options.overlay &&
+      options.overlay.entry &&
+      `${require.resolve(options.overlay.entry)}${queryString ? `?${queryString}` : ''}`,
+  ].filter(Boolean);
+
+  return { prependEntries, overlayEntries };
+}
+
+module.exports = getAdditionalEntries;

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/lib/utils/getIntegrationEntry.js

@@ -0,0 +1,22 @@
+/**
+ * Gets entry point of a supported socket integration.
+ * @param {'wds' | 'whm' | 'wps' | string} integrationType A valid socket integration type or a path to a module.
+ * @returns {string | undefined} Path to the resolved integration entry point.
+ */
+function getIntegrationEntry(integrationType) {
+  let resolvedEntry;
+  switch (integrationType) {
+    case 'whm': {
+      resolvedEntry = 'webpack-hot-middleware/client';
+      break;
+    }
+    case 'wps': {
+      resolvedEntry = 'webpack-plugin-serve/client';
+      break;
+    }
+  }
+
+  return resolvedEntry;
+}
+
+module.exports = getIntegrationEntry;

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/lib/utils/getRefreshGlobal.js

@@ -0,0 +1,96 @@
+const { getRefreshGlobalScope } = require('../globals');
+
+/**
+ * @typedef {Object} RuntimeTemplate
+ * @property {function(string, string[]): string} basicFunction
+ * @property {function(): boolean} supportsConst
+ * @property {function(string, string=): string} returningFunction
+ */
+
+/**
+ * Generates the refresh global runtime template.
+ * @param {import('webpack').Template} Template The template helpers.
+ * @param {Record<string, string>} [RuntimeGlobals] The runtime globals.
+ * @param {RuntimeTemplate} [RuntimeTemplate] The runtime template helpers.
+ * @returns {string} The refresh global runtime template.
+ */
+function getRefreshGlobal(
+  Template,
+  RuntimeGlobals = {},
+  RuntimeTemplate = {
+    basicFunction(args, body) {
+      return `function(${args}) {\n${Template.indent(body)}\n}`;
+    },
+    supportsConst() {
+      return false;
+    },
+    returningFunction(returnValue, args = '') {
+      return `function(${args}) { return ${returnValue}; }`;
+    },
+  }
+) {
+  const declaration = RuntimeTemplate.supportsConst() ? 'const' : 'var';
+  const refreshGlobal = getRefreshGlobalScope(RuntimeGlobals);
+  return Template.asString([
+    `${refreshGlobal} = {`,
+    Template.indent([
+      // Lifecycle methods - They should be specific per module and restored after module execution.
+      // These stubs ensure unwanted calls (e.g. unsupported patterns, broken transform) would not error out.
+      // If the current module is processed by our loader,
+      // they will be swapped in place during module initialisation by the `setup` method below.
+      `register: ${RuntimeTemplate.returningFunction('undefined')},`,
+      `signature: ${RuntimeTemplate.returningFunction(
+        RuntimeTemplate.returningFunction('type', 'type')
+      )},`,
+      // Runtime - This should be a singleton and persist throughout the lifetime of the app.
+      // This stub ensures calls to `runtime` would not error out.
+      // If any module within the bundle is processed by our loader,
+      // it will be swapped in place via an injected import.
+      'runtime: {',
+      Template.indent([
+        `createSignatureFunctionForTransform: ${RuntimeTemplate.returningFunction(
+          RuntimeTemplate.returningFunction('type', 'type')
+        )},`,
+        `register: ${RuntimeTemplate.returningFunction('undefined')}`,
+      ]),
+      '},',
+      // Setup - This handles initialisation of the global runtime.
+      // It should never be touched throughout the lifetime of the app.
+      `setup: ${RuntimeTemplate.basicFunction('currentModuleId', [
+        // Store all previous values for fields on `refreshGlobal` -
+        // this allows proper restoration in the `cleanup` phase.
+        `${declaration} prevModuleId = ${refreshGlobal}.moduleId;`,
+        `${declaration} prevRegister = ${refreshGlobal}.register;`,
+        `${declaration} prevSignature = ${refreshGlobal}.signature;`,
+        `${declaration} prevCleanup = ${refreshGlobal}.cleanup;`,
+        '',
+        `${refreshGlobal}.moduleId = currentModuleId;`,
+        '',
+        `${refreshGlobal}.register = ${RuntimeTemplate.basicFunction('type, id', [
+          `${declaration} typeId = currentModuleId + " " + id;`,
+          `${refreshGlobal}.runtime.register(type, typeId);`,
+        ])}`,
+        '',
+        `${refreshGlobal}.signature = ${RuntimeTemplate.returningFunction(
+          `${refreshGlobal}.runtime.createSignatureFunctionForTransform()`
+        )};`,
+        '',
+        `${refreshGlobal}.cleanup = ${RuntimeTemplate.basicFunction('cleanupModuleId', [
+          // Only cleanup if the module IDs match.
+          // In rare cases, it might get called in another module's `cleanup` phase.
+          'if (currentModuleId === cleanupModuleId) {',
+          Template.indent([
+            `${refreshGlobal}.moduleId = prevModuleId;`,
+            `${refreshGlobal}.register = prevRegister;`,
+            `${refreshGlobal}.signature = prevSignature;`,
+            `${refreshGlobal}.cleanup = prevCleanup;`,
+          ]),
+          '}',
+        ])}`,
+      ])}`,
+    ]),
+    '};',
+  ]);
+}
+
+module.exports = getRefreshGlobal;

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/lib/utils/getSocketIntegration.js

@@ -0,0 +1,30 @@
+/**
+ * Gets the socket integration to use for Webpack messages.
+ * @param {'wds' | 'whm' | 'wps' | string} integrationType A valid socket integration type or a path to a module.
+ * @returns {string} Path to the resolved socket integration module.
+ */
+function getSocketIntegration(integrationType) {
+  let resolvedSocketIntegration;
+  switch (integrationType) {
+    case 'wds': {
+      resolvedSocketIntegration = require.resolve('../../sockets/WDSSocket');
+      break;
+    }
+    case 'whm': {
+      resolvedSocketIntegration = require.resolve('../../sockets/WHMEventSource');
+      break;
+    }
+    case 'wps': {
+      resolvedSocketIntegration = require.resolve('../../sockets/WPSSocket');
+      break;
+    }
+    default: {
+      resolvedSocketIntegration = require.resolve(integrationType);
+      break;
+    }
+  }
+
+  return resolvedSocketIntegration;
+}
+
+module.exports = getSocketIntegration;

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/lib/utils/index.js

@@ -0,0 +1,19 @@
+const getAdditionalEntries = require('./getAdditionalEntries');
+const getIntegrationEntry = require('./getIntegrationEntry');
+const getRefreshGlobal = require('./getRefreshGlobal');
+const getSocketIntegration = require('./getSocketIntegration');
+const injectRefreshEntry = require('./injectRefreshEntry');
+const injectRefreshLoader = require('./injectRefreshLoader');
+const makeRefreshRuntimeModule = require('./makeRefreshRuntimeModule');
+const normalizeOptions = require('./normalizeOptions');
+
+module.exports = {
+  getAdditionalEntries,
+  getIntegrationEntry,
+  getRefreshGlobal,
+  getSocketIntegration,
+  injectRefreshEntry,
+  injectRefreshLoader,
+  makeRefreshRuntimeModule,
+  normalizeOptions,
+};

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/lib/utils/injectRefreshEntry.js

@@ -0,0 +1,98 @@
+/** @typedef {string | string[] | import('webpack').Entry} StaticEntry */
+/** @typedef {StaticEntry | import('webpack').EntryFunc} WebpackEntry */
+
+const EntryParseError = new Error(
+  [
+    '[ReactRefreshPlugin]',
+    'Failed to parse the Webpack `entry` object!',
+    'Please ensure the `entry` option in your Webpack config is specified.',
+  ].join(' ')
+);
+
+/**
+ * Webpack entries related to socket integrations.
+ * They have to run before any code that sets up the error overlay.
+ * @type {string[]}
+ */
+const socketEntries = [
+  'webpack-dev-server/client',
+  'webpack-hot-middleware/client',
+  'webpack-plugin-serve/client',
+  'react-dev-utils/webpackHotDevClient',
+];
+
+/**
+ * Checks if a Webpack entry string is related to socket integrations.
+ * @param {string} entry A Webpack entry string.
+ * @returns {boolean} Whether the entry is related to socket integrations.
+ */
+function isSocketEntry(entry) {
+  return socketEntries.some((socketEntry) => entry.includes(socketEntry));
+}
+
+/**
+ * Injects an entry to the bundle for react-refresh.
+ * @param {WebpackEntry} [originalEntry] A Webpack entry object.
+ * @param {import('./getAdditionalEntries').AdditionalEntries} additionalEntries An object that contains the Webpack entries for prepending and the overlay feature
+ * @returns {WebpackEntry} An injected entry object.
+ */
+function injectRefreshEntry(originalEntry, additionalEntries) {
+  const { prependEntries, overlayEntries } = additionalEntries;
+
+  // Single string entry point
+  if (typeof originalEntry === 'string') {
+    if (isSocketEntry(originalEntry)) {
+      return [...prependEntries, originalEntry, ...overlayEntries];
+    }
+
+    return [...prependEntries, ...overlayEntries, originalEntry];
+  }
+  // Single array entry point
+  if (Array.isArray(originalEntry)) {
+    if (originalEntry.length === 0) {
+      throw EntryParseError;
+    }
+
+    const socketEntryIndex = originalEntry.findIndex(isSocketEntry);
+
+    let socketAndPrecedingEntries = [];
+    if (socketEntryIndex !== -1) {
+      socketAndPrecedingEntries = originalEntry.splice(0, socketEntryIndex + 1);
+    }
+
+    return [...prependEntries, ...socketAndPrecedingEntries, ...overlayEntries, ...originalEntry];
+  }
+  // Multiple entry points
+  if (typeof originalEntry === 'object') {
+    const entries = Object.entries(originalEntry);
+    if (entries.length === 0) {
+      throw EntryParseError;
+    }
+
+    return entries.reduce(
+      (acc, [curKey, curEntry]) => ({
+        ...acc,
+        [curKey]:
+          typeof curEntry === 'object' && curEntry.import
+            ? {
+                ...curEntry,
+                import: injectRefreshEntry(curEntry.import, additionalEntries),
+              }
+            : injectRefreshEntry(curEntry, additionalEntries),
+      }),
+      {}
+    );
+  }
+  // Dynamic entry points
+  if (typeof originalEntry === 'function') {
+    return (...args) =>
+      Promise.resolve(originalEntry(...args)).then((resolvedEntry) =>
+        injectRefreshEntry(resolvedEntry, additionalEntries)
+      );
+  }
+
+  throw EntryParseError;
+}
+
+module.exports = injectRefreshEntry;
+module.exports.socketEntries = socketEntries;

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/lib/utils/injectRefreshLoader.js

@@ -0,0 +1,58 @@
+const path = require('path');
+
+/**
+ * @callback MatchObject
+ * @param {string} [str]
+ * @returns {boolean}
+ */
+
+/**
+ * @typedef {Object} InjectLoaderOptions
+ * @property {MatchObject} match A function to include/exclude files to be processed.
+ * @property {import('../../loader/types').ReactRefreshLoaderOptions} [options] Options passed to the loader.
+ */
+
+const resolvedLoader = require.resolve('../../loader');
+const reactRefreshPath = path.dirname(require.resolve('react-refresh'));
+const refreshUtilsPath = path.join(__dirname, '../runtime/RefreshUtils');
+
+/**
+ * Injects refresh loader to all JavaScript-like and user-specified files.
+ * @param {*} moduleData Module factory creation data.
+ * @param {InjectLoaderOptions} injectOptions Options to alter how the loader is injected.
+ * @returns {*} The injected module factory creation data.
+ */
+function injectRefreshLoader(moduleData, injectOptions) {
+  const { match, options } = injectOptions;
+
+  // Include and exclude user-specified files
+  if (!match(moduleData.matchResource || moduleData.resource)) return moduleData;
+  // Include and exclude dynamically generated modules from other loaders
+  if (moduleData.matchResource && !match(moduleData.request)) return moduleData;
+  // Exclude files referenced as assets
+  if (moduleData.type.includes('asset')) return moduleData;
+  // Check to prevent double injection
+  if (moduleData.loaders.find(({ loader }) => loader === resolvedLoader)) return moduleData;
+  // Skip react-refresh and the plugin's runtime utils to prevent self-referencing -
+  // this is useful when using the plugin as a direct dependency,
+  // or when node_modules are specified to be processed.
+  if (
+    moduleData.resource.includes(reactRefreshPath) ||
+    moduleData.resource.includes(refreshUtilsPath)
+  ) {
+    return moduleData;
+  }
+
+  // As we inject runtime code for each module,
+  // it is important to run the injected loader after everything.
+  // This way we can ensure that all code-processing have been done,
+  // and we won't risk breaking tools like Flow or ESLint.
+  moduleData.loaders.unshift({
+    loader: resolvedLoader,
+    options,
+  });
+
+  return moduleData;
+}
+
+module.exports = injectRefreshLoader;

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/lib/utils/makeRefreshRuntimeModule.js

@@ -0,0 +1,96 @@
+/**
+ * Makes a runtime module to intercept module execution for React Refresh.
+ * This module creates an isolated `__webpack_require__` function for each module,
+ * and injects a `$Refresh$` object into it for use by React Refresh.
+ * @param {import('webpack')} webpack The Webpack exports.
+ * @returns {new () => import('webpack').RuntimeModule} The runtime module class.
+ */
+function makeRefreshRuntimeModule(webpack) {
+  return class ReactRefreshRuntimeModule extends webpack.RuntimeModule {
+    constructor() {
+      // Second argument is the `stage` for this runtime module -
+      // we'll use the same stage as Webpack's HMR runtime module for safety.
+      super('react refresh', webpack.RuntimeModule.STAGE_BASIC);
+    }
+
+    /**
+     * @returns {string} runtime code
+     */
+    generate() {
+      if (!this.compilation) throw new Error('Webpack compilation missing!');
+
+      const { runtimeTemplate } = this.compilation;
+      const declareVar = runtimeTemplate.supportsConst() ? 'const' : 'var';
+      return webpack.Template.asString([
+        `${declareVar} setup = ${runtimeTemplate.basicFunction('moduleId', [
+          `${declareVar} refresh = {`,
+          webpack.Template.indent([
+            `moduleId: moduleId,`,
+            `register: ${runtimeTemplate.basicFunction('type, id', [
+              `${declareVar} typeId = moduleId + " " + id;`,
+              `refresh.runtime.register(type, typeId);`,
+            ])},`,
+            `signature: ${runtimeTemplate.returningFunction(
+              'refresh.runtime.createSignatureFunctionForTransform()'
+            )},`,
+            `runtime: {`,
+            webpack.Template.indent([
+              `createSignatureFunctionForTransform: ${runtimeTemplate.returningFunction(
+                runtimeTemplate.returningFunction('type', 'type')
+              )},`,
+              `register: ${runtimeTemplate.emptyFunction()}`,
+            ]),
+            `},`,
+          ]),
+          `};`,
+          `return refresh;`,
+        ])}`,
+        '',
+        `${webpack.RuntimeGlobals.interceptModuleExecution}.push(${runtimeTemplate.basicFunction(
+          'options',
+          [
+            `${declareVar} originalFactory = options.factory;`,
+            // Using a function declaration -
+            // ensures `this` would propagate for modules relying on it
+            `options.factory = function(moduleObject, moduleExports, webpackRequire) {`,
+            webpack.Template.indent([
+              // Our require function delegates to the original require function
+              `${declareVar} hotRequire = ${runtimeTemplate.returningFunction(
+                'webpackRequire(request)',
+                'request'
+              )};`,
+              // The propery descriptor factory below ensures all properties but `$Refresh$`
+              // are proxied through to the original require function
+              `${declareVar} createPropertyDescriptor = ${runtimeTemplate.basicFunction('name', [
+                `return {`,
+                webpack.Template.indent([
+                  `configurable: true,`,
+                  `enumerable: true,`,
+                  `get: ${runtimeTemplate.returningFunction('webpackRequire[name]')},`,
+                  `set: ${runtimeTemplate.basicFunction('value', [
+                    'webpackRequire[name] = value;',
+                  ])},`,
+                ]),
+                `};`,
+              ])};`,
+              `for (${declareVar} name in webpackRequire) {`,
+              webpack.Template.indent([
+                `if (Object.prototype.hasOwnProperty.call(webpackRequire, name) && name !== "$Refresh$") {`,
+                webpack.Template.indent([
+                  `Object.defineProperty(hotRequire, name, createPropertyDescriptor(name));`,
+                ]),
+                `}`,
+              ]),
+              `}`,
+              `hotRequire.$Refresh$ = setup(options.id);`,
+              `originalFactory.call(this, moduleObject, moduleExports, hotRequire);`,
+            ]),
+            '};',
+          ]
+        )});`,
+      ]);
+    }
+  };
+}
+
+module.exports = makeRefreshRuntimeModule;

frontend/node_modules/@pmmmwh/react-refresh-webpack-plugin/lib/utils/normalizeOptions.js

@@ -0,0 +1,44 @@
+const { d, n } = require('../../options');
+
+/**
+ * Normalizes the options for the plugin.
+ * @param {import('../types').ReactRefreshPluginOptions} options Non-normalized plugin options.
+ * @returns {import('../types').NormalizedPluginOptions} Normalized plugin options.
+ */
+const normalizeOptions = (options) => {
+  d(options, 'exclude', /node_modules/i);
+  d(options, 'include', /\.([cm]js|[jt]sx?|flow)$/i);
+  d(options, 'forceEnable');
+  d(options, 'library');
+
+  n(options, 'overlay', (overlay) => {
+    /** @type {import('../types').NormalizedErrorOverlayOptions} */
+    const defaults = {
+      entry: require.resolve('../../client/ErrorOverlayEntry'),
+      module: require.resolve('../../overlay'),
+      sockIntegration: 'wds',
+    };
+
+    if (overlay === false) {
+      return false;
+    }
+    if (typeof overlay === 'undefined' || overlay === true) {
+      return defaults;
+    }
+
+    d(overlay, 'entry', defaults.entry);
+    d(overlay, 'module', defaults.module);
+    d(overlay, 'sockIntegration', defaults.sockIntegration);
+    d(overlay, 'sockHost');
+    d(overlay, 'sockPath');
+    d(overlay, 'sockPort');
+    d(overlay, 'sockProtocol');
+    d(options, 'useURLPolyfill');
+
+    return overlay;
+  });
+
+  return options;
+};
+
+module.exports = normalizeOptions;