first commit

node_modules/eslint-loader/CHANGELOG.md

@@ -0,0 +1,218 @@
+# 2.2.1 - 2019-07-04
+
+- Fixed: path to eslint version for cache
+  ([#282](https://github.com/webpack-contrib/eslint-loader/issues/282) - @ricardogobbosouza)
+
+# 2.2.0 - 2019-07-03
+
+- [Add ESLint 6 support](https://github.com/webpack-contrib/eslint-loader/commit/b6c3938aae61c0390ac8d941af50cf36df14cfc3) by @HDuck
+
+# 2.1.2 - 2019-01-31
+
+- [Fix autofix for eslint < 5](https://github.com/webpack-contrib/eslint-loader/commit/d76372676b8badf57df3d6a22be5739d19e25637) by @eschablowski
+
+# 2.1.1 - 2018-09-19
+
+- [Stop autofixing infinite loop](https://github.com/webpack-contrib/eslint-loader/commit/704024864f737a487ec0b9f9c9b00b11881f2558) by @eschablowski
+- [Allow `formatter` to receive string (path) to file exporting formatter function](https://github.com/webpack-contrib/eslint-loader/commit/7108379e2864f6ffb75cde1d147ee1fe86890ba8) by @Timer
+
+# 2.1.0 - 2018-07-19
+
+- [Add ESLint 5 support](https://github.com/webpack-contrib/eslint-loader/commit/1dc9442d9e2344b953ac88c5c416dcb79f3c690d) by @Alex-Sokolov
+- [Fix not returning execution flow control to webpack when cache option is enabled and one of the files has a linting error](https://github.com/webpack-contrib/eslint-loader/commit/97761d724e6fa26d8dbde4a544ddb7cb3795f568) by @nicolaslt
+- dev deps updates, prettier, eslint config [...](https://github.com/webpack-contrib/eslint-loader/compare/2.0.0...2.1.0)
+
+# 2.0.0 - 2018-02-26
+
+- 🚨 Drop webpack@1.x support (by @wonism in [#212](https://github.com/webpack-contrib/eslint-loader/pull/212))
+- 🚨 Drop Node 4 supported (by @wonism in [#212](https://github.com/webpack-contrib/eslint-loader/pull/212))
+- ✨ Add webpack@4.x support (by @wonism in [#212](https://github.com/webpack-contrib/eslint-loader/pull/212))
+- 🐛 Respect `eslintPath` for formatter (by @lmnsg in [#195](https://github.com/webpack-contrib/eslint-loader/pull/195))
+
+# 1.9.0 - 2017-07-06
+
+- Added: `eslintPath` option so you can provide your own eslint path.
+  ([#183](https://github.com/webpack-contrib/eslint-loader/pull/183) - @trungdq88)
+
+# 1.8.0 - 2017-06-15
+
+- Added: support for eslint@^4.0.0
+  ([#178](https://github.com/webpack-contrib/eslint-loader/issues/178) - @Aladdin-ADD)
+
+# 1.7.1 - 2017-03-31
+
+- Fixed: Remove duplicate output with webpack 2
+  ([#169](https://github.com/webpack-contrib/eslint-loader/pull/169) - @jaridmargolin)
+
+# 1.7.0 - 2017-03-23
+
+- Fixed: outputReport option writes report for last file checked only
+  ([#160](https://github.com/webpack-contrib/eslint-loader/pull/160) - @deryni)
+- Added: use babel loader fs cache as the default caching engine
+  ([#159](https://github.com/webpack-contrib/eslint-loader/pull/159) - @viankakrisna)
+
+# 1.6.3 - 2017-02-22
+
+- Fixed: ignore cache when eslint rules have changed
+  ([#151](https://github.com/webpack-contrib/eslint-loader/pull/151) - @wrakky)
+
+# 1.6.2 - 2017-02-22
+
+- Fixed: fallback to OS temp directory if findCacheDir fails
+  ([#154](https://github.com/webpack-contrib/eslint-loader/pull/154) - @viankakrisna)
+- Fixed: `loader-utils` deprecation warning by upgrading to v1.0.0
+  ([#155](https://github.com/webpack-contrib/eslint-loader/pull/155) - @fknussel)
+
+# 1.6.1 - 2016-11-02
+
+- Fixed: multiples config per instance are now supported
+  ([#105](https://github.com/webpack-contrib/eslint-loader/issues/105) -
+  @jaythomas and @jameslnewell)
+
+# 1.6.0 - 2016-10-17
+
+- Added: Option to generate report file
+  ([#118](https://github.com/webpack-contrib/eslint-loader/pull/118) - @vidhill)
+
+# 1.5.0 - 2016-07-28
+
+- Added: `cache` options
+  ([#93](https://github.com/webpack-contrib/eslint-loader/pull/93) - @genintho)
+
+# 1.4.1 - 2016-06-07
+
+- Fixed: .eslintignore is not ignored anymore (eslint 3.x regression)
+  ([#99](https://github.com/webpack-contrib/eslint-loader/pull/99) - @waiterZen)
+
+# 1.4.0 - 2016-06-02
+
+- Added: support for eslint@^3.0.0
+  ([#96](https://github.com/webpack-contrib/eslint-loader/issues/96))
+
+# 1.3.0 - 2016-02-17
+
+- Added: support for eslint@^2.0.0
+  ([#81](https://github.com/webpack-contrib/eslint-loader/pull/81))
+
+# 1.2.1 - 2016-01-26
+
+- Updated: object-assign dependency
+  ([#77](https://github.com/webpack-contrib/eslint-loader/pull/77))
+
+# 1.2.0 - 2016-01-02
+
+- Added: this loader now pass down the input source map to the next chained
+  loader if it exists
+  ([#70](https://github.com/webpack-contrib/eslint-loader/pull/70)).
+
+# 1.1.1 - 2015-10-08
+
+- Fixed: `failOnError` and `failOnWarning` now print messages.
+
+# 1.1.0 - 2015-10-08
+
+- Added: `fix` option to enable ESLint auto fix feature.
+
+# 1.0.0 - 2015-08-08
+
+- Added: support for eslint 1.x
+- Removed: support for eslint 1.x-rc\*
+- Removed: support for eslint 0.x
+
+# 0.14.2 - 2015-07-18
+
+- Fixed: support for eslint 1.x-rc
+
+# 0.14.1 - 2015-06-15
+
+- Fixed: support for eslint 0.24.x
+
+# 0.14.0 - 2015-06-15
+
+- Added: support for eslint 0.23.x
+
+# 0.13.0 - 2015-06-14
+
+- Changed: a file that should be ignored doesn't trigger a warning
+  ([#44](https://github.com/webpack-contrib/eslint-loader/issues/44))
+
+# 0.12.0 - 2015-06-04
+
+- Changed: upgrade to eslint 0.22.x
+- Fixed: respect .eslintrc/eslintignore files in directory tree
+  ([#21](https://github.com/webpack-contrib/eslint-loader/issues/21))
+
+# 0.11.2 - 2015-05-11
+
+- Fixed: eslint range from 0.17 to 0.21
+
+# 0.11.1 - 2015-04-27
+
+- Fixed: eslint range from 0.17 to 0.20
+
+# 0.11.0 - 2015-04-27
+
+- Changed: upgrade to eslint 0.20.x
+
+# 0.10.0 - 2015-04-13
+
+- Changed: upgrade to eslint 0.19.x
+
+# 0.9.0 - 2015-03-29
+
+- Changed: upgrade to eslint 0.18.x
+
+# 0.8.0 - 2015-03-27
+
+- Changed: `reporter` is now `formatter` option to fit eslint name
+- Changed: plugin is now async as it don't need to be sync
+- Added: options are supported as query strings
+
+# 0.7.0 - 2015-03-15
+
+- Changed: upgrade to eslint 0.17.x
+- Added: `failOnError` option
+- Added: `failOnWarning` option
+
+# 0.6.0 - 2015-03-11
+
+- Changed: `reporter` now automatically drop lines that contains the filename in
+  the reporter output.
+  That mean you can use official or community reporters without worrying to see
+  lot of lines with `<text>` as filename :)
+
+# 0.5.0 - 2015-03-11
+
+- Changed: upgrade to eslint 0.16.x
+- Changed: `emitErrors` is now `emitError`
+- Changed: loader now use `webpack.emitError` or `webpack.emitWarning`
+  automatically (according to eslint configuration).
+  You can still override by using `emitError` or `emitWarning` options to override
+  this behavior
+- Added: `emitWarning` can force eslint to report warning instead of the default
+  behavior (see above)
+- Added: `quiet` option to hide warnings
+
+# 0.4.0 - 2015-02-23
+
+- Changed: upgrade to eslint 0.15.x
+- Changed: more readable default reporter
+- Added: `reporter` options allow to define a custom reporter function
+
+# 0.3.0 - 2015-02-10
+
+- Changed: upgrade to eslint 0.14.x
+
+# 0.2.1 - 2015-01-27
+
+- Changed: upgrade to eslint 0.13.x
+
+# 0.2.0 - 2015-01-23
+
+- Changed: upgrade to eslint 0.12.x
+- Added: enable loading of eslint config from webpack config, `.eslintrc`, or
+  `package.json`
+
+# 0.1.0 - 2014-12-05
+
+✨ Initial release

node_modules/eslint-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/eslint-loader/README.md

@@ -0,0 +1,322 @@
+# eslint-loader [![Build Status](https://travis-ci.org/webpack-contrib/eslint-loader.svg?branch=master)](https://travis-ci.org/webpack-contrib/eslint-loader)
+
+> eslint loader for webpack
+
+## Install
+
+```console
+$ npm install eslint-loader --save-dev
+```
+
+**NOTE**: You also need to install `eslint` from npm, if you haven't already:
+
+```console
+$ npm install eslint --save-dev
+```
+
+## Usage
+
+In your webpack configuration
+
+```js
+module.exports = {
+  // ...
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        loader: "eslint-loader",
+        options: {
+          // eslint options (if necessary)
+        }
+      }
+    ]
+  }
+  // ...
+};
+```
+
+When using with transpiling loaders (like `babel-loader`), make sure they are in correct order
+(bottom to top). Otherwise files will be checked after being processed by `babel-loader`
+
+```js
+module.exports = {
+  // ...
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        use: ["babel-loader", "eslint-loader"]
+      }
+    ]
+  }
+  // ...
+};
+```
+
+To be safe, you can use `enforce: "pre"` section to check source files, not modified
+by other loaders (like `babel-loader`)
+
+```js
+module.exports = {
+  // ...
+  module: {
+    rules: [
+      {
+        enforce: "pre",
+        test: /\.js$/,
+        exclude: /node_modules/,
+        loader: "eslint-loader"
+      },
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        loader: "babel-loader"
+      }
+    ]
+  }
+  // ...
+};
+```
+
+### Options
+
+You can pass [eslint options](http://eslint.org/docs/developer-guide/nodejs-api#cliengine)
+using standard webpack [loader options](https://webpack.js.org/configuration/module/#useentry).
+
+Note that the config option you provide will be passed to the `CLIEngine`.
+This is a different set of options than what you'd specify in `package.json` or `.eslintrc`.
+See the [eslint docs](http://eslint.org/docs/developer-guide/nodejs-api#cliengine) for more detail.
+
+#### `fix` (default: false)
+
+This option will enable
+[ESLint autofix feature](http://eslint.org/docs/user-guide/command-line-interface#fix).
+
+**Be careful: this option will change source files.**
+
+#### `cache` (default: false)
+
+This option will enable caching of the linting results into a file.
+This is particularly useful in reducing linting time when doing a full build.
+
+This can either be a `boolean` value or the cache directory path(ex: `'./.eslint-loader-cache'`).
+
+If `cache: true` is used, the cache file is written to the `./node_modules/.cache` directory.
+This is the recommended usage.
+
+#### `formatter` (default: eslint stylish formatter)
+
+Loader accepts a function that will have one argument: an array of eslint messages (object).
+The function must return the output as a string.
+You can use official eslint formatters.
+
+```js
+module.exports = {
+  entry: "...",
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        loader: "eslint-loader",
+        options: {
+          // several examples !
+
+          // default value
+          formatter: require("eslint/lib/formatters/stylish"),
+
+          // community formatter
+          formatter: require("eslint-friendly-formatter"),
+
+          // custom formatter
+          formatter: function(results) {
+            // `results` format is available here
+            // http://eslint.org/docs/developer-guide/nodejs-api.html#executeonfiles()
+
+            // you should return a string
+            // DO NOT USE console.*() directly !
+            return "OUTPUT";
+          }
+        }
+      }
+    ]
+  }
+};
+```
+
+#### `eslintPath` (default: "eslint")
+
+Path to `eslint` instance that will be used for linting.  
+If the `eslintPath` is a folder like a official eslint, or specify a `formatter` option. now you dont have to install `eslint` .
+
+```js
+module.exports = {
+  entry: "...",
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        loader: "eslint-loader",
+        options: {
+          eslintPath: path.join(__dirname, "reusable-eslint")
+        }
+      }
+    ]
+  }
+};
+```
+
+#### Errors and Warning
+
+**By default the loader will auto adjust error reporting depending
+on eslint errors/warnings counts.**
+You can still force this behavior by using `emitError` **or** `emitWarning` options:
+
+##### `emitError` (default: `false`)
+
+Loader will always return errors if this option is set to `true`.
+
+```js
+module.exports = {
+  entry: "...",
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        loader: "eslint-loader",
+        options: {
+          emitError: true
+        }
+      }
+    ]
+  }
+};
+```
+
+##### `emitWarning` (default: `false`)
+
+Loader will always return warnings if option is set to `true`. If you're using hot module replacement, you may wish to enable this in development, or else updates will be skipped when there's an eslint error.
+
+#### `quiet` (default: `false`)
+
+Loader will process and report errors only and ignore warnings if this option is set to true
+
+```js
+module.exports = {
+  entry: "...",
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        loader: "eslint-loader",
+        options: {
+          quiet: true
+        }
+      }
+    ]
+  }
+};
+```
+
+##### `failOnWarning` (default: `false`)
+
+Loader will cause the module build to fail if there are any eslint warnings.
+
+```js
+module.exports = {
+  entry: "...",
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        loader: "eslint-loader",
+        options: {
+          failOnWarning: true
+        }
+      }
+    ]
+  }
+};
+```
+
+##### `failOnError` (default: `false`)
+
+Loader will cause the module build to fail if there are any eslint errors.
+
+```js
+module.exports = {
+  entry: "...",
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        loader: "eslint-loader",
+        options: {
+          failOnError: true
+        }
+      }
+    ]
+  }
+};
+```
+
+##### `outputReport` (default: `false`)
+
+Write the output of the errors to a file, for example a checkstyle xml file for use for reporting on Jenkins CI
+
+The `filePath` is relative to the webpack config: output.path
+You can pass in a different formatter for the output file, if none is passed in the default/configured formatter will be used
+
+```js
+module.exports = {
+  entry: "...",
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        loader: "eslint-loader",
+        options: {
+          outputReport: {
+            filePath: "checkstyle.xml",
+            formatter: require("eslint/lib/formatters/checkstyle")
+          }
+        }
+      }
+    ]
+  }
+};
+```
+
+## Gotchas
+
+### NoErrorsPlugin
+
+`NoErrorsPlugin` prevents webpack from outputting anything into a bundle. So even ESLint warnings
+will fail the build. No matter what error settings are used for `eslint-loader`.
+
+So if you want to see ESLint warnings in console during development using `WebpackDevServer`
+remove `NoErrorsPlugin` from webpack config.
+
+### Defining `configFile` or using `eslint -c path/.eslintrc`
+
+Bear in mind that when you define `configFile`, `eslint` doesn't automatically look for
+`.eslintrc` files in the directory of the file to be linted.
+More information is available in official eslint documentation in section [_Using Configuration Files_](http://eslint.org/docs/user-guide/configuring#using-configuration-files).
+See [#129](https://github.com/webpack-contrib/eslint-loader/issues/129).
+
+---
+
+## Changelog
+[Changelog](CHANGELOG.md)
+
+## License
+[MIT](./LICENSE)

node_modules/eslint-loader/index.js

@@ -0,0 +1,279 @@
+"use strict";
+
+//var fs = require("fs");
+var assign = require("object-assign");
+var loaderUtils = require("loader-utils");
+var objectHash = require("object-hash");
+var createCache = require("loader-fs-cache");
+
+var pkg = require("./package.json");
+
+var cache = createCache("eslint-loader");
+
+var engines = {};
+
+/**
+ * Class representing an ESLintError.
+ * @extends Error
+ */
+class ESLintError extends Error {
+  /**
+   * Create an ESLintError.
+   * @param {string} messages - Formatted eslint errors.
+   */
+  constructor(messages) {
+    super();
+    this.name = "ESLintError";
+    this.message = messages;
+    this.stack = "";
+  }
+
+  /**
+   * Returns a stringified representation of our error. This method is called
+   * when an error is consumed by console methods
+   * ex: console.error(new ESLintError(formattedMessage))
+   * @return {string} error - A stringified representation of the error.
+   */
+  inspect() {
+    return this.message;
+  }
+}
+
+/**
+ * printLinterOutput
+ *
+ * @param {Object} eslint.executeOnText return value
+ * @param {Object} config eslint configuration
+ * @param {Object} webpack webpack instance
+ * @return {void}
+ */
+function printLinterOutput(res, config, webpack) {
+  // skip ignored file warning
+  if (
+    !(
+      res.warningCount === 1 &&
+      res.results[0].messages[0] &&
+      res.results[0].messages[0].message &&
+      res.results[0].messages[0].message.indexOf("ignore") > 1
+    )
+  ) {
+    // quiet filter done now
+    // eslint allow rules to be specified in the input between comments
+    // so we can found warnings defined in the input itself
+    if (res.warningCount && config.quiet) {
+      res.warningCount = 0;
+      res.results[0].warningCount = 0;
+      res.results[0].messages = res.results[0].messages.filter(function(
+        message
+      ) {
+        return message.severity !== 1;
+      });
+    }
+
+    // if enabled, use eslint auto-fixing where possible
+    if (
+      config.fix &&
+      (res.results[0].output !== res.src ||
+        res.results[0].fixableErrorCount > 0 ||
+        res.results[0].fixableWarningCount > 0)
+    ) {
+      var eslint = require(config.eslintPath);
+      eslint.CLIEngine.outputFixes(res);
+    }
+
+    if (res.errorCount || res.warningCount) {
+      // add filename for each results so formatter can have relevant filename
+      res.results.forEach(function(r) {
+        r.filePath = webpack.resourcePath;
+      });
+      var messages = config.formatter(res.results);
+
+      if (config.outputReport && config.outputReport.filePath) {
+        var reportOutput;
+        // if a different formatter is passed in as an option use that
+        if (config.outputReport.formatter) {
+          reportOutput = config.outputReport.formatter(res.results);
+        } else {
+          reportOutput = messages;
+        }
+        var filePath = loaderUtils.interpolateName(
+          webpack,
+          config.outputReport.filePath,
+          {
+            content: res.results
+              .map(function(r) {
+                return r.source;
+              })
+              .join("\n")
+          }
+        );
+        webpack.emitFile(filePath, reportOutput);
+      }
+
+      // default behavior: emit error only if we have errors
+      var emitter = res.errorCount ? webpack.emitError : webpack.emitWarning;
+
+      // force emitError or emitWarning if user want this
+      if (config.emitError) {
+        emitter = webpack.emitError;
+      } else if (config.emitWarning) {
+        emitter = webpack.emitWarning;
+      }
+
+      if (emitter) {
+        if (config.failOnError && res.errorCount) {
+          throw new ESLintError(
+            "Module failed because of a eslint error.\n" + messages
+          );
+        } else if (config.failOnWarning && res.warningCount) {
+          throw new ESLintError(
+            "Module failed because of a eslint warning.\n" + messages
+          );
+        }
+
+        emitter(new ESLintError(messages));
+      } else {
+        throw new Error(
+          "Your module system doesn't support emitWarning. " +
+            "Update available? \n" +
+            messages
+        );
+      }
+    }
+  }
+}
+
+/**
+ * webpack loader
+ *
+ * @param  {String|Buffer} input JavaScript string
+ * @param {Object} map input source map
+ * @return {void}
+ */
+module.exports = function(input, map) {
+  var webpack = this;
+
+  var userOptions = assign(
+    // user defaults
+    (webpack.options && webpack.options.eslint) || webpack.query || {},
+    // loader query string
+    loaderUtils.getOptions(webpack)
+  );
+
+  var eslintPkgPath = "eslint/package.json";
+  var userEslintPath = eslintPkgPath;
+
+  if (userOptions.eslintPath) {
+    userEslintPath = userOptions.eslintPath + "/package.json";
+  }
+
+  var eslintVersion;
+
+  try {
+    eslintVersion = require(require.resolve(userEslintPath)).version;
+  } catch (_) {
+    // ignored
+  }
+
+  if (!eslintVersion) {
+    try {
+      eslintVersion = require(require.resolve(eslintPkgPath)).version;
+    } catch (_) {
+      // ignored
+    }
+  }
+
+  var config = assign(
+    // loader defaults
+    {
+      cacheIdentifier: JSON.stringify({
+        "eslint-loader": pkg.version,
+        eslint: eslintVersion || "unknown version"
+      }),
+      eslintPath: "eslint"
+    },
+    userOptions
+  );
+
+  if (typeof config.formatter === "string") {
+    try {
+      config.formatter = require(config.formatter);
+      if (
+        config.formatter &&
+        typeof config.formatter !== "function" &&
+        typeof config.formatter.default === "function"
+      ) {
+        config.formatter = config.formatter.default;
+      }
+    } catch (_) {
+      // ignored
+    }
+  }
+
+  var cacheDirectory = config.cache;
+  var cacheIdentifier = config.cacheIdentifier;
+
+  delete config.cacheIdentifier;
+
+  // Create the engine only once per config
+  var configHash = objectHash(config);
+
+  if (!engines[configHash]) {
+    var eslint = require(config.eslintPath);
+    engines[configHash] = new eslint.CLIEngine(config);
+  }
+
+  var engine = engines[configHash];
+  if (config.formatter == null || typeof config.formatter !== "function") {
+    config.formatter = engine.getFormatter("stylish");
+  }
+
+  webpack.cacheable();
+
+  var resourcePath = webpack.resourcePath;
+  var cwd = process.cwd();
+
+  // remove cwd from resource path in case webpack has been started from project
+  // root, to allow having relative paths in .eslintignore
+  if (resourcePath.indexOf(cwd) === 0) {
+    resourcePath = resourcePath.substr(cwd.length + 1);
+  }
+
+  // return early if cached
+  if (config.cache) {
+    var callback = webpack.async();
+    return cache(
+      {
+        directory: cacheDirectory,
+        identifier: cacheIdentifier,
+        options: config,
+        source: input,
+        transform: function() {
+          return lint(engine, input, resourcePath);
+        }
+      },
+      function(err, res) {
+        if (err) {
+          return callback(err);
+        }
+
+        try {
+          printLinterOutput(
+            assign({}, res || {}, { src: input }),
+            config,
+            webpack
+          );
+        } catch (e) {
+          err = e;
+        }
+        return callback(err, input, map);
+      }
+    );
+  }
+  printLinterOutput(lint(engine, input, resourcePath), config, webpack);
+  webpack.callback(null, input, map);
+};
+
+function lint(engine, input, resourcePath) {
+  return engine.executeOnText(input, resourcePath, true);
+}

node_modules/eslint-loader/node_modules/.bin/json5

@@ -0,0 +1,12 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../json5/lib/cli.js" "$@"
+else 
+  exec node  "$basedir/../json5/lib/cli.js" "$@"
+fi

node_modules/eslint-loader/node_modules/.bin/json5.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\json5\lib\cli.js" %*

node_modules/eslint-loader/node_modules/.bin/json5.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../json5/lib/cli.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../json5/lib/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../json5/lib/cli.js" $args
+  } else {
+    & "node$exe"  "$basedir/../json5/lib/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/eslint-loader/node_modules/.bin/rimraf

@@ -0,0 +1,12 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../rimraf/bin.js" "$@"
+else 
+  exec node  "$basedir/../rimraf/bin.js" "$@"
+fi

node_modules/eslint-loader/node_modules/.bin/rimraf.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\rimraf\bin.js" %*

node_modules/eslint-loader/node_modules/.bin/rimraf.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../rimraf/bin.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../rimraf/bin.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../rimraf/bin.js" $args
+  } else {
+    & "node$exe"  "$basedir/../rimraf/bin.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/eslint-loader/node_modules/json5/LICENSE.md

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2012-2018 Aseem Kishore, and [others].
+
+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.
+
+[others]: https://github.com/json5/json5/contributors

node_modules/eslint-loader/node_modules/json5/README.md

@@ -0,0 +1,234 @@
+# JSON5 – JSON for Humans
+
+[![Build Status](https://travis-ci.org/json5/json5.svg)][Build Status]
+[![Coverage
+Status](https://coveralls.io/repos/github/json5/json5/badge.svg)][Coverage
+Status]
+
+The JSON5 Data Interchange Format (JSON5) is a superset of [JSON] that aims to
+alleviate some of the limitations of JSON by expanding its syntax to include
+some productions from [ECMAScript 5.1].
+
+This JavaScript library is the official reference implementation for JSON5
+parsing and serialization libraries.
+
+[Build Status]: https://travis-ci.org/json5/json5
+
+[Coverage Status]: https://coveralls.io/github/json5/json5
+
+[JSON]: https://tools.ietf.org/html/rfc7159
+
+[ECMAScript 5.1]: https://www.ecma-international.org/ecma-262/5.1/
+
+## Summary of Features
+The following ECMAScript 5.1 features, which are not supported in JSON, have
+been extended to JSON5.
+
+### Objects
+- Object keys may be an ECMAScript 5.1 _[IdentifierName]_.
+- Objects may have a single trailing comma.
+
+### Arrays
+- Arrays may have a single trailing comma.
+
+### Strings
+- Strings may be single quoted.
+- Strings may span multiple lines by escaping new line characters.
+- Strings may include character escapes.
+
+### Numbers
+- Numbers may be hexadecimal.
+- Numbers may have a leading or trailing decimal point.
+- Numbers may be [IEEE 754] positive infinity, negative infinity, and NaN.
+- Numbers may begin with an explicit plus sign.
+
+### Comments
+- Single and multi-line comments are allowed.
+
+### White Space
+- Additional white space characters are allowed.
+
+[IdentifierName]: https://www.ecma-international.org/ecma-262/5.1/#sec-7.6
+
+[IEEE 754]: http://ieeexplore.ieee.org/servlet/opac?punumber=4610933
+
+## Short Example
+```js
+{
+  // comments
+  unquoted: 'and you can quote me on that',
+  singleQuotes: 'I can use "double quotes" here',
+  lineBreaks: "Look, Mom! \
+No \\n's!",
+  hexadecimal: 0xdecaf,
+  leadingDecimalPoint: .8675309, andTrailing: 8675309.,
+  positiveSign: +1,
+  trailingComma: 'in objects', andIn: ['arrays',],
+  "backwardsCompatible": "with JSON",
+}
+```
+
+## Specification
+For a detailed explanation of the JSON5 format, please read the [official
+specification](https://json5.github.io/json5-spec/).
+
+## Installation
+### Node.js
+```sh
+npm install json5
+```
+
+```js
+const JSON5 = require('json5')
+```
+
+### Browsers
+```html
+<script src="https://unpkg.com/json5@^1.0.0"></script>
+```
+
+This will create a global `JSON5` variable.
+
+## API
+The JSON5 API is compatible with the [JSON API].
+
+[JSON API]:
+https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON
+
+### JSON5.parse()
+Parses a JSON5 string, constructing the JavaScript value or object described by
+the string. An optional reviver function can be provided to perform a
+transformation on the resulting object before it is returned.
+
+#### Syntax
+    JSON5.parse(text[, reviver])
+
+#### Parameters
+- `text`: The string to parse as JSON5.
+- `reviver`: If a function, this prescribes how the value originally produced by
+  parsing is transformed, before being returned.
+
+#### Return value
+The object corresponding to the given JSON5 text.
+
+### JSON5.stringify()
+Converts a JavaScript value to a JSON5 string, optionally replacing values if a
+replacer function is specified, or optionally including only the specified
+properties if a replacer array is specified.
+
+#### Syntax
+    JSON5.stringify(value[, replacer[, space]])
+    JSON5.stringify(value[, options])
+
+#### Parameters
+- `value`: The value to convert to a JSON5 string.
+- `replacer`: A function that alters the behavior of the stringification
+  process, or an array of String and Number objects that serve as a whitelist
+  for selecting/filtering the properties of the value object to be included in
+  the JSON5 string. If this value is null or not provided, all properties of the
+  object are included in the resulting JSON5 string.
+- `space`: A String or Number object that's used to insert white space into the
+  output JSON5 string for readability purposes. If this is a Number, it
+  indicates the number of space characters to use as white space; this number is
+  capped at 10 (if it is greater, the value is just 10). Values less than 1
+  indicate that no space should be used. If this is a String, the string (or the
+  first 10 characters of the string, if it's longer than that) is used as white
+  space. If this parameter is not provided (or is null), no white space is used.
+  If white space is used, trailing commas will be used in objects and arrays.
+- `options`: An object with the following properties:
+  - `replacer`: Same as the `replacer` parameter.
+  - `space`: Same as the `space` parameter.
+  - `quote`: A String representing the quote character to use when serializing
+    strings.
+
+#### Return value
+A JSON5 string representing the value.
+
+### Node.js `require()` JSON5 files
+When using Node.js, you can `require()` JSON5 files by adding the following
+statement.
+
+```js
+require('json5/lib/register')
+```
+
+Then you can load a JSON5 file with a Node.js `require()` statement. For
+example:
+
+```js
+const config = require('./config.json5')
+```
+
+## CLI
+Since JSON is more widely used than JSON5, this package includes a CLI for
+converting JSON5 to JSON and for validating the syntax of JSON5 documents.
+
+### Installation
+```sh
+npm install --global json5
+```
+
+### Usage
+```sh
+json5 [options] <file>
+```
+
+If `<file>` is not provided, then STDIN is used.
+
+#### Options:
+- `-s`, `--space`: The number of spaces to indent or `t` for tabs
+- `-o`, `--out-file [file]`: Output to the specified file, otherwise STDOUT
+- `-v`, `--validate`: Validate JSON5 but do not output JSON
+- `-V`, `--version`: Output the version number
+- `-h`, `--help`: Output usage information
+
+## Contibuting
+### Development
+```sh
+git clone https://github.com/json5/json5
+cd json5
+npm install
+```
+
+When contributing code, please write relevant tests and run `npm test` and `npm
+run lint` before submitting pull requests. Please use an editor that supports
+[EditorConfig](http://editorconfig.org/).
+
+### Issues
+To report bugs or request features regarding the JSON5 data format, please
+submit an issue to the [official specification
+repository](https://github.com/json5/json5-spec).
+
+To report bugs or request features regarding the JavaScript implentation of
+JSON5, please submit an issue to this repository.
+
+## License
+MIT. See [LICENSE.md](./LICENSE.md) for details.
+
+## Credits
+[Assem Kishore](https://github.com/aseemk) founded this project.
+
+[Michael Bolin](http://bolinfest.com/) independently arrived at and published
+some of these same ideas with awesome explanations and detail. Recommended
+reading: [Suggested Improvements to JSON](http://bolinfest.com/essays/json.html)
+
+[Douglas Crockford](http://www.crockford.com/) of course designed and built
+JSON, but his state machine diagrams on the [JSON website](http://json.org/), as
+cheesy as it may sound, gave us motivation and confidence that building a new
+parser to implement these ideas was within reach! The original
+implementation of JSON5 was also modeled directly off of Doug’s open-source
+[json_parse.js] parser. We’re grateful for that clean and well-documented
+code.
+
+[json_parse.js]:
+https://github.com/douglascrockford/JSON-js/blob/master/json_parse.js
+
+[Max Nanasy](https://github.com/MaxNanasy) has been an early and prolific
+supporter, contributing multiple patches and ideas.
+
+[Andrew Eisenberg](https://github.com/aeisenberg) contributed the original
+`stringify` method.
+
+[Jordan Tucker](https://github.com/jordanbtucker) has aligned JSON5 more closely
+with ES5, wrote the official JSON5 specification, completely rewrote the
+codebase from the ground up, and is actively maintaining this project.

node_modules/eslint-loader/node_modules/json5/lib/cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+'use strict';var _fs=require('fs');var _fs2=_interopRequireDefault(_fs);var _path=require('path');var _path2=_interopRequireDefault(_path);var _minimist=require('minimist');var _minimist2=_interopRequireDefault(_minimist);var _package=require('../package.json');var _package2=_interopRequireDefault(_package);var _=require('./');var _2=_interopRequireDefault(_);function _interopRequireDefault(obj){return obj&&obj.__esModule?obj:{default:obj}}var argv=(0,_minimist2.default)(process.argv.slice(2),{alias:{'convert':'c','space':'s','validate':'v','out-file':'o','version':'V','help':'h'},boolean:['convert','validate','version','help'],string:['space','out-file']});if(argv.version){version()}else if(argv.help){usage()}else{var inFilename=argv._[0];var readStream=void 0;if(inFilename){readStream=_fs2.default.createReadStream(inFilename)}else{readStream=process.stdin}var json5='';readStream.on('data',function(data){json5+=data});readStream.on('end',function(){var space=void 0;if(argv.space==='t'||argv.space==='tab'){space='\t'}else{space=Number(argv.space)}var value=void 0;try{value=_2.default.parse(json5);if(!argv.validate){var json=JSON.stringify(value,null,space);var writeStream=void 0;if(argv.convert&&inFilename&&!argv.o){var parsedFilename=_path2.default.parse(inFilename);var outFilename=_path2.default.format(Object.assign(parsedFilename,{base:_path2.default.basename(parsedFilename.base,parsedFilename.ext)+'.json'}));writeStream=_fs2.default.createWriteStream(outFilename)}else if(argv.o){writeStream=_fs2.default.createWriteStream(argv.o)}else{writeStream=process.stdout}writeStream.write(json)}}catch(err){console.error(err.message);process.exit(1)}})}function version(){console.log(_package2.default.version)}function usage(){console.log('\n  Usage: json5 [options] <file>\n\n  If <file> is not provided, then STDIN is used.\n\n  Options:\n\n    -s, --space              The number of spaces to indent or \'t\' for tabs\n    -o, --out-file [file]    Output to the specified file, otherwise STDOUT\n    -v, --validate           Validate JSON5 but do not output JSON\n    -V, --version            Output the version number\n    -h, --help               Output usage information')}

node_modules/eslint-loader/node_modules/json5/lib/index.js

@@ -0,0 +1 @@
+'use strict';Object.defineProperty(exports,'__esModule',{value:true});var _parse=require('./parse');var _parse2=_interopRequireDefault(_parse);var _stringify=require('./stringify');var _stringify2=_interopRequireDefault(_stringify);function _interopRequireDefault(obj){return obj&&obj.__esModule?obj:{default:obj}}exports.default={parse:_parse2.default,stringify:_stringify2.default};module.exports=exports['default'];

node_modules/eslint-loader/node_modules/json5/lib/register.js

@@ -0,0 +1 @@
+'use strict';var _fs=require('fs');var _fs2=_interopRequireDefault(_fs);var _=require('./');var _2=_interopRequireDefault(_);function _interopRequireDefault(obj){return obj&&obj.__esModule?obj:{default:obj}}require.extensions['.json5']=function(module,filename){var content=_fs2.default.readFileSync(filename,'utf8');try{module.exports=_2.default.parse(content)}catch(err){err.message=filename+': '+err.message;throw err}};

node_modules/eslint-loader/node_modules/json5/lib/require.js

@@ -0,0 +1 @@
+"use strict";require("./register");console.warn("'json5/require' is deprecated. Please use 'json5/register' instead.");

node_modules/eslint-loader/node_modules/json5/lib/util.js

@@ -0,0 +1 @@
+'use strict';Object.defineProperty(exports,'__esModule',{value:true});exports.isSpaceSeparator=isSpaceSeparator;exports.isIdStartChar=isIdStartChar;exports.isIdContinueChar=isIdContinueChar;exports.isDigit=isDigit;exports.isHexDigit=isHexDigit;var _unicode=require('../lib/unicode');var unicode=_interopRequireWildcard(_unicode);function _interopRequireWildcard(obj){if(obj&&obj.__esModule){return obj}else{var newObj={};if(obj!=null){for(var key in obj){if(Object.prototype.hasOwnProperty.call(obj,key))newObj[key]=obj[key]}}newObj.default=obj;return newObj}}function isSpaceSeparator(c){return unicode.Space_Separator.test(c)}function isIdStartChar(c){return c>='a'&&c<='z'||c>='A'&&c<='Z'||c==='$'||c==='_'||unicode.ID_Start.test(c)}function isIdContinueChar(c){return c>='a'&&c<='z'||c>='A'&&c<='Z'||c>='0'&&c<='9'||c==='$'||c==='_'||c==='\u200C'||c==='\u200D'||unicode.ID_Continue.test(c)}function isDigit(c){return /[0-9]/.test(c)}function isHexDigit(c){return /[0-9A-Fa-f]/.test(c)}

node_modules/eslint-loader/node_modules/json5/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "json5",
+  "version": "1.0.2",
+  "description": "JSON for humans.",
+  "main": "lib/index.js",
+  "bin": "lib/cli.js",
+  "browser": "dist/index.js",
+  "files": [
+    "lib/",
+    "dist/"
+  ],
+  "scripts": {
+    "build": "babel-node build/build.js && babel src -d lib && rollup -c",
+    "coverage": "nyc report --reporter=text-lcov | coveralls",
+    "lint": "eslint --fix build src",
+    "prepublishOnly": "npm run lint && npm test && npm run production",
+    "pretest": "cross-env NODE_ENV=test npm run build",
+    "preversion": "npm run lint && npm test && npm run production",
+    "production": "cross-env NODE_ENV=production npm run build",
+    "test": "nyc --reporter=html --reporter=text mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/json5/json5.git"
+  },
+  "keywords": [
+    "json",
+    "json5",
+    "es5",
+    "es2015",
+    "ecmascript"
+  ],
+  "author": "Aseem Kishore <aseem.kishore@gmail.com>",
+  "contributors": [
+    "Max Nanasy <max.nanasy@gmail.com>",
+    "Andrew Eisenberg <andrew@eisenberg.as>",
+    "Jordan Tucker <jordanbtucker@gmail.com>"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/json5/json5/issues"
+  },
+  "homepage": "http://json5.org/",
+  "dependencies": {
+    "minimist": "^1.2.0"
+  },
+  "devDependencies": {
+    "babel-cli": "^6.26.0",
+    "babel-core": "^6.26.0",
+    "babel-plugin-add-module-exports": "^0.2.1",
+    "babel-plugin-external-helpers": "^6.22.0",
+    "babel-plugin-istanbul": "^4.1.5",
+    "babel-preset-env": "^1.6.1",
+    "babel-register": "^6.26.0",
+    "babelrc-rollup": "^3.0.0",
+    "coveralls": "^3.0.0",
+    "cross-env": "^5.1.4",
+    "del": "^3.0.0",
+    "eslint": "^4.18.2",
+    "eslint-config-standard": "^11.0.0",
+    "eslint-plugin-import": "^2.9.0",
+    "eslint-plugin-node": "^6.0.1",
+    "eslint-plugin-promise": "^3.7.0",
+    "eslint-plugin-standard": "^3.0.1",
+    "mocha": "^5.0.4",
+    "nyc": "^11.4.1",
+    "regenerate": "^1.3.3",
+    "rollup": "^0.56.5",
+    "rollup-plugin-babel": "^3.0.3",
+    "rollup-plugin-commonjs": "^9.0.0",
+    "rollup-plugin-node-resolve": "^3.2.0",
+    "rollup-plugin-uglify": "^3.0.0",
+    "sinon": "^4.4.2",
+    "unicode-9.0.0": "^0.7.5"
+  }
+}

node_modules/eslint-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/eslint-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 md5 hash)
+* `[<hashType>:contenthash:<digestType>:<length>]` optionally one can configure
+  * other `hashType`s, i. e. `sha1`, `md5`, `sha256`, `sha512`
+  * other `digestType`s, i. e. `hex`, `base26`, `base32`, `base36`, `base49`, `base52`, `base58`, `base62`, `base64`
+  * and `length` the length in chars
+* `[hash]` the hash of `options.content` (Buffer) (by default it's the hex digest of the md5 hash)
+* `[<hashType>:hash:<digestType>:<length>]` optionally one can configure
+  * other `hashType`s, i. e. `sha1`, `md5`, `sha256`, `sha512`
+  * other `digestType`s, i. e. `hex`, `base26`, `base32`, `base36`, `base49`, `base52`, `base58`, `base62`, `base64`
+  * and `length` the length in chars
+* `[N]` the N-th match obtained from matching the current file name against `options.regExp`
+
+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 md5 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`, `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/eslint-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/eslint-loader/node_modules/loader-utils/lib/getHashDigest.js

@@ -0,0 +1,69 @@
+'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;
+}
+
+function getHashDigest(buffer, hashType, digestType, maxLength) {
+  hashType = hashType || 'md5';
+  maxLength = maxLength || 9999;
+
+  const hash = require('crypto').createHash(hashType);
+
+  hash.update(buffer);
+
+  if (
+    digestType === 'base26' ||
+    digestType === 'base32' ||
+    digestType === 'base36' ||
+    digestType === 'base49' ||
+    digestType === 'base52' ||
+    digestType === 'base58' ||
+    digestType === 'base62' ||
+    digestType === 'base64'
+  ) {
+    return encodeBufferToBase(hash.digest(), digestType.substr(4)).substr(
+      0,
+      maxLength
+    );
+  } else {
+    return hash.digest(digestType || 'hex').substr(0, maxLength);
+  }
+}
+
+module.exports = getHashDigest;

node_modules/eslint-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 null;
+  }
+
+  return query;
+}
+
+module.exports = getOptions;

node_modules/eslint-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/eslint-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/eslint-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/eslint-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/eslint-loader/node_modules/loader-utils/lib/parseQuery.js

@@ -0,0 +1,68 @@
+'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));
+
+      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/eslint-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/eslint-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/eslint-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/eslint-loader/node_modules/loader-utils/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "loader-utils",
+  "version": "1.4.2",
+  "author": "Tobias Koppers @sokra",
+  "description": "utils for webpack loaders",
+  "dependencies": {
+    "big.js": "^5.2.2",
+    "emojis-list": "^3.0.0",
+    "json5": "^1.0.1"
+  },
+  "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": ">=4.0.0"
+  },
+  "devDependencies": {
+    "coveralls": "^3.0.2",
+    "eslint": "^5.11.0",
+    "eslint-plugin-node": "^8.0.0",
+    "eslint-plugin-prettier": "^3.0.0",
+    "jest": "^21.2.1",
+    "prettier": "^1.19.1",
+    "standard-version": "^4.0.0"
+  },
+  "main": "lib/index.js",
+  "files": [
+    "lib"
+  ]
+}

node_modules/eslint-loader/node_modules/rimraf/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

node_modules/eslint-loader/node_modules/rimraf/README.md

@@ -0,0 +1,101 @@
+[![Build Status](https://travis-ci.org/isaacs/rimraf.svg?branch=master)](https://travis-ci.org/isaacs/rimraf) [![Dependency Status](https://david-dm.org/isaacs/rimraf.svg)](https://david-dm.org/isaacs/rimraf) [![devDependency Status](https://david-dm.org/isaacs/rimraf/dev-status.svg)](https://david-dm.org/isaacs/rimraf#info=devDependencies)
+
+The [UNIX command](http://en.wikipedia.org/wiki/Rm_(Unix)) `rm -rf` for node.
+
+Install with `npm install rimraf`, or just drop rimraf.js somewhere.
+
+## API
+
+`rimraf(f, [opts], callback)`
+
+The first parameter will be interpreted as a globbing pattern for files. If you
+want to disable globbing you can do so with `opts.disableGlob` (defaults to
+`false`). This might be handy, for instance, if you have filenames that contain
+globbing wildcard characters.
+
+The callback will be called with an error if there is one.  Certain
+errors are handled for you:
+
+* Windows: `EBUSY` and `ENOTEMPTY` - rimraf will back off a maximum of
+  `opts.maxBusyTries` times before giving up, adding 100ms of wait
+  between each attempt.  The default `maxBusyTries` is 3.
+* `ENOENT` - If the file doesn't exist, rimraf will return
+  successfully, since your desired outcome is already the case.
+* `EMFILE` - Since `readdir` requires opening a file descriptor, it's
+  possible to hit `EMFILE` if too many file descriptors are in use.
+  In the sync case, there's nothing to be done for this.  But in the
+  async case, rimraf will gradually back off with timeouts up to
+  `opts.emfileWait` ms, which defaults to 1000.
+
+## options
+
+* unlink, chmod, stat, lstat, rmdir, readdir,
+  unlinkSync, chmodSync, statSync, lstatSync, rmdirSync, readdirSync
+
+    In order to use a custom file system library, you can override
+    specific fs functions on the options object.
+
+    If any of these functions are present on the options object, then
+    the supplied function will be used instead of the default fs
+    method.
+
+    Sync methods are only relevant for `rimraf.sync()`, of course.
+
+    For example:
+
+    ```javascript
+    var myCustomFS = require('some-custom-fs')
+
+    rimraf('some-thing', myCustomFS, callback)
+    ```
+
+* maxBusyTries
+
+    If an `EBUSY`, `ENOTEMPTY`, or `EPERM` error code is encountered
+    on Windows systems, then rimraf will retry with a linear backoff
+    wait of 100ms longer on each try.  The default maxBusyTries is 3.
+
+    Only relevant for async usage.
+
+* emfileWait
+
+    If an `EMFILE` error is encountered, then rimraf will retry
+    repeatedly with a linear backoff of 1ms longer on each try, until
+    the timeout counter hits this max.  The default limit is 1000.
+
+    If you repeatedly encounter `EMFILE` errors, then consider using
+    [graceful-fs](http://npm.im/graceful-fs) in your program.
+
+    Only relevant for async usage.
+
+* glob
+
+    Set to `false` to disable [glob](http://npm.im/glob) pattern
+    matching.
+
+    Set to an object to pass options to the glob module.  The default
+    glob options are `{ nosort: true, silent: true }`.
+
+    Glob version 6 is used in this module.
+
+    Relevant for both sync and async usage.
+
+* disableGlob
+
+    Set to any non-falsey value to disable globbing entirely.
+    (Equivalent to setting `glob: false`.)
+
+## rimraf.sync
+
+It can remove stuff synchronously, too.  But that's not so good.  Use
+the async API.  It's better.
+
+## CLI
+
+If installed with `npm install rimraf -g` it can be used as a global
+command `rimraf <path> [<path> ...]` which is useful for cross platform support.
+
+## mkdirp
+
+If you need to create a directory recursively, check out
+[mkdirp](https://github.com/substack/node-mkdirp).

node_modules/eslint-loader/node_modules/rimraf/bin.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+var rimraf = require('./')
+
+var help = false
+var dashdash = false
+var noglob = false
+var args = process.argv.slice(2).filter(function(arg) {
+  if (dashdash)
+    return !!arg
+  else if (arg === '--')
+    dashdash = true
+  else if (arg === '--no-glob' || arg === '-G')
+    noglob = true
+  else if (arg === '--glob' || arg === '-g')
+    noglob = false
+  else if (arg.match(/^(-+|\/)(h(elp)?|\?)$/))
+    help = true
+  else
+    return !!arg
+})
+
+if (help || args.length === 0) {
+  // If they didn't ask for help, then this is not a "success"
+  var log = help ? console.log : console.error
+  log('Usage: rimraf <path> [<path> ...]')
+  log('')
+  log('  Deletes all files and folders at "path" recursively.')
+  log('')
+  log('Options:')
+  log('')
+  log('  -h, --help     Display this usage info')
+  log('  -G, --no-glob  Do not expand glob patterns in arguments')
+  log('  -g, --glob     Expand glob patterns in arguments (default)')
+  process.exit(help ? 0 : 1)
+} else
+  go(0)
+
+function go (n) {
+  if (n >= args.length)
+    return
+  var options = {}
+  if (noglob)
+    options = { glob: false }
+  rimraf(args[n], options, function (er) {
+    if (er)
+      throw er
+    go(n+1)
+  })
+}

node_modules/eslint-loader/node_modules/rimraf/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "rimraf",
+  "version": "2.7.1",
+  "main": "rimraf.js",
+  "description": "A deep deletion module for node (like `rm -rf`)",
+  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",
+  "license": "ISC",
+  "repository": "git://github.com/isaacs/rimraf.git",
+  "scripts": {
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "postpublish": "git push origin --all; git push origin --tags",
+    "test": "tap test/*.js"
+  },
+  "bin": "./bin.js",
+  "dependencies": {
+    "glob": "^7.1.3"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "bin.js",
+    "rimraf.js"
+  ],
+  "devDependencies": {
+    "mkdirp": "^0.5.1",
+    "tap": "^12.1.1"
+  }
+}

node_modules/eslint-loader/node_modules/rimraf/rimraf.js

@@ -0,0 +1,372 @@
+module.exports = rimraf
+rimraf.sync = rimrafSync
+
+var assert = require("assert")
+var path = require("path")
+var fs = require("fs")
+var glob = undefined
+try {
+  glob = require("glob")
+} catch (_err) {
+  // treat glob as optional.
+}
+var _0666 = parseInt('666', 8)
+
+var defaultGlobOpts = {
+  nosort: true,
+  silent: true
+}
+
+// for EMFILE handling
+var timeout = 0
+
+var isWindows = (process.platform === "win32")
+
+function defaults (options) {
+  var methods = [
+    'unlink',
+    'chmod',
+    'stat',
+    'lstat',
+    'rmdir',
+    'readdir'
+  ]
+  methods.forEach(function(m) {
+    options[m] = options[m] || fs[m]
+    m = m + 'Sync'
+    options[m] = options[m] || fs[m]
+  })
+
+  options.maxBusyTries = options.maxBusyTries || 3
+  options.emfileWait = options.emfileWait || 1000
+  if (options.glob === false) {
+    options.disableGlob = true
+  }
+  if (options.disableGlob !== true && glob === undefined) {
+    throw Error('glob dependency not found, set `options.disableGlob = true` if intentional')
+  }
+  options.disableGlob = options.disableGlob || false
+  options.glob = options.glob || defaultGlobOpts
+}
+
+function rimraf (p, options, cb) {
+  if (typeof options === 'function') {
+    cb = options
+    options = {}
+  }
+
+  assert(p, 'rimraf: missing path')
+  assert.equal(typeof p, 'string', 'rimraf: path should be a string')
+  assert.equal(typeof cb, 'function', 'rimraf: callback function required')
+  assert(options, 'rimraf: invalid options argument provided')
+  assert.equal(typeof options, 'object', 'rimraf: options should be object')
+
+  defaults(options)
+
+  var busyTries = 0
+  var errState = null
+  var n = 0
+
+  if (options.disableGlob || !glob.hasMagic(p))
+    return afterGlob(null, [p])
+
+  options.lstat(p, function (er, stat) {
+    if (!er)
+      return afterGlob(null, [p])
+
+    glob(p, options.glob, afterGlob)
+  })
+
+  function next (er) {
+    errState = errState || er
+    if (--n === 0)
+      cb(errState)
+  }
+
+  function afterGlob (er, results) {
+    if (er)
+      return cb(er)
+
+    n = results.length
+    if (n === 0)
+      return cb()
+
+    results.forEach(function (p) {
+      rimraf_(p, options, function CB (er) {
+        if (er) {
+          if ((er.code === "EBUSY" || er.code === "ENOTEMPTY" || er.code === "EPERM") &&
+              busyTries < options.maxBusyTries) {
+            busyTries ++
+            var time = busyTries * 100
+            // try again, with the same exact callback as this one.
+            return setTimeout(function () {
+              rimraf_(p, options, CB)
+            }, time)
+          }
+
+          // this one won't happen if graceful-fs is used.
+          if (er.code === "EMFILE" && timeout < options.emfileWait) {
+            return setTimeout(function () {
+              rimraf_(p, options, CB)
+            }, timeout ++)
+          }
+
+          // already gone
+          if (er.code === "ENOENT") er = null
+        }
+
+        timeout = 0
+        next(er)
+      })
+    })
+  }
+}
+
+// Two possible strategies.
+// 1. Assume it's a file.  unlink it, then do the dir stuff on EPERM or EISDIR
+// 2. Assume it's a directory.  readdir, then do the file stuff on ENOTDIR
+//
+// Both result in an extra syscall when you guess wrong.  However, there
+// are likely far more normal files in the world than directories.  This
+// is based on the assumption that a the average number of files per
+// directory is >= 1.
+//
+// If anyone ever complains about this, then I guess the strategy could
+// be made configurable somehow.  But until then, YAGNI.
+function rimraf_ (p, options, cb) {
+  assert(p)
+  assert(options)
+  assert(typeof cb === 'function')
+
+  // sunos lets the root user unlink directories, which is... weird.
+  // so we have to lstat here and make sure it's not a dir.
+  options.lstat(p, function (er, st) {
+    if (er && er.code === "ENOENT")
+      return cb(null)
+
+    // Windows can EPERM on stat.  Life is suffering.
+    if (er && er.code === "EPERM" && isWindows)
+      fixWinEPERM(p, options, er, cb)
+
+    if (st && st.isDirectory())
+      return rmdir(p, options, er, cb)
+
+    options.unlink(p, function (er) {
+      if (er) {
+        if (er.code === "ENOENT")
+          return cb(null)
+        if (er.code === "EPERM")
+          return (isWindows)
+            ? fixWinEPERM(p, options, er, cb)
+            : rmdir(p, options, er, cb)
+        if (er.code === "EISDIR")
+          return rmdir(p, options, er, cb)
+      }
+      return cb(er)
+    })
+  })
+}
+
+function fixWinEPERM (p, options, er, cb) {
+  assert(p)
+  assert(options)
+  assert(typeof cb === 'function')
+  if (er)
+    assert(er instanceof Error)
+
+  options.chmod(p, _0666, function (er2) {
+    if (er2)
+      cb(er2.code === "ENOENT" ? null : er)
+    else
+      options.stat(p, function(er3, stats) {
+        if (er3)
+          cb(er3.code === "ENOENT" ? null : er)
+        else if (stats.isDirectory())
+          rmdir(p, options, er, cb)
+        else
+          options.unlink(p, cb)
+      })
+  })
+}
+
+function fixWinEPERMSync (p, options, er) {
+  assert(p)
+  assert(options)
+  if (er)
+    assert(er instanceof Error)
+
+  try {
+    options.chmodSync(p, _0666)
+  } catch (er2) {
+    if (er2.code === "ENOENT")
+      return
+    else
+      throw er
+  }
+
+  try {
+    var stats = options.statSync(p)
+  } catch (er3) {
+    if (er3.code === "ENOENT")
+      return
+    else
+      throw er
+  }
+
+  if (stats.isDirectory())
+    rmdirSync(p, options, er)
+  else
+    options.unlinkSync(p)
+}
+
+function rmdir (p, options, originalEr, cb) {
+  assert(p)
+  assert(options)
+  if (originalEr)
+    assert(originalEr instanceof Error)
+  assert(typeof cb === 'function')
+
+  // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)
+  // if we guessed wrong, and it's not a directory, then
+  // raise the original error.
+  options.rmdir(p, function (er) {
+    if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM"))
+      rmkids(p, options, cb)
+    else if (er && er.code === "ENOTDIR")
+      cb(originalEr)
+    else
+      cb(er)
+  })
+}
+
+function rmkids(p, options, cb) {
+  assert(p)
+  assert(options)
+  assert(typeof cb === 'function')
+
+  options.readdir(p, function (er, files) {
+    if (er)
+      return cb(er)
+    var n = files.length
+    if (n === 0)
+      return options.rmdir(p, cb)
+    var errState
+    files.forEach(function (f) {
+      rimraf(path.join(p, f), options, function (er) {
+        if (errState)
+          return
+        if (er)
+          return cb(errState = er)
+        if (--n === 0)
+          options.rmdir(p, cb)
+      })
+    })
+  })
+}
+
+// this looks simpler, and is strictly *faster*, but will
+// tie up the JavaScript thread and fail on excessively
+// deep directory trees.
+function rimrafSync (p, options) {
+  options = options || {}
+  defaults(options)
+
+  assert(p, 'rimraf: missing path')
+  assert.equal(typeof p, 'string', 'rimraf: path should be a string')
+  assert(options, 'rimraf: missing options')
+  assert.equal(typeof options, 'object', 'rimraf: options should be object')
+
+  var results
+
+  if (options.disableGlob || !glob.hasMagic(p)) {
+    results = [p]
+  } else {
+    try {
+      options.lstatSync(p)
+      results = [p]
+    } catch (er) {
+      results = glob.sync(p, options.glob)
+    }
+  }
+
+  if (!results.length)
+    return
+
+  for (var i = 0; i < results.length; i++) {
+    var p = results[i]
+
+    try {
+      var st = options.lstatSync(p)
+    } catch (er) {
+      if (er.code === "ENOENT")
+        return
+
+      // Windows can EPERM on stat.  Life is suffering.
+      if (er.code === "EPERM" && isWindows)
+        fixWinEPERMSync(p, options, er)
+    }
+
+    try {
+      // sunos lets the root user unlink directories, which is... weird.
+      if (st && st.isDirectory())
+        rmdirSync(p, options, null)
+      else
+        options.unlinkSync(p)
+    } catch (er) {
+      if (er.code === "ENOENT")
+        return
+      if (er.code === "EPERM")
+        return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)
+      if (er.code !== "EISDIR")
+        throw er
+
+      rmdirSync(p, options, er)
+    }
+  }
+}
+
+function rmdirSync (p, options, originalEr) {
+  assert(p)
+  assert(options)
+  if (originalEr)
+    assert(originalEr instanceof Error)
+
+  try {
+    options.rmdirSync(p)
+  } catch (er) {
+    if (er.code === "ENOENT")
+      return
+    if (er.code === "ENOTDIR")
+      throw originalEr
+    if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")
+      rmkidsSync(p, options)
+  }
+}
+
+function rmkidsSync (p, options) {
+  assert(p)
+  assert(options)
+  options.readdirSync(p).forEach(function (f) {
+    rimrafSync(path.join(p, f), options)
+  })
+
+  // We only end up here once we got ENOTEMPTY at least once, and
+  // at this point, we are guaranteed to have removed all the kids.
+  // So, we know that it won't be ENOENT or ENOTDIR or anything else.
+  // try really hard to delete stuff on windows, because it has a
+  // PROFOUNDLY annoying habit of not closing handles promptly when
+  // files are deleted, resulting in spurious ENOTEMPTY errors.
+  var retries = isWindows ? 100 : 1
+  var i = 0
+  do {
+    var threw = true
+    try {
+      var ret = options.rmdirSync(p, options)
+      threw = false
+      return ret
+    } finally {
+      if (++i < retries && threw)
+        continue
+    }
+  } while (true)
+}

node_modules/eslint-loader/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "eslint-loader",
+  "version": "2.2.1",
+  "description": "eslint loader (for webpack)",
+  "keywords": [
+    "lint",
+    "linter",
+    "eslint",
+    "loader",
+    "webpack"
+  ],
+  "repository": "https://github.com/webpack-contrib/eslint-loader.git",
+  "author": "Maxime Thirouin",
+  "license": "MIT",
+  "files": [
+    "index.js"
+  ],
+  "peerDependencies": {
+    "eslint": ">=1.6.0 <7.0.0",
+    "webpack": ">=2.0.0 <5.0.0"
+  },
+  "dependencies": {
+    "loader-fs-cache": "^1.0.0",
+    "loader-utils": "^1.0.2",
+    "object-assign": "^4.0.1",
+    "object-hash": "^1.1.4",
+    "rimraf": "^2.6.1"
+  },
+  "devDependencies": {
+    "ava": "^0.17.0",
+    "eslint": "^6.0.1",
+    "eslint-config-i-am-meticulous": "^11.0.0",
+    "eslint-friendly-formatter": "^2.0.4",
+    "husky": "^0.14.3",
+    "mkdirp": "^0.5.1",
+    "npmpub": "^4.0.1",
+    "prettier": "^1.13.7",
+    "pretty-quick": "^1.6.0",
+    "webpack": "^4.0.0"
+  },
+  "scripts": {
+    "precommit": "pretty-quick --staged",
+    "lint": "eslint .",
+    "ava": "ava",
+    "test": "npm run lint && npm run ava",
+    "release": "npmpub"
+  },
+  "eslintConfig": {
+    "extends": "eslint-config-i-am-meticulous",
+    "rules": {
+      "no-var": 0,
+      "prefer-const": 0
+    }
+  },
+  "ava": {
+    "files": [
+      "test/*.js"
+    ],
+    "verbose": true
+  }
+}