Fix bin/publish: copy docs.dist from project root

Fix bin/publish: use correct .env path for rspade_system
Fix bin/publish script: prevent grep exit code 1 from terminating script

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

node_modules/html-loader/CHANGELOG.md

@@ -0,0 +1,170 @@
+# Changelog
+
+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.
+
+### [1.3.2](https://github.com/webpack-contrib/html-loader/compare/v1.3.1...v1.3.2) (2020-10-09)
+
+### Chore
+
+* update `schema-utils`
+
+### [1.3.1](https://github.com/webpack-contrib/html-loader/compare/v1.3.0...v1.3.1) (2020-09-21)
+
+
+### Bug Fixes
+
+* avoid removing redundant attributes ([#324](https://github.com/webpack-contrib/html-loader/issues/324)) ([ab299ac](https://github.com/webpack-contrib/html-loader/commit/ab299acd8784f96f9191988133fb74f72aaf89c8))
+
+## [1.3.0](https://github.com/webpack-contrib/html-loader/compare/v1.2.1...v1.3.0) (2020-08-25)
+
+
+### Features
+
+* `...` syntax to extend default tag and attributes ([#317](https://github.com/webpack-contrib/html-loader/issues/317)) ([f02bb48](https://github.com/webpack-contrib/html-loader/commit/f02bb48a1124fc567b858234b1cf3d3e68bb6c76))
+
+
+### Bug Fixes
+
+* handle `script` tags in SVG ([#315](https://github.com/webpack-contrib/html-loader/issues/315)) ([d021e42](https://github.com/webpack-contrib/html-loader/commit/d021e42fc830d36cf2ab3e9d483fd5723af23ba8))
+
+### [1.2.1](https://github.com/webpack-contrib/html-loader/compare/v1.2.0...v1.2.1) (2020-08-19)
+
+
+### Bug Fixes
+
+* ignore template sources ([#314](https://github.com/webpack-contrib/html-loader/issues/314)) ([078d9bd](https://github.com/webpack-contrib/html-loader/commit/078d9bdc36d256d6a78ab0ae9b8ccddbef11393c))
+
+## [1.2.0](https://github.com/webpack-contrib/html-loader/compare/v1.1.0...v1.2.0) (2020-08-18)
+
+
+### Features
+
+* support SVG tags ([#302](https://github.com/webpack-contrib/html-loader/issues/302)) ([1acd204](https://github.com/webpack-contrib/html-loader/commit/1acd20448dbe976b883597b135bb8ac9e1b71d1a))
+
+
+### Bug Fixes
+
+* do not handle non standard `script` types ([ddad9f2](https://github.com/webpack-contrib/html-loader/commit/ddad9f2d6f5ab75fe2afd247bf55b1646c6e1c31))
+* inline syntax for sources ([#310](https://github.com/webpack-contrib/html-loader/issues/310)) ([c247cfa](https://github.com/webpack-contrib/html-loader/commit/c247cfa9ad66281b28aef5397c8c2d2786f05867))
+* linefeed characters in sources ([#311](https://github.com/webpack-contrib/html-loader/issues/311)) ([b8ee9ee](https://github.com/webpack-contrib/html-loader/commit/b8ee9ee0d60848e84e52fb117c1f3cdc2ebf08d7))
+* minimize is more safely ([#304](https://github.com/webpack-contrib/html-loader/issues/304)) ([03152b1](https://github.com/webpack-contrib/html-loader/commit/03152b1d3b807a287d84302f6a9987ceb22d395c))
+* perf ([#300](https://github.com/webpack-contrib/html-loader/issues/300)) ([d69f259](https://github.com/webpack-contrib/html-loader/commit/d69f259d2a6b4bc9ba9c163fd2d70989c3f3a6ff))
+
+## [1.1.0](https://github.com/webpack-contrib/html-loader/compare/v1.0.0...v1.1.0) (2020-04-02)
+
+
+### Features
+
+* added support for an async functions to the `preprocessor` option ([#272](https://github.com/webpack-contrib/html-loader/issues/272)) ([e59324b](https://github.com/webpack-contrib/html-loader/commit/e59324b929557a9e1da5e1713748351cf37efdb1))
+* allowed to handle an attribute without a tag ([#273](https://github.com/webpack-contrib/html-loader/issues/273)) ([c0d6d5b](https://github.com/webpack-contrib/html-loader/commit/c0d6d5b9338af219a5cd81779ee2bcd9254420ed))
+
+
+### Bug Fixes
+
+* hash processing improved ([#275](https://github.com/webpack-contrib/html-loader/issues/275)) ([74d2c60](https://github.com/webpack-contrib/html-loader/commit/74d2c607c519bdaad995a51e74b6317c8cfaad14))
+
+## [1.0.0](https://github.com/ryanclark/html-loader/compare/v0.5.5...v1.0.0) (2020-03-19)
+
+
+### ⚠ BREAKING CHANGES
+
+* for parsing HTML now we use `htmlparser2` package
+* the `attrs` option was renamed to the `attributes` option
+* the `interpolate` option was removed, please consider migration on the [`preprocessor`](https://github.com/webpack-contrib/html-loader#preprocessor)
+* the `minimize` option is `true` by default in `production` mode. You need to list all options for `html-minifier` if you use `object` notation.
+* uppercase tags and uppercase attributes are handled by default
+* the `root` option was moved under the `attributes` option, please look at the [documentation](https://github.com/webpack-contrib/html-loader#object)
+* emit an error on broken HTML syntax when minimization is enabled
+* By default, now we process the following tags with attributes:
+  * the `src` attribute of the `audio` tag
+  * the `src` attribute of the `embed` tag
+  * the `src` attribute of the `img` tag
+  * the `srcset` attribute of the `img` tag
+  * the `src` attribute of the `input` tag
+  * the `href` attribute of the `link` tag (only for stylesheets)
+  * the `data` attribute of the `object` tag
+  * the `src` attribute of the `script` tag
+  * the `src` attribute of the `source` tag
+  * the `srcset` attribute of the `source` tag
+  * the `src` attribute of the `track` tag
+  * the `poster` attribute of the `video` tag
+  * the `src` attribute of the `video` tag
+* the `attributes` option should be `Boolean` or `Object`, please look at the [documentation](https://github.com/webpack-contrib/html-loader#object)
+* the `exportAsDefault` option were removed in favor the `esModules` option
+* the `exportAsEs6Default` option were removed in favor the `esModules` option
+
+### Features
+
+* handle more tags and attributes
+* added the `preprocessor` option
+* added the `esModule` option
+* add the `rulFilter` option for filtering some of urls, please look at the [documentation](https://github.com/webpack-contrib/html-loader#urlfilter)
+* allow to setup how to handle and filter tags and attributes, please look at the [documentation](https://github.com/webpack-contrib/html-loader#list)
+* improve error reporting
+
+### Bug Fixes
+
+* adding quotes when necessary for unquoted sources
+* do not handle empty attributes
+* escape `\u2028` and `\u2029` characters
+* handle only valid srcset tags
+* parser tags and attributes according spec
+* reduce `import`/`require` count
+* reduce size of generated modules
+* respect `#hash` in sources
+* support ES6 syntax in `script` tags when minimize
+* support ES6 import of urls
+
+<a name="0.5.5"></a>
+## [0.5.5](https://github.com/webpack-contrib/html-loader/compare/v0.5.4...v0.5.5) (2018-01-17)
+
+
+### Bug Fixes
+
+* **index:** don't prepend `./` to the URL on `interpolate=require` (`options.interpolate`) ([#165](https://github.com/webpack-contrib/html-loader/issues/165)) ([9515410](https://github.com/webpack-contrib/html-loader/commit/9515410))
+
+
+
+<a name="0.5.4"></a>
+## [0.5.4](https://github.com/webpack-contrib/html-loader/compare/v0.5.1...v0.5.4) (2018-01-05)
+
+
+### Bug Fixes
+
+* ignore attribute if `mailto:` is present ([#145](https://github.com/webpack-contrib/html-loader/issues/145)) ([4b13d4c](https://github.com/webpack-contrib/html-loader/commit/4b13d4c))
+* **index:** escape double quotes correctly (`options.interpolate`) ([#154](https://github.com/webpack-contrib/html-loader/issues/154)) ([1ef5de4](https://github.com/webpack-contrib/html-loader/commit/1ef5de4))
+
+
+<a name="0.5.1"></a>
+## [0.5.1](https://github.com/webpack/html-loader/compare/v0.5.0...v0.5.1) (2017-08-08)
+
+
+### Bug Fixes
+
+* Support for empty tags in tag-attribute matching ([#133](https://github.com/webpack/html-loader/issues/133)) ([6efa6de](https://github.com/webpack/html-loader/commit/6efa6de)), closes [#129](https://github.com/webpack/html-loader/issues/129)
+
+
+
+<a name="0.5.0"></a>
+# [0.5.0](https://github.com/webpack/html-loader/compare/v0.4.3...v0.5.0) (2017-07-26)
+
+
+### Features
+
+* add support for empty tags in `tag:attribute` matching ([#129](https://github.com/webpack/html-loader/issues/129)) ([70370dc](https://github.com/webpack/html-loader/commit/70370dc))
+
+
+<a name="0.4.5"></a>
+## [0.4.5](https://github.com/webpack/html-loader/compare/v0.4.3...v0.4.5) (2017-07-26)
+
+
+### Bug Fixes
+
+* es6 default export ([fae0309](https://github.com/webpack/html-loader/commit/fae0309))
+* Handle es6 default export ([e04e969](https://github.com/webpack/html-loader/commit/e04e969))
+* **getOptions:** deprecation warn in loaderUtils ([#114](https://github.com/webpack/html-loader/issues/114)) ([3d47e98](https://github.com/webpack/html-loader/commit/3d47e98))
+
+
+### Features
+
+* Adds exportAsDefault ([37d40d8](https://github.com/webpack/html-loader/commit/37d40d8))

node_modules/html-loader/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.

node_modules/html-loader/README.md

@@ -0,0 +1,834 @@
+<div align="center">
+  <img width="200" height="200" src="https://worldvectorlogo.com/logos/html5.svg" alt="html-loader">
+  <a href="https://github.com/webpack/webpack">
+    <img width="200" height="200" vspace="" hspace="25" src="https://webpack.js.org/assets/icon-square-big.svg" alt="webpack">
+  </a>
+</div>
+
+[![npm][npm]][npm-url]
+[![node][node]][node-url]
+[![deps][deps]][deps-url]
+[![tests][tests]][tests-url]
+[![coverage][cover]][cover-url]
+[![chat][chat]][chat-url]
+[![size][size]][size-url]
+
+# html-loader
+
+Exports HTML as string. HTML is minimized when the compiler demands.
+
+## Getting Started
+
+To begin, you'll need to install `html-loader`:
+
+```console
+npm install --save-dev html-loader
+```
+
+Then add the plugin to your `webpack` config. For example:
+
+**file.js**
+
+```js
+import html from './file.html';
+```
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.html$/i,
+        loader: 'html-loader',
+      },
+    ],
+  },
+};
+```
+
+## Options
+
+|                Name                 |        Type         |                   Default                    | Description                                      |
+| :---------------------------------: | :-----------------: | :------------------------------------------: | :----------------------------------------------- |
+|   **[`attributes`](#attributes)**   | `{Boolean\|Object}` |                    `true`                    | Enables/Disables attributes handling             |
+| **[`preprocessor`](#preprocessor)** |    `{Function}`     |                 `undefined`                  | Allows pre-processing of content before handling |
+|     **[`minimize`](#minimize)**     | `{Boolean\|Object}` | `true` in production mode, otherwise `false` | Tell `html-loader` to minimize HTML              |
+|     **[`esModule`](#esmodule)**     |     `{Boolean}`     |                   `false`                    | Use ES modules syntax                            |
+
+### `attributes`
+
+Type: `Boolean|Object`
+Default: `true`
+
+By default every loadable attributes (for example - `<img src="image.png">`) is imported (`const img = require('./image.png')` or `import img from "./image.png""`).
+You may need to specify loaders for images in your configuration (recommended `file-loader` or `url-loader`).
+
+Supported tags and attributes:
+
+- the `src` attribute of the `audio` tag
+- the `src` attribute of the `embed` tag
+- the `src` attribute of the `img` tag
+- the `srcset` attribute of the `img` tag
+- the `src` attribute of the `input` tag
+- the `href` attribute of the `link` tag (only for stylesheets)
+- the `data` attribute of the `object` tag
+- the `src` attribute of the `script` tag
+- the `href` attribute of the `script` tag
+- the `xlink:href` attribute of the `script` tag
+- the `src` attribute of the `source` tag
+- the `srcset` attribute of the `source` tag
+- the `src` attribute of the `track` tag
+- the `poster` attribute of the `video` tag
+- the `src` attribute of the `video` tag
+- the `xlink:href` attribute of the `image` tag
+- the `href` attribute of the `image` tag
+- the `xlink:href` attribute of the `use` tag
+- the `href` attribute of the `use` tag
+
+#### `Boolean`
+
+The `true` value enables processing of all default elements and attributes, the `false` disable processing of all attributes.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.html$/i,
+        loader: 'html-loader',
+        options: {
+          // Disables attributes processing
+          attributes: false,
+        },
+      },
+    ],
+  },
+};
+```
+
+#### `Object`
+
+Allows you to specify which tags and attributes to process, filter them, filter urls and process sources starts with `/`.
+
+For example:
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.html$/i,
+        loader: 'html-loader',
+        options: {
+          attributes: {
+            list: [
+              // All default supported tags and attributes
+              '...',
+              {
+                tag: 'img',
+                attribute: 'data-src',
+                type: 'src',
+              },
+              {
+                tag: 'img',
+                attribute: 'data-srcset',
+                type: 'srcset',
+              },
+            ],
+            urlFilter: (attribute, value, resourcePath) => {
+              // The `attribute` argument contains a name of the HTML attribute.
+              // The `value` argument contains a value of the HTML attribute.
+              // The `resourcePath` argument contains a path to the loaded HTML file.
+
+              if (/example\.pdf$/.test(value)) {
+                return false;
+              }
+
+              return true;
+            },
+            root: '.',
+          },
+        },
+      },
+    ],
+  },
+};
+```
+
+#### `list`
+
+Type: `Array`
+Default: [supported tags and attributes](#attributes).
+
+Allows to setup which tags and attributes to process and how, and the ability to filter some of them.
+
+Using `...` syntax allows you to extend [default supported tags and attributes](#attributes).
+
+For example:
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.html$/i,
+        loader: 'html-loader',
+        options: {
+          attributes: {
+            list: [
+              // All default supported tags and attributes
+              '...',
+              {
+                tag: 'img',
+                attribute: 'data-src',
+                type: 'src',
+              },
+              {
+                tag: 'img',
+                attribute: 'data-srcset',
+                type: 'srcset',
+              },
+              {
+                // Tag name
+                tag: 'link',
+                // Attribute name
+                attribute: 'href',
+                // Type of processing, can be `src` or `scrset`
+                type: 'src',
+                // Allow to filter some attributes
+                filter: (tag, attribute, attributes, resourcePath) => {
+                  // The `tag` argument contains a name of the HTML tag.
+                  // The `attribute` argument contains a name of the HTML attribute.
+                  // The `attributes` argument contains all attributes of the tag.
+                  // The `resourcePath` argument contains a path to the loaded HTML file.
+
+                  if (/my-html\.html$/.test(resourcePath)) {
+                    return false;
+                  }
+
+                  if (!/stylesheet/i.test(attributes.rel)) {
+                    return false;
+                  }
+
+                  if (
+                    attributes.type &&
+                    attributes.type.trim().toLowerCase() !== 'text/css'
+                  ) {
+                    return false;
+                  }
+
+                  return true;
+                },
+              },
+            ],
+          },
+        },
+      },
+    ],
+  },
+};
+```
+
+If the tag name is not specified it will process all the tags.
+
+> You can use your custom filter to specify html elements to be processed.
+
+For example:
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.html$/i,
+        loader: 'html-loader',
+        options: {
+          attributes: {
+            list: [
+              {
+                // Attribute name
+                attribute: 'src',
+                // Type of processing, can be `src` or `scrset`
+                type: 'src',
+                // Allow to filter some attributes (optional)
+                filter: (tag, attribute, attributes, resourcePath) => {
+                  // The `tag` argument contains a name of the HTML tag.
+                  // The `attribute` argument contains a name of the HTML attribute.
+                  // The `attributes` argument contains all attributes of the tag.
+                  // The `resourcePath` argument contains a path to the loaded HTML file.
+
+                  // choose all HTML tags except img tag
+                  return tag.toLowerCase() !== 'img';
+                },
+              },
+            ],
+          },
+        },
+      },
+    ],
+  },
+};
+```
+
+#### `urlFilter`
+
+Type: `Function`
+Default: `undefined`
+
+Allow to filter urls. All filtered urls will not be resolved (left in the code as they were written).
+All non requestable sources (for example `<img src="javascript:void(0)">`) do not handle by default.
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.html$/i,
+        loader: 'html-loader',
+        options: {
+          attributes: {
+            urlFilter: (attribute, value, resourcePath) => {
+              // The `attribute` argument contains a name of the HTML attribute.
+              // The `value` argument contains a value of the HTML attribute.
+              // The `resourcePath` argument contains a path to the loaded HTML file.
+
+              if (/example\.pdf$/.test(value)) {
+                return false;
+              }
+
+              return true;
+            },
+          },
+        },
+      },
+    ],
+  },
+};
+```
+
+#### `root`
+
+Type: `String`
+Default: `undefined`
+
+For urls that start with a `/`, the default behavior is to not translate them.
+If a `root` query parameter is set, however, it will be prepended to the url and then translated.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.html$/i,
+        loader: 'html-loader',
+        options: {
+          attributes: {
+            root: '.',
+          },
+        },
+      },
+    ],
+  },
+};
+```
+
+### `preprocessor`
+
+Type: `Function`
+Default: `undefined`
+
+Allows pre-processing of content before handling.
+
+> ⚠ You should always return valid HTML
+
+**file.hbs**
+
+```hbs
+<div>
+  <p>{{firstname}} {{lastname}}</p>
+  <img src="image.png" alt="alt" />
+<div>
+```
+
+#### `Function`
+
+You can set the `preprocessor` option as a `Function` instance.
+
+**webpack.config.js**
+
+```js
+const Handlebars = require('handlebars');
+
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.hbs$/i,
+        loader: 'html-loader',
+        options: {
+          preprocessor: (content, loaderContext) => {
+            let result;
+
+            try {
+              result = Handlebars.compile(content)({
+                firstname: 'Value',
+                lastname: 'OtherValue',
+              });
+            } catch (error) {
+              loaderContext.emitError(error);
+
+              return content;
+            }
+
+            return result;
+          },
+        },
+      },
+    ],
+  },
+};
+```
+
+You can also set the `preprocessor` option as an asynchronous function instance.
+
+For example:
+
+**webpack.config.js**
+
+```js
+const Handlebars = require('handlebars');
+
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.hbs$/i,
+        loader: 'html-loader',
+        options: {
+          preprocessor: async (content, loaderContext) => {
+            let result;
+
+            try {
+              result = await Handlebars.compile(content)({
+                firstname: 'Value',
+                lastname: 'OtherValue',
+              });
+            } catch (error) {
+              await loaderContext.emitError(error);
+
+              return content;
+            }
+
+            return result;
+          },
+        },
+      },
+    ],
+  },
+};
+```
+
+### `minimize`
+
+Type: `Boolean|Object`
+Default: `true` in production mode, otherwise `false`
+
+Tell `html-loader` to minimize HTML.
+
+#### `Boolean`
+
+The enabled rules for minimizing by default are the following ones:
+
+```js
+({
+  caseSensitive: true,
+  collapseWhitespace: true,
+  conservativeCollapse: true,
+  keepClosingSlash: true,
+  minifyCSS: true,
+  minifyJS: true,
+  removeComments: true,
+  removeRedundantAttributes: true,
+  removeScriptTypeAttributes: true,
+  removeStyleLinkTypeAttributes: true,
+});
+```
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.html$/i,
+        loader: 'html-loader',
+        options: {
+          minimize: true,
+        },
+      },
+    ],
+  },
+};
+```
+
+#### `Object`
+
+**webpack.config.js**
+
+See [html-minifier-terser](https://github.com/DanielRuf/html-minifier-terser)'s documentation for more information on the available options.
+
+The rules can be disabled using the following options in your `webpack.conf.js`
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.html$/i,
+        loader: 'html-loader',
+        options: {
+          minimize: {
+            removeComments: false,
+            collapseWhitespace: false,
+          },
+        },
+      },
+    ],
+  },
+};
+```
+
+### `esModule`
+
+Type: `Boolean`
+Default: `false`
+
+By default, `html-loader` generates JS modules that use the CommonJS modules syntax.
+There are some cases in which using ES modules is beneficial, like in the case of [module concatenation](https://webpack.js.org/plugins/module-concatenation-plugin/) and [tree shaking](https://webpack.js.org/guides/tree-shaking/).
+
+You can enable a ES module syntax using:
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.html$/i,
+        loader: 'html-loader',
+        options: {
+          esModule: true,
+        },
+      },
+    ],
+  },
+};
+```
+
+## Examples
+
+### CDN
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      { test: /\.jpg$/, loader: 'file-loader' },
+      { test: /\.png$/, loader: 'url-loader' },
+    ],
+  },
+  output: {
+    publicPath: 'http://cdn.example.com/[hash]/',
+  },
+};
+```
+
+**file.html**
+
+```html
+<img src="image.jpg" data-src="image2x.png" />
+```
+
+**index.js**
+
+```js
+require('html-loader!./file.html');
+
+// => '<img src="http://cdn.example.com/49eba9f/a992ca.jpg" data-src="image2x.png">'
+```
+
+```js
+require('html-loader?{"attributes":{"list":[{"tag":"img","attribute":"data-src","type":"src"}]}}!./file.html');
+
+// => '<img src="image.jpg" data-src="data:image/png;base64,..." >'
+```
+
+```js
+require('html-loader?{"attributes":{"list":[{"tag":"img","attribute":"src","type":"src"},{"tag":"img","attribute":"data-src","type":"src"}]}}!./file.html');
+
+// => '<img src="http://cdn.example.com/49eba9f/a992ca.jpg" data-src="data:image/png;base64,..." >'
+```
+
+```js
+require('html-loader?-attributes!./file.html');
+
+// => '<img src="image.jpg"  data-src="image2x.png" >'
+```
+
+> :warning: `-attributes` sets `attributes: false`.
+
+### Process `script` and `link` tags
+
+**script.file.js**
+
+```js
+console.log(document);
+```
+
+**style.file.css**
+
+```css
+a {
+  color: red;
+}
+```
+
+**file.html**
+
+```html
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <title>Title of the document</title>
+    <link rel="stylesheet" type="text/css" href="./style.file.css" />
+  </head>
+  <body>
+    Content of the document......
+    <script src="./script.file.js"></script>
+  </body>
+</html>
+```
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.html$/i,
+        use: ['file-loader?name=[name].[ext]', 'extract-loader', 'html-loader'],
+      },
+      {
+        test: /\.js$/i,
+        exclude: /\.file.js$/i,
+        loader: 'babel-loader',
+      },
+      {
+        test: /\.file.js$/i,
+        loader: 'file-loader',
+      },
+      {
+        test: /\.css$/i,
+        exclude: /\.file.css$/i,
+        loader: 'css-loader',
+      },
+      {
+        test: /\.file.css$/i,
+        loader: 'file-loader',
+      },
+    ],
+  },
+};
+```
+
+### 'Root-relative' URLs
+
+With the same configuration as in the CDN example:
+
+**file.html**
+
+```html
+<img src="/image.jpg" />
+```
+
+**scripts.js**
+
+```js
+require('html-loader!./file.html');
+
+// => '<img src="/image.jpg">'
+```
+
+**other-scripts.js**
+
+```js
+require('html-loader?{"attributes":{"root":"."}}!./file.html');
+
+// => '<img src="http://cdn.example.com/49eba9f/a992ca.jpg">'
+```
+
+### Templating
+
+You can use any template system. Below is an example for [handlebars](https://handlebarsjs.com/).
+
+**file.hbs**
+
+```hbs
+<div>
+  <p>{{firstname}} {{lastname}}</p>
+  <img src="image.png" alt="alt" />
+<div>
+```
+
+**webpack.config.js**
+
+```js
+const Handlebars = require('handlebars');
+
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.hbs$/i,
+        loader: 'html-loader',
+        options: {
+          preprocessor: (content, loaderContext) => {
+            let result;
+
+            try {
+              result = Handlebars.compile(content)({
+                firstname: 'Value',
+                lastname: 'OtherValue',
+              });
+            } catch (error) {
+              loaderContext.emitError(error);
+
+              return content;
+            }
+
+            return result;
+          },
+        },
+      },
+    ],
+  },
+};
+```
+
+### PostHTML
+
+You can use [PostHTML](https://github.com/posthtml/posthtml) without any additional loaders.
+
+**file.html**
+
+```html
+<img src="image.jpg" />
+```
+
+**webpack.config.js**
+
+```js
+const posthtml = require('posthtml');
+const posthtmlWebp = require('posthtml-webp');
+
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.hbs$/i,
+        loader: 'html-loader',
+        options: {
+          preprocessor: (content, loaderContext) => {
+            let result;
+
+            try {
+              result = posthtml().use(plugin).process(content, { sync: true });
+            } catch (error) {
+              loaderContext.emitError(error);
+
+              return content;
+            }
+
+            return result.html;
+          },
+        },
+      },
+    ],
+  },
+};
+```
+
+### Export into HTML files
+
+A very common scenario is exporting the HTML into their own _.html_ file, to
+serve them directly instead of injecting with javascript. This can be achieved
+with a combination of 3 loaders:
+
+- [file-loader](https://github.com/webpack/file-loader)
+- [extract-loader](https://github.com/peerigon/extract-loader)
+- html-loader
+
+The html-loader will parse the URLs, require the images and everything you
+expect. The extract loader will parse the javascript back into a proper html
+file, ensuring images are required and point to proper path, and the file loader
+will write the _.html_ file for you. Example:
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.html$/i,
+        use: ['file-loader?name=[name].[ext]', 'extract-loader', 'html-loader'],
+      },
+    ],
+  },
+};
+```
+
+## Contributing
+
+Please take a moment to read our contributing guidelines if you haven't yet done so.
+
+[CONTRIBUTING](./.github/CONTRIBUTING.md)
+
+## License
+
+[MIT](./LICENSE)
+
+[npm]: https://img.shields.io/npm/v/html-loader.svg
+[npm-url]: https://npmjs.com/package/html-loader
+[node]: https://img.shields.io/node/v/html-loader.svg
+[node-url]: https://nodejs.org
+[deps]: https://david-dm.org/webpack-contrib/html-loader.svg
+[deps-url]: https://david-dm.org/webpack-contrib/html-loader
+[tests]: https://github.com/webpack-contrib/html-loader/workflows/html-loader/badge.svg
+[tests-url]: https://github.com/webpack-contrib/html-loader/actions
+[cover]: https://codecov.io/gh/webpack-contrib/html-loader/branch/master/graph/badge.svg
+[cover-url]: https://codecov.io/gh/webpack-contrib/html-loader
+[chat]: https://img.shields.io/badge/gitter-webpack%2Fwebpack-brightgreen.svg
+[chat-url]: https://gitter.im/webpack/webpack
+[size]: https://packagephobia.now.sh/badge?p=html-loader
+[size-url]: https://packagephobia.now.sh/result?p=html-loader

node_modules/html-loader/dist/HtmlSourceError.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function getIndices(value) {
+  const result = [];
+  let index = value.indexOf('\n');
+
+  while (index !== -1) {
+    result.push(index + 1);
+    index = value.indexOf('\n', index + 1);
+  }
+
+  result.push(value.length + 1);
+  return result;
+}
+
+function offsetToPosition(source, offset) {
+  let index = -1;
+  const indices = getIndices(source);
+  const {
+    length
+  } = indices;
+
+  if (offset < 0) {
+    return {};
+  } // eslint-disable-next-line no-plusplus
+
+
+  while (++index < length) {
+    if (indices[index] > offset) {
+      return {
+        line: index + 1,
+        column: offset - (indices[index - 1] || 0) + 1,
+        offset
+      };
+    }
+  }
+
+  return {};
+}
+
+class HtmlSourceError extends Error {
+  constructor(error, startIndex, endIndex, source) {
+    super(error);
+    this.name = 'HtmlSourceError';
+    this.message = `${this.name}: ${this.message}`;
+    this.startIndex = startIndex;
+    this.endIndex = endIndex;
+    this.source = source;
+    const startPosition = offsetToPosition(source, this.startIndex);
+    const endPosition = offsetToPosition(source, this.endIndex);
+    this.message += ` (From line ${startPosition.line}, column ${startPosition.column}; to line ${endPosition.line}, column ${endPosition.column})`; // We don't need stack
+
+    this.stack = false;
+  }
+
+}
+
+exports.default = HtmlSourceError;

node_modules/html-loader/dist/cjs.js

@@ -0,0 +1,6 @@
+"use strict";
+
+const loader = require('./index');
+
+module.exports = loader.default;
+module.exports.raw = loader.raw;

node_modules/html-loader/dist/index.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loader;
+
+var _loaderUtils = require("loader-utils");
+
+var _schemaUtils = require("schema-utils");
+
+var _plugins = require("./plugins");
+
+var _utils = require("./utils");
+
+var _options = _interopRequireDefault(require("./options.json"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+async function loader(content) {
+  const rawOptions = (0, _loaderUtils.getOptions)(this);
+  (0, _schemaUtils.validate)(_options.default, rawOptions, {
+    name: 'HTML Loader',
+    baseDataPath: 'options'
+  });
+  const options = (0, _utils.normalizeOptions)(rawOptions, this);
+
+  if (options.preprocessor) {
+    // eslint-disable-next-line no-param-reassign
+    content = await options.preprocessor(content, this);
+  }
+
+  const plugins = [];
+  const errors = [];
+  const imports = [];
+  const replacements = [];
+
+  if (options.attributes) {
+    plugins.push((0, _plugins.sourcePlugin)({
+      urlHandler: url => (0, _loaderUtils.stringifyRequest)(this, url),
+      attributes: options.attributes,
+      resourcePath: this.resourcePath,
+      imports,
+      errors,
+      replacements
+    }));
+  }
+
+  if (options.minimize) {
+    plugins.push((0, _plugins.minimizerPlugin)({
+      minimize: options.minimize,
+      errors
+    }));
+  }
+
+  const {
+    html
+  } = (0, _utils.pluginRunner)(plugins).process(content);
+
+  for (const error of errors) {
+    this.emitError(error instanceof Error ? error : new Error(error));
+  }
+
+  const importCode = (0, _utils.getImportCode)(html, this, imports, options);
+  const moduleCode = (0, _utils.getModuleCode)(html, replacements, options);
+  const exportCode = (0, _utils.getExportCode)(html, options);
+  return `${importCode}${moduleCode}${exportCode}`;
+}

node_modules/html-loader/dist/options.json

@@ -0,0 +1,73 @@
+{
+  "type": "object",
+  "definitions": {
+    "Attribute": {
+      "anyOf": [
+        {
+          "type": "object",
+          "properties": {
+            "tag": {
+              "type": "string",
+              "minLength": 1
+            },
+            "attribute": {
+              "type": "string",
+              "minLength": 1
+            },
+            "type": {
+              "enum": ["src", "srcset"]
+            },
+            "filter": {
+              "instanceof": "Function"
+            }
+          },
+          "required": ["attribute", "type"],
+          "additionalProperties": false
+        },
+        {
+          "enum": ["..."]
+        }
+      ]
+    },
+    "AttributeList": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/Attribute"
+      },
+      "minItems": 1,
+      "uniqueItems": true
+    }
+  },
+  "properties": {
+    "preprocessor": {
+      "instanceof": "Function"
+    },
+    "attributes": {
+      "anyOf": [
+        { "type": "boolean" },
+        {
+          "type": "object",
+          "properties": {
+            "list": {
+              "$ref": "#/definitions/AttributeList"
+            },
+            "urlFilter": {
+              "instanceof": "Function"
+            },
+            "root": {
+              "type": "string"
+            }
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
+    "minimize": {
+      "anyOf": [{ "type": "boolean" }, { "type": "object" }]
+    },
+    "esModule": {
+      "type": "boolean"
+    }
+  },
+  "additionalProperties": false
+}

node_modules/html-loader/dist/plugins/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "sourcePlugin", {
+  enumerable: true,
+  get: function () {
+    return _sourcePlugin.default;
+  }
+});
+Object.defineProperty(exports, "minimizerPlugin", {
+  enumerable: true,
+  get: function () {
+    return _minimizerPlugin.default;
+  }
+});
+
+var _sourcePlugin = _interopRequireDefault(require("./source-plugin"));
+
+var _minimizerPlugin = _interopRequireDefault(require("./minimizer-plugin"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

node_modules/html-loader/dist/plugins/minimizer-plugin.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _htmlMinifierTerser = require("html-minifier-terser");
+
+var _default = options => function process(html) {
+  try {
+    // eslint-disable-next-line no-param-reassign
+    html = (0, _htmlMinifierTerser.minify)(html, options.minimize);
+  } catch (error) {
+    options.errors.push(error);
+  }
+
+  return html;
+};
+
+exports.default = _default;

node_modules/html-loader/dist/plugins/source-plugin.js

@@ -0,0 +1,271 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _htmlparser = require("htmlparser2");
+
+var _loaderUtils = require("loader-utils");
+
+var _HtmlSourceError = _interopRequireDefault(require("../HtmlSourceError"));
+
+var _utils = require("../utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = options => function process(html) {
+  const {
+    list,
+    urlFilter: maybeUrlFilter,
+    root
+  } = options.attributes;
+  const sources = [];
+  const urlFilter = (0, _utils.getFilter)(maybeUrlFilter, value => (0, _loaderUtils.isUrlRequest)(value, root));
+
+  const getAttribute = (tag, attribute, attributes, resourcePath) => {
+    return list.find(element => {
+      const foundTag = typeof element.tag === 'undefined' || typeof element.tag !== 'undefined' && element.tag.toLowerCase() === tag.toLowerCase();
+      const foundAttribute = element.attribute.toLowerCase() === attribute.toLowerCase();
+      const isNotFiltered = element.filter ? element.filter(tag, attribute, attributes, resourcePath) : true;
+      return foundTag && foundAttribute && isNotFiltered;
+    });
+  };
+
+  const {
+    resourcePath
+  } = options;
+  const parser = new _htmlparser.Parser({
+    attributesMeta: {},
+
+    onattribute(name, value) {
+      // eslint-disable-next-line no-underscore-dangle
+      const endIndex = parser._tokenizer._index;
+      const startIndex = endIndex - value.length;
+      const unquoted = html[endIndex] !== '"' && html[endIndex] !== "'";
+      this.attributesMeta[name] = {
+        startIndex,
+        unquoted
+      };
+    },
+
+    onopentag(tag, attributes) {
+      Object.keys(attributes).forEach(attribute => {
+        const value = attributes[attribute];
+        const {
+          startIndex: valueStartIndex,
+          unquoted
+        } = this.attributesMeta[attribute];
+        const foundAttribute = getAttribute(tag, attribute, attributes, resourcePath);
+
+        if (!foundAttribute) {
+          return;
+        }
+
+        const {
+          type
+        } = foundAttribute; // eslint-disable-next-line default-case
+
+        switch (type) {
+          case 'src':
+            {
+              let source;
+
+              try {
+                source = (0, _utils.parseSrc)(value);
+              } catch (error) {
+                options.errors.push(new _HtmlSourceError.default(`Bad value for attribute "${attribute}" on element "${tag}": ${error.message}`, parser.startIndex, parser.endIndex, html));
+                return;
+              }
+
+              if (!(0, _utils.isUrlRequestable)(source.value, root)) {
+                return;
+              }
+
+              const startIndex = valueStartIndex + source.startIndex;
+              const endIndex = startIndex + source.value.length;
+              sources.push({
+                name: attribute,
+                value: source.value,
+                unquoted,
+                startIndex,
+                endIndex
+              });
+              break;
+            }
+
+          case 'srcset':
+            {
+              let sourceSet;
+
+              try {
+                sourceSet = (0, _utils.parseSrcset)(value);
+              } catch (error) {
+                options.errors.push(new _HtmlSourceError.default(`Bad value for attribute "${attribute}" on element "${tag}": ${error.message}`, parser.startIndex, parser.endIndex, html));
+                return;
+              }
+
+              sourceSet.forEach(sourceItem => {
+                const {
+                  source
+                } = sourceItem;
+                const startIndex = valueStartIndex + source.startIndex;
+                const endIndex = startIndex + source.value.length;
+
+                if (!(0, _utils.isUrlRequestable)(source.value, root)) {
+                  return;
+                }
+
+                sources.push({
+                  name: attribute,
+                  value: source.value,
+                  unquoted,
+                  startIndex,
+                  endIndex
+                });
+              });
+              break;
+            }
+          // Need improve
+          // case 'include': {
+          //   let source;
+          //
+          //   // eslint-disable-next-line no-underscore-dangle
+          //   if (parser._tokenizer._state === 4) {
+          //     return;
+          //   }
+          //
+          //   try {
+          //     source = parseSrc(value);
+          //   } catch (error) {
+          //     options.errors.push(
+          //       new HtmlSourceError(
+          //         `Bad value for attribute "${attribute}" on element "${tag}": ${error.message}`,
+          //         parser.startIndex,
+          //         parser.endIndex,
+          //         html
+          //       )
+          //     );
+          //
+          //     return;
+          //   }
+          //
+          //   if (!urlFilter(attribute, source.value, resourcePath)) {
+          //     return;
+          //   }
+          //
+          //   const { startIndex } = parser;
+          //   const closingTag = html
+          //     .slice(startIndex - 1)
+          //     .match(
+          //       new RegExp(`<s*${tag}[^>]*>(?:.*?)</${tag}[^<>]*>`, 's')
+          //     );
+          //
+          //   if (!closingTag) {
+          //     return;
+          //   }
+          //
+          //   const endIndex = startIndex + closingTag[0].length;
+          //   const importItem = getImportItem(source.value);
+          //   const replacementItem = getReplacementItem(importItem);
+          //
+          //   sources.push({ replacementItem, startIndex, endIndex });
+          //
+          //   break;
+          // }
+        }
+      });
+      this.attributesMeta = {};
+    },
+
+    onerror(error) {
+      options.errors.push(error);
+    }
+
+  }, {
+    decodeEntities: false,
+    lowerCaseTags: false,
+    lowerCaseAttributeNames: false,
+    recognizeCDATA: true,
+    recognizeSelfClosing: true
+  });
+  parser.write(html);
+  parser.end();
+  const imports = new Map();
+  const replacements = new Map();
+  let offset = 0;
+
+  for (const source of sources) {
+    const {
+      name,
+      value,
+      unquoted,
+      startIndex,
+      endIndex
+    } = source;
+    let normalizedUrl = value;
+    let prefix = '';
+    const queryParts = normalizedUrl.split('!');
+
+    if (queryParts.length > 1) {
+      normalizedUrl = queryParts.pop();
+      prefix = queryParts.join('!');
+    }
+
+    normalizedUrl = (0, _utils.normalizeUrl)(normalizedUrl);
+
+    if (!urlFilter(name, value, resourcePath)) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+
+    let hash;
+    const indexHash = normalizedUrl.lastIndexOf('#');
+
+    if (indexHash >= 0) {
+      hash = normalizedUrl.substr(indexHash, indexHash);
+      normalizedUrl = normalizedUrl.substr(0, indexHash);
+    }
+
+    const request = (0, _utils.requestify)(normalizedUrl, root);
+    const newUrl = prefix ? `${prefix}!${request}` : request;
+    const importKey = newUrl;
+    let importName = imports.get(importKey);
+
+    if (!importName) {
+      importName = `___HTML_LOADER_IMPORT_${imports.size}___`;
+      imports.set(importKey, importName);
+      options.imports.push({
+        importName,
+        source: options.urlHandler(newUrl)
+      });
+    }
+
+    const replacementKey = JSON.stringify({
+      newUrl,
+      unquoted,
+      hash
+    });
+    let replacementName = replacements.get(replacementKey);
+
+    if (!replacementName) {
+      replacementName = `___HTML_LOADER_REPLACEMENT_${replacements.size}___`;
+      replacements.set(replacementKey, replacementName);
+      options.replacements.push({
+        replacementName,
+        importName,
+        hash,
+        unquoted
+      });
+    } // eslint-disable-next-line no-param-reassign
+
+
+    html = html.slice(0, startIndex + offset) + replacementName + html.slice(endIndex + offset);
+    offset += startIndex + replacementName.length - endIndex;
+  }
+
+  return html;
+};
+
+exports.default = _default;

node_modules/html-loader/dist/runtime/getUrl.js

@@ -0,0 +1,26 @@
+"use strict";
+
+module.exports = function (url, options) {
+  if (!options) {
+    // eslint-disable-next-line no-param-reassign
+    options = {};
+  } // eslint-disable-next-line no-underscore-dangle, no-param-reassign
+
+
+  url = url && url.__esModule ? url.default : url;
+
+  if (typeof url !== 'string') {
+    return url;
+  }
+
+  if (options.hash) {
+    // eslint-disable-next-line no-param-reassign
+    url += options.hash;
+  }
+
+  if (options.maybeNeedQuotes && /[\t\n\f\r "'=<>`]/.test(url)) {
+    return "\"".concat(url, "\"");
+  }
+
+  return url;
+};

node_modules/html-loader/dist/utils.js

@@ -0,0 +1,655 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseSrcset = parseSrcset;
+exports.parseSrc = parseSrc;
+exports.normalizeUrl = normalizeUrl;
+exports.requestify = requestify;
+exports.isUrlRequestable = isUrlRequestable;
+exports.normalizeOptions = normalizeOptions;
+exports.pluginRunner = pluginRunner;
+exports.getFilter = getFilter;
+exports.getImportCode = getImportCode;
+exports.getModuleCode = getModuleCode;
+exports.getExportCode = getExportCode;
+
+var _loaderUtils = require("loader-utils");
+
+function isASCIIWhitespace(character) {
+  return (// Horizontal tab
+    character === '\u0009' || // New line
+    character === '\u000A' || // Form feed
+    character === '\u000C' || // Carriage return
+    character === '\u000D' || // Space
+    character === '\u0020'
+  );
+} // (Don't use \s, to avoid matching non-breaking space)
+// eslint-disable-next-line no-control-regex
+
+
+const regexLeadingSpaces = /^[ \t\n\r\u000c]+/; // eslint-disable-next-line no-control-regex
+
+const regexLeadingCommasOrSpaces = /^[, \t\n\r\u000c]+/; // eslint-disable-next-line no-control-regex
+
+const regexLeadingNotSpaces = /^[^ \t\n\r\u000c]+/;
+const regexTrailingCommas = /[,]+$/;
+const regexNonNegativeInteger = /^\d+$/; // ( Positive or negative or unsigned integers or decimals, without or without exponents.
+// Must include at least one digit.
+// According to spec tests any decimal point must be followed by a digit.
+// No leading plus sign is allowed.)
+// https://html.spec.whatwg.org/multipage/infrastructure.html#valid-floating-point-number
+
+const regexFloatingPoint = /^-?(?:[0-9]+|[0-9]*\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/;
+
+function parseSrcset(input) {
+  // 1. Let input be the value passed to this algorithm.
+  const inputLength = input.length;
+  let url;
+  let descriptors;
+  let currentDescriptor;
+  let state;
+  let c; // 2. Let position be a pointer into input, initially pointing at the start
+  //    of the string.
+
+  let position = 0;
+  let startUrlPosition; // eslint-disable-next-line consistent-return
+
+  function collectCharacters(regEx) {
+    let chars;
+    const match = regEx.exec(input.substring(position));
+
+    if (match) {
+      [chars] = match;
+      position += chars.length;
+      return chars;
+    }
+  } // 3. Let candidates be an initially empty source set.
+
+
+  const candidates = []; // 4. Splitting loop: Collect a sequence of characters that are space
+  //    characters or U+002C COMMA characters. If any U+002C COMMA characters
+  //    were collected, that is a parse error.
+  // eslint-disable-next-line no-constant-condition
+
+  while (true) {
+    collectCharacters(regexLeadingCommasOrSpaces); // 5. If position is past the end of input, return candidates and abort these steps.
+
+    if (position >= inputLength) {
+      if (candidates.length === 0) {
+        throw new Error('Must contain one or more image candidate strings');
+      } // (we're done, this is the sole return path)
+
+
+      return candidates;
+    } // 6. Collect a sequence of characters that are not space characters,
+    //    and let that be url.
+
+
+    startUrlPosition = position;
+    url = collectCharacters(regexLeadingNotSpaces); // 7. Let descriptors be a new empty list.
+
+    descriptors = []; // 8. If url ends with a U+002C COMMA character (,), follow these substeps:
+    //		(1). Remove all trailing U+002C COMMA characters from url. If this removed
+    //         more than one character, that is a parse error.
+
+    if (url.slice(-1) === ',') {
+      url = url.replace(regexTrailingCommas, ''); // (Jump ahead to step 9 to skip tokenization and just push the candidate).
+
+      parseDescriptors();
+    } //	Otherwise, follow these substeps:
+    else {
+        tokenize();
+      } // 16. Return to the step labeled splitting loop.
+
+  }
+  /**
+   * Tokenizes descriptor properties prior to parsing
+   * Returns undefined.
+   */
+
+
+  function tokenize() {
+    // 8.1. Descriptor tokenizer: Skip whitespace
+    collectCharacters(regexLeadingSpaces); // 8.2. Let current descriptor be the empty string.
+
+    currentDescriptor = ''; // 8.3. Let state be in descriptor.
+
+    state = 'in descriptor'; // eslint-disable-next-line no-constant-condition
+
+    while (true) {
+      // 8.4. Let c be the character at position.
+      c = input.charAt(position); //  Do the following depending on the value of state.
+      //  For the purpose of this step, "EOF" is a special character representing
+      //  that position is past the end of input.
+      // In descriptor
+
+      if (state === 'in descriptor') {
+        // Do the following, depending on the value of c:
+        // Space character
+        // If current descriptor is not empty, append current descriptor to
+        // descriptors and let current descriptor be the empty string.
+        // Set state to after descriptor.
+        if (isASCIIWhitespace(c)) {
+          if (currentDescriptor) {
+            descriptors.push(currentDescriptor);
+            currentDescriptor = '';
+            state = 'after descriptor';
+          }
+        } // U+002C COMMA (,)
+        // Advance position to the next character in input. If current descriptor
+        // is not empty, append current descriptor to descriptors. Jump to the step
+        // labeled descriptor parser.
+        else if (c === ',') {
+            position += 1;
+
+            if (currentDescriptor) {
+              descriptors.push(currentDescriptor);
+            }
+
+            parseDescriptors();
+            return;
+          } // U+0028 LEFT PARENTHESIS (()
+          // Append c to current descriptor. Set state to in parens.
+          else if (c === '\u0028') {
+              currentDescriptor += c;
+              state = 'in parens';
+            } // EOF
+            // If current descriptor is not empty, append current descriptor to
+            // descriptors. Jump to the step labeled descriptor parser.
+            else if (c === '') {
+                if (currentDescriptor) {
+                  descriptors.push(currentDescriptor);
+                }
+
+                parseDescriptors();
+                return; // Anything else
+                // Append c to current descriptor.
+              } else {
+                currentDescriptor += c;
+              }
+      } // In parens
+      else if (state === 'in parens') {
+          // U+0029 RIGHT PARENTHESIS ())
+          // Append c to current descriptor. Set state to in descriptor.
+          if (c === ')') {
+            currentDescriptor += c;
+            state = 'in descriptor';
+          } // EOF
+          // Append current descriptor to descriptors. Jump to the step labeled
+          // descriptor parser.
+          else if (c === '') {
+              descriptors.push(currentDescriptor);
+              parseDescriptors();
+              return;
+            } // Anything else
+            // Append c to current descriptor.
+            else {
+                currentDescriptor += c;
+              }
+        } // After descriptor
+        else if (state === 'after descriptor') {
+            // Do the following, depending on the value of c:
+            if (isASCIIWhitespace(c)) {// Space character: Stay in this state.
+            } // EOF: Jump to the step labeled descriptor parser.
+            else if (c === '') {
+                parseDescriptors();
+                return;
+              } // Anything else
+              // Set state to in descriptor. Set position to the previous character in input.
+              else {
+                  state = 'in descriptor';
+                  position -= 1;
+                }
+          } // Advance position to the next character in input.
+
+
+      position += 1;
+    }
+  }
+  /**
+   * Adds descriptor properties to a candidate, pushes to the candidates array
+   * @return undefined
+   */
+  // Declared outside of the while loop so that it's only created once.
+
+
+  function parseDescriptors() {
+    // 9. Descriptor parser: Let error be no.
+    let pError = false; // 10. Let width be absent.
+    // 11. Let density be absent.
+    // 12. Let future-compat-h be absent. (We're implementing it now as h)
+
+    let w;
+    let d;
+    let h;
+    let i;
+    const candidate = {};
+    let desc;
+    let lastChar;
+    let value;
+    let intVal;
+    let floatVal; // 13. For each descriptor in descriptors, run the appropriate set of steps
+    // from the following list:
+
+    for (i = 0; i < descriptors.length; i++) {
+      desc = descriptors[i];
+      lastChar = desc[desc.length - 1];
+      value = desc.substring(0, desc.length - 1);
+      intVal = parseInt(value, 10);
+      floatVal = parseFloat(value); // If the descriptor consists of a valid non-negative integer followed by
+      // a U+0077 LATIN SMALL LETTER W character
+
+      if (regexNonNegativeInteger.test(value) && lastChar === 'w') {
+        // If width and density are not both absent, then let error be yes.
+        if (w || d) {
+          pError = true;
+        } // Apply the rules for parsing non-negative integers to the descriptor.
+        // If the result is zero, let error be yes.
+        // Otherwise, let width be the result.
+
+
+        if (intVal === 0) {
+          pError = true;
+        } else {
+          w = intVal;
+        }
+      } // If the descriptor consists of a valid floating-point number followed by
+      // a U+0078 LATIN SMALL LETTER X character
+      else if (regexFloatingPoint.test(value) && lastChar === 'x') {
+          // If width, density and future-compat-h are not all absent, then let error
+          // be yes.
+          if (w || d || h) {
+            pError = true;
+          } // Apply the rules for parsing floating-point number values to the descriptor.
+          // If the result is less than zero, let error be yes. Otherwise, let density
+          // be the result.
+
+
+          if (floatVal < 0) {
+            pError = true;
+          } else {
+            d = floatVal;
+          }
+        } // If the descriptor consists of a valid non-negative integer followed by
+        // a U+0068 LATIN SMALL LETTER H character
+        else if (regexNonNegativeInteger.test(value) && lastChar === 'h') {
+            // If height and density are not both absent, then let error be yes.
+            if (h || d) {
+              pError = true;
+            } // Apply the rules for parsing non-negative integers to the descriptor.
+            // If the result is zero, let error be yes. Otherwise, let future-compat-h
+            // be the result.
+
+
+            if (intVal === 0) {
+              pError = true;
+            } else {
+              h = intVal;
+            } // Anything else, Let error be yes.
+
+          } else {
+            pError = true;
+          }
+    } // 15. If error is still no, then append a new image source to candidates whose
+    // URL is url, associated with a width width if not absent and a pixel
+    // density density if not absent. Otherwise, there is a parse error.
+
+
+    if (!pError) {
+      candidate.source = {
+        value: url,
+        startIndex: startUrlPosition
+      };
+
+      if (w) {
+        candidate.width = {
+          value: w
+        };
+      }
+
+      if (d) {
+        candidate.density = {
+          value: d
+        };
+      }
+
+      if (h) {
+        candidate.height = {
+          value: h
+        };
+      }
+
+      candidates.push(candidate);
+    } else {
+      throw new Error(`Invalid srcset descriptor found in '${input}' at '${desc}'`);
+    }
+  }
+}
+
+function parseSrc(input) {
+  if (!input) {
+    throw new Error('Must be non-empty');
+  }
+
+  let startIndex = 0;
+  let value = input;
+
+  while (isASCIIWhitespace(value.substring(0, 1))) {
+    startIndex += 1;
+    value = value.substring(1, value.length);
+  }
+
+  while (isASCIIWhitespace(value.substring(value.length - 1, value.length))) {
+    value = value.substring(0, value.length - 1);
+  }
+
+  if (!value) {
+    throw new Error('Must be non-empty');
+  }
+
+  return {
+    value,
+    startIndex
+  };
+}
+
+function normalizeUrl(url) {
+  return decodeURIComponent(url).replace(/[\t\n\r]/g, '');
+}
+
+function requestify(url, root) {
+  return (0, _loaderUtils.urlToRequest)(url, root);
+}
+
+function isUrlRequestable(url, root) {
+  return (0, _loaderUtils.isUrlRequest)(url, root);
+}
+
+function isProductionMode(loaderContext) {
+  return loaderContext.mode === 'production' || !loaderContext.mode;
+}
+
+const defaultMinimizerOptions = {
+  caseSensitive: true,
+  // `collapseBooleanAttributes` is not always safe, since this can break CSS attribute selectors and not safe for XHTML
+  collapseWhitespace: true,
+  conservativeCollapse: true,
+  keepClosingSlash: true,
+  // We need ability to use cssnano, or setup own function without extra dependencies
+  minifyCSS: true,
+  minifyJS: true,
+  // `minifyURLs` is unsafe, because we can't guarantee what the base URL is
+  // `removeAttributeQuotes` is not safe in some rare cases, also HTML spec recommends against doing this
+  removeComments: true,
+  // `removeEmptyAttributes` is not safe, can affect certain style or script behavior, look at https://github.com/webpack-contrib/html-loader/issues/323
+  // `removeRedundantAttributes` is not safe, can affect certain style or script behavior, look at https://github.com/webpack-contrib/html-loader/issues/323
+  removeScriptTypeAttributes: true,
+  removeStyleLinkTypeAttributes: true // `useShortDoctype` is not safe for XHTML
+
+};
+
+function getMinimizeOption(rawOptions, loaderContext) {
+  if (typeof rawOptions.minimize === 'undefined') {
+    return isProductionMode(loaderContext) ? defaultMinimizerOptions : false;
+  }
+
+  if (typeof rawOptions.minimize === 'boolean') {
+    return rawOptions.minimize === true ? defaultMinimizerOptions : false;
+  }
+
+  return rawOptions.minimize;
+}
+
+function getAttributeValue(attributes, name) {
+  const lowercasedAttributes = Object.keys(attributes).reduce((keys, k) => {
+    // eslint-disable-next-line no-param-reassign
+    keys[k.toLowerCase()] = k;
+    return keys;
+  }, {});
+  return attributes[lowercasedAttributes[name.toLowerCase()]];
+}
+
+function scriptFilter(tag, attribute, attributes) {
+  if (attributes.type) {
+    const type = getAttributeValue(attributes, 'type').trim().toLowerCase();
+
+    if (type !== 'module' && type !== 'text/javascript' && type !== 'application/javascript') {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+const defaultAttributes = [{
+  tag: 'audio',
+  attribute: 'src',
+  type: 'src'
+}, {
+  tag: 'embed',
+  attribute: 'src',
+  type: 'src'
+}, {
+  tag: 'img',
+  attribute: 'src',
+  type: 'src'
+}, {
+  tag: 'img',
+  attribute: 'srcset',
+  type: 'srcset'
+}, {
+  tag: 'input',
+  attribute: 'src',
+  type: 'src'
+}, {
+  tag: 'link',
+  attribute: 'href',
+  type: 'src',
+  filter: (tag, attribute, attributes) => {
+    if (!/stylesheet/i.test(getAttributeValue(attributes, 'rel'))) {
+      return false;
+    }
+
+    if (attributes.type && getAttributeValue(attributes, 'type').trim().toLowerCase() !== 'text/css') {
+      return false;
+    }
+
+    return true;
+  }
+}, {
+  tag: 'object',
+  attribute: 'data',
+  type: 'src'
+}, {
+  tag: 'script',
+  attribute: 'src',
+  type: 'src',
+  filter: scriptFilter
+}, // Using href with <script> is described here: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/script
+{
+  tag: 'script',
+  attribute: 'href',
+  type: 'src',
+  filter: scriptFilter
+}, {
+  tag: 'script',
+  attribute: 'xlink:href',
+  type: 'src',
+  filter: scriptFilter
+}, {
+  tag: 'source',
+  attribute: 'src',
+  type: 'src'
+}, {
+  tag: 'source',
+  attribute: 'srcset',
+  type: 'srcset'
+}, {
+  tag: 'track',
+  attribute: 'src',
+  type: 'src'
+}, {
+  tag: 'video',
+  attribute: 'poster',
+  type: 'src'
+}, {
+  tag: 'video',
+  attribute: 'src',
+  type: 'src'
+}, // SVG
+{
+  tag: 'image',
+  attribute: 'xlink:href',
+  type: 'src'
+}, {
+  tag: 'image',
+  attribute: 'href',
+  type: 'src'
+}, {
+  tag: 'use',
+  attribute: 'xlink:href',
+  type: 'src'
+}, {
+  tag: 'use',
+  attribute: 'href',
+  type: 'src'
+}];
+
+function smartMergeSources(array, factory) {
+  if (typeof array === 'undefined') {
+    return factory();
+  }
+
+  const newArray = [];
+
+  for (let i = 0; i < array.length; i++) {
+    const item = array[i];
+
+    if (item === '...') {
+      const items = factory();
+
+      if (typeof items !== 'undefined') {
+        // eslint-disable-next-line no-shadow
+        for (const item of items) {
+          newArray.push(item);
+        }
+      }
+    } else if (typeof newArray !== 'undefined') {
+      newArray.push(item);
+    }
+  }
+
+  return newArray;
+}
+
+function getAttributesOption(rawOptions) {
+  if (typeof rawOptions.attributes === 'undefined') {
+    return {
+      list: defaultAttributes
+    };
+  }
+
+  if (typeof rawOptions.attributes === 'boolean') {
+    return rawOptions.attributes === true ? {
+      list: defaultAttributes
+    } : false;
+  }
+
+  const sources = smartMergeSources(rawOptions.attributes.list, () => defaultAttributes);
+  return {
+    list: sources,
+    urlFilter: rawOptions.attributes.urlFilter,
+    root: rawOptions.attributes.root
+  };
+}
+
+function normalizeOptions(rawOptions, loaderContext) {
+  return {
+    preprocessor: rawOptions.preprocessor,
+    attributes: getAttributesOption(rawOptions),
+    minimize: getMinimizeOption(rawOptions, loaderContext),
+    esModule: typeof rawOptions.esModule === 'undefined' ? false : rawOptions.esModule
+  };
+}
+
+function pluginRunner(plugins) {
+  return {
+    process: content => {
+      const result = {};
+
+      for (const plugin of plugins) {
+        // eslint-disable-next-line no-param-reassign
+        content = plugin(content, result);
+      }
+
+      result.html = content;
+      return result;
+    }
+  };
+}
+
+function getFilter(filter, defaultFilter = null) {
+  return (attribute, value, resourcePath) => {
+    if (defaultFilter && !defaultFilter(value)) {
+      return false;
+    }
+
+    if (typeof filter === 'function') {
+      return filter(attribute, value, resourcePath);
+    }
+
+    return true;
+  };
+}
+
+const GET_SOURCE_FROM_IMPORT_NAME = '___HTML_LOADER_GET_SOURCE_FROM_IMPORT___';
+
+function getImportCode(html, loaderContext, imports, options) {
+  if (imports.length === 0) {
+    return '';
+  }
+
+  const stringifiedHelperRequest = (0, _loaderUtils.stringifyRequest)(loaderContext, require.resolve('./runtime/getUrl.js'));
+  let code = options.esModule ? `import ${GET_SOURCE_FROM_IMPORT_NAME} from ${stringifiedHelperRequest};\n` : `var ${GET_SOURCE_FROM_IMPORT_NAME} = require(${stringifiedHelperRequest});\n`;
+
+  for (const item of imports) {
+    const {
+      importName,
+      source
+    } = item;
+    code += options.esModule ? `import ${importName} from ${source};\n` : `var ${importName} = require(${source});\n`;
+  }
+
+  return `// Imports\n${code}`;
+}
+
+function getModuleCode(html, replacements) {
+  let code = JSON.stringify(html) // Invalid in JavaScript but valid HTML
+  .replace(/[\u2028\u2029]/g, str => str === '\u2029' ? '\\u2029' : '\\u2028');
+  let replacersCode = '';
+
+  for (const item of replacements) {
+    const {
+      importName,
+      replacementName,
+      unquoted,
+      hash
+    } = item;
+    const getUrlOptions = [].concat(hash ? [`hash: ${JSON.stringify(hash)}`] : []).concat(unquoted ? 'maybeNeedQuotes: true' : []);
+    const preparedOptions = getUrlOptions.length > 0 ? `, { ${getUrlOptions.join(', ')} }` : '';
+    replacersCode += `var ${replacementName} = ${GET_SOURCE_FROM_IMPORT_NAME}(${importName}${preparedOptions});\n`;
+    code = code.replace(new RegExp(replacementName, 'g'), () => `" + ${replacementName} + "`);
+  }
+
+  return `// Module\n${replacersCode}var code = ${code};\n`;
+}
+
+function getExportCode(html, options) {
+  if (options.esModule) {
+    return `// Exports\nexport default code;`;
+  }
+
+  return `// Exports\nmodule.exports = code;`;
+}

node_modules/html-loader/node_modules/loader-utils/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.

node_modules/html-loader/node_modules/loader-utils/README.md

@@ -0,0 +1,275 @@
+# loader-utils
+
+## Methods
+
+### `getOptions`
+
+Recommended way to retrieve the options of a loader invocation:
+
+```javascript
+// inside your loader
+const options = loaderUtils.getOptions(this);
+```
+
+1. If `this.query` is a string:
+	- Tries to parse the query string and returns a new object
+	- Throws if it's not a valid query string
+2. If `this.query` is object-like, it just returns `this.query`
+3. In any other case, it just returns `null`
+
+**Please note:** The returned `options` object is *read-only*. It may be re-used across multiple invocations.
+If you pass it on to another library, make sure to make a *deep copy* of it:
+
+```javascript
+const options = Object.assign(
+	{},
+	defaultOptions,
+	loaderUtils.getOptions(this) // it is safe to pass null to Object.assign()
+);
+// don't forget nested objects or arrays
+options.obj = Object.assign({}, options.obj); 
+options.arr = options.arr.slice();
+someLibrary(options);
+```
+
+[clone](https://www.npmjs.com/package/clone) is a good library to make a deep copy of the options.
+
+#### Options as query strings
+
+If the loader options have been passed as loader query string (`loader?some&params`), the string is parsed by using [`parseQuery`](#parsequery).
+
+### `parseQuery`
+
+Parses a passed string (e.g. `loaderContext.resourceQuery`) as a query string, and returns an object.
+
+``` javascript
+const params = loaderUtils.parseQuery(this.resourceQuery); // resource: `file?param1=foo`
+if (params.param1 === "foo") {
+	// do something
+}
+```
+
+The string is parsed like this:
+
+``` text
+                             -> Error
+?                            -> {}
+?flag                        -> { flag: true }
+?+flag                       -> { flag: true }
+?-flag                       -> { flag: false }
+?xyz=test                    -> { xyz: "test" }
+?xyz=1                       -> { xyz: "1" } // numbers are NOT parsed
+?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" }
+?{data:{a:1},isJSON5:true}   -> { data: { a: 1 }, isJSON5: true }
+```
+
+### `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.
+
+> i Before call `urlToRequest` you need call `isUrlRequest` to ensure it is requestable url
+
+```javascript
+const url = "path/to/module.js";
+
+if (loaderUtils.isUrlRequest(url)) {
+  // Logic for requestable url
+  const request = loaderUtils.urlToRequest(url);
+} else {
+  // Logic for not requestable url
+}
+```
+
+Simple example:
+
+```javascript
+const url = "path/to/module.js";
+const 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
+const url = "~path/to/module.js";
+const 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
+const url = "/path/to/module.js";
+const root = "./root";
+const 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
+const url = "/path/to/module.js";
+const root = "~";
+const 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
+const 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 the resource is in
+* `[query]` the queryof the resource, i.e. `?foo=bar`
+* `[emoji]` a random emoji representation of `options.content`
+* `[emoji:<length>]` same as above, but with a customizable number of emojis
+* `[contenthash]` the hash of `options.content` (Buffer) (by default it's the hex digest of the md4 hash)
+* `[<hashType>:contenthash:<digestType>:<length>]` optionally one can configure
+  * other `hashType`s, i. e. `sha1`, `md4`, `md5`, `sha256`, `sha512`
+  * other `digestType`s, i. e. `hex`, `base26`, `base32`, `base36`, `base49`, `base52`, `base58`, `base62`, `base64`
+  * and `length` the length in chars
+* `[hash]` the hash of `options.content` (Buffer) (by default it's the hex digest of the md4 hash)
+* `[<hashType>:hash:<digestType>:<length>]` optionally one can configure
+  * other `hashType`s, i. e. `sha1`, `md4`, `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`
+
+In loader context `[hash]` and `[contenthash]` are the same, but we recommend using `[contenthash]` for avoid misleading.
+
+Examples
+
+``` javascript
+// loaderContext.resourcePath = "/absolute/path/to/app/js/javascript.js"
+loaderUtils.interpolateName(loaderContext, "js/[hash].script.[ext]", { content: ... });
+// => js/9473fdd0d880a43c21b7778d34872157.script.js
+
+// loaderContext.resourcePath = "/absolute/path/to/app/js/javascript.js"
+// loaderContext.resourceQuery = "?foo=bar"
+loaderUtils.interpolateName(loaderContext, "js/[hash].script.[ext][query]", { content: ... });
+// => js/9473fdd0d880a43c21b7778d34872157.script.js?foo=bar
+
+// loaderContext.resourcePath = "/absolute/path/to/app/js/javascript.js"
+loaderUtils.interpolateName(loaderContext, "js/[contenthash].script.[ext]", { content: ... });
+// => js/9473fdd0d880a43c21b7778d34872157.script.js
+
+// loaderContext.resourcePath = "/absolute/path/to/app/page.html"
+loaderUtils.interpolateName(loaderContext, "html-[hash:6].html", { content: ... });
+// => html-9473fd.html
+
+// loaderContext.resourcePath = "/absolute/path/to/app/flash.txt"
+loaderUtils.interpolateName(loaderContext, "[hash]", { content: ... });
+// => c31e9820c001c9c4a86bce33ce43b679
+
+// loaderContext.resourcePath = "/absolute/path/to/app/img/image.gif"
+loaderUtils.interpolateName(loaderContext, "[emoji]", { content: ... });
+// => 👍
+
+// loaderContext.resourcePath = "/absolute/path/to/app/img/image.gif"
+loaderUtils.interpolateName(loaderContext, "[emoji:4]", { content: ... });
+// => 🙍🏢📤🐝
+
+// loaderContext.resourcePath = "/absolute/path/to/app/img/image.png"
+loaderUtils.interpolateName(loaderContext, "[sha512:hash:base64:7].[ext]", { content: ... });
+// => 2BKDTjl.png
+// use sha512 hash instead of md4 and with only 7 chars of base64
+
+// loaderContext.resourcePath = "/absolute/path/to/app/img/myself.png"
+// loaderContext.query.name =
+loaderUtils.interpolateName(loaderContext, "picture.png");
+// => picture.png
+
+// loaderContext.resourcePath = "/absolute/path/to/app/dir/file.png"
+loaderUtils.interpolateName(loaderContext, "[path][name].[ext]?[hash]", { content: ... });
+// => /app/dir/file.png?9473fdd0d880a43c21b7778d34872157
+
+// loaderContext.resourcePath = "/absolute/path/to/app/js/page-home.js"
+loaderUtils.interpolateName(loaderContext, "script-[1].[ext]", { regExp: "page-(.*)\\.js", content: ... });
+// => script-home.js
+
+// loaderContext.resourcePath = "/absolute/path/to/app/js/javascript.js"
+// loaderContext.resourceQuery = "?foo=bar"
+loaderUtils.interpolateName(
+  loaderContext, 
+  (resourcePath, resourceQuery) => { 
+    // resourcePath - `/app/js/javascript.js`
+    // resourceQuery - `?foo=bar`
+
+    return "js/[hash].script.[ext]"; 
+  }, 
+  { content: ... }
+);
+// => js/9473fdd0d880a43c21b7778d34872157.script.js
+```
+
+### `getHashDigest`
+
+``` javascript
+const digestString = loaderUtils.getHashDigest(buffer, hashType, digestType, maxLength);
+```
+
+* `buffer` the content that should be hashed
+* `hashType` one of `sha1`, `md4`, `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)

node_modules/html-loader/node_modules/loader-utils/lib/getCurrentRequest.js

@@ -0,0 +1,16 @@
+'use strict';
+
+function getCurrentRequest(loaderContext) {
+  if (loaderContext.currentRequest) {
+    return loaderContext.currentRequest;
+  }
+
+  const request = loaderContext.loaders
+    .slice(loaderContext.loaderIndex)
+    .map((obj) => obj.request)
+    .concat([loaderContext.resource]);
+
+  return request.join('!');
+}
+
+module.exports = getCurrentRequest;

node_modules/html-loader/node_modules/loader-utils/lib/getHashDigest.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const baseEncodeTables = {
+  26: 'abcdefghijklmnopqrstuvwxyz',
+  32: '123456789abcdefghjkmnpqrstuvwxyz', // no 0lio
+  36: '0123456789abcdefghijklmnopqrstuvwxyz',
+  49: 'abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ', // no lIO
+  52: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+  58: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ', // no 0lIO
+  62: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+  64: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_',
+};
+
+function encodeBufferToBase(buffer, base) {
+  const encodeTable = baseEncodeTables[base];
+  if (!encodeTable) {
+    throw new Error('Unknown encoding base' + base);
+  }
+
+  const readLength = buffer.length;
+  const Big = require('big.js');
+
+  Big.RM = Big.DP = 0;
+  let b = new Big(0);
+
+  for (let i = readLength - 1; i >= 0; i--) {
+    b = b.times(256).plus(buffer[i]);
+  }
+
+  let output = '';
+  while (b.gt(0)) {
+    output = encodeTable[b.mod(base)] + output;
+    b = b.div(base);
+  }
+
+  Big.DP = 20;
+  Big.RM = 1;
+
+  return output;
+}
+
+let createMd4 = undefined;
+let BatchedHash = undefined;
+
+function getHashDigest(buffer, hashType, digestType, maxLength) {
+  hashType = hashType || 'md4';
+  maxLength = maxLength || 9999;
+
+  let hash;
+
+  try {
+    hash = require('crypto').createHash(hashType);
+  } catch (error) {
+    if (error.code === 'ERR_OSSL_EVP_UNSUPPORTED' && hashType === 'md4') {
+      if (createMd4 === undefined) {
+        createMd4 = require('./hash/md4');
+
+        if (BatchedHash === undefined) {
+          BatchedHash = require('./hash/BatchedHash');
+        }
+      }
+
+      hash = new BatchedHash(createMd4());
+    }
+
+    if (!hash) {
+      throw error;
+    }
+  }
+
+  hash.update(buffer);
+
+  if (
+    digestType === 'base26' ||
+    digestType === 'base32' ||
+    digestType === 'base36' ||
+    digestType === 'base49' ||
+    digestType === 'base52' ||
+    digestType === 'base58' ||
+    digestType === 'base62'
+  ) {
+    return encodeBufferToBase(hash.digest(), digestType.substr(4)).substr(
+      0,
+      maxLength
+    );
+  } else {
+    return hash.digest(digestType || 'hex').substr(0, maxLength);
+  }
+}
+
+module.exports = getHashDigest;

node_modules/html-loader/node_modules/loader-utils/lib/getOptions.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const parseQuery = require('./parseQuery');
+
+function getOptions(loaderContext) {
+  const query = loaderContext.query;
+
+  if (typeof query === 'string' && query !== '') {
+    return parseQuery(loaderContext.query);
+  }
+
+  if (!query || typeof query !== 'object') {
+    // Not object-like queries are not supported.
+    return {};
+  }
+
+  return query;
+}
+
+module.exports = getOptions;

node_modules/html-loader/node_modules/loader-utils/lib/getRemainingRequest.js

@@ -0,0 +1,16 @@
+'use strict';
+
+function getRemainingRequest(loaderContext) {
+  if (loaderContext.remainingRequest) {
+    return loaderContext.remainingRequest;
+  }
+
+  const request = loaderContext.loaders
+    .slice(loaderContext.loaderIndex + 1)
+    .map((obj) => obj.request)
+    .concat([loaderContext.resource]);
+
+  return request.join('!');
+}
+
+module.exports = getRemainingRequest;

node_modules/html-loader/node_modules/loader-utils/lib/hash/BatchedHash.js

@@ -0,0 +1,64 @@
+const MAX_SHORT_STRING = require('./wasm-hash').MAX_SHORT_STRING;
+
+class BatchedHash {
+  constructor(hash) {
+    this.string = undefined;
+    this.encoding = undefined;
+    this.hash = hash;
+  }
+
+  /**
+   * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+   * @param {string|Buffer} data data
+   * @param {string=} inputEncoding data encoding
+   * @returns {this} updated hash
+   */
+  update(data, inputEncoding) {
+    if (this.string !== undefined) {
+      if (
+        typeof data === 'string' &&
+        inputEncoding === this.encoding &&
+        this.string.length + data.length < MAX_SHORT_STRING
+      ) {
+        this.string += data;
+
+        return this;
+      }
+
+      this.hash.update(this.string, this.encoding);
+      this.string = undefined;
+    }
+
+    if (typeof data === 'string') {
+      if (
+        data.length < MAX_SHORT_STRING &&
+        // base64 encoding is not valid since it may contain padding chars
+        (!inputEncoding || !inputEncoding.startsWith('ba'))
+      ) {
+        this.string = data;
+        this.encoding = inputEncoding;
+      } else {
+        this.hash.update(data, inputEncoding);
+      }
+    } else {
+      this.hash.update(data);
+    }
+
+    return this;
+  }
+
+  /**
+   * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+   * @param {string=} encoding encoding of the return value
+   * @returns {string|Buffer} digest
+   */
+  digest(encoding) {
+    if (this.string !== undefined) {
+      this.hash.update(this.string, this.encoding);
+    }
+
+    return this.hash.digest(encoding);
+  }
+}
+
+module.exports = BatchedHash;

node_modules/html-loader/node_modules/loader-utils/lib/hash/md4.js

@@ -0,0 +1,20 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+'use strict';
+
+const create = require('./wasm-hash');
+
+//#region wasm code: md4 (../../../assembly/hash/md4.asm.ts) --initialMemory 1
+const md4 = new WebAssembly.Module(
+  Buffer.from(
+    // 2150 bytes
+    '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',
+    'base64'
+  )
+);
+//#endregion
+
+module.exports = create.bind(null, md4, [], 64, 32);

node_modules/html-loader/node_modules/loader-utils/lib/hash/wasm-hash.js

@@ -0,0 +1,208 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+'use strict';
+
+// 65536 is the size of a wasm memory page
+// 64 is the maximum chunk size for every possible wasm hash implementation
+// 4 is the maximum number of bytes per char for string encoding (max is utf-8)
+// ~3 makes sure that it's always a block of 4 chars, so avoid partially encoded bytes for base64
+const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3;
+
+class WasmHash {
+  /**
+   * @param {WebAssembly.Instance} instance wasm instance
+   * @param {WebAssembly.Instance[]} instancesPool pool of instances
+   * @param {number} chunkSize size of data chunks passed to wasm
+   * @param {number} digestSize size of digest returned by wasm
+   */
+  constructor(instance, instancesPool, chunkSize, digestSize) {
+    const exports = /** @type {any} */ (instance.exports);
+
+    exports.init();
+
+    this.exports = exports;
+    this.mem = Buffer.from(exports.memory.buffer, 0, 65536);
+    this.buffered = 0;
+    this.instancesPool = instancesPool;
+    this.chunkSize = chunkSize;
+    this.digestSize = digestSize;
+  }
+
+  reset() {
+    this.buffered = 0;
+    this.exports.init();
+  }
+
+  /**
+   * @param {Buffer | string} data data
+   * @param {BufferEncoding=} encoding encoding
+   * @returns {this} itself
+   */
+  update(data, encoding) {
+    if (typeof data === 'string') {
+      while (data.length > MAX_SHORT_STRING) {
+        this._updateWithShortString(data.slice(0, MAX_SHORT_STRING), encoding);
+        data = data.slice(MAX_SHORT_STRING);
+      }
+
+      this._updateWithShortString(data, encoding);
+
+      return this;
+    }
+
+    this._updateWithBuffer(data);
+
+    return this;
+  }
+
+  /**
+   * @param {string} data data
+   * @param {BufferEncoding=} encoding encoding
+   * @returns {void}
+   */
+  _updateWithShortString(data, encoding) {
+    const { exports, buffered, mem, chunkSize } = this;
+
+    let endPos;
+
+    if (data.length < 70) {
+      if (!encoding || encoding === 'utf-8' || encoding === 'utf8') {
+        endPos = buffered;
+        for (let i = 0; i < data.length; i++) {
+          const cc = data.charCodeAt(i);
+
+          if (cc < 0x80) {
+            mem[endPos++] = cc;
+          } else if (cc < 0x800) {
+            mem[endPos] = (cc >> 6) | 0xc0;
+            mem[endPos + 1] = (cc & 0x3f) | 0x80;
+            endPos += 2;
+          } else {
+            // bail-out for weird chars
+            endPos += mem.write(data.slice(i), endPos, encoding);
+            break;
+          }
+        }
+      } else if (encoding === 'latin1') {
+        endPos = buffered;
+
+        for (let i = 0; i < data.length; i++) {
+          const cc = data.charCodeAt(i);
+
+          mem[endPos++] = cc;
+        }
+      } else {
+        endPos = buffered + mem.write(data, buffered, encoding);
+      }
+    } else {
+      endPos = buffered + mem.write(data, buffered, encoding);
+    }
+
+    if (endPos < chunkSize) {
+      this.buffered = endPos;
+    } else {
+      const l = endPos & ~(this.chunkSize - 1);
+
+      exports.update(l);
+
+      const newBuffered = endPos - l;
+
+      this.buffered = newBuffered;
+
+      if (newBuffered > 0) {
+        mem.copyWithin(0, l, endPos);
+      }
+    }
+  }
+
+  /**
+   * @param {Buffer} data data
+   * @returns {void}
+   */
+  _updateWithBuffer(data) {
+    const { exports, buffered, mem } = this;
+    const length = data.length;
+
+    if (buffered + length < this.chunkSize) {
+      data.copy(mem, buffered, 0, length);
+
+      this.buffered += length;
+    } else {
+      const l = (buffered + length) & ~(this.chunkSize - 1);
+
+      if (l > 65536) {
+        let i = 65536 - buffered;
+
+        data.copy(mem, buffered, 0, i);
+        exports.update(65536);
+
+        const stop = l - buffered - 65536;
+
+        while (i < stop) {
+          data.copy(mem, 0, i, i + 65536);
+          exports.update(65536);
+          i += 65536;
+        }
+
+        data.copy(mem, 0, i, l - buffered);
+
+        exports.update(l - buffered - i);
+      } else {
+        data.copy(mem, buffered, 0, l - buffered);
+
+        exports.update(l);
+      }
+
+      const newBuffered = length + buffered - l;
+
+      this.buffered = newBuffered;
+
+      if (newBuffered > 0) {
+        data.copy(mem, 0, length - newBuffered, length);
+      }
+    }
+  }
+
+  digest(type) {
+    const { exports, buffered, mem, digestSize } = this;
+
+    exports.final(buffered);
+
+    this.instancesPool.push(this);
+
+    const hex = mem.toString('latin1', 0, digestSize);
+
+    if (type === 'hex') {
+      return hex;
+    }
+
+    if (type === 'binary' || !type) {
+      return Buffer.from(hex, 'hex');
+    }
+
+    return Buffer.from(hex, 'hex').toString(type);
+  }
+}
+
+const create = (wasmModule, instancesPool, chunkSize, digestSize) => {
+  if (instancesPool.length > 0) {
+    const old = instancesPool.pop();
+
+    old.reset();
+
+    return old;
+  } else {
+    return new WasmHash(
+      new WebAssembly.Instance(wasmModule),
+      instancesPool,
+      chunkSize,
+      digestSize
+    );
+  }
+};
+
+module.exports = create;
+module.exports.MAX_SHORT_STRING = MAX_SHORT_STRING;

node_modules/html-loader/node_modules/loader-utils/lib/index.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const getOptions = require('./getOptions');
+const parseQuery = require('./parseQuery');
+const stringifyRequest = require('./stringifyRequest');
+const getRemainingRequest = require('./getRemainingRequest');
+const getCurrentRequest = require('./getCurrentRequest');
+const isUrlRequest = require('./isUrlRequest');
+const urlToRequest = require('./urlToRequest');
+const parseString = require('./parseString');
+const getHashDigest = require('./getHashDigest');
+const interpolateName = require('./interpolateName');
+
+exports.getOptions = getOptions;
+exports.parseQuery = parseQuery;
+exports.stringifyRequest = stringifyRequest;
+exports.getRemainingRequest = getRemainingRequest;
+exports.getCurrentRequest = getCurrentRequest;
+exports.isUrlRequest = isUrlRequest;
+exports.urlToRequest = urlToRequest;
+exports.parseString = parseString;
+exports.getHashDigest = getHashDigest;
+exports.interpolateName = interpolateName;

node_modules/html-loader/node_modules/loader-utils/lib/interpolateName.js

@@ -0,0 +1,151 @@
+'use strict';
+
+const path = require('path');
+const emojisList = require('emojis-list');
+const getHashDigest = require('./getHashDigest');
+
+const emojiRegex = /[\uD800-\uDFFF]./;
+const emojiList = emojisList.filter((emoji) => emojiRegex.test(emoji));
+const emojiCache = {};
+
+function encodeStringToEmoji(content, length) {
+  if (emojiCache[content]) {
+    return emojiCache[content];
+  }
+
+  length = length || 1;
+
+  const emojis = [];
+
+  do {
+    if (!emojiList.length) {
+      throw new Error('Ran out of emoji');
+    }
+
+    const index = Math.floor(Math.random() * emojiList.length);
+
+    emojis.push(emojiList[index]);
+    emojiList.splice(index, 1);
+  } while (--length > 0);
+
+  const emojiEncoding = emojis.join('');
+
+  emojiCache[content] = emojiEncoding;
+
+  return emojiEncoding;
+}
+
+function interpolateName(loaderContext, name, options) {
+  let filename;
+
+  const hasQuery =
+    loaderContext.resourceQuery && loaderContext.resourceQuery.length > 1;
+
+  if (typeof name === 'function') {
+    filename = name(
+      loaderContext.resourcePath,
+      hasQuery ? loaderContext.resourceQuery : undefined
+    );
+  } else {
+    filename = name || '[hash].[ext]';
+  }
+
+  const context = options.context;
+  const content = options.content;
+  const regExp = options.regExp;
+
+  let ext = 'bin';
+  let basename = 'file';
+  let directory = '';
+  let folder = '';
+  let query = '';
+
+  if (loaderContext.resourcePath) {
+    const parsed = path.parse(loaderContext.resourcePath);
+    let resourcePath = loaderContext.resourcePath;
+
+    if (parsed.ext) {
+      ext = parsed.ext.substr(1);
+    }
+
+    if (parsed.dir) {
+      basename = parsed.name;
+      resourcePath = parsed.dir + path.sep;
+    }
+
+    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);
+    }
+  }
+
+  if (loaderContext.resourceQuery && loaderContext.resourceQuery.length > 1) {
+    query = loaderContext.resourceQuery;
+
+    const hashIdx = query.indexOf('#');
+
+    if (hashIdx >= 0) {
+      query = query.substr(0, hashIdx);
+    }
+  }
+
+  let url = filename;
+
+  if (content) {
+    // Match hash template
+    url = url
+      // `hash` and `contenthash` are same in `loader-utils` context
+      // let's keep `hash` for backward compatibility
+      .replace(
+        /\[(?:([^[:\]]+):)?(?:hash|contenthash)(?::([a-z]+\d*))?(?::(\d+))?\]/gi,
+        (all, hashType, digestType, maxLength) =>
+          getHashDigest(content, hashType, digestType, parseInt(maxLength, 10))
+      )
+      .replace(/\[emoji(?::(\d+))?\]/gi, (all, length) =>
+        encodeStringToEmoji(content, parseInt(length, 10))
+      );
+  }
+
+  url = url
+    .replace(/\[ext\]/gi, () => ext)
+    .replace(/\[name\]/gi, () => basename)
+    .replace(/\[path\]/gi, () => directory)
+    .replace(/\[folder\]/gi, () => folder)
+    .replace(/\[query\]/gi, () => query);
+
+  if (regExp && loaderContext.resourcePath) {
+    const match = loaderContext.resourcePath.match(new RegExp(regExp));
+
+    match &&
+      match.forEach((matched, i) => {
+        url = url.replace(new RegExp('\\[' + i + '\\]', 'ig'), matched);
+      });
+  }
+
+  if (
+    typeof loaderContext.options === 'object' &&
+    typeof loaderContext.options.customInterpolateName === 'function'
+  ) {
+    url = loaderContext.options.customInterpolateName.call(
+      loaderContext,
+      url,
+      name,
+      options
+    );
+  }
+
+  return url;
+}
+
+module.exports = interpolateName;

node_modules/html-loader/node_modules/loader-utils/lib/isUrlRequest.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const path = require('path');
+
+function isUrlRequest(url, root) {
+  // An URL is not an request if
+
+  // 1. It's an absolute url and it is not `windows` path like `C:\dir\file`
+  if (/^[a-z][a-z0-9+.-]*:/i.test(url) && !path.win32.isAbsolute(url)) {
+    return false;
+  }
+
+  // 2. It's a protocol-relative
+  if (/^\/\//.test(url)) {
+    return false;
+  }
+
+  // 3. It's some kind of url for a template
+  if (/^[{}[\]#*;,'§$%&(=?`´^°<>]/.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;
+}
+
+module.exports = isUrlRequest;

node_modules/html-loader/node_modules/loader-utils/lib/parseQuery.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const JSON5 = require('json5');
+
+const specialValues = {
+  null: null,
+  true: true,
+  false: false,
+};
+
+function parseQuery(query) {
+  if (query.substr(0, 1) !== '?') {
+    throw new Error(
+      "A valid query string passed to parseQuery should begin with '?'"
+    );
+  }
+
+  query = query.substr(1);
+
+  if (!query) {
+    return {};
+  }
+
+  if (query.substr(0, 1) === '{' && query.substr(-1) === '}') {
+    return JSON5.parse(query);
+  }
+
+  const queryArgs = query.split(/[,&]/g);
+  const result = Object.create(null);
+
+  queryArgs.forEach((arg) => {
+    const idx = arg.indexOf('=');
+
+    if (idx >= 0) {
+      let name = arg.substr(0, idx);
+      let value = decodeURIComponent(arg.substr(idx + 1));
+
+      // eslint-disable-next-line no-prototype-builtins
+      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;
+}
+
+module.exports = parseQuery;

node_modules/html-loader/node_modules/loader-utils/lib/parseString.js

@@ -0,0 +1,23 @@
+'use strict';
+
+function parseString(str) {
+  try {
+    if (str[0] === '"') {
+      return JSON.parse(str);
+    }
+
+    if (str[0] === "'" && str.substr(str.length - 1) === "'") {
+      return parseString(
+        str
+          .replace(/\\.|"/g, (x) => (x === '"' ? '\\"' : x))
+          .replace(/^'|'$/g, '"')
+      );
+    }
+
+    return JSON.parse('"' + str + '"');
+  } catch (e) {
+    return str;
+  }
+}
+
+module.exports = parseString;

node_modules/html-loader/node_modules/loader-utils/lib/stringifyRequest.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const path = require('path');
+
+const matchRelativePath = /^\.\.?[/\\]/;
+
+function isAbsolutePath(str) {
+  return path.posix.isAbsolute(str) || path.win32.isAbsolute(str);
+}
+
+function isRelativePath(str) {
+  return matchRelativePath.test(str);
+}
+
+function stringifyRequest(loaderContext, request) {
+  const splitted = request.split('!');
+  const context =
+    loaderContext.context ||
+    (loaderContext.options && loaderContext.options.context);
+
+  return JSON.stringify(
+    splitted
+      .map((part) => {
+        // First, separate singlePath from query, because the query might contain paths again
+        const splittedPart = part.match(/^(.*?)(\?.*)/);
+        const query = splittedPart ? splittedPart[2] : '';
+        let singlePath = splittedPart ? splittedPart[1] : part;
+
+        if (isAbsolutePath(singlePath) && context) {
+          singlePath = path.relative(context, singlePath);
+
+          if (isAbsolutePath(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 (isRelativePath(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('!')
+  );
+}
+
+module.exports = stringifyRequest;

node_modules/html-loader/node_modules/loader-utils/lib/urlToRequest.js

@@ -0,0 +1,60 @@
+'use strict';
+
+// we can't use path.win32.isAbsolute because it also matches paths starting with a forward slash
+const matchNativeWin32Path = /^[A-Z]:[/\\]|^\\\\/i;
+
+function urlToRequest(url, root) {
+  // Do not rewrite an empty url
+  if (url === '') {
+    return '';
+  }
+
+  const moduleRequestRegex = /^[^?]*~/;
+  let request;
+
+  if (matchNativeWin32Path.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;
+}
+
+module.exports = urlToRequest;

node_modules/html-loader/node_modules/loader-utils/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "loader-utils",
+  "version": "2.0.4",
+  "author": "Tobias Koppers @sokra",
+  "description": "utils for webpack loaders",
+  "dependencies": {
+    "big.js": "^5.2.2",
+    "emojis-list": "^3.0.0",
+    "json5": "^2.1.2"
+  },
+  "scripts": {
+    "lint": "eslint lib test",
+    "pretest": "yarn lint",
+    "test": "jest",
+    "test:ci": "jest --coverage",
+    "release": "yarn test && standard-version"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/webpack/loader-utils.git"
+  },
+  "engines": {
+    "node": ">=8.9.0"
+  },
+  "devDependencies": {
+    "coveralls": "^3.0.9",
+    "eslint": "^6.8.0",
+    "eslint-plugin-node": "^11.0.0",
+    "eslint-plugin-prettier": "^3.1.2",
+    "jest": "^25.1.0",
+    "prettier": "^1.19.1",
+    "standard-version": "^7.1.0"
+  },
+  "main": "lib/index.js",
+  "files": [
+    "lib"
+  ]
+}

node_modules/html-loader/node_modules/schema-utils/CHANGELOG.md

@@ -0,0 +1,340 @@
+# Changelog
+
+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.
+
+## [3.3.0](https://github.com/webpack/schema-utils/compare/v3.2.0...v3.3.0) (2023-06-14)
+
+
+### Features
+
+* added API to disable and enable validation ([#183](https://github.com/webpack/schema-utils/issues/183)) ([d4d334f](https://github.com/webpack/schema-utils/commit/d4d334f0ba22eb6b6564b1119e8f3ea439e1f2bb))
+
+
+### Bug Fixes
+
+* **perf:** cache compiled schema ([#182](https://github.com/webpack/schema-utils/issues/182)) ([02aa068](https://github.com/webpack/schema-utils/commit/02aa068df80d99cc576a5ed385f947eb5204c5db))
+
+## [3.2.0](https://github.com/webpack/schema-utils/compare/v3.1.2...v3.2.0) (2023-06-07)
+
+
+### Features
+
+* implement `undefinedAsNull` keyword for `enum` type ([#176](https://github.com/webpack/schema-utils/issues/176)) ([95826eb](https://github.com/webpack/schema-utils/commit/95826eb9e14bc4b10ab95f962ac2bdca447880a3))
+
+### [3.1.2](https://github.com/webpack/schema-utils/compare/v3.1.1...v3.1.2) (2023-04-15)
+
+
+### Bug Fixes
+
+* **perf:** reduced initial start time ([#170](https://github.com/webpack/schema-utils/issues/170)) ([8d052e6](https://github.com/webpack/schema-utils/commit/8d052e6764dc9247e7d5b7b1ae8f87ca5047b2b0))
+
+### [3.1.1](https://github.com/webpack/schema-utils/compare/v3.1.0...v3.1.1) (2021-07-19)
+
+
+### Bug Fixes
+
+* update error message for `integer` ([#136](https://github.com/webpack/schema-utils/issues/136)) ([2daa97e](https://github.com/webpack/schema-utils/commit/2daa97eae87e6790b92711746a6a527b859ac13b))
+
+## [3.1.0](https://github.com/webpack/schema-utils/compare/v3.0.0...v3.1.0) (2021-06-30)
+
+
+### Features
+
+* added the `link` property in validation error ([589aa59](https://github.com/webpack/schema-utils/commit/589aa5993424a8bc45ec22b67dff55be92c456a9))
+
+
+### Bug Fixes
+
+* non-empty validation error message ([#116](https://github.com/webpack/schema-utils/issues/116)) ([c51abef](https://github.com/webpack/schema-utils/commit/c51abefa4d4d62e1346b3a105182d36675595077))
+
+## [3.0.0](https://github.com/webpack/schema-utils/compare/v2.7.1...v3.0.0) (2020-10-05)
+
+
+### ⚠ BREAKING CHANGES
+
+* minimum supported `Node.js` version is `10.13.0`, 
+* the packages exports was changed, please use `const { validate } = require('schema-utils');`
+* the `ValidateError` export was removed in favor the `ValidationError` export, please use `const { ValidationError } = require('schema-utils');`
+
+### [2.7.1](https://github.com/webpack/schema-utils/compare/v2.7.0...v2.7.1) (2020-08-31)
+
+
+### Bug Fixes
+
+* remove esModuleInterop from tsconfig ([#110](https://github.com/webpack/schema-utils/issues/110)) ([#111](https://github.com/webpack/schema-utils/issues/111)) ([2f40154](https://github.com/webpack/schema-utils/commit/2f40154b91e45b393258ae9dd8f10cc3b8590b7d))
+
+## [2.7.0](https://github.com/webpack/schema-utils/compare/v2.6.6...v2.7.0) (2020-05-29)
+
+
+### Features
+
+* improve hints ([a36e535](https://github.com/webpack/schema-utils/commit/a36e535faca1b01e27c3bfa3c8bee9227c3f836c))
+* smart not case ([#101](https://github.com/webpack/schema-utils/issues/101)) ([698d8b0](https://github.com/webpack/schema-utils/commit/698d8b05462d86aadb217e25a45c7b953a79a52e))
+
+
+### Bug Fixes
+
+* move @types/json-schema from devDependencies to dependencies ([#97](https://github.com/webpack/schema-utils/issues/97)) ([#98](https://github.com/webpack/schema-utils/issues/98)) ([945e67d](https://github.com/webpack/schema-utils/commit/945e67db5e19baf7ec7df72813b0739dd56f950d))
+
+### [2.6.6](https://github.com/webpack/schema-utils/compare/v2.6.5...v2.6.6) (2020-04-17)
+
+
+### Bug Fixes
+
+* improve perf
+
+### [2.6.5](https://github.com/webpack/schema-utils/compare/v2.6.4...v2.6.5) (2020-03-11)
+
+
+### Bug Fixes
+
+* correct dots at end of sentence ([7284beb](https://github.com/webpack/schema-utils/commit/7284bebe00cd570f1bef2c15951a07b9794038e6))
+
+### [2.6.4](https://github.com/webpack/schema-utils/compare/v2.6.3...v2.6.4) (2020-01-17)
+
+
+### Bug Fixes
+
+* change `initialised` to `initialized` ([#87](https://github.com/webpack/schema-utils/issues/87)) ([70f12d3](https://github.com/webpack/schema-utils/commit/70f12d33a8eaa27249bc9c1a27f886724cf91ea7))
+
+### [2.6.3](https://github.com/webpack/schema-utils/compare/v2.6.2...v2.6.3) (2020-01-17)
+
+
+### Bug Fixes
+
+* prefer the `baseDataPath` option from arguments ([#86](https://github.com/webpack/schema-utils/issues/86)) ([e236859](https://github.com/webpack/schema-utils/commit/e236859e85b28e35e1294f86fc1ff596a5031cea))
+
+### [2.6.2](https://github.com/webpack/schema-utils/compare/v2.6.1...v2.6.2) (2020-01-14)
+
+
+### Bug Fixes
+
+* better handle Windows absolute paths ([#85](https://github.com/webpack/schema-utils/issues/85)) ([1fa2930](https://github.com/webpack/schema-utils/commit/1fa2930a161e907b9fc53a7233d605910afdb883))
+
+### [2.6.1](https://github.com/webpack/schema-utils/compare/v2.6.0...v2.6.1) (2019-11-28)
+
+
+### Bug Fixes
+
+* typescript declarations ([#84](https://github.com/webpack/schema-utils/issues/84)) ([89d55a9](https://github.com/webpack/schema-utils/commit/89d55a9a8edfa6a8ac8b112f226bb3154e260319))
+
+## [2.6.0](https://github.com/webpack/schema-utils/compare/v2.5.0...v2.6.0) (2019-11-27)
+
+
+### Features
+
+* support configuration via title ([#81](https://github.com/webpack/schema-utils/issues/81)) ([afddc10](https://github.com/webpack/schema-utils/commit/afddc109f6891cd37a9f1835d50862d119a072bf))
+
+
+### Bug Fixes
+
+* typescript definitions ([#70](https://github.com/webpack/schema-utils/issues/70)) ([f38158d](https://github.com/webpack/schema-utils/commit/f38158d6d040e2c701622778ae8122fb26a4f990))
+
+## [2.5.0](https://github.com/webpack/schema-utils/compare/v2.4.1...v2.5.0) (2019-10-15)
+
+
+### Bug Fixes
+
+* rework format for maxLength, minLength ([#67](https://github.com/webpack/schema-utils/issues/67)) ([0d12259](https://github.com/webpack/schema-utils/commit/0d12259))
+* support all cases with one number in range ([#64](https://github.com/webpack/schema-utils/issues/64)) ([7fc8069](https://github.com/webpack/schema-utils/commit/7fc8069))
+* typescript definition and export naming ([#69](https://github.com/webpack/schema-utils/issues/69)) ([a435b79](https://github.com/webpack/schema-utils/commit/a435b79))
+
+
+### Features
+
+* "smart" numbers range ([62fb107](https://github.com/webpack/schema-utils/commit/62fb107))
+
+### [2.4.1](https://github.com/webpack/schema-utils/compare/v2.4.0...v2.4.1) (2019-09-27)
+
+
+### Bug Fixes
+
+* publish definitions ([#58](https://github.com/webpack/schema-utils/issues/58)) ([1885faa](https://github.com/webpack/schema-utils/commit/1885faa))
+
+## [2.4.0](https://github.com/webpack/schema-utils/compare/v2.3.0...v2.4.0) (2019-09-26)
+
+
+### Features
+
+* better errors when the `type` keyword doesn't exist ([0988be2](https://github.com/webpack/schema-utils/commit/0988be2))
+* support $data reference ([#56](https://github.com/webpack/schema-utils/issues/56)) ([d2f11d6](https://github.com/webpack/schema-utils/commit/d2f11d6))
+* types definitions ([#52](https://github.com/webpack/schema-utils/issues/52)) ([facb431](https://github.com/webpack/schema-utils/commit/facb431))
+
+## [2.3.0](https://github.com/webpack/schema-utils/compare/v2.2.0...v2.3.0) (2019-09-26)
+
+
+### Features
+
+* support `not` keyword ([#53](https://github.com/webpack/schema-utils/issues/53)) ([765f458](https://github.com/webpack/schema-utils/commit/765f458))
+
+## [2.2.0](https://github.com/webpack/schema-utils/compare/v2.1.0...v2.2.0) (2019-09-02)
+
+
+### Features
+
+* better error output for `oneOf` and `anyOf` ([#48](https://github.com/webpack/schema-utils/issues/48)) ([#50](https://github.com/webpack/schema-utils/issues/50)) ([332242f](https://github.com/webpack/schema-utils/commit/332242f))
+
+## [2.1.0](https://github.com/webpack-contrib/schema-utils/compare/v2.0.1...v2.1.0) (2019-08-07)
+
+
+### Bug Fixes
+
+* throw error on sparse arrays ([#47](https://github.com/webpack-contrib/schema-utils/issues/47)) ([b85ac38](https://github.com/webpack-contrib/schema-utils/commit/b85ac38))
+
+
+### Features
+
+* export `ValidateError` ([#46](https://github.com/webpack-contrib/schema-utils/issues/46)) ([ff781d7](https://github.com/webpack-contrib/schema-utils/commit/ff781d7))
+
+
+
+### [2.0.1](https://github.com/webpack-contrib/schema-utils/compare/v2.0.0...v2.0.1) (2019-07-18)
+
+
+### Bug Fixes
+
+* error message for empty object ([#44](https://github.com/webpack-contrib/schema-utils/issues/44)) ([0b4b4a2](https://github.com/webpack-contrib/schema-utils/commit/0b4b4a2))
+
+
+
+### [2.0.0](https://github.com/webpack-contrib/schema-utils/compare/v1.0.0...v2.0.0) (2019-07-17)
+
+
+### BREAKING CHANGES
+
+* drop support for Node.js < 8.9.0
+* drop support `errorMessage`, please use `description` for links.
+* api was changed, please look documentation.
+* error messages was fully rewritten.
+
+
+<a name="1.0.0"></a>
+# [1.0.0](https://github.com/webpack-contrib/schema-utils/compare/v0.4.7...v1.0.0) (2018-08-07)
+
+
+### Features
+
+* **src:** add support for custom error messages ([#33](https://github.com/webpack-contrib/schema-utils/issues/33)) ([1cbe4ef](https://github.com/webpack-contrib/schema-utils/commit/1cbe4ef))
+
+
+
+<a name="0.4.7"></a>
+## [0.4.7](https://github.com/webpack-contrib/schema-utils/compare/v0.4.6...v0.4.7) (2018-08-07)
+
+
+### Bug Fixes
+
+* **src:** `node >= v4.0.0` support ([#32](https://github.com/webpack-contrib/schema-utils/issues/32)) ([cb13dd4](https://github.com/webpack-contrib/schema-utils/commit/cb13dd4))
+
+
+
+<a name="0.4.6"></a>
+## [0.4.6](https://github.com/webpack-contrib/schema-utils/compare/v0.4.5...v0.4.6) (2018-08-06)
+
+
+### Bug Fixes
+
+* **package:** remove lockfile ([#28](https://github.com/webpack-contrib/schema-utils/issues/28)) ([69f1a81](https://github.com/webpack-contrib/schema-utils/commit/69f1a81))
+* **package:** remove unnecessary `webpack` dependency ([#26](https://github.com/webpack-contrib/schema-utils/issues/26)) ([532eaa5](https://github.com/webpack-contrib/schema-utils/commit/532eaa5))
+
+
+
+<a name="0.4.5"></a>
+## [0.4.5](https://github.com/webpack-contrib/schema-utils/compare/v0.4.4...v0.4.5) (2018-02-13)
+
+
+### Bug Fixes
+
+* **CHANGELOG:** update broken links ([4483b9f](https://github.com/webpack-contrib/schema-utils/commit/4483b9f))
+* **package:** update broken links ([f2494ba](https://github.com/webpack-contrib/schema-utils/commit/f2494ba))
+
+
+
+<a name="0.4.4"></a>
+## [0.4.4](https://github.com/webpack-contrib/schema-utils/compare/v0.4.3...v0.4.4) (2018-02-13)
+
+
+### Bug Fixes
+
+* **package:** update `dependencies` ([#22](https://github.com/webpack-contrib/schema-utils/issues/22)) ([3aecac6](https://github.com/webpack-contrib/schema-utils/commit/3aecac6))
+
+
+
+<a name="0.4.3"></a>
+## [0.4.3](https://github.com/webpack-contrib/schema-utils/compare/v0.4.2...v0.4.3) (2017-12-14)
+
+
+### Bug Fixes
+
+* **validateOptions:** throw `err` instead of `process.exit(1)` ([#17](https://github.com/webpack-contrib/schema-utils/issues/17)) ([c595eda](https://github.com/webpack-contrib/schema-utils/commit/c595eda))
+* **ValidationError:** never return `this` in the ctor ([#16](https://github.com/webpack-contrib/schema-utils/issues/16)) ([c723791](https://github.com/webpack-contrib/schema-utils/commit/c723791))
+
+
+
+<a name="0.4.2"></a>
+## [0.4.2](https://github.com/webpack-contrib/schema-utils/compare/v0.4.1...v0.4.2) (2017-11-09)
+
+
+### Bug Fixes
+
+* **validateOptions:** catch `ValidationError` and handle it internally ([#15](https://github.com/webpack-contrib/schema-utils/issues/15)) ([9c5ef5e](https://github.com/webpack-contrib/schema-utils/commit/9c5ef5e))
+
+
+
+<a name="0.4.1"></a>
+## [0.4.1](https://github.com/webpack-contrib/schema-utils/compare/v0.4.0...v0.4.1) (2017-11-03)
+
+
+### Bug Fixes
+
+* **ValidationError:** use `Error.captureStackTrace` for `err.stack` handling ([#14](https://github.com/webpack-contrib/schema-utils/issues/14)) ([a6fb974](https://github.com/webpack-contrib/schema-utils/commit/a6fb974))
+
+
+
+<a name="0.4.0"></a>
+# [0.4.0](https://github.com/webpack-contrib/schema-utils/compare/v0.3.0...v0.4.0) (2017-10-28)
+
+
+### Features
+
+* add support for `typeof`, `instanceof` (`{Function\|RegExp}`) ([#10](https://github.com/webpack-contrib/schema-utils/issues/10)) ([9f01816](https://github.com/webpack-contrib/schema-utils/commit/9f01816))
+
+
+
+<a name="0.3.0"></a>
+# [0.3.0](https://github.com/webpack-contrib/schema-utils/compare/v0.2.1...v0.3.0) (2017-04-29)
+
+
+### Features
+
+* add ValidationError ([#8](https://github.com/webpack-contrib/schema-utils/issues/8)) ([d48f0fb](https://github.com/webpack-contrib/schema-utils/commit/d48f0fb))
+
+
+
+<a name="0.2.1"></a>
+## [0.2.1](https://github.com/webpack-contrib/schema-utils/compare/v0.2.0...v0.2.1) (2017-03-13)
+
+
+### Bug Fixes
+
+* Include .babelrc to `files` ([28f0363](https://github.com/webpack-contrib/schema-utils/commit/28f0363))
+* Include source to `files` ([43b0f2f](https://github.com/webpack-contrib/schema-utils/commit/43b0f2f))
+
+
+
+<a name="0.2.0"></a>
+# [0.2.0](https://github.com/webpack-contrib/schema-utils/compare/v0.1.0...v0.2.0) (2017-03-12)
+
+<a name="0.1.0"></a>
+# 0.1.0 (2017-03-07)
+
+
+### Features
+
+* **validations:** add validateOptions module ([ae9b47b](https://github.com/webpack-contrib/schema-utils/commit/ae9b47b))
+
+
+
+# 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.

node_modules/html-loader/node_modules/schema-utils/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.

node_modules/html-loader/node_modules/schema-utils/README.md

@@ -0,0 +1,290 @@
+<div align="center">
+  <a href="http://json-schema.org">
+    <img width="160" height="160"
+      src="https://raw.githubusercontent.com/webpack-contrib/schema-utils/master/.github/assets/logo.png">
+  </a>
+  <a href="https://github.com/webpack/webpack">
+    <img width="200" height="200"
+      src="https://webpack.js.org/assets/icon-square-big.svg">
+  </a>
+</div>
+
+[![npm][npm]][npm-url]
+[![node][node]][node-url]
+[![deps][deps]][deps-url]
+[![tests][tests]][tests-url]
+[![coverage][cover]][cover-url]
+[![chat][chat]][chat-url]
+[![size][size]][size-url]
+
+# schema-utils
+
+Package for validate options in loaders and plugins.
+
+## Getting Started
+
+To begin, you'll need to install `schema-utils`:
+
+```console
+npm install schema-utils
+```
+
+## API
+
+**schema.json**
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "option": {
+      "type": "boolean"
+    }
+  },
+  "additionalProperties": false
+}
+```
+
+```js
+import schema from "./path/to/schema.json";
+import { validate } from "schema-utils";
+
+const options = { option: true };
+const configuration = { name: "Loader Name/Plugin Name/Name" };
+
+validate(schema, options, configuration);
+```
+
+### `schema`
+
+Type: `String`
+
+JSON schema.
+
+Simple example of schema:
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "name": {
+      "description": "This is description of option.",
+      "type": "string"
+    }
+  },
+  "additionalProperties": false
+}
+```
+
+### `options`
+
+Type: `Object`
+
+Object with options.
+
+```js
+import schema from "./path/to/schema.json";
+import { validate } from "schema-utils";
+
+const options = { foo: "bar" };
+
+validate(schema, { name: 123 }, { name: "MyPlugin" });
+```
+
+### `configuration`
+
+Allow to configure validator.
+
+There is an alternative method to configure the `name` and`baseDataPath` options via the `title` property in the schema.
+For example:
+
+```json
+{
+  "title": "My Loader options",
+  "type": "object",
+  "properties": {
+    "name": {
+      "description": "This is description of option.",
+      "type": "string"
+    }
+  },
+  "additionalProperties": false
+}
+```
+
+The last word used for the `baseDataPath` option, other words used for the `name` option.
+Based on the example above the `name` option equals `My Loader`, the `baseDataPath` option equals `options`.
+
+#### `name`
+
+Type: `Object`
+Default: `"Object"`
+
+Allow to setup name in validation errors.
+
+```js
+import schema from "./path/to/schema.json";
+import { validate } from "schema-utils";
+
+const options = { foo: "bar" };
+
+validate(schema, options, { name: "MyPlugin" });
+```
+
+```shell
+Invalid configuration object. MyPlugin has been initialised using a configuration object that does not match the API schema.
+ - configuration.optionName should be a integer.
+```
+
+#### `baseDataPath`
+
+Type: `String`
+Default: `"configuration"`
+
+Allow to setup base data path in validation errors.
+
+```js
+import schema from "./path/to/schema.json";
+import { validate } from "schema-utils";
+
+const options = { foo: "bar" };
+
+validate(schema, options, { name: "MyPlugin", baseDataPath: "options" });
+```
+
+```shell
+Invalid options object. MyPlugin has been initialised using an options object that does not match the API schema.
+ - options.optionName should be a integer.
+```
+
+#### `postFormatter`
+
+Type: `Function`
+Default: `undefined`
+
+Allow to reformat errors.
+
+```js
+import schema from "./path/to/schema.json";
+import { validate } from "schema-utils";
+
+const options = { foo: "bar" };
+
+validate(schema, options, {
+  name: "MyPlugin",
+  postFormatter: (formattedError, error) => {
+    if (error.keyword === "type") {
+      return `${formattedError}\nAdditional Information.`;
+    }
+
+    return formattedError;
+  },
+});
+```
+
+```shell
+Invalid options object. MyPlugin has been initialized using an options object that does not match the API schema.
+ - options.optionName should be a integer.
+   Additional Information.
+```
+
+## Examples
+
+**schema.json**
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string"
+    },
+    "test": {
+      "anyOf": [
+        { "type": "array" },
+        { "type": "string" },
+        { "instanceof": "RegExp" }
+      ]
+    },
+    "transform": {
+      "instanceof": "Function"
+    },
+    "sourceMap": {
+      "type": "boolean"
+    }
+  },
+  "additionalProperties": false
+}
+```
+
+### `Loader`
+
+```js
+import { getOptions } from "loader-utils";
+import { validate } from "schema-utils";
+
+import schema from "path/to/schema.json";
+
+function loader(src, map) {
+  const options = getOptions(this);
+
+  validate(schema, options, {
+    name: "Loader Name",
+    baseDataPath: "options",
+  });
+
+  // Code...
+}
+
+export default loader;
+```
+
+### `Plugin`
+
+```js
+import { validate } from "schema-utils";
+
+import schema from "path/to/schema.json";
+
+class Plugin {
+  constructor(options) {
+    validate(schema, options, {
+      name: "Plugin Name",
+      baseDataPath: "options",
+    });
+
+    this.options = options;
+  }
+
+  apply(compiler) {
+    // Code...
+  }
+}
+
+export default Plugin;
+```
+
+## Contributing
+
+Please take a moment to read our contributing guidelines if you haven't yet done so.
+
+[CONTRIBUTING](./.github/CONTRIBUTING.md)
+
+## License
+
+[MIT](./LICENSE)
+
+[npm]: https://img.shields.io/npm/v/schema-utils.svg
+[npm-url]: https://npmjs.com/package/schema-utils
+[node]: https://img.shields.io/node/v/schema-utils.svg
+[node-url]: https://nodejs.org
+[deps]: https://david-dm.org/webpack/schema-utils.svg
+[deps-url]: https://david-dm.org/webpack/schema-utils
+[tests]: https://github.com/webpack/schema-utils/workflows/schema-utils/badge.svg
+[tests-url]: https://github.com/webpack/schema-utils/actions
+[cover]: https://codecov.io/gh/webpack/schema-utils/branch/master/graph/badge.svg
+[cover-url]: https://codecov.io/gh/webpack/schema-utils
+[chat]: https://badges.gitter.im/webpack/webpack.svg
+[chat-url]: https://gitter.im/webpack/webpack
+[size]: https://packagephobia.com/badge?p=schema-utils
+[size-url]: https://packagephobia.com/result?p=schema-utils

node_modules/html-loader/node_modules/schema-utils/declarations/ValidationError.d.ts

@@ -0,0 +1,74 @@
+export default ValidationError;
+export type JSONSchema6 = import("json-schema").JSONSchema6;
+export type JSONSchema7 = import("json-schema").JSONSchema7;
+export type Schema = import("./validate").Schema;
+export type ValidationErrorConfiguration =
+  import("./validate").ValidationErrorConfiguration;
+export type PostFormatter = import("./validate").PostFormatter;
+export type SchemaUtilErrorObject = import("./validate").SchemaUtilErrorObject;
+declare class ValidationError extends Error {
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @param {Schema} schema
+   * @param {ValidationErrorConfiguration} configuration
+   */
+  constructor(
+    errors: Array<SchemaUtilErrorObject>,
+    schema: Schema,
+    configuration?: ValidationErrorConfiguration
+  );
+  /** @type {Array<SchemaUtilErrorObject>} */
+  errors: Array<SchemaUtilErrorObject>;
+  /** @type {Schema} */
+  schema: Schema;
+  /** @type {string} */
+  headerName: string;
+  /** @type {string} */
+  baseDataPath: string;
+  /** @type {PostFormatter | null} */
+  postFormatter: PostFormatter | null;
+  /**
+   * @param {string} path
+   * @returns {Schema}
+   */
+  getSchemaPart(path: string): Schema;
+  /**
+   * @param {Schema} schema
+   * @param {boolean} logic
+   * @param {Array<Object>} prevSchemas
+   * @returns {string}
+   */
+  formatSchema(
+    schema: Schema,
+    logic?: boolean,
+    prevSchemas?: Array<Object>
+  ): string;
+  /**
+   * @param {Schema=} schemaPart
+   * @param {(boolean | Array<string>)=} additionalPath
+   * @param {boolean=} needDot
+   * @param {boolean=} logic
+   * @returns {string}
+   */
+  getSchemaPartText(
+    schemaPart?: Schema | undefined,
+    additionalPath?: (boolean | Array<string>) | undefined,
+    needDot?: boolean | undefined,
+    logic?: boolean | undefined
+  ): string;
+  /**
+   * @param {Schema=} schemaPart
+   * @returns {string}
+   */
+  getSchemaPartDescription(schemaPart?: Schema | undefined): string;
+  /**
+   * @param {SchemaUtilErrorObject} error
+   * @returns {string}
+   */
+  formatValidationError(error: SchemaUtilErrorObject): string;
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @returns {string}
+   */
+  formatValidationErrors(errors: Array<SchemaUtilErrorObject>): string;
+}

node_modules/html-loader/node_modules/schema-utils/declarations/index.d.ts

@@ -0,0 +1,12 @@
+import { validate } from "./validate";
+import { ValidationError } from "./validate";
+import { enableValidation } from "./validate";
+import { disableValidation } from "./validate";
+import { needValidate } from "./validate";
+export {
+  validate,
+  ValidationError,
+  enableValidation,
+  disableValidation,
+  needValidate,
+};

node_modules/html-loader/node_modules/schema-utils/declarations/keywords/absolutePath.d.ts

@@ -0,0 +1,10 @@
+export default addAbsolutePathKeyword;
+export type Ajv = import("ajv").Ajv;
+export type ValidateFunction = import("ajv").ValidateFunction;
+export type SchemaUtilErrorObject = import("../validate").SchemaUtilErrorObject;
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+declare function addAbsolutePathKeyword(ajv: Ajv): Ajv;

node_modules/html-loader/node_modules/schema-utils/declarations/keywords/undefinedAsNull.d.ts

@@ -0,0 +1,8 @@
+export default addUndefinedAsNullKeyword;
+export type Ajv = import("ajv").Ajv;
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+declare function addUndefinedAsNullKeyword(ajv: Ajv): Ajv;

node_modules/html-loader/node_modules/schema-utils/declarations/util/Range.d.ts

@@ -0,0 +1,79 @@
+export = Range;
+/**
+ * @typedef {[number, boolean]} RangeValue
+ */
+/**
+ * @callback RangeValueCallback
+ * @param {RangeValue} rangeValue
+ * @returns {boolean}
+ */
+declare class Range {
+  /**
+   * @param {"left" | "right"} side
+   * @param {boolean} exclusive
+   * @returns {">" | ">=" | "<" | "<="}
+   */
+  static getOperator(
+    side: "left" | "right",
+    exclusive: boolean
+  ): ">" | ">=" | "<" | "<=";
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
+  static formatRight(value: number, logic: boolean, exclusive: boolean): string;
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
+  static formatLeft(value: number, logic: boolean, exclusive: boolean): string;
+  /**
+   * @param {number} start left side value
+   * @param {number} end right side value
+   * @param {boolean} startExclusive is range exclusive from left side
+   * @param {boolean} endExclusive is range exclusive from right side
+   * @param {boolean} logic is not logic applied
+   * @returns {string}
+   */
+  static formatRange(
+    start: number,
+    end: number,
+    startExclusive: boolean,
+    endExclusive: boolean,
+    logic: boolean
+  ): string;
+  /**
+   * @param {Array<RangeValue>} values
+   * @param {boolean} logic is not logic applied
+   * @return {RangeValue} computed value and it's exclusive flag
+   */
+  static getRangeValue(values: Array<RangeValue>, logic: boolean): RangeValue;
+  /** @type {Array<RangeValue>} */
+  _left: Array<RangeValue>;
+  /** @type {Array<RangeValue>} */
+  _right: Array<RangeValue>;
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+  left(value: number, exclusive?: boolean | undefined): void;
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+  right(value: number, exclusive?: boolean | undefined): void;
+  /**
+   * @param {boolean} logic is not logic applied
+   * @return {string} "smart" range string representation
+   */
+  format(logic?: boolean): string;
+}
+declare namespace Range {
+  export { RangeValue, RangeValueCallback };
+}
+type RangeValue = [number, boolean];
+type RangeValueCallback = (rangeValue: RangeValue) => boolean;

node_modules/html-loader/node_modules/schema-utils/declarations/util/hints.d.ts

@@ -0,0 +1,3 @@
+export function stringHints(schema: Schema, logic: boolean): string[];
+export function numberHints(schema: Schema, logic: boolean): string[];
+export type Schema = import("../validate").Schema;

node_modules/html-loader/node_modules/schema-utils/declarations/validate.d.ts

@@ -0,0 +1,42 @@
+export type JSONSchema4 = import("json-schema").JSONSchema4;
+export type JSONSchema6 = import("json-schema").JSONSchema6;
+export type JSONSchema7 = import("json-schema").JSONSchema7;
+export type ErrorObject = import("ajv").ErrorObject;
+export type ValidateFunction = import("ajv").ValidateFunction;
+export type Extend = {
+  formatMinimum?: number | undefined;
+  formatMaximum?: number | undefined;
+  formatExclusiveMinimum?: boolean | undefined;
+  formatExclusiveMaximum?: boolean | undefined;
+  link?: string | undefined;
+  undefinedAsNull?: boolean | undefined;
+};
+export type Schema = (JSONSchema4 | JSONSchema6 | JSONSchema7) & Extend;
+export type SchemaUtilErrorObject = ErrorObject & {
+  children?: Array<ErrorObject>;
+};
+export type PostFormatter = (
+  formattedError: string,
+  error: SchemaUtilErrorObject
+) => string;
+export type ValidationErrorConfiguration = {
+  name?: string | undefined;
+  baseDataPath?: string | undefined;
+  postFormatter?: PostFormatter | undefined;
+};
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @param {ValidationErrorConfiguration=} configuration
+ * @returns {void}
+ */
+export function validate(
+  schema: Schema,
+  options: Array<object> | object,
+  configuration?: ValidationErrorConfiguration | undefined
+): void;
+export function enableValidation(): void;
+export function disableValidation(): void;
+export function needValidate(): boolean;
+import ValidationError from "./ValidationError";
+export { ValidationError };

node_modules/html-loader/node_modules/schema-utils/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const {
+  validate,
+  ValidationError,
+  enableValidation,
+  disableValidation,
+  needValidate
+} = require("./validate");
+
+module.exports = {
+  validate,
+  ValidationError,
+  enableValidation,
+  disableValidation,
+  needValidate
+};

node_modules/html-loader/node_modules/schema-utils/dist/keywords/absolutePath.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/** @typedef {import("ajv").Ajv} Ajv */
+
+/** @typedef {import("ajv").ValidateFunction} ValidateFunction */
+
+/** @typedef {import("../validate").SchemaUtilErrorObject} SchemaUtilErrorObject */
+
+/**
+ * @param {string} message
+ * @param {object} schema
+ * @param {string} data
+ * @returns {SchemaUtilErrorObject}
+ */
+function errorMessage(message, schema, data) {
+  return {
+    // @ts-ignore
+    // eslint-disable-next-line no-undefined
+    dataPath: undefined,
+    // @ts-ignore
+    // eslint-disable-next-line no-undefined
+    schemaPath: undefined,
+    keyword: "absolutePath",
+    params: {
+      absolutePath: data
+    },
+    message,
+    parentSchema: schema
+  };
+}
+/**
+ * @param {boolean} shouldBeAbsolute
+ * @param {object} schema
+ * @param {string} data
+ * @returns {SchemaUtilErrorObject}
+ */
+
+
+function getErrorFor(shouldBeAbsolute, schema, data) {
+  const message = shouldBeAbsolute ? `The provided value ${JSON.stringify(data)} is not an absolute path!` : `A relative path is expected. However, the provided value ${JSON.stringify(data)} is an absolute path!`;
+  return errorMessage(message, schema, data);
+}
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+
+
+function addAbsolutePathKeyword(ajv) {
+  ajv.addKeyword("absolutePath", {
+    errors: true,
+    type: "string",
+
+    compile(schema, parentSchema) {
+      /** @type {ValidateFunction} */
+      const callback = data => {
+        let passes = true;
+        const isExclamationMarkPresent = data.includes("!");
+
+        if (isExclamationMarkPresent) {
+          callback.errors = [errorMessage(`The provided value ${JSON.stringify(data)} contains exclamation mark (!) which is not allowed because it's reserved for loader syntax.`, parentSchema, data)];
+          passes = false;
+        } // ?:[A-Za-z]:\\ - Windows absolute path
+        // \\\\ - Windows network absolute path
+        // \/ - Unix-like OS absolute path
+
+
+        const isCorrectAbsolutePath = schema === /^(?:[A-Za-z]:(\\|\/)|\\\\|\/)/.test(data);
+
+        if (!isCorrectAbsolutePath) {
+          callback.errors = [getErrorFor(schema, parentSchema, data)];
+          passes = false;
+        }
+
+        return passes;
+      };
+
+      callback.errors = [];
+      return callback;
+    }
+
+  });
+  return ajv;
+}
+
+var _default = addAbsolutePathKeyword;
+exports.default = _default;

node_modules/html-loader/node_modules/schema-utils/dist/keywords/undefinedAsNull.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/** @typedef {import("ajv").Ajv} Ajv */
+
+/**
+ *
+ * @param {Ajv} ajv
+ * @param {string} keyword
+ * @param {any} definition
+ */
+function addKeyword(ajv, keyword, definition) {
+  let customRuleCode;
+
+  try {
+    // @ts-ignore
+    // eslint-disable-next-line global-require
+    customRuleCode = require("ajv/lib/dotjs/custom"); // @ts-ignore
+
+    const {
+      RULES
+    } = ajv;
+    let ruleGroup;
+
+    for (let i = 0; i < RULES.length; i++) {
+      const rg = RULES[i];
+
+      if (typeof rg.type === "undefined") {
+        ruleGroup = rg;
+        break;
+      }
+    }
+
+    const rule = {
+      keyword,
+      definition,
+      custom: true,
+      code: customRuleCode,
+      implements: definition.implements
+    };
+    ruleGroup.rules.unshift(rule);
+    RULES.custom[keyword] = rule;
+    RULES.keywords[keyword] = true;
+    RULES.all[keyword] = true;
+  } catch (e) {// Nothing, fallback
+  }
+}
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+
+
+function addUndefinedAsNullKeyword(ajv) {
+  // There is workaround for old versions of ajv, where `before` is not implemented
+  addKeyword(ajv, "undefinedAsNull", {
+    modifying: true,
+
+    /**
+     * @param {boolean} kwVal
+     * @param {unknown} data
+     * @param {any} parentSchema
+     * @param {string} dataPath
+     * @param {unknown} parentData
+     * @param {number | string} parentDataProperty
+     * @return {boolean}
+     */
+    validate(kwVal, data, parentSchema, dataPath, parentData, parentDataProperty) {
+      if (kwVal && parentSchema && typeof parentSchema.enum !== "undefined" && parentData && typeof parentDataProperty === "number") {
+        const idx =
+        /** @type {number} */
+        parentDataProperty;
+        const parentDataRef =
+        /** @type {any[]} */
+        parentData;
+
+        if (typeof parentDataRef[idx] === "undefined") {
+          parentDataRef[idx] = null;
+        }
+      }
+
+      return true;
+    }
+
+  });
+  return ajv;
+}
+
+var _default = addUndefinedAsNullKeyword;
+exports.default = _default;

node_modules/html-loader/node_modules/schema-utils/dist/util/Range.js

@@ -0,0 +1,163 @@
+"use strict";
+
+/**
+ * @typedef {[number, boolean]} RangeValue
+ */
+
+/**
+ * @callback RangeValueCallback
+ * @param {RangeValue} rangeValue
+ * @returns {boolean}
+ */
+class Range {
+  /**
+   * @param {"left" | "right"} side
+   * @param {boolean} exclusive
+   * @returns {">" | ">=" | "<" | "<="}
+   */
+  static getOperator(side, exclusive) {
+    if (side === "left") {
+      return exclusive ? ">" : ">=";
+    }
+
+    return exclusive ? "<" : "<=";
+  }
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
+
+
+  static formatRight(value, logic, exclusive) {
+    if (logic === false) {
+      return Range.formatLeft(value, !logic, !exclusive);
+    }
+
+    return `should be ${Range.getOperator("right", exclusive)} ${value}`;
+  }
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
+
+
+  static formatLeft(value, logic, exclusive) {
+    if (logic === false) {
+      return Range.formatRight(value, !logic, !exclusive);
+    }
+
+    return `should be ${Range.getOperator("left", exclusive)} ${value}`;
+  }
+  /**
+   * @param {number} start left side value
+   * @param {number} end right side value
+   * @param {boolean} startExclusive is range exclusive from left side
+   * @param {boolean} endExclusive is range exclusive from right side
+   * @param {boolean} logic is not logic applied
+   * @returns {string}
+   */
+
+
+  static formatRange(start, end, startExclusive, endExclusive, logic) {
+    let result = "should be";
+    result += ` ${Range.getOperator(logic ? "left" : "right", logic ? startExclusive : !startExclusive)} ${start} `;
+    result += logic ? "and" : "or";
+    result += ` ${Range.getOperator(logic ? "right" : "left", logic ? endExclusive : !endExclusive)} ${end}`;
+    return result;
+  }
+  /**
+   * @param {Array<RangeValue>} values
+   * @param {boolean} logic is not logic applied
+   * @return {RangeValue} computed value and it's exclusive flag
+   */
+
+
+  static getRangeValue(values, logic) {
+    let minMax = logic ? Infinity : -Infinity;
+    let j = -1;
+    const predicate = logic ?
+    /** @type {RangeValueCallback} */
+    ([value]) => value <= minMax :
+    /** @type {RangeValueCallback} */
+    ([value]) => value >= minMax;
+
+    for (let i = 0; i < values.length; i++) {
+      if (predicate(values[i])) {
+        [minMax] = values[i];
+        j = i;
+      }
+    }
+
+    if (j > -1) {
+      return values[j];
+    }
+
+    return [Infinity, true];
+  }
+
+  constructor() {
+    /** @type {Array<RangeValue>} */
+    this._left = [];
+    /** @type {Array<RangeValue>} */
+
+    this._right = [];
+  }
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+
+
+  left(value, exclusive = false) {
+    this._left.push([value, exclusive]);
+  }
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+
+
+  right(value, exclusive = false) {
+    this._right.push([value, exclusive]);
+  }
+  /**
+   * @param {boolean} logic is not logic applied
+   * @return {string} "smart" range string representation
+   */
+
+
+  format(logic = true) {
+    const [start, leftExclusive] = Range.getRangeValue(this._left, logic);
+    const [end, rightExclusive] = Range.getRangeValue(this._right, !logic);
+
+    if (!Number.isFinite(start) && !Number.isFinite(end)) {
+      return "";
+    }
+
+    const realStart = leftExclusive ? start + 1 : start;
+    const realEnd = rightExclusive ? end - 1 : end; // e.g. 5 < x < 7, 5 < x <= 6, 6 <= x <= 6
+
+    if (realStart === realEnd) {
+      return `should be ${logic ? "" : "!"}= ${realStart}`;
+    } // e.g. 4 < x < ∞
+
+
+    if (Number.isFinite(start) && !Number.isFinite(end)) {
+      return Range.formatLeft(start, logic, leftExclusive);
+    } // e.g. ∞ < x < 4
+
+
+    if (!Number.isFinite(start) && Number.isFinite(end)) {
+      return Range.formatRight(end, logic, rightExclusive);
+    }
+
+    return Range.formatRange(start, end, leftExclusive, rightExclusive, logic);
+  }
+
+}
+
+module.exports = Range;

node_modules/html-loader/node_modules/schema-utils/dist/util/hints.js

@@ -0,0 +1,105 @@
+"use strict";
+
+const Range = require("./Range");
+/** @typedef {import("../validate").Schema} Schema */
+
+/**
+ * @param {Schema} schema
+ * @param {boolean} logic
+ * @return {string[]}
+ */
+
+
+module.exports.stringHints = function stringHints(schema, logic) {
+  const hints = [];
+  let type = "string";
+  const currentSchema = { ...schema
+  };
+
+  if (!logic) {
+    const tmpLength = currentSchema.minLength;
+    const tmpFormat = currentSchema.formatMinimum;
+    const tmpExclusive = currentSchema.formatExclusiveMaximum;
+    currentSchema.minLength = currentSchema.maxLength;
+    currentSchema.maxLength = tmpLength;
+    currentSchema.formatMinimum = currentSchema.formatMaximum;
+    currentSchema.formatMaximum = tmpFormat;
+    currentSchema.formatExclusiveMaximum = !currentSchema.formatExclusiveMinimum;
+    currentSchema.formatExclusiveMinimum = !tmpExclusive;
+  }
+
+  if (typeof currentSchema.minLength === "number") {
+    if (currentSchema.minLength === 1) {
+      type = "non-empty string";
+    } else {
+      const length = Math.max(currentSchema.minLength - 1, 0);
+      hints.push(`should be longer than ${length} character${length > 1 ? "s" : ""}`);
+    }
+  }
+
+  if (typeof currentSchema.maxLength === "number") {
+    if (currentSchema.maxLength === 0) {
+      type = "empty string";
+    } else {
+      const length = currentSchema.maxLength + 1;
+      hints.push(`should be shorter than ${length} character${length > 1 ? "s" : ""}`);
+    }
+  }
+
+  if (currentSchema.pattern) {
+    hints.push(`should${logic ? "" : " not"} match pattern ${JSON.stringify(currentSchema.pattern)}`);
+  }
+
+  if (currentSchema.format) {
+    hints.push(`should${logic ? "" : " not"} match format ${JSON.stringify(currentSchema.format)}`);
+  }
+
+  if (currentSchema.formatMinimum) {
+    hints.push(`should be ${currentSchema.formatExclusiveMinimum ? ">" : ">="} ${JSON.stringify(currentSchema.formatMinimum)}`);
+  }
+
+  if (currentSchema.formatMaximum) {
+    hints.push(`should be ${currentSchema.formatExclusiveMaximum ? "<" : "<="} ${JSON.stringify(currentSchema.formatMaximum)}`);
+  }
+
+  return [type].concat(hints);
+};
+/**
+ * @param {Schema} schema
+ * @param {boolean} logic
+ * @return {string[]}
+ */
+
+
+module.exports.numberHints = function numberHints(schema, logic) {
+  const hints = [schema.type === "integer" ? "integer" : "number"];
+  const range = new Range();
+
+  if (typeof schema.minimum === "number") {
+    range.left(schema.minimum);
+  }
+
+  if (typeof schema.exclusiveMinimum === "number") {
+    range.left(schema.exclusiveMinimum, true);
+  }
+
+  if (typeof schema.maximum === "number") {
+    range.right(schema.maximum);
+  }
+
+  if (typeof schema.exclusiveMaximum === "number") {
+    range.right(schema.exclusiveMaximum, true);
+  }
+
+  const rangeFormat = range.format(logic);
+
+  if (rangeFormat) {
+    hints.push(rangeFormat);
+  }
+
+  if (typeof schema.multipleOf === "number") {
+    hints.push(`should${logic ? "" : " not"} be multiple of ${schema.multipleOf}`);
+  }
+
+  return hints;
+};

node_modules/html-loader/node_modules/schema-utils/dist/validate.js

@@ -0,0 +1,258 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validate = validate;
+exports.enableValidation = enableValidation;
+exports.disableValidation = disableValidation;
+exports.needValidate = needValidate;
+Object.defineProperty(exports, "ValidationError", {
+  enumerable: true,
+  get: function () {
+    return _ValidationError.default;
+  }
+});
+
+var _absolutePath = _interopRequireDefault(require("./keywords/absolutePath"));
+
+var _undefinedAsNull = _interopRequireDefault(require("./keywords/undefinedAsNull"));
+
+var _ValidationError = _interopRequireDefault(require("./ValidationError"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * @template T
+ * @param fn {(function(): any) | undefined}
+ * @returns {function(): T}
+ */
+const memoize = fn => {
+  let cache = false;
+  /** @type {T} */
+
+  let result;
+  return () => {
+    if (cache) {
+      return result;
+    }
+
+    result =
+    /** @type {function(): any} */
+    fn();
+    cache = true; // Allow to clean up memory for fn
+    // and all dependent resources
+    // eslint-disable-next-line no-undefined, no-param-reassign
+
+    fn = undefined;
+    return result;
+  };
+};
+
+const getAjv = memoize(() => {
+  // Use CommonJS require for ajv libs so TypeScript consumers aren't locked into esModuleInterop (see #110).
+  // eslint-disable-next-line global-require
+  const Ajv = require("ajv"); // eslint-disable-next-line global-require
+
+
+  const ajvKeywords = require("ajv-keywords");
+
+  const ajv = new Ajv({
+    allErrors: true,
+    verbose: true,
+    $data: true
+  });
+  ajvKeywords(ajv, ["instanceof", "formatMinimum", "formatMaximum", "patternRequired"]); // Custom keywords
+
+  (0, _absolutePath.default)(ajv);
+  (0, _undefinedAsNull.default)(ajv);
+  return ajv;
+});
+/** @typedef {import("json-schema").JSONSchema4} JSONSchema4 */
+
+/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
+
+/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
+
+/** @typedef {import("ajv").ErrorObject} ErrorObject */
+
+/** @typedef {import("ajv").ValidateFunction} ValidateFunction */
+
+/**
+ * @typedef {Object} Extend
+ * @property {number=} formatMinimum
+ * @property {number=} formatMaximum
+ * @property {boolean=} formatExclusiveMinimum
+ * @property {boolean=} formatExclusiveMaximum
+ * @property {string=} link
+ * @property {boolean=} undefinedAsNull
+ */
+
+/** @typedef {(JSONSchema4 | JSONSchema6 | JSONSchema7) & Extend} Schema */
+
+/** @typedef {ErrorObject & { children?: Array<ErrorObject>}} SchemaUtilErrorObject */
+
+/**
+ * @callback PostFormatter
+ * @param {string} formattedError
+ * @param {SchemaUtilErrorObject} error
+ * @returns {string}
+ */
+
+/**
+ * @typedef {Object} ValidationErrorConfiguration
+ * @property {string=} name
+ * @property {string=} baseDataPath
+ * @property {PostFormatter=} postFormatter
+ */
+
+/**
+ * @param {SchemaUtilErrorObject} error
+ * @param {number} idx
+ * @returns {SchemaUtilErrorObject}
+ */
+
+function applyPrefix(error, idx) {
+  // eslint-disable-next-line no-param-reassign
+  error.dataPath = `[${idx}]${error.dataPath}`;
+
+  if (error.children) {
+    error.children.forEach(err => applyPrefix(err, idx));
+  }
+
+  return error;
+}
+
+let skipValidation = false; // We use `process.env.SKIP_VALIDATION` because you can have multiple `schema-utils` with different version,
+// so we want to disable it globally, `process.env` doesn't supported by browsers, so we have the local `skipValidation` variables
+// Enable validation
+
+function enableValidation() {
+  skipValidation = false; // Disable validation for any versions
+
+  if (process && process.env) {
+    process.env.SKIP_VALIDATION = "n";
+  }
+} // Disable validation
+
+
+function disableValidation() {
+  skipValidation = true;
+
+  if (process && process.env) {
+    process.env.SKIP_VALIDATION = "y";
+  }
+} // Check if we need to confirm
+
+
+function needValidate() {
+  if (skipValidation) {
+    return false;
+  }
+
+  if (process && process.env && process.env.SKIP_VALIDATION) {
+    const value = process.env.SKIP_VALIDATION.trim();
+
+    if (/^(?:y|yes|true|1|on)$/i.test(value)) {
+      return false;
+    }
+
+    if (/^(?:n|no|false|0|off)$/i.test(value)) {
+      return true;
+    }
+  }
+
+  return true;
+}
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @param {ValidationErrorConfiguration=} configuration
+ * @returns {void}
+ */
+
+
+function validate(schema, options, configuration) {
+  if (!needValidate()) {
+    return;
+  }
+
+  let errors = [];
+
+  if (Array.isArray(options)) {
+    for (let i = 0; i <= options.length - 1; i++) {
+      errors.push(...validateObject(schema, options[i]).map(err => applyPrefix(err, i)));
+    }
+  } else {
+    errors = validateObject(schema, options);
+  }
+
+  if (errors.length > 0) {
+    throw new _ValidationError.default(errors, schema, configuration);
+  }
+}
+/** @typedef {WeakMap<Schema, ValidateFunction>} */
+
+
+const schemaCache = new WeakMap();
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @returns {Array<SchemaUtilErrorObject>}
+ */
+
+function validateObject(schema, options) {
+  let compiledSchema = schemaCache.get(schema);
+
+  if (!compiledSchema) {
+    compiledSchema = getAjv().compile(schema);
+    schemaCache.set(schema, compiledSchema);
+  }
+
+  const valid = compiledSchema(options);
+  if (valid) return [];
+  return compiledSchema.errors ? filterErrors(compiledSchema.errors) : [];
+}
+/**
+ * @param {Array<ErrorObject>} errors
+ * @returns {Array<SchemaUtilErrorObject>}
+ */
+
+
+function filterErrors(errors) {
+  /** @type {Array<SchemaUtilErrorObject>} */
+  let newErrors = [];
+
+  for (const error of
+  /** @type {Array<SchemaUtilErrorObject>} */
+  errors) {
+    const {
+      dataPath
+    } = error;
+    /** @type {Array<SchemaUtilErrorObject>} */
+
+    let children = [];
+    newErrors = newErrors.filter(oldError => {
+      if (oldError.dataPath.includes(dataPath)) {
+        if (oldError.children) {
+          children = children.concat(oldError.children.slice(0));
+        } // eslint-disable-next-line no-undefined, no-param-reassign
+
+
+        oldError.children = undefined;
+        children.push(oldError);
+        return false;
+      }
+
+      return true;
+    });
+
+    if (children.length) {
+      error.children = children;
+    }
+
+    newErrors.push(error);
+  }
+
+  return newErrors;
+}

node_modules/html-loader/node_modules/schema-utils/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "schema-utils",
+  "version": "3.3.0",
+  "description": "webpack Validation Utils",
+  "license": "MIT",
+  "repository": "webpack/schema-utils",
+  "author": "webpack Contrib (https://github.com/webpack-contrib)",
+  "homepage": "https://github.com/webpack/schema-utils",
+  "bugs": "https://github.com/webpack/schema-utils/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/webpack"
+  },
+  "main": "dist/index.js",
+  "types": "declarations/index.d.ts",
+  "engines": {
+    "node": ">= 10.13.0"
+  },
+  "scripts": {
+    "start": "npm run build -- -w",
+    "clean": "del-cli dist declarations",
+    "prebuild": "npm run clean",
+    "build:types": "tsc --declaration --emitDeclarationOnly --outDir declarations && prettier \"declarations/**/*.ts\" --write",
+    "build:code": "cross-env NODE_ENV=production babel src -d dist --copy-files",
+    "build": "npm-run-all -p \"build:**\"",
+    "commitlint": "commitlint --from=master",
+    "security": "npm audit --production",
+    "fmt:check": "prettier \"{**/*,*}.{js,json,md,yml,css,ts}\" --list-different",
+    "lint:js": "eslint --cache .",
+    "lint:types": "tsc --pretty --noEmit",
+    "lint": "npm-run-all lint:js lint:types fmt:check",
+    "fmt": "npm run fmt:check -- --write",
+    "fix:js": "npm run lint:js -- --fix",
+    "fix": "npm-run-all fix:js fmt",
+    "test:only": "cross-env NODE_ENV=test jest",
+    "test:watch": "npm run test:only -- --watch",
+    "test:coverage": "npm run test:only -- --collectCoverageFrom=\"src/**/*.js\" --coverage",
+    "pretest": "npm run lint",
+    "test": "npm run test:coverage",
+    "prepare": "npm run build && husky install",
+    "release": "standard-version"
+  },
+  "files": [
+    "dist",
+    "declarations"
+  ],
+  "dependencies": {
+    "@types/json-schema": "^7.0.8",
+    "ajv": "^6.12.5",
+    "ajv-keywords": "^3.5.2"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.14.3",
+    "@babel/core": "^7.14.6",
+    "@babel/preset-env": "^7.14.7",
+    "@commitlint/cli": "^12.1.4",
+    "@commitlint/config-conventional": "^12.1.4",
+    "@webpack-contrib/eslint-config-webpack": "^3.0.0",
+    "babel-jest": "^27.0.6",
+    "cross-env": "^7.0.3",
+    "del": "^6.0.0",
+    "del-cli": "^3.0.1",
+    "eslint": "^7.31.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.23.4",
+    "husky": "^6.0.0",
+    "jest": "^27.0.6",
+    "lint-staged": "^11.0.1",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.3.2",
+    "standard-version": "^9.3.1",
+    "typescript": "^4.3.5",
+    "webpack": "^5.45.1"
+  },
+  "keywords": [
+    "webpack"
+  ]
+}

node_modules/html-loader/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "html-loader",
+  "version": "1.3.2",
+  "description": "Html loader module for webpack",
+  "license": "MIT",
+  "repository": "webpack-contrib/html-loader",
+  "author": "Tobias Koppers @sokra",
+  "homepage": "https://github.com/webpack-contrib/html-loader",
+  "bugs": "https://github.com/webpack-contrib/html-loader/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/webpack"
+  },
+  "main": "dist/cjs.js",
+  "engines": {
+    "node": ">= 10.13.0"
+  },
+  "scripts": {
+    "start": "npm run build -- -w",
+    "clean": "del-cli dist",
+    "validate:runtime": "es-check es5 \"dist/runtime/**/*.js\"",
+    "prebuild": "npm run clean",
+    "build": "cross-env NODE_ENV=production babel src -d dist --copy-files",
+    "postbuild": "npm run validate:runtime",
+    "commitlint": "commitlint --from=master",
+    "security": "npm audit",
+    "lint:prettier": "prettier --list-different .",
+    "lint:js": "eslint --cache .",
+    "lint": "npm-run-all -l -p \"lint:**\"",
+    "test:only": "cross-env NODE_ENV=test jest",
+    "test:watch": "npm run test:only -- --watch",
+    "test:coverage": "npm run test:only -- --coverage",
+    "pretest": "npm run lint",
+    "test": "npm run test:coverage",
+    "prepare": "npm run build",
+    "release": "standard-version",
+    "defaults": "webpack-defaults"
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "webpack": "^4.0.0 || ^5.0.0"
+  },
+  "dependencies": {
+    "html-minifier-terser": "^5.1.1",
+    "htmlparser2": "^4.1.0",
+    "loader-utils": "^2.0.0",
+    "schema-utils": "^3.0.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.11.6",
+    "@babel/core": "^7.11.6",
+    "@babel/preset-env": "^7.11.5",
+    "@commitlint/cli": "^11.0.0",
+    "@commitlint/config-conventional": "^11.0.0",
+    "@webpack-contrib/defaults": "^6.3.0",
+    "@webpack-contrib/eslint-config-webpack": "^3.0.0",
+    "babel-jest": "^26.5.2",
+    "cross-env": "^7.0.2",
+    "del": "^6.0.0",
+    "del-cli": "^3.0.1",
+    "es-check": "^5.1.1",
+    "eslint": "^7.10.0",
+    "eslint-config-prettier": "^6.12.0",
+    "eslint-plugin-import": "^2.22.1",
+    "file-loader": "^6.1.1",
+    "handlebars": "^4.7.6",
+    "husky": "^4.3.0",
+    "jest": "^26.5.2",
+    "lint-staged": "^10.4.0",
+    "memfs": "^3.2.0",
+    "npm-run-all": "^4.1.5",
+    "posthtml": "^0.13.3",
+    "posthtml-webp": "^2.1.0",
+    "prettier": "^2.1.2",
+    "standard-version": "^9.0.0",
+    "url-loader": "^4.1.1",
+    "webpack": "^4.44.2"
+  },
+  "keywords": [
+    "webpack",
+    "html",
+    "loader"
+  ]
+}