Initial commit

node_modules/webpack-dev-middleware/dist/utils/compatibleAPI.js

@@ -0,0 +1,318 @@
+"use strict";
+
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+/** @typedef {import("../index").OutputFileSystem} OutputFileSystem */
+
+/**
+ * @typedef {Object} ExpectedIncomingMessage
+ * @property {(name: string) => string | string[] | undefined} [getHeader]
+ * @property {() => string | undefined} [getMethod]
+ * @property {() => string | undefined} [getURL]
+ */
+
+/**
+ * @typedef {Object} ExpectedServerResponse
+ * @property {(status: number) => void} [setStatusCode]
+ * @property {() => number} [getStatusCode]
+ * @property {(name: string) => string | string[] | undefined | number} [getHeader]
+ * @property {(name: string, value: number | string | Readonly<string[]>) => ExpectedServerResponse} [setHeader]
+ * @property {(name: string) => void} [removeHeader]
+ * @property {(data: string | Buffer) => void} [send]
+ * @property {(data?: string | Buffer) => void} [finish]
+ * @property {() => string[]} [getResponseHeaders]
+ * @property {() => boolean} [getHeadersSent]
+ * @property {(data: any) => void} [stream]
+ * @property {() => any} [getOutgoing]
+ * @property {(name: string, value: any) => void} [setState]
+ * @property {() => "ready" | "open" | "readable"} [getReadyReadableStreamState]
+ */
+
+/**
+ * @template {IncomingMessage & ExpectedIncomingMessage} Request
+ * @param {Request} req
+ * @param {string} name
+ * @returns {string | string[] | undefined}
+ */
+function getRequestHeader(req, name) {
+  // Pseudo API
+  if (typeof req.getHeader === "function") {
+    return req.getHeader(name);
+  }
+  return req.headers[name];
+}
+
+/**
+ * @template {IncomingMessage & ExpectedIncomingMessage} Request
+ * @param {Request} req
+ * @returns {string | undefined}
+ */
+function getRequestMethod(req) {
+  // Pseudo API
+  if (typeof req.getMethod === "function") {
+    return req.getMethod();
+  }
+  return req.method;
+}
+
+/**
+ * @template {IncomingMessage & ExpectedIncomingMessage} Request
+ * @param {Request} req
+ * @returns {string | undefined}
+ */
+function getRequestURL(req) {
+  // Pseudo API
+  if (typeof req.getURL === "function") {
+    return req.getURL();
+  }
+  return req.url;
+}
+
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res
+ * @param {number} code
+ */
+function setStatusCode(res, code) {
+  // Pseudo API
+  if (typeof res.setStatusCode === "function") {
+    res.setStatusCode(code);
+    return;
+  }
+
+  // Node.js API
+  // eslint-disable-next-line no-param-reassign
+  res.statusCode = code;
+}
+
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res
+ * @returns {number}
+ */
+function getStatusCode(res) {
+  // Pseudo API
+  if (typeof res.getStatusCode === "function") {
+    return res.getStatusCode();
+  }
+  return res.statusCode;
+}
+
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res
+ * @param {string} name
+ * @returns {string | string[] | undefined | number}
+ */
+function getResponseHeader(res, name) {
+  // Real and Pseudo API
+  return res.getHeader(name);
+}
+
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res
+ * @param {string} name
+ * @param {number | string | Readonly<string[]>} value
+ * @returns {Response}
+ */
+function setResponseHeader(res, name, value) {
+  // Real and Pseudo API
+  return res.setHeader(name, value);
+}
+
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res
+ * @param {string} name
+ */
+function removeResponseHeader(res, name) {
+  // Real and Pseudo API
+  res.removeHeader(name);
+}
+
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res
+ * @returns {string[]}
+ */
+function getResponseHeaders(res) {
+  // Pseudo API
+  if (typeof res.getResponseHeaders === "function") {
+    return res.getResponseHeaders();
+  }
+  return res.getHeaderNames();
+}
+
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res
+ * @returns {boolean}
+ */
+function getHeadersSent(res) {
+  // Pseudo API
+  if (typeof res.getHeadersSent === "function") {
+    return res.getHeadersSent();
+  }
+  return res.headersSent;
+}
+
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res
+ * @param {import("fs").ReadStream} bufferOrStream
+ */
+function pipe(res, bufferOrStream) {
+  // Pseudo API and Koa API
+  if (typeof res.stream === "function") {
+    // Writable stream into Readable stream
+    res.stream(bufferOrStream);
+    return;
+  }
+
+  // Node.js API and Express API and Hapi API
+  bufferOrStream.pipe(res);
+}
+
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res
+ * @param {string | Buffer} bufferOrString
+ */
+function send(res, bufferOrString) {
+  // Pseudo API and Express API and Koa API
+  if (typeof res.send === "function") {
+    res.send(bufferOrString);
+    return;
+  }
+  res.end(bufferOrString);
+}
+
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res
+ * @param {string | Buffer} [data]
+ */
+function finish(res, data) {
+  // Pseudo API and Express API and Koa API
+  if (typeof res.finish === "function") {
+    res.finish(data);
+    return;
+  }
+
+  // Pseudo API and Express API and Koa API
+  res.end(data);
+}
+
+/**
+ * @param {string} filename
+ * @param {OutputFileSystem} outputFileSystem
+ * @param {number} start
+ * @param {number} end
+ * @returns {{ bufferOrStream: (Buffer | import("fs").ReadStream), byteLength: number }}
+ */
+function createReadStreamOrReadFileSync(filename, outputFileSystem, start, end) {
+  /** @type {string | Buffer | import("fs").ReadStream} */
+  let bufferOrStream;
+  /** @type {number} */
+  let byteLength;
+
+  // Stream logic
+  const isFsSupportsStream = typeof outputFileSystem.createReadStream === "function";
+  if (isFsSupportsStream) {
+    bufferOrStream = /** @type {import("fs").createReadStream} */
+    outputFileSystem.createReadStream(filename, {
+      start,
+      end
+    });
+
+    // Handle files with zero bytes
+    byteLength = end === 0 ? 0 : end - start + 1;
+  } else {
+    bufferOrStream = outputFileSystem.readFileSync(filename);
+    ({
+      byteLength
+    } = bufferOrStream);
+  }
+  return {
+    bufferOrStream,
+    byteLength
+  };
+}
+
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res
+ * @returns {Response} res
+ */
+function getOutgoing(res) {
+  // Pseudo API and Express API and Koa API
+  if (typeof res.getOutgoing === "function") {
+    return res.getOutgoing();
+  }
+  return res;
+}
+
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res
+ */
+function initState(res) {
+  if (typeof res.setState === "function") {
+    return;
+  }
+
+  // fixes #282. credit @cexoso. in certain edge situations res.locals is undefined.
+  // eslint-disable-next-line no-param-reassign
+  res.locals = res.locals || {};
+}
+
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res
+ * @param {string} name
+ * @param {any} value
+ */
+function setState(res, name, value) {
+  if (typeof res.setState === "function") {
+    res.setState(name, value);
+    return;
+  }
+
+  /** @type {any} */
+  // eslint-disable-next-line no-param-reassign
+  res.locals[name] = value;
+}
+
+/**
+ * @template {ServerResponse & ExpectedServerResponse} Response
+ * @param {Response} res
+ * @returns {"ready" | "open" | "readable"}
+ */
+function getReadyReadableStreamState(res) {
+  // Pseudo API and Express API and Koa API
+  if (typeof res.getReadyReadableStreamState === "function") {
+    return res.getReadyReadableStreamState();
+  }
+  return "ready";
+}
+module.exports = {
+  setStatusCode,
+  getStatusCode,
+  getRequestHeader,
+  getRequestMethod,
+  getRequestURL,
+  getResponseHeader,
+  setResponseHeader,
+  removeResponseHeader,
+  getResponseHeaders,
+  getHeadersSent,
+  pipe,
+  send,
+  finish,
+  createReadStreamOrReadFileSync,
+  getOutgoing,
+  initState,
+  setState,
+  getReadyReadableStreamState
+};

node_modules/webpack-dev-middleware/dist/utils/escapeHtml.js

@@ -0,0 +1,55 @@
+"use strict";
+
+const matchHtmlRegExp = /["'&<>]/;
+
+/**
+ * @param {string} string raw HTML
+ * @returns {string} escaped HTML
+ */
+function escapeHtml(string) {
+  const str = `${string}`;
+  const match = matchHtmlRegExp.exec(str);
+  if (!match) {
+    return str;
+  }
+  let escape;
+  let html = "";
+  let index = 0;
+  let lastIndex = 0;
+  for (({
+    index
+  } = match); index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      // "
+      case 34:
+        escape = "&quot;";
+        break;
+      // &
+      case 38:
+        escape = "&amp;";
+        break;
+      // '
+      case 39:
+        escape = "&#39;";
+        break;
+      // <
+      case 60:
+        escape = "&lt;";
+        break;
+      // >
+      case 62:
+        escape = "&gt;";
+        break;
+      default:
+        // eslint-disable-next-line no-continue
+        continue;
+    }
+    if (lastIndex !== index) {
+      html += str.substring(lastIndex, index);
+    }
+    lastIndex = index + 1;
+    html += escape;
+  }
+  return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
+}
+module.exports = escapeHtml;

node_modules/webpack-dev-middleware/dist/utils/etag.js

@@ -0,0 +1,78 @@
+"use strict";
+
+const crypto = require("crypto");
+
+/** @typedef {import("fs").Stats} Stats */
+/** @typedef {import("fs").ReadStream} ReadStream */
+
+/**
+ * Generate a tag for a stat.
+ *
+ * @param {Stats} stat
+ * @return {{ hash: string, buffer?: Buffer }}
+ */
+function statTag(stat) {
+  const mtime = stat.mtime.getTime().toString(16);
+  const size = stat.size.toString(16);
+  return {
+    hash: `W/"${size}-${mtime}"`
+  };
+}
+
+/**
+ * Generate an entity tag.
+ *
+ * @param {Buffer | ReadStream} entity
+ * @return {Promise<{ hash: string, buffer?: Buffer }>}
+ */
+async function entityTag(entity) {
+  const sha1 = crypto.createHash("sha1");
+  if (!Buffer.isBuffer(entity)) {
+    let byteLength = 0;
+
+    /** @type {Buffer[]} */
+    const buffers = [];
+    await new Promise((resolve, reject) => {
+      entity.on("data", chunk => {
+        sha1.update(chunk);
+        buffers.push( /** @type {Buffer} */chunk);
+        byteLength += /** @type {Buffer} */chunk.byteLength;
+      }).on("end", () => {
+        resolve(sha1);
+      }).on("error", reject);
+    });
+    return {
+      buffer: Buffer.concat(buffers),
+      hash: `"${byteLength.toString(16)}-${sha1.digest("base64").substring(0, 27)}"`
+    };
+  }
+  if (entity.byteLength === 0) {
+    // Fast-path empty
+    return {
+      hash: '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"'
+    };
+  }
+
+  // Compute hash of entity
+  const hash = sha1.update(entity).digest("base64").substring(0, 27);
+
+  // Compute length of entity
+  const {
+    byteLength
+  } = entity;
+  return {
+    hash: `"${byteLength.toString(16)}-${hash}"`
+  };
+}
+
+/**
+ * Create a simple ETag.
+ *
+ * @param {Buffer | ReadStream | Stats} entity
+ * @return {Promise<{ hash: string, buffer?: Buffer }>}
+ */
+async function etag(entity) {
+  const isStrong = Buffer.isBuffer(entity) || typeof ( /** @type {ReadStream} */entity.pipe) === "function";
+  return isStrong ? entityTag( /** @type {Buffer | ReadStream} */entity) : statTag( /** @type {import("fs").Stats} */entity);
+}
+module.exports = etag;

node_modules/webpack-dev-middleware/dist/utils/getFilenameFromUrl.js

@@ -0,0 +1,150 @@
+"use strict";
+
+const path = require("path");
+const {
+  parse
+} = require("url");
+const querystring = require("querystring");
+const getPaths = require("./getPaths");
+const memorize = require("./memorize");
+
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+
+// eslint-disable-next-line no-undefined
+const memoizedParse = memorize(parse, undefined, value => {
+  if (value.pathname) {
+    // eslint-disable-next-line no-param-reassign
+    value.pathname = decode(value.pathname);
+  }
+  return value;
+});
+const UP_PATH_REGEXP = /(?:^|[\\/])\.\.(?:[\\/]|$)/;
+
+/**
+ * @typedef {Object} Extra
+ * @property {import("fs").Stats=} stats
+ * @property {number=} errorCode
+ * @property {boolean=} immutable
+ */
+
+/**
+ * decodeURIComponent.
+ *
+ * Allows V8 to only deoptimize this fn instead of all of send().
+ *
+ * @param {string} input
+ * @returns {string}
+ */
+
+function decode(input) {
+  return querystring.unescape(input);
+}
+
+// TODO refactor me in the next major release, this function should return `{ filename, stats, error }`
+// TODO fix redirect logic when `/` at the end, like https://github.com/pillarjs/send/blob/master/index.js#L586
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").FilledContext<Request, Response>} context
+ * @param {string} url
+ * @param {Extra=} extra
+ * @returns {string | undefined}
+ */
+function getFilenameFromUrl(context, url, extra = {}) {
+  const {
+    options
+  } = context;
+  const paths = getPaths(context);
+
+  /** @type {string | undefined} */
+  let foundFilename;
+  /** @type {URL} */
+  let urlObject;
+  try {
+    // The `url` property of the `request` is contains only  `pathname`, `search` and `hash`
+    urlObject = memoizedParse(url, false, true);
+  } catch (_ignoreError) {
+    return;
+  }
+  for (const {
+    publicPath,
+    outputPath,
+    assetsInfo
+  } of paths) {
+    /** @type {string | undefined} */
+    let filename;
+    /** @type {URL} */
+    let publicPathObject;
+    try {
+      publicPathObject = memoizedParse(publicPath !== "auto" && publicPath ? publicPath : "/", false, true);
+    } catch (_ignoreError) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+    const {
+      pathname
+    } = urlObject;
+    const {
+      pathname: publicPathPathname
+    } = publicPathObject;
+    if (pathname && pathname.startsWith(publicPathPathname)) {
+      // Null byte(s)
+      if (pathname.includes("\0")) {
+        // eslint-disable-next-line no-param-reassign
+        extra.errorCode = 400;
+        return;
+      }
+
+      // ".." is malicious
+      if (UP_PATH_REGEXP.test(path.normalize(`./${pathname}`))) {
+        // eslint-disable-next-line no-param-reassign
+        extra.errorCode = 403;
+        return;
+      }
+
+      // Strip the `pathname` property from the `publicPath` option from the start of requested url
+      // `/complex/foo.js` => `foo.js`
+      // and add outputPath
+      // `foo.js` => `/home/user/my-project/dist/foo.js`
+      filename = path.join(outputPath, pathname.slice(publicPathPathname.length));
+      try {
+        // eslint-disable-next-line no-param-reassign
+        extra.stats = context.outputFileSystem.statSync(filename);
+      } catch (_ignoreError) {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+      if (extra.stats.isFile()) {
+        foundFilename = filename;
+
+        // Rspack does not yet support `assetsInfo`, so we need to check if `assetsInfo` exists here
+        if (assetsInfo) {
+          const assetInfo = assetsInfo.get(pathname.slice(publicPathObject.pathname.length));
+
+          // eslint-disable-next-line no-param-reassign
+          extra.immutable = assetInfo ? assetInfo.immutable : false;
+        }
+        break;
+      } else if (extra.stats.isDirectory() && (typeof options.index === "undefined" || options.index)) {
+        const indexValue = typeof options.index === "undefined" || typeof options.index === "boolean" ? "index.html" : options.index;
+        filename = path.join(filename, indexValue);
+        try {
+          // eslint-disable-next-line no-param-reassign
+          extra.stats = context.outputFileSystem.statSync(filename);
+        } catch (__ignoreError) {
+          // eslint-disable-next-line no-continue
+          continue;
+        }
+        if (extra.stats.isFile()) {
+          foundFilename = filename;
+          break;
+        }
+      }
+    }
+  }
+
+  // eslint-disable-next-line consistent-return
+  return foundFilename;
+}
+module.exports = getFilenameFromUrl;

node_modules/webpack-dev-middleware/dist/utils/getPaths.js

@@ -0,0 +1,42 @@
+"use strict";
+
+/** @typedef {import("webpack").Compiler} Compiler */
+/** @typedef {import("webpack").Stats} Stats */
+/** @typedef {import("webpack").MultiStats} MultiStats */
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").FilledContext<Request, Response>} context
+ */
+function getPaths(context) {
+  const {
+    stats,
+    options
+  } = context;
+  /** @type {Stats[]} */
+  const childStats = /** @type {MultiStats} */
+  stats.stats ? /** @type {MultiStats} */stats.stats : [( /** @type {Stats} */stats)];
+  const publicPaths = [];
+  for (const {
+    compilation
+  } of childStats) {
+    if (compilation.options.devServer === false) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+
+    // The `output.path` is always present and always absolute
+    const outputPath = compilation.getPath(compilation.outputOptions.path || "");
+    const publicPath = options.publicPath ? compilation.getPath(options.publicPath) : compilation.outputOptions.publicPath ? compilation.getPath(compilation.outputOptions.publicPath) : "";
+    publicPaths.push({
+      outputPath,
+      publicPath,
+      assetsInfo: compilation.assetsInfo
+    });
+  }
+  return publicPaths;
+}
+module.exports = getPaths;

node_modules/webpack-dev-middleware/dist/utils/memorize.js

@@ -0,0 +1,39 @@
+"use strict";
+
+const cacheStore = new WeakMap();
+
+/**
+ * @template T
+ * @param {Function} fn
+ * @param {{ cache?: Map<string, { data: T }> } | undefined} cache
+ * @param {((value: T) => T)=} callback
+ * @returns {any}
+ */
+function memorize(fn, {
+  cache = new Map()
+} = {}, callback) {
+  /**
+   * @param {any} arguments_
+   * @return {any}
+   */
+  const memoized = (...arguments_) => {
+    const [key] = arguments_;
+    const cacheItem = cache.get(key);
+    if (cacheItem) {
+      return cacheItem.data;
+    }
+
+    // @ts-ignore
+    let result = fn.apply(this, arguments_);
+    if (callback) {
+      result = callback(result);
+    }
+    cache.set(key, {
+      data: result
+    });
+    return result;
+  };
+  cacheStore.set(memoized, cache);
+  return memoized;
+}
+module.exports = memorize;

node_modules/webpack-dev-middleware/dist/utils/parseTokenList.js

@@ -0,0 +1,42 @@
+"use strict";
+
+/**
+ * Parse a HTTP token list.
+ *
+ * @param {string} str
+ * @returns {string[]} tokens
+ */
+function parseTokenList(str) {
+  let end = 0;
+  let start = 0;
+  const list = [];
+
+  // gather tokens
+  for (let i = 0, len = str.length; i < len; i++) {
+    switch (str.charCodeAt(i)) {
+      case 0x20 /*   */:
+        if (start === end) {
+          end = i + 1;
+          start = end;
+        }
+        break;
+      case 0x2c /* , */:
+        if (start !== end) {
+          list.push(str.substring(start, end));
+        }
+        end = i + 1;
+        start = end;
+        break;
+      default:
+        end = i + 1;
+        break;
+    }
+  }
+
+  // final token
+  if (start !== end) {
+    list.push(str.substring(start, end));
+  }
+  return list;
+}
+module.exports = parseTokenList;

node_modules/webpack-dev-middleware/dist/utils/ready.js

@@ -0,0 +1,23 @@
+"use strict";
+
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").FilledContext<Request, Response>} context
+ * @param {(...args: any[]) => any} callback
+ * @param {Request} [req]
+ * @returns {void}
+ */
+function ready(context, callback, req) {
+  if (context.state) {
+    callback(context.stats);
+    return;
+  }
+  const name = req && req.url || callback.name;
+  context.logger.info(`wait until bundle finished${name ? `: ${name}` : ""}`);
+  context.callbacks.push(callback);
+}
+module.exports = ready;

node_modules/webpack-dev-middleware/dist/utils/setupHooks.js

@@ -0,0 +1,153 @@
+"use strict";
+
+/** @typedef {import("webpack").Configuration} Configuration */
+/** @typedef {import("webpack").Compiler} Compiler */
+/** @typedef {import("webpack").MultiCompiler} MultiCompiler */
+/** @typedef {import("webpack").Stats} Stats */
+/** @typedef {import("webpack").MultiStats} MultiStats */
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+
+/** @typedef {Configuration["stats"]} StatsOptions */
+/** @typedef {{ children: Configuration["stats"][] }} MultiStatsOptions */
+/** @typedef {Exclude<Configuration["stats"], boolean | string | undefined>} StatsObjectOptions */
+
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").WithOptional<import("../index.js").Context<Request, Response>, "watching" | "outputFileSystem">} context
+ */
+function setupHooks(context) {
+  function invalid() {
+    if (context.state) {
+      context.logger.log("Compilation starting...");
+    }
+
+    // We are now in invalid state
+    // eslint-disable-next-line no-param-reassign
+    context.state = false;
+    // eslint-disable-next-line no-param-reassign, no-undefined
+    context.stats = undefined;
+  }
+
+  /**
+   * @param {StatsOptions} statsOptions
+   * @returns {StatsObjectOptions}
+   */
+  function normalizeStatsOptions(statsOptions) {
+    if (typeof statsOptions === "undefined") {
+      // eslint-disable-next-line no-param-reassign
+      statsOptions = {
+        preset: "normal"
+      };
+    } else if (typeof statsOptions === "boolean") {
+      // eslint-disable-next-line no-param-reassign
+      statsOptions = statsOptions ? {
+        preset: "normal"
+      } : {
+        preset: "none"
+      };
+    } else if (typeof statsOptions === "string") {
+      // eslint-disable-next-line no-param-reassign
+      statsOptions = {
+        preset: statsOptions
+      };
+    }
+    return statsOptions;
+  }
+
+  /**
+   * @param {Stats | MultiStats} stats
+   */
+  function done(stats) {
+    // We are now on valid state
+    // eslint-disable-next-line no-param-reassign
+    context.state = true;
+    // eslint-disable-next-line no-param-reassign
+    context.stats = stats;
+
+    // Do the stuff in nextTick, because bundle may be invalidated if a change happened while compiling
+    process.nextTick(() => {
+      const {
+        compiler,
+        logger,
+        options,
+        state,
+        callbacks
+      } = context;
+
+      // Check if still in valid state
+      if (!state) {
+        return;
+      }
+      logger.log("Compilation finished");
+      const isMultiCompilerMode = Boolean( /** @type {MultiCompiler} */
+      compiler.compilers);
+
+      /**
+       * @type {StatsOptions | MultiStatsOptions | undefined}
+       */
+      let statsOptions;
+      if (typeof options.stats !== "undefined") {
+        statsOptions = isMultiCompilerMode ? {
+          children: /** @type {MultiCompiler} */
+          compiler.compilers.map(() => options.stats)
+        } : options.stats;
+      } else {
+        statsOptions = isMultiCompilerMode ? {
+          children: /** @type {MultiCompiler} */
+          compiler.compilers.map(child => child.options.stats)
+        } : /** @type {Compiler} */compiler.options.stats;
+      }
+      if (isMultiCompilerMode) {
+        /** @type {MultiStatsOptions} */
+        statsOptions.children = /** @type {MultiStatsOptions} */
+        statsOptions.children.map(
+        /**
+         * @param {StatsOptions} childStatsOptions
+         * @return {StatsObjectOptions}
+         */
+        childStatsOptions => {
+          // eslint-disable-next-line no-param-reassign
+          childStatsOptions = normalizeStatsOptions(childStatsOptions);
+          if (typeof childStatsOptions.colors === "undefined") {
+            // eslint-disable-next-line no-param-reassign
+            childStatsOptions.colors =
+            // eslint-disable-next-line global-require
+            require("colorette").isColorSupported;
+          }
+          return childStatsOptions;
+        });
+      } else {
+        statsOptions = normalizeStatsOptions( /** @type {StatsOptions} */statsOptions);
+        if (typeof statsOptions.colors === "undefined") {
+          // eslint-disable-next-line global-require
+          statsOptions.colors = require("colorette").isColorSupported;
+        }
+      }
+      const printedStats = stats.toString( /** @type {StatsObjectOptions} */statsOptions);
+
+      // Avoid extra empty line when `stats: 'none'`
+      if (printedStats) {
+        // eslint-disable-next-line no-console
+        console.log(printedStats);
+      }
+
+      // eslint-disable-next-line no-param-reassign
+      context.callbacks = [];
+
+      // Execute callback that are delayed
+      for (const callback of callbacks) {
+        callback(stats);
+      }
+    });
+  }
+
+  // eslint-disable-next-line prefer-destructuring
+  const compiler = /** @type {import("../index.js").Context<Request, Response>} */
+  context.compiler;
+  compiler.hooks.watchRun.tap("webpack-dev-middleware", invalid);
+  compiler.hooks.invalid.tap("webpack-dev-middleware", invalid);
+  compiler.hooks.done.tap("webpack-dev-middleware", done);
+}
+module.exports = setupHooks;

node_modules/webpack-dev-middleware/dist/utils/setupOutputFileSystem.js

@@ -0,0 +1,59 @@
+"use strict";
+
+const memfs = require("memfs");
+
+/** @typedef {import("webpack").MultiCompiler} MultiCompiler */
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").WithOptional<import("../index.js").Context<Request, Response>, "watching" | "outputFileSystem">} context
+ */
+function setupOutputFileSystem(context) {
+  let outputFileSystem;
+  if (context.options.outputFileSystem) {
+    const {
+      outputFileSystem: outputFileSystemFromOptions
+    } = context.options;
+    outputFileSystem = outputFileSystemFromOptions;
+  }
+  // Don't use `memfs` when developer wants to write everything to a disk, because it doesn't make sense.
+  else if (context.options.writeToDisk !== true) {
+    outputFileSystem = memfs.createFsFromVolume(new memfs.Volume());
+  } else {
+    const isMultiCompiler = /** @type {MultiCompiler} */
+    context.compiler.compilers;
+    if (isMultiCompiler) {
+      // Prefer compiler with `devServer` option or fallback on the first
+      // TODO we need to support webpack-dev-server as a plugin or revisit it
+      const compiler = /** @type {MultiCompiler} */
+      context.compiler.compilers.filter(item => Object.prototype.hasOwnProperty.call(item.options, "devServer") && item.options.devServer !== false);
+      ({
+        outputFileSystem
+      } = compiler[0] || /** @type {MultiCompiler} */
+      context.compiler.compilers[0]);
+    } else {
+      ({
+        outputFileSystem
+      } = context.compiler);
+    }
+  }
+  const compilers = /** @type {MultiCompiler} */
+  context.compiler.compilers || [context.compiler];
+  for (const compiler of compilers) {
+    if (compiler.options.devServer === false) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+
+    // @ts-ignore
+    compiler.outputFileSystem = outputFileSystem;
+  }
+
+  // @ts-ignore
+  // eslint-disable-next-line no-param-reassign
+  context.outputFileSystem = outputFileSystem;
+}
+module.exports = setupOutputFileSystem;

node_modules/webpack-dev-middleware/dist/utils/setupWriteToDisk.js

@@ -0,0 +1,70 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+/** @typedef {import("webpack").Compiler} Compiler */
+/** @typedef {import("webpack").MultiCompiler} MultiCompiler */
+/** @typedef {import("webpack").Compilation} Compilation */
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").WithOptional<import("../index.js").Context<Request, Response>, "watching" | "outputFileSystem">} context
+ */
+function setupWriteToDisk(context) {
+  /**
+   * @type {Compiler[]}
+   */
+  const compilers = /** @type {MultiCompiler} */
+  context.compiler.compilers || [context.compiler];
+  for (const compiler of compilers) {
+    if (compiler.options.devServer === false) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+    compiler.hooks.emit.tap("DevMiddleware", () => {
+      // @ts-ignore
+      if (compiler.hasWebpackDevMiddlewareAssetEmittedCallback) {
+        return;
+      }
+      compiler.hooks.assetEmitted.tapAsync("DevMiddleware", (file, info, callback) => {
+        const {
+          targetPath,
+          content
+        } = info;
+        const {
+          writeToDisk: filter
+        } = context.options;
+        const allowWrite = filter && typeof filter === "function" ? filter(targetPath) : true;
+        if (!allowWrite) {
+          return callback();
+        }
+        const dir = path.dirname(targetPath);
+        const name = compiler.options.name ? `Child "${compiler.options.name}": ` : "";
+        return fs.mkdir(dir, {
+          recursive: true
+        }, mkdirError => {
+          if (mkdirError) {
+            context.logger.error(`${name}Unable to write "${dir}" directory to disk:\n${mkdirError}`);
+            return callback(mkdirError);
+          }
+          return fs.writeFile(targetPath, content, writeFileError => {
+            if (writeFileError) {
+              context.logger.error(`${name}Unable to write "${targetPath}" asset to disk:\n${writeFileError}`);
+              return callback(writeFileError);
+            }
+            context.logger.log(`${name}Asset written to disk: "${targetPath}"`);
+            return callback();
+          });
+        });
+      });
+
+      // @ts-ignore
+      compiler.hasWebpackDevMiddlewareAssetEmittedCallback = true;
+    });
+  }
+}
+module.exports = setupWriteToDisk;