switch to vuepress

17 files changed, 2632 insertions, 0 deletions

diff --git a/node_modules/vuepress-html-webpack-plugin/CHANGELOG.md b/node_modules/vuepress-html-webpack-plugin/CHANGELOG.md
new file mode 100644
index 00000000..48108ea1
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/CHANGELOG.md
@@ -0,0 +1,452 @@
+# 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.2.0"></a>
+# [3.2.0](https://github.com/jantimon/html-webpack-plugin/compare/v3.1.0...v3.2.0) (2018-04-03)
+
+
+### Bug Fixes
+
+* **loader:** Allow to add new template parameters ([f7eac19](https://github.com/jantimon/html-webpack-plugin/commit/f7eac19)), closes [#915](https://github.com/jantimon/html-webpack-plugin/issues/915)
+* **loader:** Use lodash inside the loader directly ([7b4eb7f](https://github.com/jantimon/html-webpack-plugin/commit/7b4eb7f)), closes [#786](https://github.com/jantimon/html-webpack-plugin/issues/786)
+
+
+### Features
+
+* Add meta tag option ([a7d37ca](https://github.com/jantimon/html-webpack-plugin/commit/a7d37ca))
+* Support node 6.9 ([74a22c4](https://github.com/jantimon/html-webpack-plugin/commit/74a22c4)), closes [#918](https://github.com/jantimon/html-webpack-plugin/issues/918)
+
+
+
+<a name="3.1.0"></a>
+# [3.1.0](https://github.com/jantimon/html-webpack-plugin/compare/v3.0.8...v3.1.0) (2018-03-22)
+
+
+### Features
+
+* Allow to overwrite the templateParameter [#830](https://github.com/jantimon/html-webpack-plugin/issues/830) ([c5e32d3](https://github.com/jantimon/html-webpack-plugin/commit/c5e32d3))
+
+
+
+<a name="3.0.8"></a>
+## [3.0.8](https://github.com/jantimon/html-webpack-plugin/compare/v3.0.7...v3.0.8) (2018-03-22)
+
+
+### Bug Fixes
+
+* **compiler:** Fallback to 3.0.7 because of [#900](https://github.com/jantimon/html-webpack-plugin/issues/900) ([05ee29b](https://github.com/jantimon/html-webpack-plugin/commit/05ee29b))
+
+
+
+<a name="3.0.7"></a>
+## [3.0.7](https://github.com/jantimon/html-webpack-plugin/compare/v3.0.6...v3.0.7) (2018-03-19)
+
+
+### Bug Fixes
+
+* **compiler:** Set single entry name [#895](https://github.com/jantimon/html-webpack-plugin/issues/895) ([26dcb98](https://github.com/jantimon/html-webpack-plugin/commit/26dcb98))
+
+
+
+<a name="3.0.6"></a>
+## [3.0.6](https://github.com/jantimon/html-webpack-plugin/compare/v3.0.5...v3.0.6) (2018-03-06)
+
+
+### Bug Fixes
+
+* **hooks:** Call tapable.apply directly [#879](https://github.com/jantimon/html-webpack-plugin/issues/879) ([bcbb036](https://github.com/jantimon/html-webpack-plugin/commit/bcbb036))
+
+
+
+<a name="3.0.5"></a>
+## [3.0.5](https://github.com/jantimon/html-webpack-plugin/compare/v3.0.2...v3.0.5) (2018-03-06)
+
+
+### Bug Fixes
+
+* **entries:** do not ignore JS if there is also CSS ([020b714](https://github.com/jantimon/html-webpack-plugin/commit/020b714))
+* **entries:** Don't add css entries twice ([0348d6b](https://github.com/jantimon/html-webpack-plugin/commit/0348d6b))
+* **hooks:** Remove deprecated tapable calls [#879](https://github.com/jantimon/html-webpack-plugin/issues/879) ([2288f20](https://github.com/jantimon/html-webpack-plugin/commit/2288f20))
+
+
+
+<a name="3.0.4"></a>
+## [3.0.4](https://github.com/jantimon/html-webpack-plugin/compare/v3.0.2...v3.0.4) (2018-03-01)
+
+
+### Bug Fixes
+
+* **entries:** Don't add css entries twice ([e890f23](https://github.com/jantimon/html-webpack-plugin/commit/e890f23))
+
+
+
+<a name="3.0.3"></a>
+## [3.0.3](https://github.com/jantimon/html-webpack-plugin/compare/v3.0.2...v3.0.3) (2018-03-01)
+
+
+### Refactor
+
+* **performance:** Reduce the amount of chunk information gathered based on #825 ([06c59a7](https://github.com/jantimon/html-webpack-plugin/commit/06c59a7))
+
+
+<a name="3.0.2"></a>
+## [3.0.2](https://github.com/jantimon/html-webpack-plugin/compare/v3.0.1...v3.0.2) (2018-03-01)
+
+
+### Bug Fixes
+
+* **query-loader:** In case no query is provided, return an empty object. This fixes #727 ([7587754](https://github.com/jantimon/html-webpack-plugin/commit/7587754))
+
+
+
+<a name="3.0.1"></a>
+## [3.0.1](https://github.com/jantimon/html-webpack-plugin/compare/v3.0.0...v3.0.1) (2018-03-01)
+
+
+### Bug Fixes
+
+* **package:** Remove the extract-text-webpack-plugin peer dependency ([57411a9](https://github.com/jantimon/html-webpack-plugin/commit/57411a9))
+
+<a name="3.0.0"></a>
+## [3.0.0](https://github.com/jantimon/html-webpack-plugin/compare/v2.30.1...v3.0.0) (2018-28-02)
+
+### Features
+
+* Add support for the new [webpack tapable](https://github.com/webpack/tapable) to be compatible with webpack 4.x
+* Remove bluebird dependency
+
+### BREAKING CHANGES
+
+* Similar to webpack 4.x the support for node versions older than 6 are no longer supported
+
+<a name="2.30.1"></a>
+## 2.30.1
+
+* Revert part the performance optimization ([#723](https://github.com/jantimon/html-webpack-plugin/pull/723)) because of [#753](https://github.com/jantimon/html-webpack-plugin/issues/753).
+
+<a name="2.30.0"></a>
+## 2.30.0
+
+* Add manual sort
+* Performance improvements ([#723](https://github.com/jantimon/html-webpack-plugin/pull/723))
+
+<a name="2.29.0"></a>
+## 2.29.0
+
+* Add support for Webpack 3
+
+<a name="2.28.0"></a>
+## 2.28.0
+
+* Backport 3.x void tag for plugin authors
+
+<a name="2.27.1"></a>
+## 2.27.1
+
+* Revert 2.25.0 loader resolving
+
+<a name="2.27.0"></a>
+## 2.27.0
+
+* Fix a chunksorter webpack 2 issue ([#569](https://github.com/jantimon/html-webpack-plugin/pull/569))
+* Fix template path resolving ([#542](https://github.com/jantimon/html-webpack-plugin/pull/542))
+
+<a name="2.26.0"></a>
+## 2.26.0
+
+* Allow plugins to add attributes without values to the `<script>` and `<link>` tags
+
+<a name="2.25.0"></a>
+## 2.25.0
+
+* Clearer loader output
+* Add basic support for webpack 2
+
+<a name="2.24.1"></a>
+## 2.24.1
+
+* Hide event deprecated warning of 'applyPluginsAsyncWaterfall' for html-webpack-plugin-after-emit and improve the warning message.
+
+<a name="2.24.0"></a>
+## 2.24.0
+
+* Update dependencies
+* Add deprecate warning for plugins not returning a result
+* Add [path] for favicons
+
+<a name="2.23.0"></a>
+## 2.23.0
+
+* Update dependencies
+* Stop automated tests for webpack 2 beta because of [#401](https://github.com/jantimon/html-webpack-plugin/issues/401)
+
+<a name="2.22.0"></a>
+## 2.22.0
+
+* Update dependencies
+
+<a name="2.21.1"></a>
+## 2.21.1
+
+* Better error handling ([#354](https://github.com/jantimon/html-webpack-plugin/pull/354))
+
+<a name="2.21.0"></a>
+## 2.21.0
+
+* Add `html-webpack-plugin-alter-asset-tags` event to allow plugins to adjust the script/link tags
+
+<a name="2.20.0"></a>
+## 2.20.0
+
+* Exclude chunks works now even if combined with dependency sort
+
+<a name="2.19.0"></a>
+## 2.19.0
+
+* Add `html-webpack-plugin-alter-chunks` event for custom chunk sorting and interpolation
+
+<a name="2.18.0"></a>
+## 2.18.0
+
+* Updated all dependencies
+
+<a name="2.17.0"></a>
+## 2.17.0
+
+* Add `type` attribute to `script` element to prevent issues in Safari 9.1.1
+
+<a name="2.16.2"></a>
+## 2.16.2
+
+* Fix bug introduced by 2.16.2. Fixes  [#315](https://github.com/jantimon/html-webpack-plugin/issues/315)
+
+<a name="2.16.1"></a>
+## 2.16.1
+
+* Fix hot module replacement for webpack 2.x
+
+<a name="2.16.0"></a>
+## 2.16.0
+
+* Add support for dynamic filenames like index[hash].html
+
+<a name="2.15.0"></a>
+## 2.15.0
+
+* Add full unit test coverage for the webpack 2 beta version
+* For webpack 2 the default sort will be 'dependency' instead of 'id'
+* Upgrade dependencies
+
+<a name="2.14.0"></a>
+## 2.14.0
+
+* Export publicPath to the template
+* Add example for inlining css and js
+
+<a name="2.13.0"></a>
+## 2.13.0
+
+* Add support for absolute output file names
+* Add support for relative file names outside the output path
+
+<a name="2.12.0"></a>
+## 2.12.0
+
+* Basic Webpack 2.x support #225
+
+<a name="2.11.0"></a>
+## 2.11.0
+
+* Add `xhtml` option which is turned of by default. When activated it will inject self closed `<link href=".." />` tags instead of unclosed `<link href="..">` tags. ([#255](https://github.com/ampedandwired/html-webpack-plugin/pull/255))
+* Add support for webpack placeholders inside the public path e.g. `'/dist/[hash]/'`. ([#249](https://github.com/ampedandwired/html-webpack-plugin/pull/249))
+
+<a name="2.10.0"></a>
+## 2.10.0
+
+* Add `hash` field to the chunk object
+* Add `compilation` field to the templateParam object ([#237](https://github.com/ampedandwired/html-webpack-plugin/issues/237))
+* Add `html-webpack-plugin-before-html-generation` event
+* Improve error messages
+
+<a name="2.9.0"></a>
+## 2.9.0
+
+* Fix favicon path ([#185](https://github.com/ampedandwired/html-webpack-plugin/issues/185), [#208](https://github.com/ampedandwired/html-webpack-plugin/issues/208), [#215](https://github.com/ampedandwired/html-webpack-plugin/pull/215))
+
+<a name="2.8.2"></a>
+## 2.8.2
+
+* Support relative URLs on Windows ([#205](https://github.com/ampedandwired/html-webpack-plugin/issues/205))
+
+<a name="2.8.1"></a>
+## 2.8.1
+
+* Caching improvements ([#204](https://github.com/ampedandwired/html-webpack-plugin/issues/204))
+
+<a name="2.8.0"></a>
+## 2.8.0
+
+* Add `dependency` mode for `chunksSortMode` to sort chunks based on their dependencies with each other
+
+<a name="2.7.2"></a>
+## 2.7.2
+
+* Add support for require in js templates
+
+<a name="2.7.1"></a>
+## 2.7.1
+
+* Refactoring
+* Fix relative windows path
+
+<a name="2.6.5"></a>
+## 2.6.5
+
+* Minor refactoring
+
+<a name="2.6.4"></a>
+## 2.6.4
+
+* Fix for `"Uncaught TypeError: __webpack_require__(...) is not a function"`
+* Fix incomplete cache modules causing "HtmlWebpackPlugin Error: No source available"
+* Fix some issues on Windows
+
+<a name="2.6.3"></a>
+## 2.6.3
+
+* Prevent parsing the base template with the html-loader
+
+<a name="2.6.2"></a>
+## 2.6.2
+
+* Fix `lodash` resolve error ([#172](https://github.com/ampedandwired/html-webpack-plugin/issues/172))
+
+<a name="2.6.1"></a>
+## 2.6.1
+
+* Fix missing module ([#164](https://github.com/ampedandwired/html-webpack-plugin/issues/164))
+
+<a name="2.6.0"></a>
+## 2.6.0
+
+* Move compiler to its own file
+* Improve error messages
+* Fix global HTML_WEBPACK_PLUGIN variable
+
+<a name="2.5.0"></a>
+## 2.5.0
+
+* Support `lodash` template's HTML _"escape"_ delimiter (`<%- %>`)
+* Fix bluebird warning ([#130](https://github.com/ampedandwired/html-webpack-plugin/issues/130))
+* Fix an issue where incomplete cache modules were used
+
+<a name="2.4.0"></a>
+## 2.4.0
+
+* Don't recompile if the assets didn't change
+
+<a name="2.3.0"></a>
+## 2.3.0
+
+* Add events `html-webpack-plugin-before-html-processing`, `html-webpack-plugin-after-html-processing`, `html-webpack-plugin-after-emit` to allow other plugins to alter the html this plugin executes
+
+<a name="2.2.0"></a>
+## 2.2.0
+
+* Inject css and js even if the html file is incomplete ([#135](https://github.com/ampedandwired/html-webpack-plugin/issues/135))
+* Update dependencies
+
+<a name="2.1.0"></a>
+## 2.1.0
+
+* Synchronize with the stable `@1` version
+
+<a name="2.0.4"></a>
+## 2.0.4
+
+* Fix `minify` option
+* Fix missing hash interpolation in publicPath
+
+<a name="2.0.3"></a>
+## 2.0.3
+
+* Add support for webpack.BannerPlugin
+
+<a name="2.0.2"></a>
+## 2.0.2
+
+* Add support for loaders in templates ([#41](https://github.com/ampedandwired/html-webpack-plugin/pull/41))
+* Remove `templateContent` option from configuration
+* Better error messages
+* Update dependencies
+
+
+<a name="1.7.0"></a>
+## 1.7.0
+
+* Add `chunksSortMode` option to configuration to control how chunks should be sorted before they are included to the html
+* Don't insert async chunks into html ([#95](https://github.com/ampedandwired/html-webpack-plugin/issues/95))
+* Update dependencies
+
+<a name="1.6.2"></a>
+## 1.6.2
+
+* Fix paths on Windows
+* Fix missing hash interpolation in publicPath
+* Allow only `false` or `object` in `minify` configuration option
+
+<a name="1.6.1"></a>
+## 1.6.1
+
+* Add `size` field to the chunk object
+* Fix stylesheet `<link>`s being discarded when used with `"inject: 'head'"`
+* Update dependencies
+
+<a name="1.6.0"></a>
+## 1.6.0
+
+* Support placing templates in subfolders
+* Don't include chunks with undefined name ([#60](https://github.com/ampedandwired/html-webpack-plugin/pull/60))
+* Don't include async chunks
+
+<a name="1.5.2"></a>
+## 1.5.2
+
+* Update dependencies (lodash)
+
+<a name="1.5.1"></a>
+## 1.5.1
+
+* Fix error when manifest is specified ([#56](https://github.com/ampedandwired/html-webpack-plugin/issues/56))
+
+<a name="1.5.0"></a>
+## 1.5.0
+
+* Allow to inject javascript files into the head of the html page
+* Fix error reporting
+
+<a name="1.4.0"></a>
+## 1.4.0
+
+* Add `favicon.ico` option
+* Add html minifcation
+
+<a name="1.2.0"></a>
+## 1.2.0
+
+* Set charset using HTML5 meta attribute
+* Reload upon change when using webpack watch mode
+* Generate manifest attribute when using
+  [appcache-webpack-plugin](https://github.com/lettertwo/appcache-webpack-plugin)
+* Optionally add webpack hash as a query string to resources included in the HTML
+  (`hash: true`) for cache busting
+* CSS files generated using webpack (for example, by using the
+  [extract-text-webpack-plugin](https://github.com/webpack/extract-text-webpack-plugin))
+  are now automatically included into the generated HTML
+* More detailed information about the files generated by webpack is now available
+  to templates in the `o.htmlWebpackPlugin.files` attribute. See readme for more
+  details. This new attribute deprecates the old `o.htmlWebpackPlugin.assets` attribute.
+* The `templateContent` option can now be a function that returns the template string to use
+* Expose webpack configuration to templates (`o.webpackConfig`)
+* Sort chunks to honour dependencies between them (useful for use with CommonsChunkPlugin).
diff --git a/node_modules/vuepress-html-webpack-plugin/LICENSE b/node_modules/vuepress-html-webpack-plugin/LICENSE
new file mode 100644
index 00000000..8c11fc72
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/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/vuepress-html-webpack-plugin/README.md b/node_modules/vuepress-html-webpack-plugin/README.md
new file mode 100644
index 00000000..1f490cb4
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/README.md
@@ -0,0 +1,419 @@
+# Fork
+
+This is published as `vuepress-html-webpack-plugin` to be used in VuePress. This is to fix a situation when the user installs a version of `html-webpack-plugin` that is compatible with VuePress' (which causes it to be hoisted to `node_modules` root) but also with a version of webpack that is incompatible. Because `html-webpack-plugin` directly make requires into webpack internals, it ends up requiring the internal modules from the incompatible version of webpack.
+
+[![npm][npm]][npm-url]
+[![node][node]][node-url]
+![npm](https://img.shields.io/npm/dw/html-webpack-plugin.svg)
+[![deps][deps]][deps-url]
+[![tests][tests]][tests-url]
+[![Backers on Open Collective](https://opencollective.com/html-webpack-plugin/backers/badge.svg)](#backers)
+ [![Sponsors on Open Collective](https://opencollective.com/html-webpack-plugin/sponsors/badge.svg)](#sponsors)
+
+<div align="center">
+  <img width="200" height="200" src="https://worldvectorlogo.com/logos/html5.svg">
+  <a href="https://github.com/webpack/webpack">
+    <img width="200" height="200"
+      src="https://webpack.js.org/assets/icon-square-big.svg">
+  </a>
+  <div>
+    <img width="100" height="100" title="Webpack Plugin" src="http://michael-ciniawsky.github.io/postcss-load-plugins/logo.svg">
+  </div>
+  <h1>HTML Webpack Plugin</h1>
+  <p>Plugin that simplifies creation of HTML files to serve your bundles</p>
+</div>
+
+<h2 align="center">Install</h2>
+
+
+```bash
+  npm i --save-dev html-webpack-plugin
+```
+
+```bash
+  yarn add --dev html-webpack-plugin
+```
+
+
+
+This is a [webpack](http://webpack.js.org/) plugin that simplifies creation of HTML files to serve your `webpack` bundles. This is especially useful for `webpack` bundles that include a hash in the filename which changes every compilation. You can either let the plugin generate an HTML file for you, supply
+your own template using `lodash` templates or use your own loader.
+
+### `Plugins`
+
+The `html-webpack-plugin` provides [hooks](https://github.com/jantimon/html-webpack-plugin#events) to extend it to your needs. There are already some really powerful plugins which can be integrated with zero configuration
+
+ * [webpack-subresource-integrity](https://www.npmjs.com/package/webpack-subresource-integrity) for enhanced asset security
+ * [appcache-webpack-plugin](https://github.com/lettertwo/appcache-webpack-plugin) for iOS and Android offline usage
+ * [favicons-webpack-plugin](https://github.com/jantimon/favicons-webpack-plugin) which generates favicons and icons for iOS, Android and desktop browsers
+ * [html-webpack-harddisk-plugin](https://github.com/jantimon/html-webpack-harddisk-plugin) can be used to always write to disk the html file, useful when webpack-dev-server / HMR are being used
+ * [html-webpack-inline-source-plugin](https://github.com/DustinJackson/html-webpack-inline-source-plugin) to inline your assets in the resulting HTML file
+ * [html-webpack-inline-svg-plugin](https://github.com/thegc/html-webpack-inline-svg-plugin) to inline SVGs in the resulting HTML file.
+ * [html-webpack-exclude-assets-plugin](https://github.com/jamesjieye/html-webpack-exclude-assets-plugin) for excluding assets using regular expressions
+ * [html-webpack-include-assets-plugin](https://github.com/jharris4/html-webpack-include-assets-plugin) for including lists of js or css file paths (such as those copied by the copy-webpack-plugin).
+ * [script-ext-html-webpack-plugin](https://github.com/numical/script-ext-html-webpack-plugin) to add `async`, `defer` or `module` attributes to your `<script>` elements, or even inline them
+ * [style-ext-html-webpack-plugin](https://github.com/numical/style-ext-html-webpack-plugin) to convert your `<link>`s to external stylesheets into `<style>` elements containing internal CSS
+ * [resource-hints-webpack-plugin](https://github.com/jantimon/resource-hints-webpack-plugin) to add resource hints for faster initial page loads using `<link rel='preload'>` and `<link rel='prefetch'>`
+ * [preload-webpack-plugin](https://github.com/GoogleChrome/preload-webpack-plugin) for automatically wiring up asynchronous (and other types) of JavaScript chunks using `<link rel='preload'>` helping with lazy-loading
+ * [link-media-html-webpack-plugin](https://github.com/yaycmyk/link-media-html-webpack-plugin) allows for injected stylesheet `<link />` tags to have their media attribute set automatically; useful for providing specific desktop/mobile/print etc. stylesheets that the browser will conditionally download
+ * [inline-chunk-manifest-html-webpack-plugin](https://github.com/jouni-kantola/inline-chunk-manifest-html-webpack-plugin) for inlining webpack's chunk manifest. Default extracts manifest and inlines in `<head>`
+ * [html-webpack-inline-style-plugin](https://github.com/djaax/html-webpack-inline-style-plugin) for inlining styles to HTML elements using [juice](https://github.com/Automattic/juice). Useful for email generation automatisation.
+ * [html-webpack-exclude-empty-assets-plugin](https://github.com/KnisterPeter/html-webpack-exclude-empty-assets-plugin) removes empty assets from being added to the html. This fixes some problems with extract-text-plugin with webpack 4.
+ * [webpack-concat-plugin](https://github.com/hxlniada/webpack-concat-plugin) for concat and uglify files that needn't to be webpack bundles(for legacy files) and inject to html-webpack-plugin.
+
+
+<h2 align="center">Usage</h2>
+
+The plugin will generate an HTML5 file for you that includes all your `webpack`
+bundles in the body using `script` tags. Just add the plugin to your `webpack`
+config as follows:
+
+**webpack.config.js**
+```js
+const HtmlWebpackPlugin = require('html-webpack-plugin')
+
+module.exports = {
+  entry: 'index.js',
+  output: {
+    path: __dirname + '/dist',
+    filename: 'index_bundle.js'
+  },
+  plugins: [
+    new HtmlWebpackPlugin()
+  ]
+}
+```
+
+This will generate a file `dist/index.html` containing the following
+
+```html
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <title>Webpack App</title>
+  </head>
+  <body>
+    <script src="index_bundle.js"></script>
+  </body>
+</html>
+```
+
+If you have multiple `webpack` entry points, they will all be included with `script` tags in the generated HTML.
+
+If you have any CSS assets in webpack's output (for example, CSS extracted with the [ExtractTextPlugin](https://github.com/webpack/extract-text-webpack-plugin))
+then these will be included with `<link>` tags in the HTML head.
+
+If you have plugins that make use of it, `html-webpack-plugin` should be ordered first before any of the integrated plugins.
+
+<h2 align="center">Options</h2>
+
+You can pass a hash of configuration options to `html-webpack-plugin`.
+Allowed values are as follows
+
+|Name|Type|Default|Description|
+|:--:|:--:|:-----:|:----------|
+|**[`title`](#)**|`{String}`|``|The title to use for the generated HTML document|
+|**[`filename`](#)**|`{String}`|`'index.html'`|The file to write the HTML to. Defaults to `index.html`. You can specify a subdirectory here too (eg: `assets/admin.html`)|
+|**[`template`](#)**|`{String}`|``|`webpack` require path to the template. Please see the [docs](https://github.com/jantimon/html-webpack-plugin/blob/master/docs/template-option.md) for details|
+|**[`templateParameters`](#)**|`{Boolean\|Object\|Function}`|``| Allows to overwrite the parameters used in the template |
+|**[`inject`](#)**|`{Boolean\|String}`|`true`|`true \|\| 'head' \|\| 'body' \|\| false` Inject all assets into the given `template` or `templateContent`. When passing `true` or `'body'` all javascript resources will be placed at the bottom of the body element. `'head'` will place the scripts in the head element|
+|**[`favicon`](#)**|`{String}`|``|Adds the given favicon path to the output HTML|
+|**[`meta`](#)**|`{Object}`|`{}`|Allows to inject `meta`-tags. E.g. `meta: {viewport: 'width=device-width, initial-scale=1, shrink-to-fit=no'}`|
+|**[`minify`](#)**|`{Boolean\|Object}`|`true`|Pass [html-minifier](https://github.com/kangax/html-minifier#options-quick-reference)'s options as object to minify the output|
+|**[`hash`](#)**|`{Boolean}`|`false`|If `true` then append a unique `webpack` compilation hash to all included scripts and CSS files. This is useful for cache busting|
+|**[`cache`](#)**|`{Boolean}`|`true`|Emit the file only if it was changed|
+|**[`showErrors`](#)**|`{Boolean}`|`true`|Errors details will be written into the HTML page|
+|**[`chunks`](#)**|`{?}`|`?`|Allows you to add only some chunks (e.g only the unit-test chunk)|
+|**[`chunksSortMode`](#plugins)**|`{String\|Function}`|`auto`|Allows to control how chunks should be sorted before they are included to the HTML. Allowed values are `'none' \| 'auto' \| 'dependency' \| 'manual' \| {Function}`|
+|**[`excludeChunks`](#)**|`{Array.<string>}`|``|Allows you to skip some chunks (e.g don't add the unit-test chunk)|
+|**[`xhtml`](#)**|`{Boolean}`|`false`|If `true` render the `link` tags as self-closing (XHTML compliant)|
+
+Here's an example webpack config illustrating how to use these options
+
+**webpack.config.js**
+```js
+{
+  entry: 'index.js',
+  output: {
+    path: __dirname + '/dist',
+    filename: 'index_bundle.js'
+  },
+  plugins: [
+    new HtmlWebpackPlugin({
+      title: 'My App',
+      filename: 'assets/admin.html'
+    })
+  ]
+}
+```
+
+### `Generating Multiple HTML Files`
+
+To generate more than one HTML file, declare the plugin more than
+once in your plugins array
+
+**webpack.config.js**
+```js
+{
+  entry: 'index.js',
+  output: {
+    path: __dirname + '/dist',
+    filename: 'index_bundle.js'
+  },
+  plugins: [
+    new HtmlWebpackPlugin(), // Generates default index.html
+    new HtmlWebpackPlugin({  // Also generate a test.html
+      filename: 'test.html',
+      template: 'src/assets/test.html'
+    })
+  ]
+}
+```
+
+### `Writing Your Own Templates`
+
+If the default generated HTML doesn't meet your needs you can supply
+your own template. The easiest way is to use the `template` option and pass a custom HTML file.
+The html-webpack-plugin will automatically inject all necessary CSS, JS, manifest
+and favicon files into the markup.
+
+```js
+plugins: [
+  new HtmlWebpackPlugin({
+    title: 'Custom template',
+    // Load a custom template (lodash by default see the FAQ for details)
+    template: 'index.html'
+  })
+]
+```
+
+**index.html**
+```html
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8"/>
+    <title><%= htmlWebpackPlugin.options.title %></title>
+  </head>
+  <body>
+  </body>
+</html>
+```
+
+If you already have a template loader, you can use it to parse the template.
+Please note that this will also happen if you specifiy the html-loader and use `.html` file as template.
+
+**webpack.config.js**
+```js
+module: {
+  loaders: [
+    { test: /\.hbs$/, loader: "handlebars" }
+  ]
+},
+plugins: [
+  new HtmlWebpackPlugin({
+    title: 'Custom template using Handlebars',
+    template: 'index.hbs'
+  })
+]
+```
+
+You can use the `lodash` syntax out of the box. If the `inject` feature doesn't fit your needs and you want full control over the asset placement use the [default template](https://github.com/jaketrent/html-webpack-template/blob/86f285d5c790a6c15263f5cc50fd666d51f974fd/index.html) of the [html-webpack-template project](https://github.com/jaketrent/html-webpack-template) as a starting point for writing your own.
+
+The following variables are available in the template:
+- `htmlWebpackPlugin`: data specific to this plugin
+  - `htmlWebpackPlugin.files`: a massaged representation of the
+    `assetsByChunkName` attribute of webpack's [stats](https://github.com/webpack/docs/wiki/node.js-api#stats)
+    object. It contains a mapping from entry point name to the bundle filename, eg:
+    ```json
+    "htmlWebpackPlugin": {
+      "files": {
+        "css": [ "main.css" ],
+        "js": [ "assets/head_bundle.js", "assets/main_bundle.js"],
+        "chunks": {
+          "head": {
+            "entry": "assets/head_bundle.js",
+            "css": [ "main.css" ]
+          },
+          "main": {
+            "entry": "assets/main_bundle.js",
+            "css": []
+          },
+        }
+      }
+    }
+    ```
+    If you've set a publicPath in your webpack config this will be reflected
+    correctly in this assets hash.
+
+  - `htmlWebpackPlugin.options`: the options hash that was passed to
+     the plugin. In addition to the options actually used by this plugin,
+     you can use this hash to pass arbitrary data through to your template.
+
+- `webpack`: the webpack [stats](https://github.com/webpack/docs/wiki/node.js-api#stats)
+  object. Note that this is the stats object as it was at the time the HTML template
+  was emitted and as such may not have the full set of stats that are available
+  after the webpack run is complete.
+
+- `webpackConfig`: the webpack configuration that was used for this compilation. This
+  can be used, for example, to get the `publicPath` (`webpackConfig.output.publicPath`).
+
+- `compilation`: the webpack [compilation](https://webpack.js.org/api/compilation/) object.
+  This can be used, for example, to get the contents of processed assets and inline them
+  directly in the page, through `compilation.assets[...].source()`
+  (see [the inline template example](examples/inline/template.jade)).
+
+
+### `Filtering Chunks`
+
+To include only certain chunks you can limit the chunks being used
+
+**webpack.config.js**
+```js
+plugins: [
+  new HtmlWebpackPlugin({
+    chunks: ['app']
+  })
+]
+```
+
+It is also possible to exclude certain chunks by setting the `excludeChunks` option
+
+**webpack.config.js**
+```js
+plugins: [
+  new HtmlWebpackPlugin({
+    excludeChunks: [ 'dev-helper' ]
+  })
+]
+```
+
+### `Events`
+
+To allow other [plugins](https://github.com/webpack/docs/wiki/plugins) to alter the HTML this plugin executes the following events:
+
+#### `Sync`
+
+* `html-webpack-plugin-alter-chunks`
+
+#### `Async`
+
+* `html-webpack-plugin-before-html-generation`
+* `html-webpack-plugin-before-html-processing`
+* `html-webpack-plugin-alter-asset-tags`
+* `html-webpack-plugin-after-html-processing`
+* `html-webpack-plugin-after-emit`
+
+Example implementation: [html-webpack-harddisk-plugin](https://github.com/jantimon/html-webpack-harddisk-plugin)
+
+**plugin.js**
+```js
+function MyPlugin(options) {
+  // Configure your plugin with options...
+}
+
+MyPlugin.prototype.apply = function (compiler) {
+  compiler.plugin('compilation', (compilation) => {
+    console.log('The compiler is starting a new compilation...');
+
+    compilation.plugin(
+      'html-webpack-plugin-before-html-processing',
+      (data, cb) => {
+        data.html += 'The Magic Footer'
+
+        cb(null, data)
+      }
+    )
+  })
+}
+
+module.exports = MyPlugin
+```
+
+**webpack.config.js**
+```js
+plugins: [
+  new MyPlugin({ options: '' })
+]
+```
+
+Note that the callback must be passed the HtmlWebpackPluginData in order to pass this onto any other plugins listening on the same `html-webpack-plugin-before-html-processing` event
+
+<h2 align="center">Maintainers</h2>
+
+<table>
+  <tbody>
+    <tr>
+      <td align="center">
+        <img width="150" height="150"
+        src="https://avatars3.githubusercontent.com/u/4113649?v=3&s=150">
+        </br>
+        <a href="https://github.com/jantimon">Jan Nicklas</a>
+      </td>
+      <td align="center">
+        <img width="150" height="150"
+        src="https://avatars2.githubusercontent.com/u/4112409?v=3&s=150">
+        </br>
+        <a href="https://github.com/mastilver">Thomas Sileghem</a>
+      </td>
+    </tr>
+  <tbody>
+</table>
+
+
+[npm]: https://img.shields.io/npm/v/html-webpack-plugin.svg
+[npm-url]: https://npmjs.com/package/html-webpack-plugin
+
+[node]: https://img.shields.io/node/v/html-webpack-plugin.svg
+[node-url]: https://nodejs.org
+
+[deps]: https://david-dm.org/jantimon/html-webpack-plugin.svg
+[deps-url]: https://david-dm.org/jantimon/html-webpack-plugin
+
+[tests]: http://img.shields.io/travis/jantimon/html-webpack-plugin.svg
+[tests-url]: https://travis-ci.org/jantimon/html-webpack-plugin
+
+
+## Contributors
+
+This project exists thanks to all the people who contribute.
+
+You're free to contribute to this project by submitting [issues](https://github.com/jantimon/html-webpack-plugin/issues) and/or [pull requests](https://github.com/jantimon/html-webpack-plugin/pulls). This project is test-driven, so keep in mind that every change and new feature should be covered by tests.
+
+This project uses the [semistandard code style](https://github.com/Flet/semistandard).
+
+<a href="https://github.com/jantimon/html-webpack-plugin/graphs/contributors"><img src="https://opencollective.com/html-webpack-plugin/contributors.svg?width=890&button=false" /></a>
+
+
+## Backers
+
+Thank you to all our backers! 🙏 [Become a backer](https://opencollective.com/html-webpack-plugin#backer)
+
+<a href="https://opencollective.com/html-webpack-plugin/backer/0/website?requireActive=false" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/backer/0/avatar.svg?requireActive=false"></a>
+<a href="https://opencollective.com/html-webpack-plugin/backer/1/website?requireActive=false" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/backer/1/avatar.svg?requireActive=false"></a>
+<a href="https://opencollective.com/html-webpack-plugin/backer/2/website?requireActive=false" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/backer/2/avatar.svg?requireActive=false"></a>
+<a href="https://opencollective.com/html-webpack-plugin/backer/3/website?requireActive=false" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/backer/3/avatar.svg?requireActive=false"></a>
+<a href="https://opencollective.com/html-webpack-plugin/backer/4/website?requireActive=false" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/backer/4/avatar.svg?requireActive=false"></a>
+<a href="https://opencollective.com/html-webpack-plugin/backer/5/website?requireActive=false" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/backer/5/avatar.svg?requireActive=false"></a>
+<a href="https://opencollective.com/html-webpack-plugin/backer/6/website?requireActive=false" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/backer/6/avatar.svg?requireActive=false"></a>
+<a href="https://opencollective.com/html-webpack-plugin/backer/7/website?requireActive=false" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/backer/7/avatar.svg?requireActive=false"></a>
+<a href="https://opencollective.com/html-webpack-plugin/backer/8/website?requireActive=false" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/backer/8/avatar.svg?requireActive=false"></a>
+<a href="https://opencollective.com/html-webpack-plugin/backer/9/website?requireActive=false" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/backer/9/avatar.svg?requireActive=false"></a>
+
+## Sponsors
+
+Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [Become a sponsor](https://opencollective.com/html-webpack-plugin#sponsor)
+
+<a href="https://opencollective.com/html-webpack-plugin/sponsor/0/website" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/sponsor/0/avatar.svg"></a>
+<a href="https://opencollective.com/html-webpack-plugin/sponsor/1/website" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/sponsor/1/avatar.svg"></a>
+<a href="https://opencollective.com/html-webpack-plugin/sponsor/2/website" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/sponsor/2/avatar.svg"></a>
+<a href="https://opencollective.com/html-webpack-plugin/sponsor/3/website" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/sponsor/3/avatar.svg"></a>
+<a href="https://opencollective.com/html-webpack-plugin/sponsor/4/website" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/sponsor/4/avatar.svg"></a>
+<a href="https://opencollective.com/html-webpack-plugin/sponsor/5/website" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/sponsor/5/avatar.svg"></a>
+<a href="https://opencollective.com/html-webpack-plugin/sponsor/6/website" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/sponsor/6/avatar.svg"></a>
+<a href="https://opencollective.com/html-webpack-plugin/sponsor/7/website" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/sponsor/7/avatar.svg"></a>
+<a href="https://opencollective.com/html-webpack-plugin/sponsor/8/website" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/sponsor/8/avatar.svg"></a>
+<a href="https://opencollective.com/html-webpack-plugin/sponsor/9/website" target="_blank"><img src="https://opencollective.com/html-webpack-plugin/sponsor/9/avatar.svg"></a>
+
+
diff --git a/node_modules/vuepress-html-webpack-plugin/default_index.ejs b/node_modules/vuepress-html-webpack-plugin/default_index.ejs
new file mode 100644
index 00000000..f9466a46
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/default_index.ejs
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <title><%= htmlWebpackPlugin.options.title %></title>
+  </head>
+  <body>
+  </body>
+</html>
\ No newline at end of file
diff --git a/node_modules/vuepress-html-webpack-plugin/index.js b/node_modules/vuepress-html-webpack-plugin/index.js
new file mode 100644
index 00000000..55a357dc
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/index.js
@@ -0,0 +1,729 @@
+'use strict';
+
+// use Polyfill for util.promisify in node versions < v8
+const promisify = require('util.promisify');
+
+const vm = require('vm');
+const fs = require('fs');
+const _ = require('lodash');
+const path = require('path');
+const childCompiler = require('./lib/compiler.js');
+const prettyError = require('./lib/errors.js');
+const chunkSorter = require('./lib/chunksorter.js');
+
+const fsStatAsync = promisify(fs.stat);
+const fsReadFileAsync = promisify(fs.readFile);
+
+class HtmlWebpackPlugin {
+  constructor (options) {
+    // Default options
+    this.options = _.extend({
+      template: path.join(__dirname, 'default_index.ejs'),
+      templateParameters: templateParametersGenerator,
+      filename: 'index.html',
+      hash: false,
+      inject: true,
+      compile: true,
+      favicon: false,
+      minify: false,
+      cache: true,
+      showErrors: true,
+      chunks: 'all',
+      excludeChunks: [],
+      chunksSortMode: 'auto',
+      meta: {},
+      title: 'Webpack App',
+      xhtml: false
+    }, options);
+  }
+
+  apply (compiler) {
+    const self = this;
+    let isCompilationCached = false;
+    let compilationPromise;
+
+    this.options.template = this.getFullTemplatePath(this.options.template, compiler.context);
+
+    // convert absolute filename into relative so that webpack can
+    // generate it at correct location
+    const filename = this.options.filename;
+    if (path.resolve(filename) === path.normalize(filename)) {
+      this.options.filename = path.relative(compiler.options.output.path, filename);
+    }
+
+    // setup hooks for webpack 4
+    if (compiler.hooks) {
+      compiler.hooks.compilation.tap('HtmlWebpackPluginHooks', compilation => {
+        const SyncWaterfallHook = require('tapable').SyncWaterfallHook;
+        const AsyncSeriesWaterfallHook = require('tapable').AsyncSeriesWaterfallHook;
+        compilation.hooks.htmlWebpackPluginAlterChunks = new SyncWaterfallHook(['chunks', 'objectWithPluginRef']);
+        compilation.hooks.htmlWebpackPluginBeforeHtmlGeneration = new AsyncSeriesWaterfallHook(['pluginArgs']);
+        compilation.hooks.htmlWebpackPluginBeforeHtmlProcessing = new AsyncSeriesWaterfallHook(['pluginArgs']);
+        compilation.hooks.htmlWebpackPluginAlterAssetTags = new AsyncSeriesWaterfallHook(['pluginArgs']);
+        compilation.hooks.htmlWebpackPluginAfterHtmlProcessing = new AsyncSeriesWaterfallHook(['pluginArgs']);
+        compilation.hooks.htmlWebpackPluginAfterEmit = new AsyncSeriesWaterfallHook(['pluginArgs']);
+      });
+    }
+
+    // Backwards compatible version of: compiler.hooks.make.tapAsync()
+    (compiler.hooks ? compiler.hooks.make.tapAsync.bind(compiler.hooks.make, 'HtmlWebpackPlugin') : compiler.plugin.bind(compiler, 'make'))((compilation, callback) => {
+      // Compile the template (queued)
+      compilationPromise = childCompiler.compileTemplate(self.options.template, compiler.context, self.options.filename, compilation)
+        .catch(err => {
+          compilation.errors.push(prettyError(err, compiler.context).toString());
+          return {
+            content: self.options.showErrors ? prettyError(err, compiler.context).toJsonHtml() : 'ERROR',
+            outputName: self.options.filename
+          };
+        })
+        .then(compilationResult => {
+          // If the compilation change didnt change the cache is valid
+          isCompilationCached = compilationResult.hash && self.childCompilerHash === compilationResult.hash;
+          self.childCompilerHash = compilationResult.hash;
+          self.childCompilationOutputName = compilationResult.outputName;
+          callback();
+          return compilationResult.content;
+        });
+    });
+
+    // Backwards compatible version of: compiler.plugin.emit.tapAsync()
+    (compiler.hooks ? compiler.hooks.emit.tapAsync.bind(compiler.hooks.emit, 'HtmlWebpackPlugin') : compiler.plugin.bind(compiler, 'emit'))((compilation, callback) => {
+      const applyPluginsAsyncWaterfall = self.applyPluginsAsyncWaterfall(compilation);
+      // Get chunks info as json
+      // Note: we're excluding stuff that we don't need to improve toJson serialization speed.
+      const chunkOnlyConfig = {
+        assets: false,
+        cached: false,
+        children: false,
+        chunks: true,
+        chunkModules: false,
+        chunkOrigins: false,
+        errorDetails: false,
+        hash: false,
+        modules: false,
+        reasons: false,
+        source: false,
+        timings: false,
+        version: false
+      };
+      const allChunks = compilation.getStats().toJson(chunkOnlyConfig).chunks;
+      // Filter chunks (options.chunks and options.excludeCHunks)
+      let chunks = self.filterChunks(allChunks, self.options.chunks, self.options.excludeChunks);
+      // Sort chunks
+      chunks = self.sortChunks(chunks, self.options.chunksSortMode, compilation);
+      // Let plugins alter the chunks and the chunk sorting
+      if (compilation.hooks) {
+        chunks = compilation.hooks.htmlWebpackPluginAlterChunks.call(chunks, { plugin: self });
+      } else {
+        // Before Webpack 4
+        chunks = compilation.applyPluginsWaterfall('html-webpack-plugin-alter-chunks', chunks, { plugin: self });
+      }
+      // Get assets
+      const assets = self.htmlWebpackPluginAssets(compilation, chunks);
+      // If this is a hot update compilation, move on!
+      // This solves a problem where an `index.html` file is generated for hot-update js files
+      // It only happens in Webpack 2, where hot updates are emitted separately before the full bundle
+      if (self.isHotUpdateCompilation(assets)) {
+        return callback();
+      }
+
+      // If the template and the assets did not change we don't have to emit the html
+      const assetJson = JSON.stringify(self.getAssetFiles(assets));
+      if (isCompilationCached && self.options.cache && assetJson === self.assetJson) {
+        return callback();
+      } else {
+        self.assetJson = assetJson;
+      }
+
+      Promise.resolve()
+        // Favicon
+        .then(() => {
+          if (self.options.favicon) {
+            return self.addFileToAssets(self.options.favicon, compilation)
+              .then(faviconBasename => {
+                let publicPath = compilation.mainTemplate.getPublicPath({hash: compilation.hash}) || '';
+                if (publicPath && publicPath.substr(-1) !== '/') {
+                  publicPath += '/';
+                }
+                assets.favicon = publicPath + faviconBasename;
+              });
+          }
+        })
+        // Wait for the compilation to finish
+        .then(() => compilationPromise)
+        .then(compiledTemplate => {
+          // Allow to use a custom function / string instead
+          if (self.options.templateContent !== undefined) {
+            return self.options.templateContent;
+          }
+          // Once everything is compiled evaluate the html factory
+          // and replace it with its content
+          return self.evaluateCompilationResult(compilation, compiledTemplate);
+        })
+        // Allow plugins to make changes to the assets before invoking the template
+        // This only makes sense to use if `inject` is `false`
+        .then(compilationResult => applyPluginsAsyncWaterfall('html-webpack-plugin-before-html-generation', false, {
+          assets: assets,
+          outputName: self.childCompilationOutputName,
+          plugin: self
+        })
+      .then(() => compilationResult))
+        // Execute the template
+        .then(compilationResult => typeof compilationResult !== 'function'
+        ? compilationResult
+        : self.executeTemplate(compilationResult, chunks, assets, compilation))
+        // Allow plugins to change the html before assets are injected
+        .then(html => {
+          const pluginArgs = {html: html, assets: assets, plugin: self, outputName: self.childCompilationOutputName};
+          return applyPluginsAsyncWaterfall('html-webpack-plugin-before-html-processing', true, pluginArgs);
+        })
+        .then(result => {
+          const html = result.html;
+          const assets = result.assets;
+          // Prepare script and link tags
+          const assetTags = self.generateHtmlTags(assets);
+          const pluginArgs = {head: assetTags.head, body: assetTags.body, plugin: self, chunks: chunks, outputName: self.childCompilationOutputName};
+          // Allow plugins to change the assetTag definitions
+          return applyPluginsAsyncWaterfall('html-webpack-plugin-alter-asset-tags', true, pluginArgs)
+            .then(result => self.postProcessHtml(html, assets, { body: result.body, head: result.head })
+            .then(html => _.extend(result, {html: html, assets: assets})));
+        })
+        // Allow plugins to change the html after assets are injected
+        .then(result => {
+          const html = result.html;
+          const assets = result.assets;
+          const pluginArgs = {html: html, assets: assets, plugin: self, outputName: self.childCompilationOutputName};
+          return applyPluginsAsyncWaterfall('html-webpack-plugin-after-html-processing', true, pluginArgs)
+            .then(result => result.html);
+        })
+        .catch(err => {
+          // In case anything went wrong the promise is resolved
+          // with the error message and an error is logged
+          compilation.errors.push(prettyError(err, compiler.context).toString());
+          // Prevent caching
+          self.hash = null;
+          return self.options.showErrors ? prettyError(err, compiler.context).toHtml() : 'ERROR';
+        })
+        .then(html => {
+          // Replace the compilation result with the evaluated html code
+          compilation.assets[self.childCompilationOutputName] = {
+            source: () => html,
+            size: () => html.length
+          };
+        })
+        .then(() => applyPluginsAsyncWaterfall('html-webpack-plugin-after-emit', false, {
+          html: compilation.assets[self.childCompilationOutputName],
+          outputName: self.childCompilationOutputName,
+          plugin: self
+        }).catch(err => {
+          console.error(err);
+          return null;
+        }).then(() => null))
+        // Let webpack continue with it
+        .then(() => {
+          callback();
+        });
+    });
+  }
+
+  /**
+   * Evaluates the child compilation result
+   * Returns a promise
+   */
+  evaluateCompilationResult (compilation, source) {
+    if (!source) {
+      return Promise.reject('The child compilation didn\'t provide a result');
+    }
+
+    // The LibraryTemplatePlugin stores the template result in a local variable.
+    // To extract the result during the evaluation this part has to be removed.
+    source = source.replace('var HTML_WEBPACK_PLUGIN_RESULT =', '');
+    const template = this.options.template.replace(/^.+!/, '').replace(/\?.+$/, '');
+    const vmContext = vm.createContext(_.extend({HTML_WEBPACK_PLUGIN: true, require: require}, global));
+    const vmScript = new vm.Script(source, {filename: template});
+    // Evaluate code and cast to string
+    let newSource;
+    try {
+      newSource = vmScript.runInContext(vmContext);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+    if (typeof newSource === 'object' && newSource.__esModule && newSource.default) {
+      newSource = newSource.default;
+    }
+    return typeof newSource === 'string' || typeof newSource === 'function'
+      ? Promise.resolve(newSource)
+      : Promise.reject('The loader "' + this.options.template + '" didn\'t return html.');
+  }
+
+  /**
+   * Generate the template parameters for the template function
+   */
+  getTemplateParameters (compilation, assets) {
+    if (typeof this.options.templateParameters === 'function') {
+      return this.options.templateParameters(compilation, assets, this.options);
+    }
+    if (typeof this.options.templateParameters === 'object') {
+      return this.options.templateParameters;
+    }
+    return {};
+  }
+
+  /**
+   * Html post processing
+   *
+   * Returns a promise
+   */
+  executeTemplate (templateFunction, chunks, assets, compilation) {
+    return Promise.resolve()
+      // Template processing
+      .then(() => {
+        const templateParams = this.getTemplateParameters(compilation, assets);
+        let html = '';
+        try {
+          html = templateFunction(templateParams);
+        } catch (e) {
+          compilation.errors.push(new Error('Template execution failed: ' + e));
+          return Promise.reject(e);
+        }
+        return html;
+      });
+  }
+
+  /**
+   * Html post processing
+   *
+   * Returns a promise
+   */
+  postProcessHtml (html, assets, assetTags) {
+    const self = this;
+    if (typeof html !== 'string') {
+      return Promise.reject('Expected html to be a string but got ' + JSON.stringify(html));
+    }
+    return Promise.resolve()
+      // Inject
+      .then(() => {
+        if (self.options.inject) {
+          return self.injectAssetsIntoHtml(html, assets, assetTags);
+        } else {
+          return html;
+        }
+      })
+      // Minify
+      .then(html => {
+        if (self.options.minify) {
+          const minify = require('html-minifier').minify;
+          return minify(html, self.options.minify);
+        }
+        return html;
+      });
+  }
+
+  /*
+   * Pushes the content of the given filename to the compilation assets
+   */
+  addFileToAssets (filename, compilation) {
+    filename = path.resolve(compilation.compiler.context, filename);
+    return Promise.all([
+      fsStatAsync(filename),
+      fsReadFileAsync(filename)
+    ])
+    .then(([size, source]) => {
+      return {
+        size,
+        source
+      };
+    })
+    .catch(() => Promise.reject(new Error('HtmlWebpackPlugin: could not load file ' + filename)))
+    .then(results => {
+      const basename = path.basename(filename);
+      if (compilation.fileDependencies.add) {
+        compilation.fileDependencies.add(filename);
+      } else {
+        // Before Webpack 4 - fileDepenencies was an array
+        compilation.fileDependencies.push(filename);
+      }
+      compilation.assets[basename] = {
+        source: () => results.source,
+        size: () => results.size.size
+      };
+      return basename;
+    });
+  }
+
+  /**
+   * Helper to sort chunks
+   */
+  sortChunks (chunks, sortMode, compilation) {
+    // Custom function
+    if (typeof sortMode === 'function') {
+      return chunks.sort(sortMode);
+    }
+    // Check if the given sort mode is a valid chunkSorter sort mode
+    if (typeof chunkSorter[sortMode] !== 'undefined') {
+      return chunkSorter[sortMode](chunks, this.options, compilation);
+    }
+    throw new Error('"' + sortMode + '" is not a valid chunk sort mode');
+  }
+
+  /**
+   * Return all chunks from the compilation result which match the exclude and include filters
+   */
+  filterChunks (chunks, includedChunks, excludedChunks) {
+    return chunks.filter(chunk => {
+      const chunkName = chunk.names[0];
+      // This chunk doesn't have a name. This script can't handled it.
+      if (chunkName === undefined) {
+        return false;
+      }
+      // Skip if the chunk should be lazy loaded
+      if (typeof chunk.isInitial === 'function') {
+        if (!chunk.isInitial()) {
+          return false;
+        }
+      } else if (!chunk.initial) {
+        return false;
+      }
+      // Skip if the chunks should be filtered and the given chunk was not added explicity
+      if (Array.isArray(includedChunks) && includedChunks.indexOf(chunkName) === -1) {
+        return false;
+      }
+      // Skip if the chunks should be filtered and the given chunk was excluded explicity
+      if (Array.isArray(excludedChunks) && excludedChunks.indexOf(chunkName) !== -1) {
+        return false;
+      }
+      // Add otherwise
+      return true;
+    });
+  }
+
+  isHotUpdateCompilation (assets) {
+    return assets.js.length && assets.js.every(name => /\.hot-update\.js$/.test(name));
+  }
+
+  htmlWebpackPluginAssets (compilation, chunks) {
+    const self = this;
+    const compilationHash = compilation.hash;
+
+    // Use the configured public path or build a relative path
+    let publicPath = typeof compilation.options.output.publicPath !== 'undefined'
+      // If a hard coded public path exists use it
+      ? compilation.mainTemplate.getPublicPath({hash: compilationHash})
+      // If no public path was set get a relative url path
+      : path.relative(path.resolve(compilation.options.output.path, path.dirname(self.childCompilationOutputName)), compilation.options.output.path)
+        .split(path.sep).join('/');
+
+    if (publicPath.length && publicPath.substr(-1, 1) !== '/') {
+      publicPath += '/';
+    }
+
+    const assets = {
+      // The public path
+      publicPath: publicPath,
+      // Will contain all js & css files by chunk
+      chunks: {},
+      // Will contain all js files
+      js: [],
+      // Will contain all css files
+      css: [],
+      // Will contain the html5 appcache manifest files if it exists
+      manifest: Object.keys(compilation.assets).filter(assetFile => path.extname(assetFile) === '.appcache')[0]
+    };
+
+    // Append a hash for cache busting
+    if (this.options.hash) {
+      assets.manifest = self.appendHash(assets.manifest, compilationHash);
+      assets.favicon = self.appendHash(assets.favicon, compilationHash);
+    }
+
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const chunkName = chunk.names[0];
+
+      assets.chunks[chunkName] = {};
+
+      // Prepend the public path to all chunk files
+      let chunkFiles = [].concat(chunk.files).map(chunkFile => publicPath + chunkFile);
+
+      // Append a hash for cache busting
+      if (this.options.hash) {
+        chunkFiles = chunkFiles.map(chunkFile => self.appendHash(chunkFile, compilationHash));
+      }
+
+      // Webpack outputs an array for each chunk when using sourcemaps
+      // or when one chunk hosts js and css simultaneously
+      const js = chunkFiles.find(chunkFile => /.js($|\?)/.test(chunkFile));
+      if (js) {
+        assets.chunks[chunkName].size = chunk.size;
+        assets.chunks[chunkName].entry = js;
+        assets.chunks[chunkName].hash = chunk.hash;
+        assets.js.push(js);
+      }
+
+      // Gather all css files
+      const css = chunkFiles.filter(chunkFile => /.css($|\?)/.test(chunkFile));
+      assets.chunks[chunkName].css = css;
+      assets.css = assets.css.concat(css);
+    }
+
+    // Duplicate css assets can occur on occasion if more than one chunk
+    // requires the same css.
+    assets.css = _.uniq(assets.css);
+
+    return assets;
+  }
+
+  /**
+   * Generate meta tags
+   */
+  getMetaTags () {
+    if (this.options.meta === false) {
+      return [];
+    }
+    // Make tags self-closing in case of xhtml
+    // Turn { "viewport" : "width=500, initial-scale=1" } into
+    // [{ name:"viewport" content:"width=500, initial-scale=1" }]
+    const selfClosingTag = !!this.options.xhtml;
+    const metaTagAttributeObjects = Object.keys(this.options.meta).map((metaName) => {
+      const metaTagContent = this.options.meta[metaName];
+      return (typeof metaTagContent === 'object') ? metaTagContent : {
+        name: metaName,
+        content: metaTagContent
+      };
+    });
+    // Turn [{ name:"viewport" content:"width=500, initial-scale=1" }] into
+    // the html-webpack-plugin tag structure
+    return metaTagAttributeObjects.map((metaTagAttributes) => {
+      return {
+        tagName: 'meta',
+        voidTag: true,
+        selfClosingTag: selfClosingTag,
+        attributes: metaTagAttributes
+      };
+    });
+  }
+
+  /**
+   * Injects the assets into the given html string
+   */
+  generateHtmlTags (assets) {
+    // Turn script files into script tags
+    const scripts = assets.js.map(scriptPath => ({
+      tagName: 'script',
+      closeTag: true,
+      attributes: {
+        type: 'text/javascript',
+        src: scriptPath
+      }
+    }));
+    // Make tags self-closing in case of xhtml
+    const selfClosingTag = !!this.options.xhtml;
+    // Turn css files into link tags
+    const styles = assets.css.map(stylePath => ({
+      tagName: 'link',
+      selfClosingTag: selfClosingTag,
+      voidTag: true,
+      attributes: {
+        href: stylePath,
+        rel: 'stylesheet'
+      }
+    }));
+    // Injection targets
+    let head = this.getMetaTags();
+    let body = [];
+
+    // If there is a favicon present, add it to the head
+    if (assets.favicon) {
+      head.push({
+        tagName: 'link',
+        selfClosingTag: selfClosingTag,
+        voidTag: true,
+        attributes: {
+          rel: 'shortcut icon',
+          href: assets.favicon
+        }
+      });
+    }
+    // Add styles to the head
+    head = head.concat(styles);
+    // Add scripts to body or head
+    if (this.options.inject === 'head') {
+      head = head.concat(scripts);
+    } else {
+      body = body.concat(scripts);
+    }
+    return {head: head, body: body};
+  }
+
+  /**
+   * Injects the assets into the given html string
+   */
+  injectAssetsIntoHtml (html, assets, assetTags) {
+    const htmlRegExp = /(<html[^>]*>)/i;
+    const headRegExp = /(<\/head\s*>)/i;
+    const bodyRegExp = /(<\/body\s*>)/i;
+    const body = assetTags.body.map(this.createHtmlTag.bind(this));
+    const head = assetTags.head.map(this.createHtmlTag.bind(this));
+
+    if (body.length) {
+      if (bodyRegExp.test(html)) {
+        // Append assets to body element
+        html = html.replace(bodyRegExp, match => body.join('') + match);
+      } else {
+        // Append scripts to the end of the file if no <body> element exists:
+        html += body.join('');
+      }
+    }
+
+    if (head.length) {
+      // Create a head tag if none exists
+      if (!headRegExp.test(html)) {
+        if (!htmlRegExp.test(html)) {
+          html = '<head></head>' + html;
+        } else {
+          html = html.replace(htmlRegExp, match => match + '<head></head>');
+        }
+      }
+
+      // Append assets to head element
+      html = html.replace(headRegExp, match => head.join('') + match);
+    }
+
+    // Inject manifest into the opening html tag
+    if (assets.manifest) {
+      html = html.replace(/(<html[^>]*)(>)/i, (match, start, end) => {
+        // Append the manifest only if no manifest was specified
+        if (/\smanifest\s*=/.test(match)) {
+          return match;
+        }
+        return start + ' manifest="' + assets.manifest + '"' + end;
+      });
+    }
+    return html;
+  }
+
+  /**
+   * Appends a cache busting hash
+   */
+  appendHash (url, hash) {
+    if (!url) {
+      return url;
+    }
+    return url + (url.indexOf('?') === -1 ? '?' : '&') + hash;
+  }
+
+  /**
+   * Turn a tag definition into a html string
+   */
+  createHtmlTag (tagDefinition) {
+    const attributes = Object.keys(tagDefinition.attributes || {})
+      .filter(attributeName => tagDefinition.attributes[attributeName] !== false)
+      .map(attributeName => {
+        if (tagDefinition.attributes[attributeName] === true) {
+          return attributeName;
+        }
+        return attributeName + '="' + tagDefinition.attributes[attributeName] + '"';
+      });
+    // Backport of 3.x void tag definition
+    const voidTag = tagDefinition.voidTag !== undefined ? tagDefinition.voidTag : !tagDefinition.closeTag;
+    const selfClosingTag = tagDefinition.voidTag !== undefined ? tagDefinition.voidTag && this.options.xhtml : tagDefinition.selfClosingTag;
+    return '<' + [tagDefinition.tagName].concat(attributes).join(' ') + (selfClosingTag ? '/' : '') + '>' +
+      (tagDefinition.innerHTML || '') +
+      (voidTag ? '' : '</' + tagDefinition.tagName + '>');
+  }
+
+  /**
+   * Helper to return the absolute template path with a fallback loader
+   */
+  getFullTemplatePath (template, context) {
+    // If the template doesn't use a loader use the lodash template loader
+    if (template.indexOf('!') === -1) {
+      template = require.resolve('./lib/loader.js') + '!' + path.resolve(context, template);
+    }
+    // Resolve template path
+    return template.replace(
+      /([!])([^/\\][^!?]+|[^/\\!?])($|\?[^!?\n]+$)/,
+      (match, prefix, filepath, postfix) => prefix + path.resolve(filepath) + postfix);
+  }
+
+  /**
+   * Helper to return a sorted unique array of all asset files out of the
+   * asset object
+   */
+  getAssetFiles (assets) {
+    const files = _.uniq(Object.keys(assets).filter(assetType => assetType !== 'chunks' && assets[assetType]).reduce((files, assetType) => files.concat(assets[assetType]), []));
+    files.sort();
+    return files;
+  }
+
+  /**
+   * Helper to promisify compilation.applyPluginsAsyncWaterfall that returns
+   * a function that helps to merge given plugin arguments with processed ones
+   */
+  applyPluginsAsyncWaterfall (compilation) {
+    if (compilation.hooks) {
+      return (eventName, requiresResult, pluginArgs) => {
+        const ccEventName = trainCaseToCamelCase(eventName);
+        if (!compilation.hooks[ccEventName]) {
+          compilation.errors.push(
+            new Error('No hook found for ' + eventName)
+          );
+        }
+
+        return compilation.hooks[ccEventName].promise(pluginArgs);
+      };
+    }
+
+    // Before Webpack 4
+    const promisedApplyPluginsAsyncWaterfall = function (name, init) {
+      return new Promise((resolve, reject) => {
+        const callback = function (err, result) {
+          if (err) {
+            return reject(err);
+          }
+          resolve(result);
+        };
+        compilation.applyPluginsAsyncWaterfall(name, init, callback);
+      });
+    };
+
+    return (eventName, requiresResult, pluginArgs) => promisedApplyPluginsAsyncWaterfall(eventName, pluginArgs)
+      .then(result => {
+        if (requiresResult && !result) {
+          compilation.warnings.push(
+            new Error('Using ' + eventName + ' without returning a result is deprecated.')
+          );
+        }
+        return _.extend(pluginArgs, result);
+      });
+  }
+}
+
+/**
+ * Takes a string in train case and transforms it to camel case
+ *
+ * Example: 'hello-my-world' to 'helloMyWorld'
+ *
+ * @param {string} word
+ */
+function trainCaseToCamelCase (word) {
+  return word.replace(/-([\w])/g, (match, p1) => p1.toUpperCase());
+}
+
+/**
+ * The default for options.templateParameter
+ * Generate the template parameters
+ */
+function templateParametersGenerator (compilation, assets, options) {
+  return {
+    compilation: compilation,
+    webpack: compilation.getStats().toJson(),
+    webpackConfig: compilation.options,
+    htmlWebpackPlugin: {
+      files: assets,
+      options: options
+    }
+  };
+}
+
+module.exports = HtmlWebpackPlugin;
diff --git a/node_modules/vuepress-html-webpack-plugin/lib/chunksorter.js b/node_modules/vuepress-html-webpack-plugin/lib/chunksorter.js
new file mode 100644
index 00000000..36b5c9a9
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/lib/chunksorter.js
@@ -0,0 +1,139 @@
+'use strict';
+
+const toposort = require('toposort');
+const _ = require('lodash');
+
+/**
+  Sorts dependencies between chunks by their "parents" attribute.
+
+  This function sorts chunks based on their dependencies with each other.
+  The parent relation between chunks as generated by Webpack for each chunk
+  is used to define a directed (and hopefully acyclic) graph, which is then
+  topologically sorted in order to retrieve the correct order in which
+  chunks need to be embedded into HTML. A directed edge in this graph is
+  describing a "is parent of" relationship from a chunk to another (distinct)
+  chunk. Thus topological sorting orders chunks from bottom-layer chunks to
+  highest level chunks that use the lower-level chunks.
+
+  @param {Array} chunks an array of chunks as generated by the html-webpack-plugin.
+  - For webpack < 4, It is assumed that each entry contains at least the properties
+  "id" (containing the chunk id) and "parents" (array containing the ids of the
+  parent chunks).
+  - For webpack 4+ the see the chunkGroups param for parent-child relationships
+
+  @param {Array} chunks an array of ChunkGroups that has a getParents method.
+  Each ChunkGroup contains a list of chunks in order.
+
+  @return {Array} A topologically sorted version of the input chunks
+*/
+module.exports.dependency = (chunks, options, compilation) => {
+  const chunkGroups = compilation.chunkGroups;
+  if (!chunks) {
+    return chunks;
+  }
+
+  // We build a map (chunk-id -> chunk) for faster access during graph building.
+  const nodeMap = {};
+
+  chunks.forEach(chunk => {
+    nodeMap[chunk.id] = chunk;
+  });
+
+  // Next, we add an edge for each parent relationship into the graph
+  let edges = [];
+
+  if (chunkGroups) {
+    // Add an edge for each parent (parent -> child)
+    edges = chunkGroups.reduce((result, chunkGroup) => result.concat(
+      Array.from(chunkGroup.parentsIterable, parentGroup => [parentGroup, chunkGroup])
+    ), []);
+    const sortedGroups = toposort.array(chunkGroups, edges);
+    // flatten chunkGroup into chunks
+    const sortedChunks = sortedGroups
+      .reduce((result, chunkGroup) => result.concat(chunkGroup.chunks), [])
+      .map(chunk => // use the chunk from the list passed in, since it may be a filtered list
+    nodeMap[chunk.id])
+      .filter((chunk, index, self) => {
+        // make sure exists (ie excluded chunks not in nodeMap)
+        const exists = !!chunk;
+        // make sure we have a unique list
+        const unique = self.indexOf(chunk) === index;
+        return exists && unique;
+      });
+    return sortedChunks;
+  } else {
+    // before webpack 4 there was no chunkGroups
+    chunks.forEach(chunk => {
+      if (chunk.parents) {
+        // Add an edge for each parent (parent -> child)
+        chunk.parents.forEach(parentId => {
+          // webpack2 chunk.parents are chunks instead of string id(s)
+          const parentChunk = _.isObject(parentId) ? parentId : nodeMap[parentId];
+          // If the parent chunk does not exist (e.g. because of an excluded chunk)
+          // we ignore that parent
+          if (parentChunk) {
+            edges.push([parentChunk, chunk]);
+          }
+        });
+      }
+    });
+    // We now perform a topological sorting on the input chunks and built edges
+    return toposort.array(chunks, edges);
+  }
+};
+
+/**
+ * Sorts the chunks based on the chunk id.
+ *
+ * @param  {Array} chunks the list of chunks to sort
+ * @return {Array} The sorted list of chunks
+ */
+module.exports.id = chunks => chunks.sort(function orderEntryLast (a, b) {
+  if (a.entry !== b.entry) {
+    return b.entry ? 1 : -1;
+  } else {
+    return b.id - a.id;
+  }
+});
+
+/**
+ * Performs identity mapping (no-sort).
+ * @param  {Array} chunks the chunks to sort
+ * @return {Array} The sorted chunks
+ */
+module.exports.none = chunks => chunks;
+
+/**
+ * Sort manually by the chunks
+ * @param  {Array} chunks the chunks to sort
+ * @return {Array} The sorted chunks
+ */
+module.exports.manual = (chunks, options) => {
+  const specifyChunks = options.chunks;
+  const chunksResult = [];
+  let filterResult = [];
+  if (Array.isArray(specifyChunks)) {
+    for (var i = 0; i < specifyChunks.length; i++) {
+      filterResult = chunks.filter(chunk => {
+        if (chunk.names[0] && chunk.names[0] === specifyChunks[i]) {
+          return true;
+        }
+        return false;
+      });
+      filterResult.length > 0 && chunksResult.push(filterResult[0]);
+    }
+  }
+  return chunksResult;
+};
+
+/**
+ * Defines the default sorter.
+ */
+module.exports.auto = module.exports.id;
+
+// In webpack 2 the ids have been flipped.
+// Therefore the id sort doesn't work the same way as it did for webpack 1
+// Luckily the dependency sort is working as expected
+if (Number(require('webpack/package.json').version.split('.')[0]) > 1) {
+  module.exports.auto = module.exports.dependency;
+}
diff --git a/node_modules/vuepress-html-webpack-plugin/lib/compiler.js b/node_modules/vuepress-html-webpack-plugin/lib/compiler.js
new file mode 100644
index 00000000..d5c91b6c
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/lib/compiler.js
@@ -0,0 +1,125 @@
+/*
+ * This file uses webpack to compile a template with a child compiler.
+ *
+ * [TEMPLATE] -> [JAVASCRIPT]
+ *
+ */
+'use strict';
+const path = require('path');
+const NodeTemplatePlugin = require('webpack/lib/node/NodeTemplatePlugin');
+const NodeTargetPlugin = require('webpack/lib/node/NodeTargetPlugin');
+const LoaderTargetPlugin = require('webpack/lib/LoaderTargetPlugin');
+const LibraryTemplatePlugin = require('webpack/lib/LibraryTemplatePlugin');
+const SingleEntryPlugin = require('webpack/lib/SingleEntryPlugin');
+
+/**
+ * Compiles the template into a nodejs factory, adds its to the compilation.assets
+ * and returns a promise of the result asset object.
+ *
+ * @param template relative path to the template file
+ * @param context path context
+ * @param outputFilename the file name
+ * @param compilation The webpack compilation object
+ *
+ * Returns an object:
+ * {
+ *  hash: {String} - Base64 hash of the file
+ *  content: {String} - Javascript executable code of the template
+ * }
+ *
+ */
+module.exports.compileTemplate = function compileTemplate (template, context, outputFilename, compilation) {
+  // The entry file is just an empty helper as the dynamic template
+  // require is added in "loader.js"
+  const outputOptions = {
+    filename: outputFilename,
+    publicPath: compilation.outputOptions.publicPath
+  };
+  // Store the result of the parent compilation before we start the child compilation
+  const assetsBeforeCompilation = Object.assign({}, compilation.assets[outputOptions.filename]);
+  // Create an additional child compiler which takes the template
+  // and turns it into an Node.JS html factory.
+  // This allows us to use loaders during the compilation
+  const compilerName = getCompilerName(context, outputFilename);
+  const childCompiler = compilation.createChildCompiler(compilerName, outputOptions);
+  childCompiler.context = context;
+  new NodeTemplatePlugin(outputOptions).apply(childCompiler);
+  new NodeTargetPlugin().apply(childCompiler);
+  new LibraryTemplatePlugin('HTML_WEBPACK_PLUGIN_RESULT', 'var').apply(childCompiler);
+
+  // Using undefined as name for the SingleEntryPlugin causes a unexpected output as described in
+  // https://github.com/jantimon/html-webpack-plugin/issues/895
+  // Using a string as a name for the SingleEntryPlugin causes problems with HMR as described in
+  // https://github.com/jantimon/html-webpack-plugin/issues/900
+  // Until the HMR issue is fixed we keep the ugly output:
+  new SingleEntryPlugin(this.context, template, undefined).apply(childCompiler);
+
+  new LoaderTargetPlugin('node').apply(childCompiler);
+
+  // Fix for "Uncaught TypeError: __webpack_require__(...) is not a function"
+  // Hot module replacement requires that every child compiler has its own
+  // cache. @see https://github.com/ampedandwired/html-webpack-plugin/pull/179
+
+  // Backwards compatible version of: childCompiler.hooks.compilation
+  (childCompiler.hooks ? childCompiler.hooks.compilation.tap.bind(childCompiler.hooks.compilation, 'HtmlWebpackPlugin') : childCompiler.plugin.bind(childCompiler, 'compilation'))(compilation => {
+    if (compilation.cache) {
+      if (!compilation.cache[compilerName]) {
+        compilation.cache[compilerName] = {};
+      }
+      compilation.cache = compilation.cache[compilerName];
+    }
+  });
+
+  // Compile and return a promise
+  return new Promise((resolve, reject) => {
+    childCompiler.runAsChild((err, entries, childCompilation) => {
+      // Resolve / reject the promise
+      if (childCompilation && childCompilation.errors && childCompilation.errors.length) {
+        const errorDetails = childCompilation.errors.map(error => error.message + (error.error ? ':\n' + error.error : '')).join('\n');
+        reject(new Error('Child compilation failed:\n' + errorDetails));
+      } else if (err) {
+        reject(err);
+      } else {
+        // Replace [hash] placeholders in filename
+        // In webpack 4 the plugin interface changed, so check for available fns
+        const outputName = compilation.mainTemplate.getAssetPath
+          ? compilation.mainTemplate.hooks.assetPath.call(outputOptions.filename, {
+            hash: childCompilation.hash,
+            chunk: entries[0]
+          })
+          : compilation.mainTemplate.applyPluginsWaterfall(
+              'asset-path',
+              outputOptions.filename,
+            {
+              hash: childCompilation.hash,
+              chunk: entries[0]
+            });
+
+        // Restore the parent compilation to the state like it
+        // was before the child compilation
+        compilation.assets[outputName] = assetsBeforeCompilation[outputName];
+        if (assetsBeforeCompilation[outputName] === undefined) {
+          // If it wasn't there - delete it
+          delete compilation.assets[outputName];
+        }
+        resolve({
+          // Hash of the template entry point
+          hash: entries[0].hash,
+          // Output name
+          outputName: outputName,
+          // Compiled code
+          content: childCompilation.assets[outputName].source()
+        });
+      }
+    });
+  });
+};
+
+/**
+ * Returns the child compiler name e.g. 'html-webpack-plugin for "index.html"'
+ */
+function getCompilerName (context, filename) {
+  const absolutePath = path.resolve(context, filename);
+  const relativePath = path.relative(context, absolutePath);
+  return 'html-webpack-plugin for "' + (absolutePath.length < relativePath.length ? absolutePath : relativePath) + '"';
+}
diff --git a/node_modules/vuepress-html-webpack-plugin/lib/errors.js b/node_modules/vuepress-html-webpack-plugin/lib/errors.js
new file mode 100644
index 00000000..2b946dad
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/lib/errors.js
@@ -0,0 +1,23 @@
+'use strict';
+const PrettyError = require('pretty-error');
+const prettyError = new PrettyError();
+prettyError.withoutColors();
+prettyError.skipPackage(['html-plugin-evaluation']);
+prettyError.skipNodeFiles();
+prettyError.skip(function (traceLine) {
+  return traceLine.path === 'html-plugin-evaluation';
+});
+
+module.exports = function (err, context) {
+  return {
+    toHtml: function () {
+      return 'Html Webpack Plugin:\n<pre>\n' + this.toString() + '</pre>';
+    },
+    toJsonHtml: function () {
+      return JSON.stringify(this.toHtml());
+    },
+    toString: function () {
+      return prettyError.render(err).replace(/webpack:\/\/\/\./g, context);
+    }
+  };
+};
diff --git a/node_modules/vuepress-html-webpack-plugin/lib/loader.js b/node_modules/vuepress-html-webpack-plugin/lib/loader.js
new file mode 100644
index 00000000..c1062d1f
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/lib/loader.js
@@ -0,0 +1,35 @@
+/* This loader renders the template with underscore if no other loader was found */
+'use strict';
+
+const _ = require('lodash');
+const loaderUtils = require('loader-utils');
+
+module.exports = function (source) {
+  if (this.cacheable) {
+    this.cacheable();
+  }
+  const allLoadersButThisOne = this.loaders.filter(function (loader) {
+    // Loader API changed from `loader.module` to `loader.normal` in Webpack 2.
+    return (loader.module || loader.normal) !== module.exports;
+  });
+  // This loader shouldn't kick in if there is any other loader
+  if (allLoadersButThisOne.length > 0) {
+    return source;
+  }
+  // Skip .js files
+  if (/\.js$/.test(this.resourcePath)) {
+    return source;
+  }
+
+  // The following part renders the tempalte with lodash as aminimalistic loader
+  //
+  // Get templating options
+  const options = this.query !== '' ? loaderUtils.parseQuery(this.query) : {};
+  const template = _.template(source, _.defaults(options, { variable: 'data' }));
+  // Require !!lodash - using !! will disable all loaders (e.g. babel)
+  return 'var _ = require(' + loaderUtils.stringifyRequest(this, '!!' + require.resolve('lodash')) + ');' +
+    'module.exports = function (templateParams) { with(templateParams) {' +
+      // Execute the lodash template
+      'return (' + template.source + ')();' +
+    '}}';
+};
diff --git a/node_modules/vuepress-html-webpack-plugin/node_modules/.bin/html-minifier b/node_modules/vuepress-html-webpack-plugin/node_modules/.bin/html-minifier
new file mode 120000
index 00000000..82bf699e
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/node_modules/.bin/html-minifier
@@ -0,0 +1 @@
+../../../html-minifier/cli.js
\ No newline at end of file
diff --git a/node_modules/vuepress-html-webpack-plugin/node_modules/.bin/webpack b/node_modules/vuepress-html-webpack-plugin/node_modules/.bin/webpack
new file mode 120000
index 00000000..8a1900f6
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/node_modules/.bin/webpack
@@ -0,0 +1 @@
+../../../webpack/bin/webpack.js
\ No newline at end of file
diff --git a/node_modules/vuepress-html-webpack-plugin/node_modules/loader-utils/LICENSE b/node_modules/vuepress-html-webpack-plugin/node_modules/loader-utils/LICENSE
new file mode 100644
index 00000000..c4bdf1b8
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/node_modules/loader-utils/LICENSE
@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2012 - 2015 Tobias Koppers
+
+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/vuepress-html-webpack-plugin/node_modules/loader-utils/README.md b/node_modules/vuepress-html-webpack-plugin/node_modules/loader-utils/README.md
new file mode 100644
index 00000000..305fa902
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/node_modules/loader-utils/README.md
@@ -0,0 +1,217 @@
+# loader-utils
+
+## Methods
+
+### `getLoaderConfig`
+
+Recommended way to retrieve the loader config:
+
+```javascript
+// inside your loader
+config = loaderUtils.getLoaderConfig(this, "myLoader");
+```
+
+Tries to read the loader config from the `webpack.config.js` under the given property name (`"myLoader"` in this case) and merges the result with the loader query. For example, if your `webpack.config.js` had this property...
+
+```javascript
+cheesecakeLoader: {
+	type: "delicious",
+	slices: 4
+}
+```
+
+...and your loader was called with `?slices=8`, `getLoaderConfig(this, "cheesecakeLoader")` would return
+
+```javascript
+{
+	type: "delicious",
+	slices: 8
+}
+```
+
+It is recommended that you use the camelCased loader name as your default config property name.
+
+### `parseQuery`
+
+``` javascript
+var query = loaderUtils.parseQuery(this.query);
+assert(typeof query == "object");
+if(query.flag)
+	// ...
+```
+
+``` text
+null                   -> {}
+?                      -> {}
+?flag                  -> { flag: true }
+?+flag                 -> { flag: true }
+?-flag                 -> { flag: false }
+?xyz=test              -> { xyz: "test" }
+?xyz[]=a               -> { xyz: ["a"] }
+?flag1&flag2           -> { flag1: true, flag2: true }
+?+flag1,-flag2         -> { flag1: true, flag2: false }
+?xyz[]=a,xyz[]=b       -> { xyz: ["a", "b"] }
+?a%2C%26b=c%2C%26d     -> { "a,&b": "c,&d" }
+?{json:5,data:{a:1}}   -> { json: 5, data: { a: 1 } }
+```
+
+### `stringifyRequest`
+
+Turns a request into a string that can be used inside `require()` or `import` while avoiding absolute paths.
+Use it instead of `JSON.stringify(...)` if you're generating code inside a loader.
+
+**Why is this necessary?** Since webpack calculates the hash before module paths are translated into module ids, we must avoid absolute paths to ensure
+consistent hashes across different compilations.
+
+This function:
+
+- resolves absolute requests into relative requests if the request and the module are on the same hard drive
+- replaces `\` with `/` if the request and the module are on the same hard drive
+- won't change the path at all if the request and the module are on different hard drives
+- applies `JSON.stringify` to the result
+
+```javascript
+loaderUtils.stringifyRequest(this, "./test.js");
+// "\"./test.js\""
+
+loaderUtils.stringifyRequest(this, ".\\test.js");
+// "\"./test.js\""
+
+loaderUtils.stringifyRequest(this, "test");
+// "\"test\""
+
+loaderUtils.stringifyRequest(this, "test/lib/index.js");
+// "\"test/lib/index.js\""
+
+loaderUtils.stringifyRequest(this, "otherLoader?andConfig!test?someConfig");
+// "\"otherLoader?andConfig!test?someConfig\""
+
+loaderUtils.stringifyRequest(this, require.resolve("test"));
+// "\"../node_modules/some-loader/lib/test.js\""
+
+loaderUtils.stringifyRequest(this, "C:\\module\\test.js");
+// "\"../../test.js\"" (on Windows, in case the module and the request are on the same drive)
+
+loaderUtils.stringifyRequest(this, "C:\\module\\test.js");
+// "\"C:\\module\\test.js\"" (on Windows, in case the module and the request are on different drives)
+
+loaderUtils.stringifyRequest(this, "\\\\network-drive\\test.js");
+// "\"\\\\network-drive\\\\test.js\"" (on Windows, in case the module and the request are on different drives)
+```
+
+### `urlToRequest`
+
+Converts some resource URL to a webpack module request.
+
+```javascript
+var url = "path/to/module.js";
+var request = loaderUtils.urlToRequest(url); // "./path/to/module.js"
+```
+
+#### Module URLs
+
+Any URL containing a `~` will be interpreted as a module request. Anything after the `~` will be considered the request path.
+
+```javascript
+var url = "~path/to/module.js";
+var request = loaderUtils.urlToRequest(url); // "path/to/module.js"
+```
+
+#### Root-relative URLs
+
+URLs that are root-relative (start with `/`) can be resolved relative to some arbitrary path by using the `root` parameter:
+
+```javascript
+var url = "/path/to/module.js";
+var root = "./root";
+var request = loaderUtils.urlToRequest(url, root); // "./root/path/to/module.js"
+```
+
+To convert a root-relative URL into a module URL, specify a `root` value that starts with `~`:
+
+```javascript
+var url = "/path/to/module.js";
+var root = "~";
+var request = loaderUtils.urlToRequest(url, root); // "path/to/module.js"
+```
+
+### `interpolateName`
+
+Interpolates a filename template using multiple placeholders and/or a regular expression.
+The template and regular expression are set as query params called `name` and `regExp` on the current loader's context.
+
+```javascript
+var interpolatedName = loaderUtils.interpolateName(loaderContext, name, options);
+```
+
+The following tokens are replaced in the `name` parameter:
+
+* `[ext]` the extension of the resource
+* `[name]` the basename of the resource
+* `[path]` the path of the resource relative to the `context` query parameter or option.
+* `[folder]` the folder of the resource is in.
+* `[emoji]` a random emoji representation of `options.content`
+* `[emoji:<length>]` same as above, but with a customizable number of emojis
+* `[hash]` the hash of `options.content` (Buffer) (by default it's the hex digest of the md5 hash)
+* `[<hashType>:hash:<digestType>:<length>]` optionally one can configure
+  * other `hashType`s, i. e. `sha1`, `md5`, `sha256`, `sha512`
+  * other `digestType`s, i. e. `hex`, `base26`, `base32`, `base36`, `base49`, `base52`, `base58`, `base62`, `base64`
+  * and `length` the length in chars
+* `[N]` the N-th match obtained from matching the current file name against `options.regExp`
+
+Examples
+
+``` javascript
+// loaderContext.resourcePath = "/app/js/javascript.js"
+loaderUtils.interpolateName(loaderContext, "js/[hash].script.[ext]", { content: ... });
+// => js/9473fdd0d880a43c21b7778d34872157.script.js
+
+// loaderContext.resourcePath = "/app/page.html"
+loaderUtils.interpolateName(loaderContext, "html-[hash:6].html", { content: ... });
+// => html-9473fd.html
+
+// loaderContext.resourcePath = "/app/flash.txt"
+loaderUtils.interpolateName(loaderContext, "[hash]", { content: ... });
+// => c31e9820c001c9c4a86bce33ce43b679
+
+// loaderContext.resourcePath = "/app/img/image.gif"
+loaderUtils.interpolateName(loaderContext, "[emoji]", { content: ... });
+// => 👍
+
+// loaderContext.resourcePath = "/app/img/image.gif"
+loaderUtils.interpolateName(loaderContext, "[emoji:4]", { content: ... });
+// => 🙍🏢📤🐝
+
+// loaderContext.resourcePath = "/app/img/image.png"
+loaderUtils.interpolateName(loaderContext, "[sha512:hash:base64:7].[ext]", { content: ... });
+// => 2BKDTjl.png
+// use sha512 hash instead of md5 and with only 7 chars of base64
+
+// loaderContext.resourcePath = "/app/img/myself.png"
+// loaderContext.query.name =
+loaderUtils.interpolateName(loaderContext, "picture.png");
+// => picture.png
+
+// loaderContext.resourcePath = "/app/dir/file.png"
+loaderUtils.interpolateName(loaderContext, "[path][name].[ext]?[hash]", { content: ... });
+// => /app/dir/file.png?9473fdd0d880a43c21b7778d34872157
+
+// loaderContext.resourcePath = "/app/js/page-home.js"
+loaderUtils.interpolateName(loaderContext, "script-[1].[ext]", { regExp: "page-(.*)\\.js", content: ... });
+// => script-home.js
+```
+
+### `getHashDigest`
+
+``` javascript
+var digestString = loaderUtils.getHashDigest(buffer, hashType, digestType, maxLength);
+```
+
+* `buffer` the content that should be hashed
+* `hashType` one of `sha1`, `md5`, `sha256`, `sha512` or any other node.js supported hash type
+* `digestType` one of `hex`, `base26`, `base32`, `base36`, `base49`, `base52`, `base58`, `base62`, `base64`
+* `maxLength` the maximum length in chars
+
+## License
+
+MIT (http://www.opensource.org/licenses/mit-license.php)
diff --git a/node_modules/vuepress-html-webpack-plugin/node_modules/loader-utils/index.js b/node_modules/vuepress-html-webpack-plugin/node_modules/loader-utils/index.js
new file mode 100644
index 00000000..49e1d18f
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/node_modules/loader-utils/index.js
@@ -0,0 +1,331 @@
+var JSON5 = require("json5");
+var path = require("path");
+var util = require("util");
+var os = require("os");
+var assign = require("object-assign");
+var emojiRegex = /[\uD800-\uDFFF]./;
+var emojiList = require("emojis-list").filter(function(emoji) {
+	return emojiRegex.test(emoji)
+});
+var matchAbsolutePath = /^\/|^[A-Z]:[/\\]|^\\\\/i; // node 0.10 does not support path.isAbsolute()
+var matchAbsoluteWin32Path = /^[A-Z]:[/\\]|^\\\\/i;
+var matchRelativePath = /^\.\.?[/\\]/;
+
+var baseEncodeTables = {
+	26: "abcdefghijklmnopqrstuvwxyz",
+	32: "123456789abcdefghjkmnpqrstuvwxyz", // no 0lio
+	36: "0123456789abcdefghijklmnopqrstuvwxyz",
+	49: "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ", // no lIO
+	52: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+	58: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ", // no 0lIO
+	62: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+	64: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_"
+};
+var emojiCache = {};
+var parseQueryDeprecationWarning = util.deprecate(function() {},
+	"loaderUtils.parseQuery() received a non-string value which can be problematic, " +
+	"see https://github.com/webpack/loader-utils/issues/56" + os.EOL +
+	"parseQuery() will be replaced with getOptions() in the next major version of loader-utils."
+);
+
+function encodeStringToEmoji(content, length) {
+	if (emojiCache[content]) return emojiCache[content];
+	length = length || 1;
+	var emojis = [];
+	do {
+		var index = Math.floor(Math.random() * emojiList.length);
+		emojis.push(emojiList[index]);
+		emojiList.splice(index, 1);
+	} while (--length > 0);
+	var emojiEncoding = emojis.join('');
+	emojiCache[content] = emojiEncoding;
+	return emojiEncoding;
+}
+
+function encodeBufferToBase(buffer, base) {
+	var encodeTable = baseEncodeTables[base];
+	if (!encodeTable) throw new Error("Unknown encoding base" + base);
+
+	var readLength = buffer.length;
+
+	var Big = require('big.js');
+	Big.RM = Big.DP = 0;
+	var b = new Big(0);
+	for (var i = readLength - 1; i >= 0; i--) {
+		b = b.times(256).plus(buffer[i]);
+	}
+
+	var output = "";
+	while (b.gt(0)) {
+		output = encodeTable[b.mod(base)] + output;
+		b = b.div(base);
+	}
+
+	Big.DP = 20;
+	Big.RM = 1;
+
+	return output;
+}
+
+exports.parseQuery = function parseQuery(query) {
+	var specialValues = {
+		'null': null,
+		'true': true,
+		'false': false
+	};
+	if(!query) return {};
+	if(typeof query !== "string") {
+		parseQueryDeprecationWarning();
+		return query;
+	}
+	if(query.substr(0, 1) !== "?")
+		throw new Error("a valid query string passed to parseQuery should begin with '?'");
+	query = query.substr(1);
+	var queryLength = query.length;
+	if(query.substr(0, 1) === "{" && query.substr(-1) === "}") {
+		return JSON5.parse(query);
+	}
+	var queryArgs = query.split(/[,\&]/g);
+	var result = {};
+	queryArgs.forEach(function(arg) {
+		var idx = arg.indexOf("=");
+		if(idx >= 0) {
+			var name = arg.substr(0, idx);
+			var value = decodeURIComponent(arg.substr(idx+1));
+			if (specialValues.hasOwnProperty(value)) {
+				value = specialValues[value];
+			}
+			if(name.substr(-2) === "[]") {
+				name = decodeURIComponent(name.substr(0, name.length-2));
+				if(!Array.isArray(result[name]))
+					result[name] = [];
+				result[name].push(value);
+			} else {
+				name = decodeURIComponent(name);
+				result[name] = value;
+			}
+		} else {
+			if(arg.substr(0, 1) === "-") {
+				result[decodeURIComponent(arg.substr(1))] = false;
+			} else if(arg.substr(0, 1) === "+") {
+				result[decodeURIComponent(arg.substr(1))] = true;
+			} else {
+				result[decodeURIComponent(arg)] = true;
+			}
+		}
+	});
+	return result;
+};
+
+exports.getLoaderConfig = function(loaderContext, defaultConfigKey) {
+	var query = exports.parseQuery(loaderContext.query);
+	var configKey = query.config || defaultConfigKey;
+	if (configKey) {
+		var config = loaderContext.options[configKey] || {};
+		delete query.config;
+		return assign({}, config, query);
+	}
+
+	return query;
+};
+
+exports.stringifyRequest = function(loaderContext, request) {
+	var splitted = request.split("!");
+	var context = loaderContext.context || (loaderContext.options && loaderContext.options.context);
+	return JSON.stringify(splitted.map(function(part) {
+		// First, separate singlePath from query, because the query might contain paths again
+		var splittedPart = part.match(/^(.*?)(\?.*)/);
+		var singlePath = splittedPart ? splittedPart[1] : part;
+		var query = splittedPart ? splittedPart[2] : "";
+		if(matchAbsolutePath.test(singlePath) && context) {
+			singlePath = path.relative(context, singlePath);
+			if(matchAbsolutePath.test(singlePath)) {
+				// If singlePath still matches an absolute path, singlePath was on a different drive than context.
+				// In this case, we leave the path platform-specific without replacing any separators.
+				// @see https://github.com/webpack/loader-utils/pull/14
+				return singlePath + query;
+			}
+			if(matchRelativePath.test(singlePath) === false) {
+				// Ensure that the relative path starts at least with ./ otherwise it would be a request into the modules directory (like node_modules).
+				singlePath = "./" + singlePath;
+			}
+		}
+		return singlePath.replace(/\\/g, "/") + query;
+	}).join("!"));
+};
+
+function dotRequest(obj) {
+	return obj.request;
+}
+
+exports.getRemainingRequest = function(loaderContext) {
+	if(loaderContext.remainingRequest)
+		return loaderContext.remainingRequest;
+	var request = loaderContext.loaders.slice(loaderContext.loaderIndex+1).map(dotRequest).concat([loaderContext.resource]);
+	return request.join("!");
+};
+
+exports.getCurrentRequest = function(loaderContext) {
+	if(loaderContext.currentRequest)
+		return loaderContext.currentRequest;
+	var request = loaderContext.loaders.slice(loaderContext.loaderIndex).map(dotRequest).concat([loaderContext.resource]);
+	return request.join("!");
+};
+
+exports.isUrlRequest = function(url, root) {
+	// An URL is not an request if
+	// 1. it's a Data Url
+	// 2. it's an absolute url or and protocol-relative
+	// 3. it's some kind of url for a template
+	if(/^data:|^chrome-extension:|^(https?:)?\/\/|^[\{\}\[\]#*;,'§\$%&\(=?`´\^°<>]/.test(url)) return false;
+	// 4. It's also not an request if root isn't set and it's a root-relative url
+	if((root === undefined || root === false) && /^\//.test(url)) return false;
+	return true;
+};
+
+exports.urlToRequest = function(url, root) {
+	var moduleRequestRegex = /^[^?]*~/;
+	var request;
+
+	if(matchAbsoluteWin32Path.test(url)) {
+		// absolute windows path, keep it
+		request = url;
+	} else if(root !== undefined && root !== false && /^\//.test(url)) {
+		// if root is set and the url is root-relative
+		switch(typeof root) {
+			// 1. root is a string: root is prefixed to the url
+			case "string":
+				// special case: `~` roots convert to module request
+				if (moduleRequestRegex.test(root)) {
+					request = root.replace(/([^~\/])$/, "$1/") + url.slice(1);
+				} else {
+					request = root + url;
+				}
+				break;
+			// 2. root is `true`: absolute paths are allowed
+			//    *nix only, windows-style absolute paths are always allowed as they doesn't start with a `/`
+			case "boolean":
+				request = url;
+				break;
+			default:
+				throw new Error("Unexpected parameters to loader-utils 'urlToRequest': url = " + url + ", root = " + root + ".");
+		}
+	} else if(/^\.\.?\//.test(url)) {
+		// A relative url stays
+		request = url;
+	} else {
+		// every other url is threaded like a relative url
+		request = "./" + url;
+	}
+
+	// A `~` makes the url an module
+	if (moduleRequestRegex.test(request)) {
+		request = request.replace(moduleRequestRegex, "");
+	}
+
+	return request;
+};
+
+exports.parseString = function parseString(str) {
+	try {
+		if(str[0] === '"') return JSON.parse(str);
+		if(str[0] === "'" && str.substr(str.length - 1) === "'") {
+			return parseString(str.replace(/\\.|"/g, function(x) {
+				if(x === '"') return '\\"';
+				return x;
+			}).replace(/^'|'$/g, '"'));
+		}
+		return JSON.parse('"' + str + '"');
+	} catch(e) {
+		return str;
+	}
+};
+
+exports.getHashDigest = function getHashDigest(buffer, hashType, digestType, maxLength) {
+	hashType = hashType || "md5";
+	maxLength = maxLength || 9999;
+	var hash = require("crypto").createHash(hashType);
+	hash.update(buffer);
+	if (digestType === "base26" || digestType === "base32" || digestType === "base36" ||
+	    digestType === "base49" || digestType === "base52" || digestType === "base58" ||
+	    digestType === "base62" || digestType === "base64") {
+		return encodeBufferToBase(hash.digest(), digestType.substr(4)).substr(0, maxLength);
+	} else {
+		return hash.digest(digestType || "hex").substr(0, maxLength);
+	}
+};
+
+exports.interpolateName = function interpolateName(loaderContext, name, options) {
+	var filename;
+	if (typeof name === "function") {
+		filename = name(loaderContext.resourcePath);
+	} else {
+		filename = name || "[hash].[ext]";
+	}
+	var context = options.context;
+	var content = options.content;
+	var regExp = options.regExp;
+	var ext = "bin";
+	var basename = "file";
+	var directory = "";
+	var folder = "";
+	if(loaderContext.resourcePath) {
+		var resourcePath = loaderContext.resourcePath;
+		var idx = resourcePath.lastIndexOf(".");
+		var i = resourcePath.lastIndexOf("\\");
+		var j = resourcePath.lastIndexOf("/");
+		var p = i < 0 ? j : j < 0 ? i : i < j ? i : j;
+		if(idx >= 0) {
+			ext = resourcePath.substr(idx+1);
+			resourcePath = resourcePath.substr(0, idx);
+		}
+		if(p >= 0) {
+			basename = resourcePath.substr(p+1);
+			resourcePath = resourcePath.substr(0, p+1);
+		}
+		if (typeof context !== 'undefined') {
+			directory = path.relative(context, resourcePath + "_").replace(/\\/g, "/").replace(/\.\.(\/)?/g, "_$1");
+			directory = directory.substr(0, directory.length-1);
+		}
+		else {
+			directory = resourcePath.replace(/\\/g, "/").replace(/\.\.(\/)?/g, "_$1");
+		}
+		if (directory.length === 1) {
+			directory = "";
+		} else if (directory.length > 1) {
+			folder = path.basename(directory);
+		}
+	}
+	var url = filename;
+	if(content) {
+		// Match hash template
+		url = url.replace(/\[(?:(\w+):)?hash(?::([a-z]+\d*))?(?::(\d+))?\]/ig, function() {
+			return exports.getHashDigest(content, arguments[1], arguments[2], parseInt(arguments[3], 10));
+		}).replace(/\[emoji(?::(\d+))?\]/ig, function() {
+			return encodeStringToEmoji(content, arguments[1]);
+		});
+	}
+	url = url.replace(/\[ext\]/ig, function() {
+		return ext;
+	}).replace(/\[name\]/ig, function() {
+		return basename;
+	}).replace(/\[path\]/ig, function() {
+		return directory;
+	}).replace(/\[folder\]/ig, function() {
+		return folder;
+	});
+	if(regExp && loaderContext.resourcePath) {
+		var re = new RegExp(regExp);
+		var match = loaderContext.resourcePath.match(re);
+		if(match) {
+			for (var i = 0; i < match.length; i++) {
+				var re = new RegExp("\\[" + i + "\\]", "ig");
+				url = url.replace(re, match[i]);
+			}
+		}
+	}
+	if(typeof loaderContext.options === "object" && typeof loaderContext.options.customInterpolateName === "function") {
+		url = loaderContext.options.customInterpolateName.call(loaderContext, url, name, options);
+	}
+	return url;
+};
diff --git a/node_modules/vuepress-html-webpack-plugin/node_modules/loader-utils/node_modules/.bin/json5 b/node_modules/vuepress-html-webpack-plugin/node_modules/loader-utils/node_modules/.bin/json5
new file mode 120000
index 00000000..09cacab1
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/node_modules/loader-utils/node_modules/.bin/json5
@@ -0,0 +1 @@
+../../../../../json5/lib/cli.js
\ No newline at end of file
diff --git a/node_modules/vuepress-html-webpack-plugin/node_modules/loader-utils/package.json b/node_modules/vuepress-html-webpack-plugin/node_modules/loader-utils/package.json
new file mode 100644
index 00000000..699cb028
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/node_modules/loader-utils/package.json
@@ -0,0 +1,31 @@
+{
+  "name": "loader-utils",
+  "version": "0.2.17",
+  "author": "Tobias Koppers @sokra",
+  "description": "utils for webpack loaders",
+  "dependencies": {
+    "big.js": "^3.1.3",
+    "emojis-list": "^2.0.0",
+    "json5": "^0.5.0",
+    "object-assign": "^4.0.1"
+  },
+  "scripts": {
+    "test": "mocha",
+    "travis": "npm run cover -- --report lcovonly",
+    "cover": "istanbul cover -x *.runtime.js node_modules/mocha/bin/_mocha",
+    "publish-patch": "mocha && npm version patch && git push && git push --tags && npm publish"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/webpack/loader-utils.git"
+  },
+  "devDependencies": {
+    "coveralls": "^2.11.2",
+    "istanbul": "^0.3.14",
+    "mocha": "^1.21.4"
+  },
+  "files": [
+    "index.js"
+  ]
+}
diff --git a/node_modules/vuepress-html-webpack-plugin/package.json b/node_modules/vuepress-html-webpack-plugin/package.json
new file mode 100644
index 00000000..e0587227
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/package.json
@@ -0,0 +1,77 @@
+{
+  "name": "vuepress-html-webpack-plugin",
+  "version": "3.2.0",
+  "license": "MIT",
+  "description": "Simplifies creation of HTML files to serve your webpack bundles",
+  "author": "Charles Blaxland <charles.blaxland@gmail.com> (https://github.com/ampedandwired)",
+  "main": "index.js",
+  "files": [
+    "lib/",
+    "index.js",
+    "default_index.ejs"
+  ],
+  "scripts": {
+    "pretest": "semistandard",
+    "commit": "git-cz",
+    "build-examples": "node examples/build-examples.js",
+    "test": "jasmine",
+    "release": "standard-version"
+  },
+  "semistandard": {
+    "ignore": [
+      "examples/*/dist/**/*.*"
+    ]
+  },
+  "devDependencies": {
+    "appcache-webpack-plugin": "^1.3.0",
+    "commitizen": "2.9.6",
+    "css-loader": "^0.26.1",
+    "cz-conventional-changelog": "2.1.0",
+    "dir-compare": "1.3.0",
+    "es6-promise": "^4.0.5",
+    "extract-text-webpack-plugin": "^1.0.1",
+    "file-loader": "^0.9.0",
+    "html-loader": "^0.4.4",
+    "jade": "^1.11.0",
+    "jade-loader": "^0.8.0",
+    "jasmine": "^2.5.2",
+    "jasmine-diff-matchers": "^2.0.0",
+    "rimraf": "^2.5.4",
+    "semistandard": "8.0.0",
+    "standard-version": "^4.3.0",
+    "style-loader": "^0.13.1",
+    "underscore-template-loader": "^0.7.3",
+    "url-loader": "^0.5.7",
+    "webpack": "^1.14.0",
+    "webpack-recompilation-simulator": "^1.3.0"
+  },
+  "dependencies": {
+    "html-minifier": "^3.2.3",
+    "loader-utils": "^0.2.16",
+    "lodash": "^4.17.3",
+    "pretty-error": "^2.0.2",
+    "tapable": "^1.0.0",
+    "toposort": "^1.0.0",
+    "util.promisify": "1.0.0"
+  },
+  "peerDependencies": {
+    "webpack": "^1.0.0 || ^2.0.0 || ^3.0.0 || ^4.0.0"
+  },
+  "keywords": [
+    "webpack",
+    "plugin",
+    "html",
+    "html-webpack-plugin"
+  ],
+  "bugs": "https://github.com/jantimon/html-webpack-plugin/issues",
+  "homepage": "https://github.com/jantimon/html-webpack-plugin",
+  "repository": "https://github.com/jantimon/html-webpack-plugin.git",
+  "engines": {
+    "node": ">=6.9"
+  },
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
+  }
+}