switch to vuepress

23 files changed, 1763 insertions, 0 deletions

diff --git a/node_modules/webpack-dev-middleware/CHANGELOG.md b/node_modules/webpack-dev-middleware/CHANGELOG.md
new file mode 100644
index 00000000..e75a0b1f
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/CHANGELOG.md
@@ -0,0 +1,26 @@
+# Change Log
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+<a name="3.3.0"></a>
+# [3.3.0](https://github.com/webpack/webpack-dev-middleware/compare/v3.2.0...v3.3.0) (2018-09-10)
+
+
+### Features
+
+* **middleware:** expose the memory filesystem (`response.locals.fs`) ([#337](https://github.com/webpack/webpack-dev-middleware/issues/337)) ([f9a138e](https://github.com/webpack/webpack-dev-middleware/commit/f9a138e))
+
+
+
+<a name="3.2.0"></a>
+# [3.2.0](https://github.com/webpack/webpack-dev-middleware/compare/v3.1.3...v3.2.0) (2018-08-23)
+
+
+### Bug Fixes
+
+* **package:** 18 security vulnerabilities ([#329](https://github.com/webpack/webpack-dev-middleware/issues/329)) ([5951de9](https://github.com/webpack/webpack-dev-middleware/commit/5951de9))
+
+
+### Features
+
+* **middleware:** add `methods` option (`options.methods`) ([#319](https://github.com/webpack/webpack-dev-middleware/issues/319)) ([fe6bb86](https://github.com/webpack/webpack-dev-middleware/commit/fe6bb86))
diff --git a/node_modules/webpack-dev-middleware/LICENSE b/node_modules/webpack-dev-middleware/LICENSE
new file mode 100644
index 00000000..8c11fc72
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/LICENSE
@@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/webpack-dev-middleware/README.md b/node_modules/webpack-dev-middleware/README.md
new file mode 100644
index 00000000..91a9cf06
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/README.md
@@ -0,0 +1,445 @@
+<div align="center">
+  <a href="https://github.com/webpack/webpack">
+    <img width="200" height="200" src="https://webpack.js.org/assets/icon-square-big.svg">
+  </a>
+</div>
+
+[![npm][npm]][npm-url]
+[![node][node]][node-url]
+[![deps][deps]][deps-url]
+[![tests][tests]][tests-url]
+[![coverage][cover]][cover-url]
+[![chat][chat]][chat-url]
+
+# webpack-dev-middleware
+
+An express-style development middleware for use with [webpack](https://webpack.js.org)
+bundles and allows for serving of the files emitted from webpack.
+This should be used for **development only**.
+
+Some of the benefits of using this middleware include:
+
+- No files are written to disk, rather it handles files in memory
+- If files changed in watch mode, the middleware delays requests until compiling
+has completed.
+- Supports hot module reload (HMR).
+
+## Requirements
+
+This module requires a minimum of Node v6.9.0 and Webpack v4.0.0, and must be used with a
+server that accepts express-style middleware.
+
+## Getting Started
+
+First thing's first, install the module:
+
+```console
+npm install webpack-dev-middleware --save-dev
+```
+
+_Note: We do not recommend installing this module globally._
+
+## Usage
+
+```js
+const webpack = require('webpack');
+const middleware = require('webpack-dev-middleware');
+const compiler = webpack({ .. webpack options .. });
+const express = require('express');
+const app = express();
+
+app.use(middleware(compiler, {
+  // webpack-dev-middleware options
+}));
+
+app.listen(3000, () => console.log('Example app listening on port 3000!'))
+```
+
+## Options
+
+The middleware accepts an `options` Object. The following is a property reference
+for the Object.
+
+_Note: The `publicPath` property is required, whereas all other options are optional_
+
+### methods
+
+Type: `Array`  
+Default: `[ 'GET' ]`
+
+This property allows a user to pass the list of HTTP request methods accepted by the server. 
+
+### headers
+
+Type: `Object`  
+Default: `undefined`
+
+This property allows a user to pass custom HTTP headers on each request. eg.
+`{ "X-Custom-Header": "yes" }`
+
+### index
+
+Type: `String`  
+Default: `undefined`
+
+"index.html",
+// The index path for web server, defaults to "index.html".
+// If falsy (but not undefined), the server will not respond to requests to the root URL.
+
+
+### lazy
+
+Type: `Boolean`  
+Default: `undefined`
+
+This option instructs the module to operate in 'lazy' mode, meaning that it won't
+recompile when files change, but rather on each request.
+
+### logger
+
+Type: `Object`  
+Default: [`webpack-log`](https://github.com/webpack-contrib/webpack-log/blob/master/index.js)
+
+In the rare event that a user would like to provide a custom logging interface,
+this property allows the user to assign one. The module leverages
+[`webpack-log`](https://github.com/webpack-contrib/webpack-log#readme)
+for creating the [`loglevelnext`](https://github.com/shellscape/loglevelnext#readme)
+logging management by default. Any custom logger must adhere to the same
+exports for compatibility. Specifically, all custom loggers must have the
+following exported methods at a minimum:
+
+- `log.trace`
+- `log.debug`
+- `log.info`
+- `log.warn`
+- `log.error`
+
+Please see the documentation for `loglevel` for more information.
+
+### logLevel
+
+Type: `String`  
+Default: `'info'`
+
+This property defines the level of messages that the module will log. Valid levels
+include:
+
+- `trace`
+- `debug`
+- `info`
+- `warn`
+- `error`
+- `silent`
+
+Setting a log level means that all other levels below it will be visible in the
+console. Setting `logLevel: 'silent'` will hide all console output. The module
+leverages [`webpack-log`](https://github.com/webpack-contrib/webpack-log#readme)
+for logging management, and more information can be found on its page.
+
+### logTime
+
+Type: `Boolean`  
+Default: `false`
+
+If `true` the log output of the module will be prefixed by a timestamp in the
+`HH:mm:ss` format.
+
+### mimeTypes
+
+Type: `Object`  
+Default: `null`
+
+This property allows a user to register custom mime types or extension mappings.
+eg. `{ 'text/html': [ 'phtml' ] }`. Please see the documentation for
+[`node-mime`](https://github.com/broofa/node-mime#mimedefine) for more information.
+
+### publicPath
+
+Type: `String`  
+_Required_
+
+The public path that the middleware is bound to. _Best Practice: use the same
+`publicPath` defined in your webpack config. For more information about
+`publicPath`, please see
+[the webpack documentation](https://webpack.js.org/guides/public-path)._
+
+### reporter
+
+Type: `Object`  
+Default: `undefined`
+
+Allows users to provide a custom reporter to handle logging within the module.
+Please see the [default reporter](/lib/reporter.js)
+for an example.
+
+### serverSideRender
+
+Type: `Boolean`  
+Default: `undefined`
+
+Instructs the module to enable or disable the server-side rendering mode. Please
+see [Server-Side Rendering](#server-side-rendering) for more information.
+
+### stats
+
+Type: `Object`  
+Default: `{ context: process.cwd() }`
+
+Options for formatting statistics displayed during and after compile. For more
+information and property details, please see the
+[webpack documentation](https://webpack.js.org/configuration/stats/#stats).
+
+### watchOptions
+
+Type: `Object`  
+Default: `{ aggregateTimeout: 200 }`
+
+The module accepts an `Object` containing options for file watching, which is
+passed directly to the compiler provided. For more information on watch options
+please see the [webpack documentation](https://webpack.js.org/configuration/watch/#watchoptions)
+
+### writeToDisk
+
+Type: `Boolean|Function`  
+Default: `false`
+
+If true, the option will instruct the module to write files to the configured
+location on disk as specified in your `webpack` config file. _Setting
+`writeToDisk: true` won't change the behavior of the `webpack-dev-middleware`,
+and bundle files accessed through the browser will still be served from memory._
+This option provides the same capabilities as the
+[`WriteFilePlugin`](https://github.com/gajus/write-file-webpack-plugin/pulls).
+
+This option also accepts a `Function` value, which can be used to filter which
+files are written to disk. The function follows the same premise as
+[`Array#filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
+in which a return value of `false` _will not_ write the file, and a return value
+of `true` _will_ write the file to disk. eg.
+
+```js
+{
+  writeToDisk: (filePath) {
+    return /superman\.css$/.test(filePath);
+  }
+}
+```
+
+## API
+
+`webpack-dev-middleware` also provides convenience methods that can be use to
+interact with the middleware at runtime:
+
+### `close(callback)`
+
+Instructs a webpack-dev-middleware instance to stop watching for file changes.
+
+### Parameters
+
+#### callback
+
+Type: `Function`
+
+A function executed once the middleware has stopped watching.
+
+### `invalidate()`
+
+Instructs a webpack-dev-middleware instance to recompile the bundle.
+e.g. after a change to the configuration.
+
+```js
+const webpack = require('webpack');
+const compiler = webpack({ ... });
+const middleware = require('webpack-dev-middleware');
+const instance = middleware(compiler);
+
+app.use(instance);
+
+setTimeout(() => {
+  // After a short delay the configuration is changed and a banner plugin is added
+  // to the config
+  compiler.apply(new webpack.BannerPlugin('A new banner'));
+
+  // Recompile the bundle with the banner plugin:
+  instance.invalidate();
+}, 1000);
+```
+
+### `waitUntilValid(callback)`
+
+Executes a callback function when the compiler bundle is valid, typically after
+compilation.
+
+### Parameters
+
+#### callback
+
+Type: `Function`
+
+A function executed when the bundle becomes valid. If the bundle is
+valid at the time of calling, the callback is executed immediately.
+
+```js
+const webpack = require('webpack');
+const compiler = webpack({ ... });
+const middleware = require('webpack-dev-middleware');
+const instance = middleware(compiler);
+
+app.use(instance);
+
+instance.waitUntilValid(() => {
+  console.log('Package is in a valid state');
+});
+```
+## Known Issues
+
+### Multiple Successive Builds
+
+Watching (by means of `lazy: false`) will frequently cause multiple compilations
+as the bundle changes during compilation. This is due in part to cross-platform
+differences in file watchers, so that webpack doesn't loose file changes when
+watched files change rapidly. If you run into this situation, please make use of
+the [`TimeFixPlugin`](https://github.com/egoist/time-fix-plugin).
+
+## Server-Side Rendering
+
+_Note: this feature is experimental and may be removed or changed completely in the future._
+
+In order to develop an app using server-side rendering, we need access to the
+[`stats`](https://github.com/webpack/docs/wiki/node.js-api#stats), which is
+generated with each build.
+
+With server-side rendering enabled, `webpack-dev-middleware` sets the `stat` to
+`res.locals.webpackStats` and the memory filesystem to `res.locals.fs` before invoking the next middleware, allowing a
+developer to render the page body and manage the response to clients.
+
+_Note: Requests for bundle files will still be handled by
+`webpack-dev-middleware` and all requests will be pending until the build
+process is finished with server-side rendering enabled._
+
+Example Implementation:
+
+```js
+const webpack = require('webpack');
+const compiler = webpack({ ... });
+const isObject = require('is-object');
+const middleware = require('webpack-dev-middleware');
+
+// This function makes server rendering of asset references consistent with different webpack chunk/entry configurations
+function normalizeAssets(assets) {
+  if (isObject(assets)) {
+    return Object.values(assets)
+  }
+  return Array.isArray(assets) ? assets : [assets]
+}
+
+app.use(middleware(compiler, { serverSideRender: true }))
+
+// The following middleware would not be invoked until the latest build is finished.
+app.use((req, res) => {
+  const assetsByChunkName = res.locals.webpackStats.toJson().assetsByChunkName
+  const fs = res.locals.fs
+  const outputPath = res.locals.webpackStats.toJson().outputPath
+
+  // then use `assetsByChunkName` for server-sider rendering
+  // For example, if you have only one main chunk:
+  res.send(`
+<html>
+  <head>
+    <title>My App</title>
+    <style>
+		${normalizeAssets(assetsByChunkName.main)
+			  .filter(path => path.endsWith('.css'))
+			  .map(path => fs.readFileSync(outputPath + '/' + path))
+			  .join('\n')}
+    </style>
+  </head>
+  <body>
+    <div id="root"></div>
+		${normalizeAssets(assetsByChunkName.main)
+			  .filter(path => path.endsWith('.js'))
+			  .map(path => `<script src="${path}"></script>`)
+			  .join('\n')}
+  </body>
+</html>
+  `)
+
+})
+```
+
+## Support
+
+We do our best to keep Issues in the repository focused on bugs, features, and
+needed modifications to the code for the module. Because of that, we ask users
+with general support, "how-to", or "why isn't this working" questions to try one
+of the other support channels that are available.
+
+Your first-stop-shop for support for webpack-dev-server should by the excellent
+[documentation][docs-url] for the module. If you see an opportunity for improvement
+of those docs, please head over to the [webpack.js.org repo][wjo-url] and open a
+pull request.
+
+From there, we encourage users to visit the [webpack Gitter chat][chat-url] and
+talk to the fine folks there. If your quest for answers comes up dry in chat,
+head over to [StackOverflow][stack-url] and do a quick search or open a new
+question. Remember; It's always much easier to answer questions that include your
+`webpack.config.js` and relevant files!
+
+If you're twitter-savvy you can tweet [#webpack][hash-url] with your question
+and someone should be able to reach out and lend a hand.
+
+If you have discovered a :bug:, have a feature suggestion, of would like to see
+a modification, please feel free to create an issue on Github. _Note: The issue
+template isn't optional, so please be sure not to remove it, and please fill it
+out completely._
+
+## Contributing
+
+We welcome your contributions! Please have a read of [CONTRIBUTING.md](CONTRIBUTING.md) for more information on how to get involved.
+
+## Maintainers
+
+<table>
+  <tbody>
+    <tr>
+      <td align="center">
+        <img src="https://avatars.githubusercontent.com/SpaceK33z?v=4&s=150">
+        <br />
+        <a href="https://github.com/SpaceK33z">Kees Kluskens</a>
+      </td>
+      <td align="center">
+        <img src="https://i.imgur.com/4v6pgxh.png">
+        <br />
+        <a href="https://github.com/shellscape">Andrew Powell</a>
+      </td>
+    </tr>
+  </tbody>
+</table>
+
+## License
+
+#### [MIT](./LICENSE)
+
+[npm]: https://img.shields.io/npm/v/webpack-dev-middleware.svg
+[npm-url]: https://npmjs.com/package/webpack-dev-middleware
+
+[node]: https://img.shields.io/node/v/webpack-dev-middleware.svg
+[node-url]: https://nodejs.org
+
+[deps]: https://david-dm.org/webpack/webpack-dev-middleware.svg
+[deps-url]: https://david-dm.org/webpack/webpack-dev-middleware
+
+[tests]: http://img.shields.io/travis/webpack/webpack-dev-middleware.svg
+[tests-url]: https://travis-ci.org/webpack/webpack-dev-middleware
+
+[cover]: https://codecov.io/gh/webpack/webpack-dev-middleware/branch/master/graph/badge.svg
+[cover-url]: https://codecov.io/gh/webpack/webpack-dev-middleware
+
+[chat]: https://badges.gitter.im/webpack/webpack.svg
+[chat-url]: https://gitter.im/webpack/webpack
+
+[docs-url]: https://webpack.js.org/guides/development/#using-webpack-dev-middleware
+[hash-url]: https://twitter.com/search?q=webpack
+[middleware-url]: https://github.com/webpack/webpack-dev-middleware
+[stack-url]: https://stackoverflow.com/questions/tagged/webpack-dev-middleware
+[uglify-url]: https://github.com/webpack-contrib/uglifyjs-webpack-plugin
+[wjo-url]: https://github.com/webpack/webpack.js.org
diff --git a/node_modules/webpack-dev-middleware/index.js b/node_modules/webpack-dev-middleware/index.js
new file mode 100644
index 00000000..8389e568
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/index.js
@@ -0,0 +1,100 @@
+'use strict';
+
+const mime = require('mime');
+const createContext = require('./lib/context');
+const middleware = require('./lib/middleware');
+const reporter = require('./lib/reporter');
+const { setFs, toDisk } = require('./lib/fs');
+const { getFilenameFromUrl, noop, ready } = require('./lib/util');
+
+const defaults = {
+  logLevel: 'info',
+  logTime: false,
+  logger: null,
+  mimeTypes: null,
+  reporter,
+  stats: {
+    colors: true,
+    context: process.cwd()
+  },
+  watchOptions: {
+    aggregateTimeout: 200
+  },
+  writeToDisk: false
+};
+
+module.exports = function wdm(compiler, opts) {
+  const options = Object.assign({}, defaults, opts);
+
+  if (options.lazy) {
+    if (typeof options.filename === 'string') {
+      const filename = options.filename
+        .replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&') // eslint-disable-line no-useless-escape
+        .replace(/\\\[[a-z]+\\\]/ig, '.+');
+
+      options.filename = new RegExp(`^[/]{0,1}${filename}$`);
+    }
+  }
+
+  // defining custom MIME type
+  if (options.mimeTypes) {
+    mime.define(options.mimeTypes);
+  }
+
+  const context = createContext(compiler, options);
+
+  // start watching
+  if (!options.lazy) {
+    const watching = compiler.watch(options.watchOptions, (err) => {
+      if (err) {
+        context.log.error(err.stack || err);
+        if (err.details) {
+          context.log.error(err.details);
+        }
+      }
+    });
+
+    context.watching = watching;
+  } else {
+    context.state = true;
+  }
+
+  if (options.writeToDisk) {
+    toDisk(context);
+  }
+
+  setFs(context, compiler);
+
+  return Object.assign(middleware(context), {
+    close(callback) {
+      callback = callback || noop;
+
+      if (context.watching) {
+        context.watching.close(callback);
+      } else {
+        callback();
+      }
+    },
+
+    context,
+
+    fileSystem: context.fs,
+
+    getFilenameFromUrl: getFilenameFromUrl.bind(this, context.options.publicPath, context.compiler),
+
+    invalidate(callback) {
+      callback = callback || noop;
+      if (context.watching) {
+        ready(context, callback, {});
+        context.watching.invalidate();
+      } else {
+        callback();
+      }
+    },
+
+    waitUntilValid(callback) {
+      callback = callback || noop;
+      ready(context, callback, {});
+    }
+  });
+};
diff --git a/node_modules/webpack-dev-middleware/lib/DevMiddlewareError.js b/node_modules/webpack-dev-middleware/lib/DevMiddlewareError.js
new file mode 100644
index 00000000..0ae2ce81
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/lib/DevMiddlewareError.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = class DevMiddlewareError extends Error {
+
+};
diff --git a/node_modules/webpack-dev-middleware/lib/context.js b/node_modules/webpack-dev-middleware/lib/context.js
new file mode 100644
index 00000000..5e9abba7
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/lib/context.js
@@ -0,0 +1,103 @@
+'use strict';
+
+const weblog = require('webpack-log');
+
+module.exports = function ctx(compiler, options) {
+  const context = {
+    state: false,
+    webpackStats: null,
+    callbacks: [],
+    options,
+    compiler,
+    watching: null,
+    forceRebuild: false
+  };
+
+  if (options.logger) {
+    context.log = options.logger;
+  } else {
+    context.log = weblog({
+      level: options.logLevel || 'info',
+      name: 'wdm',
+      timestamp: options.logTime
+    });
+  }
+
+  const { log } = context;
+
+  function done(stats) {
+    // We are now on valid state
+    context.state = true;
+    context.webpackStats = stats;
+
+    // Do the stuff in nextTick, because bundle may be invalidated
+    // if a change happened while compiling
+    process.nextTick(() => {
+      // check if still in valid state
+      if (!context.state) {
+        return;
+      }
+
+      // print webpack output
+      context.options.reporter(context.options, {
+        log,
+        state: true,
+        stats
+      });
+
+      // execute callback that are delayed
+      const cbs = context.callbacks;
+      context.callbacks = [];
+      cbs.forEach((cb) => {
+        cb(stats);
+      });
+    });
+
+    // In lazy mode, we may issue another rebuild
+    if (context.forceRebuild) {
+      context.forceRebuild = false;
+      rebuild();
+    }
+  }
+
+  function invalid(callback) {
+    if (context.state) {
+      context.options.reporter(context.options, {
+        log,
+        state: false
+      });
+    }
+
+    // We are now in invalid state
+    context.state = false;
+    if (typeof callback === 'function') {
+      callback();
+    }
+  }
+
+  function rebuild() {
+    if (context.state) {
+      context.state = false;
+      context.compiler.run((err) => {
+        if (err) {
+          log.error(err.stack || err);
+          if (err.details) {
+            log.error(err.details);
+          }
+        }
+      });
+    } else {
+      context.forceRebuild = true;
+    }
+  }
+
+  context.rebuild = rebuild;
+  context.compiler.hooks.invalid.tap('WebpackDevMiddleware', invalid);
+  context.compiler.hooks.run.tap('WebpackDevMiddleware', invalid);
+  context.compiler.hooks.done.tap('WebpackDevMiddleware', done);
+  context.compiler.hooks.watchRun.tap('WebpackDevMiddleware', (comp, callback) => {
+    invalid(callback);
+  });
+
+  return context;
+};
diff --git a/node_modules/webpack-dev-middleware/lib/fs.js b/node_modules/webpack-dev-middleware/lib/fs.js
new file mode 100644
index 00000000..1823b67a
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/lib/fs.js
@@ -0,0 +1,73 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const MemoryFileSystem = require('memory-fs');
+const { colors } = require('webpack-log');
+const NodeOutputFileSystem = require('webpack/lib/node/NodeOutputFileSystem');
+const DevMiddlewareError = require('./DevMiddlewareError');
+
+const { mkdirp } = new NodeOutputFileSystem();
+
+module.exports = {
+  toDisk(context) {
+    const compilers = context.compiler.compilers || [context.compiler];
+    for (const compiler of compilers) {
+      compiler.hooks.afterEmit.tap('WebpackDevMiddleware', (compilation) => {
+        const { assets } = compilation;
+        const { log } = context;
+        const { writeToDisk: filter } = context.options;
+        let { outputPath } = compiler;
+
+        if (outputPath === '/') {
+          outputPath = compiler.context;
+        }
+
+        for (const assetPath of Object.keys(assets)) {
+          const asset = assets[assetPath];
+          const source = asset.source();
+          const isAbsolute = path.isAbsolute(assetPath);
+          const writePath = isAbsolute ? assetPath : path.join(outputPath, assetPath);
+          const relativePath = path.relative(process.cwd(), writePath);
+          const allowWrite = filter && typeof filter === 'function' ? filter(writePath) : true;
+
+          if (allowWrite) {
+            let output = source;
+
+            mkdirp.sync(path.dirname(writePath));
+
+            if (Array.isArray(source)) {
+              output = source.join('\n');
+            }
+
+            try {
+              fs.writeFileSync(writePath, output, 'utf-8');
+              log.debug(colors.cyan(`Asset written to disk: ${relativePath}`));
+            } catch (e) {
+              log.error(`Unable to write asset to disk:\n${e}`);
+            }
+          }
+        }
+      });
+    }
+  },
+
+  setFs(context, compiler) {
+    if (typeof compiler.outputPath === 'string' && !path.posix.isAbsolute(compiler.outputPath) && !path.win32.isAbsolute(compiler.outputPath)) {
+      throw new DevMiddlewareError('`output.path` needs to be an absolute path or `/`.');
+    }
+
+    let fileSystem;
+    // store our files in memory
+    const isMemoryFs = !compiler.compilers && compiler.outputFileSystem instanceof MemoryFileSystem;
+
+    if (isMemoryFs) {
+      fileSystem = compiler.outputFileSystem;
+    } else {
+      fileSystem = new MemoryFileSystem();
+      compiler.outputFileSystem = fileSystem;
+    }
+
+    context.fs = fileSystem;
+  }
+};
diff --git a/node_modules/webpack-dev-middleware/lib/middleware.js b/node_modules/webpack-dev-middleware/lib/middleware.js
new file mode 100644
index 00000000..602632b6
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/lib/middleware.js
@@ -0,0 +1,98 @@
+'use strict';
+
+const path = require('path');
+const mime = require('mime');
+const DevMiddlewareError = require('./DevMiddlewareError');
+const { getFilenameFromUrl, handleRangeHeaders, handleRequest, ready } = require('./util');
+
+module.exports = function wrapper(context) {
+  return function middleware(req, res, next) {
+    // fixes #282. credit @cexoso. in certain edge situations res.locals is
+    // undefined.
+    res.locals = res.locals || {};
+
+    function goNext() {
+      if (!context.options.serverSideRender) {
+        return next();
+      }
+
+      return new Promise(((resolve) => {
+        ready(context, () => {
+          res.locals.webpackStats = context.webpackStats;
+          res.locals.fs = context.fs;
+          resolve(next());
+        }, req);
+      }));
+    }
+
+    const acceptedMethods = context.options.methods || ['GET'];
+    if (acceptedMethods.indexOf(req.method) === -1) {
+      return goNext();
+    }
+
+    let filename = getFilenameFromUrl(context.options.publicPath, context.compiler, req.url);
+
+    if (filename === false) {
+      return goNext();
+    }
+
+    return new Promise(((resolve) => {
+      handleRequest(context, filename, processRequest, req);
+      function processRequest() {
+        try {
+          let stat = context.fs.statSync(filename);
+
+          if (!stat.isFile()) {
+            if (stat.isDirectory()) {
+              let { index } = context.options;
+
+              if (index === undefined || index === true) {
+                index = 'index.html';
+              } else if (!index) {
+                throw new DevMiddlewareError('next');
+              }
+
+              filename = path.posix.join(filename, index);
+              stat = context.fs.statSync(filename);
+              if (!stat.isFile()) {
+                throw new DevMiddlewareError('next');
+              }
+            } else {
+              throw new DevMiddlewareError('next');
+            }
+          }
+        } catch (e) {
+          return resolve(goNext());
+        }
+
+        // server content
+        let content = context.fs.readFileSync(filename);
+        content = handleRangeHeaders(content, req, res);
+
+        let contentType = mime.getType(filename);
+
+        // do not add charset to WebAssembly files, otherwise compileStreaming will fail in the client
+        if (!/\.wasm$/.test(filename)) {
+          contentType += '; charset=UTF-8';
+        }
+
+        res.setHeader('Content-Type', contentType);
+        res.setHeader('Content-Length', content.length);
+
+        const { headers } = context.options;
+        if (headers) {
+          for (const name in headers) {
+            if ({}.hasOwnProperty.call(headers, name)) {
+              res.setHeader(name, context.options.headers[name]);
+            }
+          }
+        }
+        // Express automatically sets the statusCode to 200, but not all servers do (Koa).
+        res.statusCode = res.statusCode || 200;
+        if (res.send) res.send(content);
+        else res.end(content);
+        resolve();
+      }
+    }));
+  };
+};
diff --git a/node_modules/webpack-dev-middleware/lib/reporter.js b/node_modules/webpack-dev-middleware/lib/reporter.js
new file mode 100644
index 00000000..3c820f7e
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/lib/reporter.js
@@ -0,0 +1,30 @@
+'use strict';
+
+module.exports = function reporter(middlewareOptions, options) {
+  const { log, state, stats } = options;
+
+  if (state) {
+    const displayStats = (middlewareOptions.stats !== false);
+
+    if (displayStats) {
+      if (stats.hasErrors()) {
+        log.error(stats.toString(middlewareOptions.stats));
+      } else if (stats.hasWarnings()) {
+        log.warn(stats.toString(middlewareOptions.stats));
+      } else {
+        log.info(stats.toString(middlewareOptions.stats));
+      }
+    }
+
+    let message = 'Compiled successfully.';
+
+    if (stats.hasErrors()) {
+      message = 'Failed to compile.';
+    } else if (stats.hasWarnings()) {
+      message = 'Compiled with warnings.';
+    }
+    log.info(message);
+  } else {
+    log.info('Compiling...');
+  }
+};
diff --git a/node_modules/webpack-dev-middleware/lib/util.js b/node_modules/webpack-dev-middleware/lib/util.js
new file mode 100644
index 00000000..e8a70bef
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/lib/util.js
@@ -0,0 +1,173 @@
+'use strict';
+
+const path = require('path');
+const { parse } = require('url');
+const querystring = require('querystring');
+const parseRange = require('range-parser');
+
+const HASH_REGEXP = /[0-9a-f]{10,}/;
+
+// support for multi-compiler configuration
+// see: https://github.com/webpack/webpack-dev-server/issues/641
+function getPaths(publicPath, compiler, url) {
+  const compilers = compiler && compiler.compilers;
+  if (Array.isArray(compilers)) {
+    let compilerPublicPath;
+
+    // the path portion of compilerPublicPath
+    let compilerPublicPathBase;
+
+    for (let i = 0; i < compilers.length; i++) {
+      compilerPublicPath = compilers[i].options
+    && compilers[i].options.output
+    && compilers[i].options.output.publicPath;
+
+      if (compilerPublicPath) {
+        if (compilerPublicPath.indexOf('/') === 0) {
+          compilerPublicPathBase = compilerPublicPath;
+        } else {
+          // handle the case where compilerPublicPath is a URL with hostname
+          compilerPublicPathBase = parse(compilerPublicPath).pathname;
+        }
+
+        // check the url vs the path part of the compilerPublicPath
+        if (url.indexOf(compilerPublicPathBase) === 0) {
+          return {
+            publicPath: compilerPublicPath,
+            outputPath: compilers[i].outputPath
+          };
+        }
+      }
+    }
+  }
+  return {
+    publicPath,
+    outputPath: compiler.outputPath
+  };
+}
+
+function ready(context, fn, req) {
+  if (context.state) {
+    return fn(context.webpackStats);
+  }
+
+  context.log.info(`wait until bundle finished: ${req.url || fn.name}`);
+  context.callbacks.push(fn);
+}
+
+module.exports = {
+  getFilenameFromUrl(pubPath, compiler, url) {
+    const { outputPath, publicPath } = getPaths(pubPath, compiler, url);
+    // localPrefix is the folder our bundle should be in
+    const localPrefix = parse(publicPath || '/', false, true);
+    const urlObject = parse(url);
+    let filename;
+
+    // publicPath has the hostname that is not the same as request url's, should fail
+    if (localPrefix.hostname !== null && urlObject.hostname !== null &&
+        localPrefix.hostname !== urlObject.hostname) {
+      return false;
+    }
+
+    // publicPath is not in url, so it should fail
+    if (publicPath && localPrefix.hostname === urlObject.hostname &&
+        url.indexOf(publicPath) !== 0) {
+      return false;
+    }
+
+    // strip localPrefix from the start of url
+    if (urlObject.pathname.indexOf(localPrefix.pathname) === 0) {
+      filename = urlObject.pathname.substr(localPrefix.pathname.length);
+    }
+
+    if (!urlObject.hostname && localPrefix.hostname &&
+        url.indexOf(localPrefix.path) !== 0) {
+      return false;
+    }
+
+    let uri = outputPath;
+
+    /* istanbul ignore if */
+    if (process.platform === 'win32') {
+      // Path Handling for Microsoft Windows
+      if (filename) {
+        uri = path.posix.join((outputPath || ''), querystring.unescape(filename));
+
+        if (!path.win32.isAbsolute(uri)) {
+          uri = `/${uri}`;
+        }
+      }
+
+      return uri;
+    }
+
+    // Path Handling for all other operating systems
+    if (filename) {
+      uri = path.posix.join((outputPath || ''), filename);
+
+      if (!path.posix.isAbsolute(uri)) {
+        uri = `/${uri}`;
+      }
+    }
+
+    // if no matches, use outputPath as filename
+    return querystring.unescape(uri);
+  },
+
+  handleRangeHeaders(content, req, res) {
+    // assumes express API. For other servers, need to add logic to access
+    // alternative header APIs
+    res.setHeader('Accept-Ranges', 'bytes');
+
+    if (req.headers.range) {
+      const ranges = parseRange(content.length, req.headers.range);
+
+      // unsatisfiable
+      if (ranges === -1) {
+        res.setHeader('Content-Range', `bytes */${content.length}`);
+        res.statusCode = 416;
+      }
+
+      // valid (syntactically invalid/multiple ranges are treated as a
+      // regular response)
+      if (ranges !== -2 && ranges.length === 1) {
+        const { length } = content;
+
+        // Content-Range
+        res.statusCode = 206;
+        res.setHeader(
+          'Content-Range',
+          `bytes ${ranges[0].start}-${ranges[0].end}/${length}`
+        );
+
+        content = content.slice(ranges[0].start, ranges[0].end + 1);
+      }
+    }
+
+    return content;
+  },
+
+  handleRequest(context, filename, processRequest, req) {
+    // in lazy mode, rebuild on bundle request
+    if (context.options.lazy && (!context.options.filename || context.options.filename.test(filename))) {
+      context.rebuild();
+    }
+
+    if (HASH_REGEXP.test(filename)) {
+      try {
+        if (context.fs.statSync(filename).isFile()) {
+          processRequest();
+          return;
+        }
+      } catch (e) {
+        // eslint-disable-line
+      }
+    }
+
+    ready(context, processRequest, req);
+  },
+
+  noop: () => {},
+
+  ready
+};
diff --git a/node_modules/webpack-dev-middleware/node_modules/.bin/mime b/node_modules/webpack-dev-middleware/node_modules/.bin/mime
new file mode 120000
index 00000000..210a0bd4
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/node_modules/.bin/mime
@@ -0,0 +1 @@
+../../../mime/cli.js
\ No newline at end of file
diff --git a/node_modules/webpack-dev-middleware/node_modules/.bin/webpack b/node_modules/webpack-dev-middleware/node_modules/.bin/webpack
new file mode 120000
index 00000000..8a1900f6
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/node_modules/.bin/webpack
@@ -0,0 +1 @@
+../../../webpack/bin/webpack.js
\ No newline at end of file
diff --git a/node_modules/webpack-dev-middleware/node_modules/webpack-log/CHANGELOG.md b/node_modules/webpack-dev-middleware/node_modules/webpack-log/CHANGELOG.md
new file mode 100644
index 00000000..a6b3e869
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/node_modules/webpack-log/CHANGELOG.md
@@ -0,0 +1,16 @@
+# Change Log
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+<a name="2.0.0"></a>
+# [2.0.0](https://github.com/webpack-contrib/webpack-log/compare/v1.2.0...v2.0.0) (2018-08-23)
+
+
+### Code Refactoring
+
+* **package:** replace `chalk` with `ansi-colors` (`dependencies`) ([#4](https://github.com/webpack-contrib/webpack-log/issues/4)) ([5b793d4](https://github.com/webpack-contrib/webpack-log/commit/5b793d4))
+
+
+### BREAKING CHANGES
+
+* **package:** `module.exports.chalk` was renamed to `module.exports.colors`
diff --git a/node_modules/webpack-dev-middleware/node_modules/webpack-log/LICENSE b/node_modules/webpack-dev-middleware/node_modules/webpack-log/LICENSE
new file mode 100644
index 00000000..1e1bdc96
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/node_modules/webpack-log/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 webpack-contrib
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/node_modules/webpack-dev-middleware/node_modules/webpack-log/README.md b/node_modules/webpack-dev-middleware/node_modules/webpack-log/README.md
new file mode 100644
index 00000000..e909b195
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/node_modules/webpack-log/README.md
@@ -0,0 +1,132 @@
+<div align="center">
+  <a href="https://github.com/webpack/webpack">
+    <img width="200" height="200" src="https://webpack.js.org/assets/icon-square-big.svg">
+  </a>
+</div>
+
+[![npm][npm]][npm-url]
+[![node][node]][node-url]
+[![deps][deps]][deps-url]
+[![tests][tests]][tests-url]
+[![coverage][cover]][cover-url]
+[![chat][chat]][chat-url]
+
+# webpack-log
+
+A common logging module for the Webpack ecosystem. `webpack-log` leverages
+[`loglevelnext`][loglevelnext].
+
+## Getting Started
+
+First thing's first, install the module:
+
+```console
+npm install webpack-log --save
+```
+
+_Note: We do not recommend installing this module globally._
+
+## Requirements
+
+`webpack-log` requires Node v6 or higher.
+
+## Usage
+
+```js
+const weblog = require('webpack-log');
+const log = weblog({ name: 'wds' }) // webpack-dev-server
+
+log.info('Server Starting');
+```
+
+The code above will produce:
+
+![output](output.png)
+
+## Options
+
+The default export (`function`) will return a logger, given an `options` Object.
+The following is a property reference for the Object.
+
+_Note: the logger returned is unique by default, due to the nature of the `webpack`
+ecosystem. Please reference the [`unique`](#unique) option below for disabling
+this feature and to force caching._
+
+### level
+
+Type: `String`  
+Default: `'info'`
+
+Specifies the level the logger should use. A logger will not produce output for
+any log level _beneath_ the specified level. Available levels and order are:
+
+```js
+[
+  'trace',
+  'debug',
+  'info',
+  'warn',
+  'error',
+  'silent'
+]
+```
+
+_Note: The level names shown above correspond to the available logging methods,
+with the notable exception of the `silent` level._
+
+### name
+
+_Required_  
+Type: `String`  
+Default: `'<unknown>'`
+
+Specifies the name of the log to create. This property is required, and used to
+differentiate between loggers when `webpack-log` is used in multiple projects
+executing in the same process space.
+
+### timestamp
+
+Type: `Boolean`  
+Default: `false`
+
+If `true`, instructs the logger to display a timestamp for log output, preceding
+all other data.
+
+### unique
+
+Type: `Boolean`  
+Default: `true`
+
+If `false`, instructs the logger to used cached versions of a log with the same
+name. Due to the nature of the `webpack` ecosystem and multiple plugin/loader
+use in the same process space, loggers are created as unique instances by default.
+By passing `false` for this property, the module is instructed to cache the
+requested logger.
+
+## Contributing
+
+We welcome your contributions! Please have a read of [CONTRIBUTING.md](CONTRIBUTING.md) for more information on how to get involved.
+
+## License
+
+#### [MIT](./LICENSE)
+
+[npm]: https://img.shields.io/npm/v/webpack-log.svg
+[npm-url]: https://npmjs.com/package/webpack-log
+
+[node]: https://img.shields.io/node/v/webpack-log.svg
+[node-url]: https://nodejs.org
+
+[deps]: https://david-dm.org/webpack-contrib/webpack-log.svg
+[deps-url]: https://david-dm.org/webpack-contrib/webpack-log
+
+[tests]: http://img.shields.io/travis/webpack-contrib/webpack-log.svg
+[tests-url]: https://travis-ci.org/webpack-contrib/webpack-log
+
+[cover]: https://codecov.io/gh/webpack-contrib/webpack-log/branch/master/graph/badge.svg
+[cover-url]: https://codecov.io/gh/webpack-contrib/webpack-log
+
+[chat]: https://badges.gitter.im/webpack/webpack.svg
+[chat-url]: https://gitter.im/webpack/webpack
+
+[loglevelnext]: https://github.com/shellscape/loglevelnext
diff --git a/node_modules/webpack-dev-middleware/node_modules/webpack-log/node_modules/.bin/uuid b/node_modules/webpack-dev-middleware/node_modules/webpack-log/node_modules/.bin/uuid
new file mode 120000
index 00000000..41c70364
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/node_modules/webpack-log/node_modules/.bin/uuid
@@ -0,0 +1 @@
+../../../../../uuid/bin/uuid
\ No newline at end of file
diff --git a/node_modules/webpack-dev-middleware/node_modules/webpack-log/package.json b/node_modules/webpack-dev-middleware/node_modules/webpack-log/package.json
new file mode 100644
index 00000000..539b337a
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/node_modules/webpack-log/package.json
@@ -0,0 +1,37 @@
+{
+  "name": "webpack-log",
+  "version": "2.0.0",
+  "description": "A common logger for the webpack ecosystem",
+  "main": "src/index.js",
+  "files": [
+    "src"
+  ],
+  "engines": {
+    "node": ">= 6"
+  },
+  "scripts": {
+    "lint": "eslint src test",
+    "test": "nyc --reporter lcovonly mocha --full-trace --check-leaks",
+    "release": "standard-version"
+  },
+  "dependencies": {
+    "ansi-colors": "^3.0.0",
+    "uuid": "^3.3.2"
+  },
+  "devDependencies": {
+    "assert": "^1.4.1",
+    "eslint": "^5.4.0",
+    "eslint-config-webpack": "^1.2.5",
+    "eslint-plugin-import": "^2.14.0",
+    "mocha": "^5.2.0",
+    "nyc": "^12.0.2",
+    "sinon": "^6.1.5",
+    "standard-version": "^4.4.0",
+    "strip-ansi": "^4.0.0"
+  },
+  "author": "Andrew Powell <andrew@shellscape.org>",
+  "issues": "https://github.com/webpack-contrib/webpack-log/issues",
+  "homepage": "https://github.com/webpack-contrib/webpack-log#readme",
+  "repository": "https://github.com/webpack-contrib/webpack-log.git",
+  "license": "MIT"
+}
diff --git a/node_modules/webpack-dev-middleware/node_modules/webpack-log/src/index.js b/node_modules/webpack-dev-middleware/node_modules/webpack-log/src/index.js
new file mode 100644
index 00000000..fc91104f
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/node_modules/webpack-log/src/index.js
@@ -0,0 +1,80 @@
+'use strict';
+
+/* global window: true */
+/* eslint-disable
+  no-shadow,
+  no-param-reassign,
+  space-before-function-paren
+*/
+const uuid = require('uuid/v4');
+const colors = require('ansi-colors');
+const loglevel = require('./loglevel');
+
+const symbols = {
+  trace: colors.grey('₸'),
+  debug: colors.cyan('➤'),
+  info: colors.blue(colors.symbols.info),
+  warn: colors.yellow(colors.symbols.warning),
+  error: colors.red(colors.symbols.cross)
+};
+
+const defaults = {
+  name: '<unknown>',
+  level: 'info',
+  unique: true
+};
+
+const prefix = {
+  level (options) {
+    return symbols[options.level];
+  },
+  template: `{{level}} ${colors.gray('｢{{name}}｣')}: `
+};
+
+function log (options) {
+  const opts = Object.assign({}, defaults, options);
+  const { id } = options;
+
+  opts.prefix = Object.assign({}, prefix, options.prefix);
+  delete opts.id;
+
+  Object.defineProperty(opts, 'id', {
+    get() {
+      if (!id) {
+        return this.name + (opts.unique ? `-${uuid()}` : '');
+      }
+
+      return id;
+    }
+  });
+
+  if (opts.timestamp) {
+    opts.prefix.template = `[{{time}}] ${opts.prefix.template}`;
+  }
+
+  const log = loglevel.getLogger(opts);
+
+  if (!Object.prototype.hasOwnProperty.call(log, 'id')) {
+    Object.defineProperty(log, 'id', {
+      get() {
+        return opts.id;
+      }
+    });
+  }
+
+  return log;
+}
+
+module.exports = log;
+// NOTE: this is exported so that consumers of webpack-log can use the same
+// version of ansi-colors to decorate log messages without incurring additional
+// dependency overhead
+module.exports.colors = colors;
+// NOTE: This is an undocumented function solely for the purpose of tests.
+// Do not use this method in production code. Using in production code
+// may result in strange behavior.
+module.exports.delLogger = function delLogger(name) {
+  delete loglevel.loggers[name];
+};
+
+module.exports.factories = loglevel.factories;
diff --git a/node_modules/webpack-dev-middleware/node_modules/webpack-log/src/loglevel/LogLevel.js b/node_modules/webpack-dev-middleware/node_modules/webpack-log/src/loglevel/LogLevel.js
new file mode 100644
index 00000000..ff1c3eea
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/node_modules/webpack-log/src/loglevel/LogLevel.js
@@ -0,0 +1,91 @@
+'use strict';
+
+/* global window: true */
+/* eslint-disable
+  multiline-ternary,
+  no-param-reassign
+*/
+const PrefixFactory = require('./PrefixFactory');
+const MethodFactory = require('./MethodFactory');
+
+const defaults = {
+  name: +new Date(),
+  level: 'warn',
+  prefix: null,
+  factory: null
+};
+
+class LogLevel {
+  constructor(options) {
+    // implement for some _very_ loose type checking. avoids getting into a
+    // circular require between MethodFactory and LogLevel
+    this.type = 'LogLevel';
+    this.options = Object.assign({}, defaults, options);
+    this.methodFactory = options.factory;
+
+    if (!this.methodFactory) {
+      const factory = options.prefix
+        ? new PrefixFactory(this, options.prefix)
+        : new MethodFactory(this);
+
+      this.methodFactory = factory;
+    }
+
+    if (!this.methodFactory.logger) {
+      this.methodFactory.logger = this;
+    }
+
+    this.name = options.name || '<unknown>';
+    // this.level is a setter, do this after setting up the factory
+    this.level = this.options.level;
+  }
+
+  get factory() {
+    return this.methodFactory;
+  }
+
+  set factory(factory) {
+    factory.logger = this;
+
+    this.methodFactory = factory;
+    this.methodFactory.replaceMethods(this.level);
+  }
+
+  enable() {
+    this.level = this.levels.TRACE;
+  }
+
+  disable() {
+    this.level = this.levels.SILENT;
+  }
+
+  get level() {
+    return this.currentLevel;
+  }
+
+  set level(logLevel) {
+    const level = this.methodFactory.distillLevel(logLevel);
+
+    if (level == null) {
+      throw new Error(
+        `loglevel: setLevel() called with invalid level: ${logLevel}`
+      );
+    }
+
+    this.currentLevel = level;
+    this.methodFactory.replaceMethods(level);
+
+    if (typeof console === 'undefined' && level < this.levels.SILENT) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        'loglevel: console is undefined. The log will produce no output'
+      );
+    }
+  }
+
+  get levels() { // eslint-disable-line class-methods-use-this
+    return this.methodFactory.levels;
+  }
+}
+
+module.exports = LogLevel;
diff --git a/node_modules/webpack-dev-middleware/node_modules/webpack-log/src/loglevel/MethodFactory.js b/node_modules/webpack-dev-middleware/node_modules/webpack-log/src/loglevel/MethodFactory.js
new file mode 100644
index 00000000..3bbaa6f2
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/node_modules/webpack-log/src/loglevel/MethodFactory.js
@@ -0,0 +1,140 @@
+'use strict';
+
+/* eslint-disable
+  arrow-parens,
+  multiline-ternary,
+  consistent-return,
+  no-param-reassign,
+  prefer-destructuring
+*/
+const noop = () => {};
+
+const levels = Symbol('levels');
+const instance = Symbol('instance');
+
+class MethodFactory {
+  constructor(logger) {
+    this[levels] = {
+      TRACE: 0,
+      DEBUG: 1,
+      INFO: 2,
+      WARN: 3,
+      ERROR: 4,
+      SILENT: 5
+    };
+
+    this[instance] = logger;
+  }
+
+  set logger(logger) {
+    this[instance] = logger;
+  }
+
+  get logger() {
+    return this[instance];
+  }
+
+  get levels() {
+    return this[levels];
+  }
+
+  get methods() {
+    return Object.keys(this.levels)
+      .map((key) => key.toLowerCase())
+      .filter((key) => key !== 'silent');
+  }
+
+  distillLevel(level) {
+    let result = level;
+
+    if (
+      typeof result === 'string' &&
+      typeof this.levels[result.toUpperCase()] !== 'undefined'
+    ) {
+      result = this.levels[result.toUpperCase()];
+    }
+
+    if (this.levelValid(result)) {
+      return result;
+    }
+  }
+
+  levelValid(level) {
+    if (
+      typeof level === 'number' && level >= 0 &&
+      level <= this.levels.SILENT
+    ) {
+      return true;
+    }
+
+    return false;
+  }
+  /**
+   * Build the best logging method possible for this env
+   * Wherever possible we want to bind, not wrap, to preserve stack traces.
+   * Since we're targeting modern browsers, there's no need to wait for the
+   * console to become available.
+   */
+  // eslint-disable-next-line class-methods-use-this
+  make(method) {
+    if (method === 'debug') {
+      method = 'log';
+    }
+
+    /* eslint-disable no-console */
+    if (typeof console[method] !== 'undefined') {
+      return this.bindMethod(console, method);
+    } else if (typeof console.log !== 'undefined') {
+      return this.bindMethod(console, 'log');
+    }
+
+    /* eslint-enable no-console */
+    return noop;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  bindMethod(obj, name) {
+    const method = obj[name];
+
+    if (typeof method.bind === 'function') {
+      return method.bind(obj);
+    }
+
+    try {
+      return Function.prototype.bind.call(method, obj);
+    } catch (err) {
+      // Missing bind shim or IE8 + Modernizr, fallback to wrapping
+      return function result() {
+        // eslint-disable-next-line prefer-rest-params
+        return Function.prototype.apply.apply(method, [obj, arguments]);
+      };
+    }
+  }
+
+  replaceMethods(logLevel) {
+    const level = this.distillLevel(logLevel);
+
+    if (level == null) {
+      throw new Error(
+        `loglevel: replaceMethods() called with invalid level: ${logLevel}`
+      );
+    }
+
+    if (!this.logger || this.logger.type !== 'LogLevel') {
+      throw new TypeError(
+        'loglevel: Logger is undefined or invalid. Please specify a valid Logger instance.'
+      );
+    }
+
+    this.methods.forEach((method) => {
+      this.logger[method] = (this.levels[method.toUpperCase()] < level)
+        ? noop
+        : this.make(method);
+    });
+
+    // Define log.log as an alias for log.debug
+    this.logger.log = this.logger.debug;
+  }
+}
+
+module.exports = MethodFactory;
diff --git a/node_modules/webpack-dev-middleware/node_modules/webpack-log/src/loglevel/PrefixFactory.js b/node_modules/webpack-dev-middleware/node_modules/webpack-log/src/loglevel/PrefixFactory.js
new file mode 100644
index 00000000..83aa4f18
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/node_modules/webpack-log/src/loglevel/PrefixFactory.js
@@ -0,0 +1,60 @@
+'use strict';
+
+/* eslint-disable
+  no-param-reassign,
+  space-before-function-paren
+*/
+const MethodFactory = require('./MethodFactory');
+
+const defaults = {
+  name (options) {
+    return options.logger.name;
+  },
+  time () {
+    return new Date().toTimeString().split(' ')[0];
+  },
+  level (options) {
+    return `[${options.level}]`;
+  },
+  template: '{{time}} {{level}} '
+};
+
+class PrefixFactory extends MethodFactory {
+  constructor(logger, options) {
+    super(logger);
+
+    this.options = Object.assign({}, defaults, options);
+  }
+
+  interpolate(level) {
+    return this.options.template.replace(/{{([^{}]*)}}/g, (stache, prop) => {
+      const fn = this.options[prop];
+
+      if (fn) {
+        return fn({ level, logger: this.logger });
+      }
+
+      return stache;
+    });
+  }
+
+  make(method) {
+    const og = super.make(method);
+
+    return (...args) => {
+      const [first] = args;
+
+      const output = this.interpolate(method);
+
+      if (typeof first === 'string') {
+        args[0] = output + first;
+      } else {
+        args.unshift(output);
+      }
+
+      og(...args);
+    };
+  }
+}
+
+module.exports = PrefixFactory;
diff --git a/node_modules/webpack-dev-middleware/node_modules/webpack-log/src/loglevel/index.js b/node_modules/webpack-dev-middleware/node_modules/webpack-log/src/loglevel/index.js
new file mode 100644
index 00000000..f6e2e42f
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/node_modules/webpack-log/src/loglevel/index.js
@@ -0,0 +1,64 @@
+'use strict';
+
+/* global window: true */
+/* eslint-disable
+  no-shadow,
+  no-param-reassign,
+  space-before-function-paren
+*/
+const LogLevel = require('./LogLevel');
+const MethodFactory = require('./MethodFactory');
+const PrefixFactory = require('./PrefixFactory');
+
+const defaultLogger = new LogLevel({ name: 'default' });
+const cache = { default: defaultLogger };
+
+// Grab the current global log variable in case of overwrite
+const existing = (typeof window !== 'undefined') ? window.log : null;
+
+const loglevel = Object.assign(defaultLogger, {
+  get factories() {
+    return {
+      MethodFactory,
+      PrefixFactory
+    };
+  },
+  get loggers() {
+    return cache;
+  },
+  getLogger(options) {
+    if (typeof options === 'string') {
+      options = { name: options };
+    }
+
+    if (!options.id) {
+      options.id = options.name;
+    }
+
+    const { name, id } = options;
+    const defaults = { level: defaultLogger.level };
+
+    if (typeof name !== 'string' || !name || !name.length) {
+      throw new TypeError('You must supply a name when creating a logger');
+    }
+
+    let logger = cache[id];
+
+    if (!logger) {
+      logger = new LogLevel(Object.assign({}, defaults, options));
+
+      cache[id] = logger;
+    }
+
+    return logger;
+  },
+  noConflict() {
+    if (typeof window !== 'undefined' && window.log === defaultLogger) {
+      window.log = existing;
+    }
+
+    return defaultLogger;
+  }
+});
+
+module.exports = loglevel;
diff --git a/node_modules/webpack-dev-middleware/package.json b/node_modules/webpack-dev-middleware/package.json
new file mode 100644
index 00000000..7edad9f2
--- /dev/null
+++ b/node_modules/webpack-dev-middleware/package.json
@@ -0,0 +1,46 @@
+{
+  "name": "webpack-dev-middleware",
+  "version": "3.4.0",
+  "description": "A development middleware for webpack",
+  "main": "index.js",
+  "files": [
+    "lib",
+    "index.js"
+  ],
+  "engines": {
+    "node": ">= 6"
+  },
+  "scripts": {
+    "lint": "eslint index.js lib test",
+    "test": "nyc --reporter lcovonly mocha --full-trace --check-leaks --exit",
+    "release": "standard-version"
+  },
+  "dependencies": {
+    "memory-fs": "~0.4.1",
+    "mime": "^2.3.1",
+    "range-parser": "^1.0.3",
+    "webpack-log": "^2.0.0"
+  },
+  "devDependencies": {
+    "assert": "^1.4.1",
+    "eslint": "^5.4.0",
+    "eslint-config-webpack": "^1.2.5",
+    "eslint-plugin-import": "^2.14.0",
+    "express": "^4.14.0",
+    "file-loader": "^2.0.0",
+    "mocha": "^5.2.0",
+    "nyc": "^12.0.2",
+    "sinon": "^6.1.5",
+    "standard-version": "^4.4.0",
+    "supertest": "^3.1.0",
+    "webpack": "^4.17.1"
+  },
+  "peerDependencies": {
+    "webpack": "^4.0.0"
+  },
+  "author": "Tobias Koppers @sokra",
+  "bugs": "https://github.com/webpack/webpack-dev-middleware/issues",
+  "homepage": "https://github.com/webpack/webpack-dev-middleware",
+  "repository": "https://github.com/webpack/webpack-dev-middleware.git",
+  "license": "MIT"
+}