update

2022-07-18 02:50:52 +00:00
parent befd344ab0
commit 06181b34d6
8569 changed files with 818704 additions and 352705 deletions
@@ -1,7 +1,48 @@
-# Change Log
+# 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.0.4](https://github.com/webpack-contrib/thread-loader/compare/v3.0.3...v3.0.4) (2021-05-10)
+
+
+### Bug Fixes
+
+* do not crash on `this.addBuildDependency` usage ([#117](https://github.com/webpack-contrib/thread-loader/issues/117)) ([1c7a8a2](https://github.com/webpack-contrib/thread-loader/commit/1c7a8a2454c7540a226b2a7fa6e0cbfef6ebf2c6))
+* `this.addMissingDependency` works fine ([#119](https://github.com/webpack-contrib/thread-loader/issues/119)) ([5a0ea0c](https://github.com/webpack-contrib/thread-loader/commit/5a0ea0c4239e69cffd68e79a01f9615250c66755))
+
+### [3.0.3](https://github.com/webpack-contrib/thread-loader/compare/v3.0.2...v3.0.3) (2021-04-13)
+
+
+### Bug Fixes
+
+* `getOptions` usage ([#113](https://github.com/webpack-contrib/thread-loader/issues/113)) ([d7531ef](https://github.com/webpack-contrib/thread-loader/commit/d7531efd39b90eff3e6cdd5e6917997f5b392bff))
+
+### [3.0.2](https://github.com/webpack-contrib/thread-loader/compare/v3.0.1...v3.0.2) (2021-04-12)
+
+
+### Bug Fixes
+
+* support serialization of RegExp ([#102](https://github.com/webpack-contrib/thread-loader/issues/102)) ([3766560](https://github.com/webpack-contrib/thread-loader/commit/37665608bea01c4072fa974b038de1352a82961c))
+
+### [3.0.1](https://github.com/webpack-contrib/thread-loader/compare/v3.0.0...v3.0.1) (2020-10-27)
+
+
+### Bug Fixes
+
+* pass rootContext to loaders ([#104](https://github.com/webpack-contrib/thread-loader/issues/104)) ([8e56785](https://github.com/webpack-contrib/thread-loader/commit/8e567853efa3a0d6b95423d3598a68ad77598bc4))
+
+## [3.0.0](https://github.com/webpack-contrib/thread-loader/compare/v2.1.3...v3.0.0) (2020-09-12)
+
+
+### ⚠ BREAKING CHANGES
+
+* minimum supported `Node.js` version is `10.13`
+
+### Bug Fixes
+
+* `loadModule` and `fs` are now available in a loader context ([#88](https://github.com/webpack-contrib/thread-loader/issues/88)) ([ea5c9ad](https://github.com/webpack-contrib/thread-loader/commit/ea5c9ad8ffd3898e1fe136cc3cf371b3d15e3f97))
+* `getResolve` is now available in a loader context ([#99](https://github.com/webpack-contrib/thread-loader/issues/99)) ([16bbc23](https://github.com/webpack-contrib/thread-loader/commit/16bbc236dfdc26c857c97c8c005bbad6883c49ed))
+
 <a name="2.1.3"></a>
 ## [2.1.3](https://github.com/webpack-contrib/thread-loader/compare/v2.1.2...v2.1.3) (2019-08-08)

@@ -1,38 +1,40 @@
-[![npm][npm]][npm-url]
-[![deps][deps]][deps-url]
-[![test][test]][test-url]
-[![coverage][cover]][cover-url]
-[![chat][chat]][chat-url]
-
 <div align="center">
  <a href="https://webpack.js.org/">
    <img width="200" height="200" vspace="" hspace="25" src="https://cdn.rawgit.com/webpack/media/e7485eb2/logo/icon-square-big.svg">
  </a>
-  <h1>thread-loader</h1>
-  <p>Runs the following loaders in a worker pool.</p>
 </div>

-<h2 align="center">Install</h2>
+[![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]
+
+# thread-loader
+
+Runs the following loaders in a worker pool.
+
+## Getting Started

 ```bash
 npm install --save-dev thread-loader
 ```

-<h2 align="center">Usage</h2>
-
 Put this loader in front of other loaders. The following loaders run in a worker pool.

 Loaders running in a worker pool are limited. Examples:

-* Loaders cannot emit files.
-* Loaders cannot use custom loader API (i. e. by plugins).
-* Loaders cannot access the webpack options.
+- Loaders cannot emit files.
+- Loaders cannot use custom loader API (i. e. by plugins).
+- Loaders cannot access the webpack options.

 Each worker is a separate node.js process, which has an overhead of ~600ms. There is also an overhead of inter-process communication.

 Use this loader only for expensive operations!

-<h2 align="center">Examples</h2>
+### Examples

 **webpack.config.js**

@@ -42,15 +44,15 @@ module.exports = {
    rules: [
      {
        test: /\.js$/,
-        include: path.resolve("src"),
+        include: path.resolve('src'),
        use: [
-          "thread-loader",
+          'thread-loader',
          // your expensive loader (e.g babel-loader)
-        ]
-      }
-    ]
-  }
-}
+        ],
+      },
+    ],
+  },
+};
 ```

 **with options**
@@ -58,7 +60,7 @@ module.exports = {
 ```js
 use: [
  {
-    loader: "thread-loader",
+    loader: 'thread-loader',
    // loaders with equal options will share worker pools
    options: {
      // the number of spawned workers, defaults to (number of cpus - 1) or
@@ -89,11 +91,11 @@ use: [

      // name of the pool
      // can be used to create different pools with elsewise identical options
-      name: "my-pool"
-    }
+      name: 'my-pool',
+    },
  },
  // your expensive loader (e.g babel-loader)
-]
+];
 ```

 **prewarming**
@@ -102,50 +104,45 @@ To prevent the high delay when booting workers it possible to warmup the worker

 This boots the max number of workers in the pool and loads specified modules into the node.js module cache.

-``` js
+```js
 const threadLoader = require('thread-loader');

-threadLoader.warmup({
-  // pool options, like passed to loader options
-  // must match loader options to boot the correct pool
-}, [
-  // modules to load
-  // can be any module, i. e.
-  'babel-loader',
-  'babel-preset-es2015',
-  'sass-loader',
-]);
+threadLoader.warmup(
+  {
+    // pool options, like passed to loader options
+    // must match loader options to boot the correct pool
+  },
+  [
+    // modules to load
+    // can be any module, i. e.
+    'babel-loader',
+    'babel-preset-es2015',
+    'sass-loader',
+  ]
+);
 ```

+## Contributing

-<h2 align="center">Maintainers</h2>
+Please take a moment to read our contributing guidelines if you haven't yet done so.

-<table>
-  <tbody>
-    <tr>
-      <td align="center">
-        <a href="https://github.com/sokra">
-          <img width="150" height="150" src="https://github.com/sokra.png?size=150">
-          </br>
-          sokra
-        </a>
-      </td>
-    </tr>
-  <tbody>
-</table>
+[CONTRIBUTING](./.github/CONTRIBUTING.md)

+## License
+
+[MIT](./LICENSE)

 [npm]: https://img.shields.io/npm/v/thread-loader.svg
 [npm-url]: https://npmjs.com/package/thread-loader
-
+[node]: https://img.shields.io/node/v/thread-loader.svg
+[node-url]: https://nodejs.org
 [deps]: https://david-dm.org/webpack-contrib/thread-loader.svg
 [deps-url]: https://david-dm.org/webpack-contrib/thread-loader
-
-[chat]: https://img.shields.io/badge/gitter-webpack%2Fwebpack-brightgreen.svg
-[chat-url]: https://gitter.im/webpack/webpack
-
-[test]: http://img.shields.io/travis/webpack-contrib/thread-loader.svg
-[test-url]: https://travis-ci.org/webpack-contrib/thread-loader
-
+[tests]: https://github.com/webpack-contrib/thread-loader/workflows/thread-loader/badge.svg
+[tests-url]: https://github.com/webpack-contrib/thread-loader/actions
 [cover]: https://codecov.io/gh/webpack-contrib/thread-loader/branch/master/graph/badge.svg
 [cover-url]: https://codecov.io/gh/webpack-contrib/thread-loader
+[chat]: https://badges.gitter.im/webpack/webpack.svg
+[chat-url]: https://gitter.im/webpack/webpack
+[size]: https://packagephobia.now.sh/badge?p=thread-loader
+[size-url]: https://packagephobia.now.sh/result?p=thread-loader
@@ -1,19 +1,17 @@
-'use strict';
+"use strict";

 Object.defineProperty(exports, "__esModule", {
  value: true
 });
+exports.default = void 0;
+
 const stack = (err, worker, workerId) => {
  const originError = (err.stack || '').split('\n').filter(line => line.trim().startsWith('at'));
-
  const workerError = worker.split('\n').filter(line => line.trim().startsWith('at'));
-
  const diff = workerError.slice(0, workerError.length - originError.length).join('\n');
-
  originError.unshift(diff);
  originError.unshift(err.message);
  originError.unshift(`Thread Loader (Worker ${workerId})`);
-
  return originError.join('\n');
 };

@@ -22,11 +20,11 @@ class WorkerError extends Error {
    super(err);
    this.name = err.name;
    this.message = err.message;
-
    Error.captureStackTrace(this, this.constructor);
-
    this.stack = stack(err, this.stack, workerId);
  }
+
 }

-exports.default = WorkerError;
+var _default = WorkerError;
+exports.default = _default;
@@ -1,32 +1,26 @@
-'use strict';
+"use strict";

 Object.defineProperty(exports, "__esModule", {
  value: true
 });
+exports.default = void 0;

-var _child_process = require('child_process');
+var _child_process = _interopRequireDefault(require("child_process"));

-var _child_process2 = _interopRequireDefault(_child_process);
+var _queue = _interopRequireDefault(require("neo-async/queue"));

-var _queue = require('neo-async/queue');
+var _mapSeries = _interopRequireDefault(require("neo-async/mapSeries"));

-var _queue2 = _interopRequireDefault(_queue);
+var _readBuffer = _interopRequireDefault(require("./readBuffer"));

-var _mapSeries = require('neo-async/mapSeries');
+var _WorkerError = _interopRequireDefault(require("./WorkerError"));

-var _mapSeries2 = _interopRequireDefault(_mapSeries);
-
-var _readBuffer = require('./readBuffer');
-
-var _readBuffer2 = _interopRequireDefault(_readBuffer);
-
-var _WorkerError = require('./WorkerError');
-
-var _WorkerError2 = _interopRequireDefault(_WorkerError);
+var _serializer = require("./serializer");

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

-const workerPath = require.resolve('./worker'); /* eslint-disable no-console */
+/* eslint-disable no-console */
+const workerPath = require.resolve('./worker');

 let workerId = 0;

@@ -38,21 +32,17 @@ class PoolWorker {
    this.activeJobs = 0;
    this.onJobDone = onJobDone;
    this.id = workerId;
+    workerId += 1; // Empty or invalid node args would break the child process

-    workerId += 1;
-    // Empty or invalid node args would break the child process
    const sanitizedNodeArgs = (options.nodeArgs || []).filter(opt => !!opt);
-
-    this.worker = _child_process2.default.spawn(process.execPath, [].concat(sanitizedNodeArgs).concat(workerPath, options.parallelJobs), {
+    this.worker = _child_process.default.spawn(process.execPath, [].concat(sanitizedNodeArgs).concat(workerPath, options.parallelJobs), {
      detached: true,
      stdio: ['ignore', 'pipe', 'pipe', 'pipe', 'pipe']
    });
-
-    this.worker.unref();
-
-    // This prevents a problem where the worker stdio can be undefined
+    this.worker.unref(); // This prevents a problem where the worker stdio can be undefined
    // when the kernel hits the limit of open files.
    // More info can be found on: https://github.com/webpack-contrib/thread-loader/issues/2
+
    if (!this.worker.stdio) {
      throw new Error(`Failed to create the worker pool with workerId: ${workerId} and ${''}configuration: ${JSON.stringify(options)}. Please verify if you hit the OS open files limit.`);
    }
@@ -99,7 +89,10 @@ class PoolWorker {
  run(data, callback) {
    const jobId = this.nextJobId;
    this.nextJobId += 1;
-    this.jobs[jobId] = { data, callback };
+    this.jobs[jobId] = {
+      data,
+      callback
+    };
    this.activeJobs += 1;
    this.writeJson({
      type: 'job',
@@ -117,7 +110,7 @@ class PoolWorker {

  writeJson(data) {
    const lengthBuffer = Buffer.alloc(4);
-    const messageBuffer = Buffer.from(JSON.stringify(data), 'utf-8');
+    const messageBuffer = Buffer.from(JSON.stringify(data, _serializer.replacer), 'utf-8');
    lengthBuffer.writeInt32BE(messageBuffer.length, 0);
    this.writePipe.write(lengthBuffer);
    this.writePipe.write(messageBuffer);
@@ -136,24 +129,26 @@ class PoolWorker {
        console.error(`Failed to communicate with worker (read length) ${lengthReadError}`);
        return;
      }
+
      this.state = 'length read';
      const length = lengthBuffer.readInt32BE(0);
-
      this.state = 'read message';
      this.readBuffer(length, (messageError, messageBuffer) => {
        if (messageError) {
          console.error(`Failed to communicate with worker (read message) ${messageError}`);
          return;
        }
+
        this.state = 'message read';
        const messageString = messageBuffer.toString('utf-8');
-        const message = JSON.parse(messageString);
+        const message = JSON.parse(messageString, _serializer.reviver);
        this.state = 'process message';
        this.onWorkerMessage(message, err => {
          if (err) {
            console.error(`Failed to communicate with worker (process message) ${err}`);
            return;
          }
+
          this.state = 'soon next';
          setImmediate(() => this.readNextMessage());
        });
@@ -162,57 +157,85 @@ class PoolWorker {
  }

  onWorkerMessage(message, finalCallback) {
-    const { type, id } = message;
+    const {
+      type,
+      id
+    } = message;
+
    switch (type) {
      case 'job':
        {
-          const { data, error, result } = message;
-          (0, _mapSeries2.default)(data, (length, callback) => this.readBuffer(length, callback), (eachErr, buffers) => {
-            const { callback: jobCallback } = this.jobs[id];
+          const {
+            data,
+            error,
+            result
+          } = message;
+          (0, _mapSeries.default)(data, (length, callback) => this.readBuffer(length, callback), (eachErr, buffers) => {
+            const {
+              callback: jobCallback
+            } = this.jobs[id];
+
            const callback = (err, arg) => {
              if (jobCallback) {
                delete this.jobs[id];
                this.activeJobs -= 1;
                this.onJobDone();
+
                if (err) {
                  jobCallback(err instanceof Error ? err : new Error(err), arg);
                } else {
                  jobCallback(null, arg);
                }
              }
+
              finalCallback();
            };
+
            if (eachErr) {
              callback(eachErr);
              return;
            }
+
            let bufferPosition = 0;
+
            if (result.result) {
              result.result = result.result.map(r => {
                if (r.buffer) {
                  const buffer = buffers[bufferPosition];
                  bufferPosition += 1;
+
                  if (r.string) {
                    return buffer.toString('utf-8');
                  }
+
                  return buffer;
                }
+
                return r.data;
              });
            }
+
            if (error) {
              callback(this.fromErrorObj(error), result);
              return;
            }
+
            callback(null, result);
          });
          break;
        }
-      case 'resolve':
+
+      case 'loadModule':
        {
-          const { context, request, questionId } = message;
-          const { data } = this.jobs[id];
-          data.resolve(context, request, (error, result) => {
+          const {
+            request,
+            questionId
+          } = message;
+          const {
+            data
+          } = this.jobs[id]; // eslint-disable-next-line no-unused-vars
+
+          data.loadModule(request, (error, source, sourceMap, module) => {
            this.writeJson({
              type: 'result',
              id: questionId,
@@ -221,28 +244,85 @@ class PoolWorker {
                details: error.details,
                missing: error.missing
              } : null,
-              result
+              result: [source, sourceMap // TODO: Serialize module?
+              // module,
+              ]
            });
          });
          finalCallback();
          break;
        }
+
+      case 'resolve':
+        {
+          const {
+            context,
+            request,
+            options,
+            questionId
+          } = message;
+          const {
+            data
+          } = this.jobs[id];
+
+          if (options) {
+            data.getResolve(options)(context, request, (error, result) => {
+              this.writeJson({
+                type: 'result',
+                id: questionId,
+                error: error ? {
+                  message: error.message,
+                  details: error.details,
+                  missing: error.missing
+                } : null,
+                result
+              });
+            });
+          } else {
+            data.resolve(context, request, (error, result) => {
+              this.writeJson({
+                type: 'result',
+                id: questionId,
+                error: error ? {
+                  message: error.message,
+                  details: error.details,
+                  missing: error.missing
+                } : null,
+                result
+              });
+            });
+          }
+
+          finalCallback();
+          break;
+        }
+
      case 'emitWarning':
        {
-          const { data } = message;
-          const { data: jobData } = this.jobs[id];
+          const {
+            data
+          } = message;
+          const {
+            data: jobData
+          } = this.jobs[id];
          jobData.emitWarning(this.fromErrorObj(data));
          finalCallback();
          break;
        }
+
      case 'emitError':
        {
-          const { data } = message;
-          const { data: jobData } = this.jobs[id];
+          const {
+            data
+          } = message;
+          const {
+            data: jobData
+          } = this.jobs[id];
          jobData.emitError(this.fromErrorObj(data));
          finalCallback();
          break;
        }
+
      default:
        {
          console.error(`Unexpected worker message ${type} in WorkerPool.`);
@@ -254,16 +334,20 @@ class PoolWorker {

  fromErrorObj(arg) {
    let obj;
+
    if (typeof arg === 'string') {
-      obj = { message: arg };
+      obj = {
+        message: arg
+      };
    } else {
      obj = arg;
    }
-    return new _WorkerError2.default(obj, this.id);
+
+    return new _WorkerError.default(obj, this.id);
  }

  readBuffer(length, callback) {
-    (0, _readBuffer2.default)(this.readPipe, length, callback);
+    (0, _readBuffer.default)(this.readPipe, length, callback);
  }

  dispose() {
@@ -273,6 +357,7 @@ class PoolWorker {
      this.writeEnd();
    }
  }
+
 }

 class WorkerPool {
@@ -285,9 +370,8 @@ class WorkerPool {
    this.workers = new Set();
    this.activeJobs = 0;
    this.timeout = null;
-    this.poolQueue = (0, _queue2.default)(this.distributeJob.bind(this), options.poolParallelJobs);
+    this.poolQueue = (0, _queue.default)(this.distributeJob.bind(this), options.poolParallelJobs);
    this.terminated = false;
-
    this.setupLifeCycle();
  }

@@ -316,6 +400,7 @@ class WorkerPool {
      clearTimeout(this.timeout);
      this.timeout = null;
    }
+
    this.activeJobs += 1;
    this.poolQueue.push(data, callback);
  }
@@ -323,15 +408,18 @@ class WorkerPool {
  distributeJob(data, callback) {
    // use worker with the fewest jobs
    let bestWorker;
+
    for (const worker of this.workers) {
      if (!bestWorker || worker.activeJobs < bestWorker.activeJobs) {
        bestWorker = worker;
      }
    }
+
    if (bestWorker && (bestWorker.activeJobs === 0 || this.workers.size >= this.numberOfWorkers)) {
      bestWorker.run(data, callback);
      return;
    }
+
    const newWorker = this.createWorker();
    newWorker.run(data, callback);
  }
@@ -354,6 +442,7 @@ class WorkerPool {

  onJobDone() {
    this.activeJobs -= 1;
+
    if (this.activeJobs === 0 && isFinite(this.poolTimeout)) {
      this.timeout = setTimeout(() => this.disposeWorkers(), this.poolTimeout);
    }
@@ -369,8 +458,11 @@ class WorkerPool {
      for (const worker of this.workers) {
        worker.dispose();
      }
+
      this.workers.clear();
    }
  }
+
 }
+
 exports.default = WorkerPool;
@@ -1,3 +1,3 @@
-'use strict';
+"use strict";

 module.exports = require('./index');
@@ -1,24 +1,26 @@
-'use strict';
+"use strict";

 Object.defineProperty(exports, "__esModule", {
  value: true
 });
-exports.warmup = exports.pitch = undefined;
+exports.pitch = pitch;
+exports.warmup = warmup;

-var _loaderUtils = require('loader-utils');
+var _loaderUtils = _interopRequireDefault(require("loader-utils"));

-var _loaderUtils2 = _interopRequireDefault(_loaderUtils);
-
-var _workerPools = require('./workerPools');
+var _workerPools = require("./workerPools");

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 function pitch() {
-  const options = _loaderUtils2.default.getOptions(this) || {};
+  const options = _loaderUtils.default.getOptions(this);
+
  const workerPool = (0, _workerPools.getPool)(options);
+
  if (!workerPool.isAbleToRun()) {
    return;
  }
+
  const callback = this.async();
  workerPool.run({
    loaders: this.loaders.slice(this.loaderIndex + 1).map(l => {
@@ -32,20 +34,28 @@ function pitch() {
    sourceMap: this.sourceMap,
    emitError: this.emitError,
    emitWarning: this.emitWarning,
+    loadModule: this.loadModule,
    resolve: this.resolve,
+    getResolve: this.getResolve,
    target: this.target,
    minimize: this.minimize,
    resourceQuery: this.resourceQuery,
-    optionsContext: this.rootContext || this.options.context
+    optionsContext: this.rootContext || this.options.context,
+    rootContext: this.rootContext
  }, (err, r) => {
    if (r) {
      r.fileDependencies.forEach(d => this.addDependency(d));
      r.contextDependencies.forEach(d => this.addContextDependency(d));
+      r.missingDependencies.forEach(d => this.addMissingDependency(d));
+      r.buildDependencies.forEach(d => // Compatibility with webpack v4
+      this.addBuildDependency ? this.addBuildDependency(d) : this.addDependency(d));
    }
+
    if (err) {
      callback(err);
      return;
    }
+
    callback(null, ...r.result);
  });
 }
@@ -53,7 +63,4 @@ function pitch() {
 function warmup(options, requires) {
  const workerPool = (0, _workerPools.getPool)(options);
  workerPool.warmup(requires);
-}
-
-exports.pitch = pitch;
-exports.warmup = warmup; // eslint-disable-line import/prefer-default-export
+} // eslint-disable-line import/prefer-default-export
@@ -1,9 +1,10 @@
-'use strict';
+"use strict";

 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.default = readBuffer;
+
 function readBuffer(pipe, length, callback) {
  if (length === 0) {
    callback(null, Buffer.alloc(0));
@@ -17,6 +18,7 @@ function readBuffer(pipe, length, callback) {
    const onChunk = arg => {
      let chunk = arg;
      let overflow;
+
      if (chunk.length > remainingLength) {
        overflow = chunk.slice(remainingLength);
        chunk = chunk.slice(0, remainingLength);
@@ -24,7 +26,9 @@ function readBuffer(pipe, length, callback) {
      } else {
        remainingLength -= chunk.length;
      }
+
      buffers.push(chunk);
+
      if (remainingLength === 0) {
        pipe.removeListener('data', onChunk);
        pipe.pause();
@@ -40,5 +44,6 @@ function readBuffer(pipe, length, callback) {
    pipe.on('data', onChunk);
    pipe.resume();
  };
+
  readChunk();
 }
@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.replacer = replacer;
+exports.reviver = reviver;
+
+function replacer(_key, value) {
+  if (value instanceof RegExp) {
+    return {
+      __serialized_type: 'RegExp',
+      source: value.source,
+      flags: value.flags
+    };
+  }
+
+  return value;
+}
+
+function reviver(_key, value) {
+  if (typeof value === 'object' && value !== null) {
+    // eslint-disable-next-line no-underscore-dangle
+    if (value.__serialized_type === 'RegExp') {
+      return new RegExp(value.source, value.flags);
+    }
+  }
+
+  return value;
+}
@@ -1,42 +1,41 @@
-'use strict';
+"use strict";

-var _fs = require('fs');
+var _fs = _interopRequireDefault(require("fs"));

-var _fs2 = _interopRequireDefault(_fs);
+var _module = _interopRequireDefault(require("module"));

-var _module = require('module');
+var _querystring = _interopRequireDefault(require("querystring"));

-var _module2 = _interopRequireDefault(_module);
+var _loaderRunner = _interopRequireDefault(require("loader-runner"));

-var _loaderRunner = require('loader-runner');
+var _queue = _interopRequireDefault(require("neo-async/queue"));

-var _loaderRunner2 = _interopRequireDefault(_loaderRunner);
+var _jsonParseBetterErrors = _interopRequireDefault(require("json-parse-better-errors"));

-var _queue = require('neo-async/queue');
+var _schemaUtils = require("schema-utils");

-var _queue2 = _interopRequireDefault(_queue);
+var _readBuffer = _interopRequireDefault(require("./readBuffer"));

-var _readBuffer = require('./readBuffer');
-
-var _readBuffer2 = _interopRequireDefault(_readBuffer);
+var _serializer = require("./serializer");

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

-const writePipe = _fs2.default.createWriteStream(null, { fd: 3 }); /* global require */
 /* eslint-disable no-console */
+const writePipe = _fs.default.createWriteStream(null, {
+  fd: 3
+});

-const readPipe = _fs2.default.createReadStream(null, { fd: 4 });
+const readPipe = _fs.default.createReadStream(null, {
+  fd: 4
+});

 writePipe.on('finish', onTerminateWrite);
 readPipe.on('end', onTerminateRead);
 writePipe.on('close', onTerminateWrite);
 readPipe.on('close', onTerminateRead);
-
 readPipe.on('error', onError);
 writePipe.on('error', onError);
-
 const PARALLEL_JOBS = +process.argv[2] || 20;
-
 let terminated = false;
 let nextQuestionId = 0;
 const callbackMap = Object.create(null);
@@ -108,34 +107,120 @@ function writeJson(data) {
  process.nextTick(() => {
    writePipeUncork();
  });
-
  const lengthBuffer = Buffer.alloc(4);
-  const messageBuffer = Buffer.from(JSON.stringify(data), 'utf-8');
+  const messageBuffer = Buffer.from(JSON.stringify(data, _serializer.replacer), 'utf-8');
  lengthBuffer.writeInt32BE(messageBuffer.length, 0);
-
  writePipeWrite(lengthBuffer);
  writePipeWrite(messageBuffer);
 }

-const queue = (0, _queue2.default)(({ id, data }, taskCallback) => {
+const queue = (0, _queue.default)(({
+  id,
+  data
+}, taskCallback) => {
  try {
-    _loaderRunner2.default.runLoaders({
+    const resolveWithOptions = (context, request, callback, options) => {
+      callbackMap[nextQuestionId] = callback;
+      writeJson({
+        type: 'resolve',
+        id,
+        questionId: nextQuestionId,
+        context,
+        request,
+        options
+      });
+      nextQuestionId += 1;
+    };
+
+    const buildDependencies = [];
+
+    _loaderRunner.default.runLoaders({
      loaders: data.loaders,
      resource: data.resource,
-      readResource: _fs2.default.readFile.bind(_fs2.default),
+      readResource: _fs.default.readFile.bind(_fs.default),
      context: {
        version: 2,
-        resolve: (context, request, callback) => {
-          callbackMap[nextQuestionId] = callback;
+        fs: _fs.default,
+        loadModule: (request, callback) => {
+          callbackMap[nextQuestionId] = (error, result) => callback(error, ...result);
+
          writeJson({
-            type: 'resolve',
+            type: 'loadModule',
            id,
            questionId: nextQuestionId,
-            context,
            request
          });
          nextQuestionId += 1;
        },
+        resolve: (context, request, callback) => {
+          resolveWithOptions(context, request, callback);
+        },
+        // eslint-disable-next-line consistent-return
+        getResolve: options => (context, request, callback) => {
+          if (callback) {
+            resolveWithOptions(context, request, callback, options);
+          } else {
+            return new Promise((resolve, reject) => {
+              resolveWithOptions(context, request, (err, result) => {
+                if (err) {
+                  reject(err);
+                } else {
+                  resolve(result);
+                }
+              }, options);
+            });
+          }
+        },
+
+        // Not an arrow function because it uses this
+        getOptions(schema) {
+          // loaders, loaderIndex will be defined by runLoaders
+          const loader = this.loaders[this.loaderIndex]; // Verbatim copy from
+          // https://github.com/webpack/webpack/blob/v5.31.2/lib/NormalModule.js#L471-L508
+          // except eslint/prettier differences
+          // -- unfortunate result of getOptions being synchronous functions.
+
+          let {
+            options
+          } = loader;
+
+          if (typeof options === 'string') {
+            if (options.substr(0, 1) === '{' && options.substr(-1) === '}') {
+              try {
+                options = (0, _jsonParseBetterErrors.default)(options);
+              } catch (e) {
+                throw new Error(`Cannot parse string options: ${e.message}`);
+              }
+            } else {
+              options = _querystring.default.parse(options, '&', '=', {
+                maxKeys: 0
+              });
+            }
+          } // eslint-disable-next-line no-undefined
+
+
+          if (options === null || options === undefined) {
+            options = {};
+          }
+
+          if (schema) {
+            let name = 'Loader';
+            let baseDataPath = 'options';
+            let match; // eslint-disable-next-line no-cond-assign
+
+            if (schema.title && (match = /^(.+) (.+)$/.exec(schema.title))) {
+              [, name, baseDataPath] = match;
+            }
+
+            (0, _schemaUtils.validate)(schema, options, {
+              name,
+              baseDataPath
+            });
+          }
+
+          return options;
+        },
+
        emitWarning: warning => {
          writeJson({
            type: 'emitWarning',
@@ -151,12 +236,19 @@ const queue = (0, _queue2.default)(({ id, data }, taskCallback) => {
          });
        },
        exec: (code, filename) => {
-          const module = new _module2.default(filename, undefined);
-          module.paths = _module2.default._nodeModulePaths(undefined.context); // eslint-disable-line no-underscore-dangle
+          const module = new _module.default(filename, void 0);
+          module.paths = _module.default._nodeModulePaths((void 0).context); // eslint-disable-line no-underscore-dangle
+
          module.filename = filename;
+
          module._compile(code, filename); // eslint-disable-line no-underscore-dangle
+
+
          return module.exports;
        },
+        addBuildDependency: filename => {
+          buildDependencies.push(filename);
+        },
        options: {
          context: data.optionsContext
        },
@@ -165,24 +257,28 @@ const queue = (0, _queue2.default)(({ id, data }, taskCallback) => {
        sourceMap: data.sourceMap,
        target: data.target,
        minimize: data.minimize,
-        resourceQuery: data.resourceQuery
+        resourceQuery: data.resourceQuery,
+        rootContext: data.rootContext
      }
    }, (err, lrResult) => {
      const {
        result,
        cacheable,
        fileDependencies,
-        contextDependencies
+        contextDependencies,
+        missingDependencies
      } = lrResult;
      const buffersToSend = [];
      const convertedResult = Array.isArray(result) && result.map(item => {
        const isBuffer = Buffer.isBuffer(item);
+
        if (isBuffer) {
          buffersToSend.push(item);
          return {
            buffer: true
          };
        }
+
        if (typeof item === 'string') {
          const stringBuffer = Buffer.from(item, 'utf-8');
          buffersToSend.push(stringBuffer);
@@ -191,6 +287,7 @@ const queue = (0, _queue2.default)(({ id, data }, taskCallback) => {
            string: true
          };
        }
+
        return {
          data: item
        };
@@ -203,7 +300,9 @@ const queue = (0, _queue2.default)(({ id, data }, taskCallback) => {
          result: convertedResult,
          cacheable,
          fileDependencies,
-          contextDependencies
+          contextDependencies,
+          missingDependencies,
+          buildDependencies
        },
        data: buffersToSend.map(buffer => buffer.length)
      });
@@ -224,40 +323,54 @@ const queue = (0, _queue2.default)(({ id, data }, taskCallback) => {

 function dispose() {
  terminate();
-
  queue.kill();
  process.exit(0);
 }

 function onMessage(message) {
  try {
-    const { type, id } = message;
+    const {
+      type,
+      id
+    } = message;
+
    switch (type) {
      case 'job':
        {
          queue.push(message);
          break;
        }
+
      case 'result':
        {
-          const { error, result } = message;
+          const {
+            error,
+            result
+          } = message;
          const callback = callbackMap[id];
+
          if (callback) {
            const nativeError = toNativeError(error);
            callback(nativeError, result);
          } else {
            console.error(`Worker got unexpected result id ${id}`);
          }
+
          delete callbackMap[id];
          break;
        }
+
      case 'warmup':
        {
-          const { requires } = message;
-          // load modules into process
+          const {
+            requires
+          } = message; // load modules into process
+
          requires.forEach(r => require(r)); // eslint-disable-line import/no-dynamic-require, global-require
+
          break;
        }
+
      default:
        {
          console.error(`Worker got unexpected job type ${type}`);
@@ -270,7 +383,7 @@ function onMessage(message) {
 }

 function readNextMessage() {
-  (0, _readBuffer2.default)(readPipe, 4, (lengthReadError, lengthBuffer) => {
+  (0, _readBuffer.default)(readPipe, 4, (lengthReadError, lengthBuffer) => {
    if (lengthReadError) {
      console.error(`Failed to communicate with main process (read length) ${lengthReadError}`);
      return;
@@ -283,7 +396,8 @@ function readNextMessage() {
      dispose();
      return;
    }
-    (0, _readBuffer2.default)(readPipe, length, (messageError, messageBuffer) => {
+
+    (0, _readBuffer.default)(readPipe, length, (messageError, messageBuffer) => {
      if (terminated) {
        return;
      }
@@ -292,14 +406,14 @@ function readNextMessage() {
        console.error(`Failed to communicate with main process (read message) ${messageError}`);
        return;
      }
-      const messageString = messageBuffer.toString('utf-8');
-      const message = JSON.parse(messageString);

+      const messageString = messageBuffer.toString('utf-8');
+      const message = JSON.parse(messageString, _serializer.reviver);
      onMessage(message);
      setImmediate(() => readNextMessage());
    });
  });
-}
+} // start reading messages from main process
+

-// start reading messages from main process
 readNextMessage();
@@ -1,17 +1,13 @@
-'use strict';
+"use strict";

 Object.defineProperty(exports, "__esModule", {
  value: true
 });
-exports.getPool = undefined;
+exports.getPool = getPool;

-var _os = require('os');
+var _os = _interopRequireDefault(require("os"));

-var _os2 = _interopRequireDefault(_os);
-
-var _WorkerPool = require('./WorkerPool');
-
-var _WorkerPool2 = _interopRequireDefault(_WorkerPool);
+var _WorkerPool = _interopRequireDefault(require("./WorkerPool"));

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

@@ -21,8 +17,9 @@ function calculateNumberOfWorkers() {
  // There are situations when this call will return undefined so
  // we are fallback here to 1.
  // More info on: https://github.com/nodejs/node/issues/19022
-  const cpus = _os2.default.cpus() || { length: 1 };
-
+  const cpus = _os.default.cpus() || {
+    length: 1
+  };
  return Math.max(1, cpus.length - 1);
 }

@@ -37,9 +34,6 @@ function getPool(options) {
    poolRespawn: options.poolRespawn || false
  };
  const tpKey = JSON.stringify(workerPoolOptions);
-  workerPools[tpKey] = workerPools[tpKey] || new _WorkerPool2.default(workerPoolOptions);
-  const workerPool = workerPools[tpKey];
-  return workerPool;
-}
-
-exports.getPool = getPool; // eslint-disable-line import/prefer-default-export
+  workerPools[tpKey] = workerPools[tpKey] || new _WorkerPool.default(workerPoolOptions);
+  return workerPools[tpKey];
+} // eslint-disable-line import/prefer-default-export
@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) Tobias Koppers @sokra
+
+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.
@@ -0,0 +1,53 @@
+# loader-runner
+
+``` js
+import { runLoaders } from "loader-runner";
+
+runLoaders({
+	resource: "/abs/path/to/file.txt?query",
+	// String: Absolute path to the resource (optionally including query string)
+
+	loaders: ["/abs/path/to/loader.js?query"],
+	// String[]: Absolute paths to the loaders (optionally including query string)
+	// {loader, options}[]: Absolute paths to the loaders with options object
+
+	context: { minimize: true },
+	// Additional loader context which is used as base context
+
+	processResource: (loaderContext, resourcePath, callback) => { ... },
+	// Optional: A function to process the resource
+	// Must have signature function(context, path, function(err, buffer))
+	// By default readResource is used and the resource is added a fileDependency
+
+	readResource: fs.readFile.bind(fs)
+	// Optional: A function to read the resource
+	// Only used when 'processResource' is not provided
+	// Must have signature function(path, function(err, buffer))
+	// By default fs.readFile is used
+}, function(err, result) {
+	// err: Error?
+
+	// result.result: Buffer | String
+	// The result
+	// only available when no error occured
+
+	// result.resourceBuffer: Buffer
+	// The raw resource as Buffer (useful for SourceMaps)
+	// only available when no error occured
+
+	// result.cacheable: Bool
+	// Is the result cacheable or do it require reexecution?
+
+	// result.fileDependencies: String[]
+	// An array of paths (existing files) on which the result depends on
+
+	// result.missingDependencies: String[]
+	// An array of paths (not existing files) on which the result depends on
+
+	// result.contextDependencies: String[]
+	// An array of paths (directories) on which the result depends on
+})
+```
+
+More documentation following...
+
@@ -0,0 +1,11 @@
+"use strict";
+
+class LoadingLoaderError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LoaderRunnerError";
+		Error.captureStackTrace(this, this.constructor);
+	}
+}
+
+module.exports = LoadingLoaderError;
@@ -0,0 +1,416 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var fs = require("fs");
+var readFile = fs.readFile.bind(fs);
+var loadLoader = require("./loadLoader");
+
+function utf8BufferToString(buf) {
+	var str = buf.toString("utf-8");
+	if(str.charCodeAt(0) === 0xFEFF) {
+		return str.substr(1);
+	} else {
+		return str;
+	}
+}
+
+const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
+
+/**
+ * @param {string} str the path with query and fragment
+ * @returns {{ path: string, query: string, fragment: string }} parsed parts
+ */
+function parsePathQueryFragment(str) {
+	var match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
+	return {
+		path: match[1].replace(/\0(.)/g, "$1"),
+		query: match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
+		fragment: match[3] || ""
+	};
+}
+
+function dirname(path) {
+	if(path === "/") return "/";
+	var i = path.lastIndexOf("/");
+	var j = path.lastIndexOf("\\");
+	var i2 = path.indexOf("/");
+	var j2 = path.indexOf("\\");
+	var idx = i > j ? i : j;
+	var idx2 = i > j ? i2 : j2;
+	if(idx < 0) return path;
+	if(idx === idx2) return path.substr(0, idx + 1);
+	return path.substr(0, idx);
+}
+
+function createLoaderObject(loader) {
+	var obj = {
+		path: null,
+		query: null,
+		fragment: null,
+		options: null,
+		ident: null,
+		normal: null,
+		pitch: null,
+		raw: null,
+		data: null,
+		pitchExecuted: false,
+		normalExecuted: false
+	};
+	Object.defineProperty(obj, "request", {
+		enumerable: true,
+		get: function() {
+			return obj.path.replace(/#/g, "\0#") + obj.query.replace(/#/g, "\0#") + obj.fragment;
+		},
+		set: function(value) {
+			if(typeof value === "string") {
+				var splittedRequest = parsePathQueryFragment(value);
+				obj.path = splittedRequest.path;
+				obj.query = splittedRequest.query;
+				obj.fragment = splittedRequest.fragment;
+				obj.options = undefined;
+				obj.ident = undefined;
+			} else {
+				if(!value.loader)
+					throw new Error("request should be a string or object with loader and options (" + JSON.stringify(value) + ")");
+				obj.path = value.loader;
+				obj.fragment = value.fragment || "";
+				obj.type = value.type;
+				obj.options = value.options;
+				obj.ident = value.ident;
+				if(obj.options === null)
+					obj.query = "";
+				else if(obj.options === undefined)
+					obj.query = "";
+				else if(typeof obj.options === "string")
+					obj.query = "?" + obj.options;
+				else if(obj.ident)
+					obj.query = "??" + obj.ident;
+				else if(typeof obj.options === "object" && obj.options.ident)
+					obj.query = "??" + obj.options.ident;
+				else
+					obj.query = "?" + JSON.stringify(obj.options);
+			}
+		}
+	});
+	obj.request = loader;
+	if(Object.preventExtensions) {
+		Object.preventExtensions(obj);
+	}
+	return obj;
+}
+
+function runSyncOrAsync(fn, context, args, callback) {
+	var isSync = true;
+	var isDone = false;
+	var isError = false; // internal error
+	var reportedError = false;
+	context.async = function async() {
+		if(isDone) {
+			if(reportedError) return; // ignore
+			throw new Error("async(): The callback was already called.");
+		}
+		isSync = false;
+		return innerCallback;
+	};
+	var innerCallback = context.callback = function() {
+		if(isDone) {
+			if(reportedError) return; // ignore
+			throw new Error("callback(): The callback was already called.");
+		}
+		isDone = true;
+		isSync = false;
+		try {
+			callback.apply(null, arguments);
+		} catch(e) {
+			isError = true;
+			throw e;
+		}
+	};
+	try {
+		var result = (function LOADER_EXECUTION() {
+			return fn.apply(context, args);
+		}());
+		if(isSync) {
+			isDone = true;
+			if(result === undefined)
+				return callback();
+			if(result && typeof result === "object" && typeof result.then === "function") {
+				return result.then(function(r) {
+					callback(null, r);
+				}, callback);
+			}
+			return callback(null, result);
+		}
+	} catch(e) {
+		if(isError) throw e;
+		if(isDone) {
+			// loader is already "done", so we cannot use the callback function
+			// for better debugging we print the error on the console
+			if(typeof e === "object" && e.stack) console.error(e.stack);
+			else console.error(e);
+			return;
+		}
+		isDone = true;
+		reportedError = true;
+		callback(e);
+	}
+
+}
+
+function convertArgs(args, raw) {
+	if(!raw && Buffer.isBuffer(args[0]))
+		args[0] = utf8BufferToString(args[0]);
+	else if(raw && typeof args[0] === "string")
+		args[0] = Buffer.from(args[0], "utf-8");
+}
+
+function iteratePitchingLoaders(options, loaderContext, callback) {
+	// abort after last loader
+	if(loaderContext.loaderIndex >= loaderContext.loaders.length)
+		return processResource(options, loaderContext, callback);
+
+	var currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
+
+	// iterate
+	if(currentLoaderObject.pitchExecuted) {
+		loaderContext.loaderIndex++;
+		return iteratePitchingLoaders(options, loaderContext, callback);
+	}
+
+	// load loader module
+	loadLoader(currentLoaderObject, function(err) {
+		if(err) {
+			loaderContext.cacheable(false);
+			return callback(err);
+		}
+		var fn = currentLoaderObject.pitch;
+		currentLoaderObject.pitchExecuted = true;
+		if(!fn) return iteratePitchingLoaders(options, loaderContext, callback);
+
+		runSyncOrAsync(
+			fn,
+			loaderContext, [loaderContext.remainingRequest, loaderContext.previousRequest, currentLoaderObject.data = {}],
+			function(err) {
+				if(err) return callback(err);
+				var args = Array.prototype.slice.call(arguments, 1);
+				// Determine whether to continue the pitching process based on
+				// argument values (as opposed to argument presence) in order
+				// to support synchronous and asynchronous usages.
+				var hasArg = args.some(function(value) {
+					return value !== undefined;
+				});
+				if(hasArg) {
+					loaderContext.loaderIndex--;
+					iterateNormalLoaders(options, loaderContext, args, callback);
+				} else {
+					iteratePitchingLoaders(options, loaderContext, callback);
+				}
+			}
+		);
+	});
+}
+
+function processResource(options, loaderContext, callback) {
+	// set loader index to last loader
+	loaderContext.loaderIndex = loaderContext.loaders.length - 1;
+
+	var resourcePath = loaderContext.resourcePath;
+	if(resourcePath) {
+		options.processResource(loaderContext, resourcePath, function(err) {
+			if(err) return callback(err);
+			var args = Array.prototype.slice.call(arguments, 1);
+			options.resourceBuffer = args[0];
+			iterateNormalLoaders(options, loaderContext, args, callback);
+		});
+	} else {
+		iterateNormalLoaders(options, loaderContext, [null], callback);
+	}
+}
+
+function iterateNormalLoaders(options, loaderContext, args, callback) {
+	if(loaderContext.loaderIndex < 0)
+		return callback(null, args);
+
+	var currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
+
+	// iterate
+	if(currentLoaderObject.normalExecuted) {
+		loaderContext.loaderIndex--;
+		return iterateNormalLoaders(options, loaderContext, args, callback);
+	}
+
+	var fn = currentLoaderObject.normal;
+	currentLoaderObject.normalExecuted = true;
+	if(!fn) {
+		return iterateNormalLoaders(options, loaderContext, args, callback);
+	}
+
+	convertArgs(args, currentLoaderObject.raw);
+
+	runSyncOrAsync(fn, loaderContext, args, function(err) {
+		if(err) return callback(err);
+
+		var args = Array.prototype.slice.call(arguments, 1);
+		iterateNormalLoaders(options, loaderContext, args, callback);
+	});
+}
+
+exports.getContext = function getContext(resource) {
+	var path = parsePathQueryFragment(resource).path;
+	return dirname(path);
+};
+
+exports.runLoaders = function runLoaders(options, callback) {
+	// read options
+	var resource = options.resource || "";
+	var loaders = options.loaders || [];
+	var loaderContext = options.context || {};
+	var processResource = options.processResource || ((readResource, context, resource, callback) => {
+		context.addDependency(resource);
+		readResource(resource, callback);
+	}).bind(null, options.readResource || readFile);
+
+	//
+	var splittedResource = resource && parsePathQueryFragment(resource);
+	var resourcePath = splittedResource ? splittedResource.path : undefined;
+	var resourceQuery = splittedResource ? splittedResource.query : undefined;
+	var resourceFragment = splittedResource ? splittedResource.fragment : undefined;
+	var contextDirectory = resourcePath ? dirname(resourcePath) : null;
+
+	// execution state
+	var requestCacheable = true;
+	var fileDependencies = [];
+	var contextDependencies = [];
+	var missingDependencies = [];
+
+	// prepare loader objects
+	loaders = loaders.map(createLoaderObject);
+
+	loaderContext.context = contextDirectory;
+	loaderContext.loaderIndex = 0;
+	loaderContext.loaders = loaders;
+	loaderContext.resourcePath = resourcePath;
+	loaderContext.resourceQuery = resourceQuery;
+	loaderContext.resourceFragment = resourceFragment;
+	loaderContext.async = null;
+	loaderContext.callback = null;
+	loaderContext.cacheable = function cacheable(flag) {
+		if(flag === false) {
+			requestCacheable = false;
+		}
+	};
+	loaderContext.dependency = loaderContext.addDependency = function addDependency(file) {
+		fileDependencies.push(file);
+	};
+	loaderContext.addContextDependency = function addContextDependency(context) {
+		contextDependencies.push(context);
+	};
+	loaderContext.addMissingDependency = function addMissingDependency(context) {
+		missingDependencies.push(context);
+	};
+	loaderContext.getDependencies = function getDependencies() {
+		return fileDependencies.slice();
+	};
+	loaderContext.getContextDependencies = function getContextDependencies() {
+		return contextDependencies.slice();
+	};
+	loaderContext.getMissingDependencies = function getMissingDependencies() {
+		return missingDependencies.slice();
+	};
+	loaderContext.clearDependencies = function clearDependencies() {
+		fileDependencies.length = 0;
+		contextDependencies.length = 0;
+		missingDependencies.length = 0;
+		requestCacheable = true;
+	};
+	Object.defineProperty(loaderContext, "resource", {
+		enumerable: true,
+		get: function() {
+			if(loaderContext.resourcePath === undefined)
+				return undefined;
+			return loaderContext.resourcePath.replace(/#/g, "\0#") + loaderContext.resourceQuery.replace(/#/g, "\0#") + loaderContext.resourceFragment;
+		},
+		set: function(value) {
+			var splittedResource = value && parsePathQueryFragment(value);
+			loaderContext.resourcePath = splittedResource ? splittedResource.path : undefined;
+			loaderContext.resourceQuery = splittedResource ? splittedResource.query : undefined;
+			loaderContext.resourceFragment = splittedResource ? splittedResource.fragment : undefined;
+		}
+	});
+	Object.defineProperty(loaderContext, "request", {
+		enumerable: true,
+		get: function() {
+			return loaderContext.loaders.map(function(o) {
+				return o.request;
+			}).concat(loaderContext.resource || "").join("!");
+		}
+	});
+	Object.defineProperty(loaderContext, "remainingRequest", {
+		enumerable: true,
+		get: function() {
+			if(loaderContext.loaderIndex >= loaderContext.loaders.length - 1 && !loaderContext.resource)
+				return "";
+			return loaderContext.loaders.slice(loaderContext.loaderIndex + 1).map(function(o) {
+				return o.request;
+			}).concat(loaderContext.resource || "").join("!");
+		}
+	});
+	Object.defineProperty(loaderContext, "currentRequest", {
+		enumerable: true,
+		get: function() {
+			return loaderContext.loaders.slice(loaderContext.loaderIndex).map(function(o) {
+				return o.request;
+			}).concat(loaderContext.resource || "").join("!");
+		}
+	});
+	Object.defineProperty(loaderContext, "previousRequest", {
+		enumerable: true,
+		get: function() {
+			return loaderContext.loaders.slice(0, loaderContext.loaderIndex).map(function(o) {
+				return o.request;
+			}).join("!");
+		}
+	});
+	Object.defineProperty(loaderContext, "query", {
+		enumerable: true,
+		get: function() {
+			var entry = loaderContext.loaders[loaderContext.loaderIndex];
+			return entry.options && typeof entry.options === "object" ? entry.options : entry.query;
+		}
+	});
+	Object.defineProperty(loaderContext, "data", {
+		enumerable: true,
+		get: function() {
+			return loaderContext.loaders[loaderContext.loaderIndex].data;
+		}
+	});
+
+	// finish loader context
+	if(Object.preventExtensions) {
+		Object.preventExtensions(loaderContext);
+	}
+
+	var processOptions = {
+		resourceBuffer: null,
+		processResource: processResource
+	};
+	iteratePitchingLoaders(processOptions, loaderContext, function(err, result) {
+		if(err) {
+			return callback(err, {
+				cacheable: requestCacheable,
+				fileDependencies: fileDependencies,
+				contextDependencies: contextDependencies,
+				missingDependencies: missingDependencies
+			});
+		}
+		callback(null, {
+			result: result,
+			resourceBuffer: processOptions.resourceBuffer,
+			cacheable: requestCacheable,
+			fileDependencies: fileDependencies,
+			contextDependencies: contextDependencies,
+			missingDependencies: missingDependencies
+		});
+	});
+};
@@ -0,0 +1,54 @@
+var LoaderLoadingError = require("./LoaderLoadingError");
+var url;
+
+module.exports = function loadLoader(loader, callback) {
+	if(loader.type === "module") {
+		try {
+			if(url === undefined) url = require("url");
+			var loaderUrl = url.pathToFileURL(loader.path);
+			var modulePromise = eval("import(" + JSON.stringify(loaderUrl.toString()) + ")");
+			modulePromise.then(function(module) {
+				handleResult(loader, module, callback);
+			}, callback);
+			return;
+		} catch(e) {
+			callback(e);
+		}
+	} else {
+		try {
+			var module = require(loader.path);
+		} catch(e) {
+			// it is possible for node to choke on a require if the FD descriptor
+			// limit has been reached. give it a chance to recover.
+			if(e instanceof Error && e.code === "EMFILE") {
+				var retry = loadLoader.bind(null, loader, callback);
+				if(typeof setImmediate === "function") {
+					// node >= 0.9.0
+					return setImmediate(retry);
+				} else {
+					// node < 0.9.0
+					return process.nextTick(retry);
+				}
+			}
+			return callback(e);
+		}
+		return handleResult(loader, module, callback);
+	}
+};
+
+function handleResult(loader, module, callback) {
+	if(typeof module !== "function" && typeof module !== "object") {
+		return callback(new LoaderLoadingError(
+			"Module '" + loader.path + "' is not a loader (export function or es6 module)"
+		));
+	}
+	loader.normal = typeof module === "function" ? module : module.default;
+	loader.pitch = module.pitch;
+	loader.raw = module.raw;
+	if(typeof loader.normal !== "function" && typeof loader.pitch !== "function") {
+		return callback(new LoaderLoadingError(
+			"Module '" + loader.path + "' is not a loader (must have normal or pitch function)"
+		));
+	}
+	callback();
+}
@@ -0,0 +1,75 @@
+{
+  "_args": [
+    [
+      "loader-runner@4.3.0",
+      "/home/node/nuxt"
+    ]
+  ],
+  "_from": "loader-runner@4.3.0",
+  "_id": "loader-runner@4.3.0",
+  "_inBundle": false,
+  "_integrity": "sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==",
+  "_location": "/thread-loader/loader-runner",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "loader-runner@4.3.0",
+    "name": "loader-runner",
+    "escapedName": "loader-runner",
+    "rawSpec": "4.3.0",
+    "saveSpec": null,
+    "fetchSpec": "4.3.0"
+  },
+  "_requiredBy": [
+    "/thread-loader"
+  ],
+  "_resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.3.0.tgz",
+  "_spec": "4.3.0",
+  "_where": "/home/node/nuxt",
+  "author": {
+    "name": "Tobias Koppers @sokra"
+  },
+  "bugs": {
+    "url": "https://github.com/webpack/loader-runner/issues"
+  },
+  "description": "Runs (webpack) loaders",
+  "devDependencies": {
+    "eslint": "^3.12.2",
+    "eslint-plugin-node": "^3.0.5",
+    "eslint-plugin-nodeca": "^1.0.3",
+    "istanbul": "^0.4.1",
+    "mocha": "^3.2.0",
+    "should": "^8.0.2"
+  },
+  "engines": {
+    "node": ">=6.11.5"
+  },
+  "files": [
+    "lib/",
+    "bin/",
+    "hot/",
+    "web_modules/",
+    "schemas/"
+  ],
+  "homepage": "https://github.com/webpack/loader-runner#readme",
+  "keywords": [
+    "webpack",
+    "loader"
+  ],
+  "license": "MIT",
+  "main": "lib/LoaderRunner.js",
+  "name": "loader-runner",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/webpack/loader-runner.git"
+  },
+  "scripts": {
+    "cover": "istanbul cover node_modules/mocha/bin/_mocha",
+    "lint": "eslint lib test",
+    "precover": "npm run lint",
+    "pretest": "npm run lint",
+    "test": "mocha --reporter spec"
+  },
+  "version": "4.3.0"
+}
@@ -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.
@@ -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)
@@ -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;
@@ -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;
@@ -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;
@@ -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;
@@ -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;
@@ -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);
@@ -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;
@@ -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;
@@ -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;
@@ -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;
@@ -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 = {};
+
+  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;
@@ -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;
@@ -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;
@@ -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;
@@ -0,0 +1,73 @@
+{
+  "_args": [
+    [
+      "loader-utils@2.0.2",
+      "/home/node/nuxt"
+    ]
+  ],
+  "_from": "loader-utils@2.0.2",
+  "_id": "loader-utils@2.0.2",
+  "_inBundle": false,
+  "_integrity": "sha512-TM57VeHptv569d/GKh6TAYdzKblwDNiumOdkFnejjD0XwTH87K90w3O7AiJRqdQoXygvi1VQTJTLGhJl7WqA7A==",
+  "_location": "/thread-loader/loader-utils",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "loader-utils@2.0.2",
+    "name": "loader-utils",
+    "escapedName": "loader-utils",
+    "rawSpec": "2.0.2",
+    "saveSpec": null,
+    "fetchSpec": "2.0.2"
+  },
+  "_requiredBy": [
+    "/thread-loader"
+  ],
+  "_resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-2.0.2.tgz",
+  "_spec": "2.0.2",
+  "_where": "/home/node/nuxt",
+  "author": {
+    "name": "Tobias Koppers @sokra"
+  },
+  "bugs": {
+    "url": "https://github.com/webpack/loader-utils/issues"
+  },
+  "dependencies": {
+    "big.js": "^5.2.2",
+    "emojis-list": "^3.0.0",
+    "json5": "^2.1.2"
+  },
+  "description": "utils for webpack loaders",
+  "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"
+  },
+  "engines": {
+    "node": ">=8.9.0"
+  },
+  "files": [
+    "lib"
+  ],
+  "homepage": "https://github.com/webpack/loader-utils#readme",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "name": "loader-utils",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/webpack/loader-utils.git"
+  },
+  "scripts": {
+    "lint": "eslint lib test",
+    "pretest": "yarn lint",
+    "release": "yarn test && standard-version",
+    "test": "jest",
+    "test:ci": "jest --coverage"
+  },
+  "version": "2.0.2"
+}
@@ -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.
@@ -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
@@ -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;
+}
@@ -0,0 +1,3 @@
+import { validate } from "./validate";
+import { ValidationError } from "./validate";
+export { validate, ValidationError };
@@ -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;
@@ -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;
@@ -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;
@@ -0,0 +1,37 @@
+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 Extend = {
+  formatMinimum?: number | undefined;
+  formatMaximum?: number | undefined;
+  formatExclusiveMinimum?: boolean | undefined;
+  formatExclusiveMaximum?: boolean | undefined;
+  link?: string | 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;
+import ValidationError from "./ValidationError";
+export { ValidationError };
@@ -0,0 +1,11 @@
+"use strict";
+
+const {
+  validate,
+  ValidationError
+} = require("./validate");
+
+module.exports = {
+  validate,
+  ValidationError
+};
@@ -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;
@@ -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;
@@ -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;
+};
@@ -0,0 +1,163 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validate = validate;
+Object.defineProperty(exports, "ValidationError", {
+  enumerable: true,
+  get: function () {
+    return _ValidationError.default;
+  }
+});
+
+var _absolutePath = _interopRequireDefault(require("./keywords/absolutePath"));
+
+var _ValidationError = _interopRequireDefault(require("./ValidationError"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Use CommonJS require for ajv libs so TypeScript consumers aren't locked into esModuleInterop (see #110).
+const Ajv = require("ajv");
+
+const ajvKeywords = require("ajv-keywords");
+/** @typedef {import("json-schema").JSONSchema4} JSONSchema4 */
+
+/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
+
+/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
+
+/** @typedef {import("ajv").ErrorObject} ErrorObject */
+
+/**
+ * @typedef {Object} Extend
+ * @property {number=} formatMinimum
+ * @property {number=} formatMaximum
+ * @property {boolean=} formatExclusiveMinimum
+ * @property {boolean=} formatExclusiveMaximum
+ * @property {string=} link
+ */
+
+/** @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
+ */
+
+
+const ajv = new Ajv({
+  allErrors: true,
+  verbose: true,
+  $data: true
+});
+ajvKeywords(ajv, ["instanceof", "formatMinimum", "formatMaximum", "patternRequired"]); // Custom keywords
+
+(0, _absolutePath.default)(ajv);
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @param {ValidationErrorConfiguration=} configuration
+ * @returns {void}
+ */
+
+function validate(schema, options, configuration) {
+  let errors = [];
+
+  if (Array.isArray(options)) {
+    errors = Array.from(options, nestedOptions => validateObject(schema, nestedOptions));
+    errors.forEach((list, idx) => {
+      const applyPrefix =
+      /**
+       * @param {SchemaUtilErrorObject} error
+       */
+      error => {
+        // eslint-disable-next-line no-param-reassign
+        error.dataPath = `[${idx}]${error.dataPath}`;
+
+        if (error.children) {
+          error.children.forEach(applyPrefix);
+        }
+      };
+
+      list.forEach(applyPrefix);
+    });
+    errors = errors.reduce((arr, items) => {
+      arr.push(...items);
+      return arr;
+    }, []);
+  } else {
+    errors = validateObject(schema, options);
+  }
+
+  if (errors.length > 0) {
+    throw new _ValidationError.default(errors, schema, configuration);
+  }
+}
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @returns {Array<SchemaUtilErrorObject>}
+ */
+
+
+function validateObject(schema, options) {
+  const compiledSchema = ajv.compile(schema);
+  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;
+}
@@ -0,0 +1,114 @@
+{
+  "_args": [
+    [
+      "schema-utils@3.1.1",
+      "/home/node/nuxt"
+    ]
+  ],
+  "_from": "schema-utils@3.1.1",
+  "_id": "schema-utils@3.1.1",
+  "_inBundle": false,
+  "_integrity": "sha512-Y5PQxS4ITlC+EahLuXaY86TXfR7Dc5lw294alXOq86JAHCihAIZfqv8nNCWvaEJvaC51uN9hbLGeV0cFBdH+Fw==",
+  "_location": "/thread-loader/schema-utils",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "schema-utils@3.1.1",
+    "name": "schema-utils",
+    "escapedName": "schema-utils",
+    "rawSpec": "3.1.1",
+    "saveSpec": null,
+    "fetchSpec": "3.1.1"
+  },
+  "_requiredBy": [
+    "/thread-loader"
+  ],
+  "_resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.1.1.tgz",
+  "_spec": "3.1.1",
+  "_where": "/home/node/nuxt",
+  "author": {
+    "name": "webpack Contrib",
+    "url": "https://github.com/webpack-contrib"
+  },
+  "bugs": {
+    "url": "https://github.com/webpack/schema-utils/issues"
+  },
+  "dependencies": {
+    "@types/json-schema": "^7.0.8",
+    "ajv": "^6.12.5",
+    "ajv-keywords": "^3.5.2"
+  },
+  "description": "webpack Validation Utils",
+  "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"
+  },
+  "engines": {
+    "node": ">= 10.13.0"
+  },
+  "files": [
+    "dist",
+    "declarations"
+  ],
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/webpack"
+  },
+  "homepage": "https://github.com/webpack/schema-utils",
+  "keywords": [
+    "webpack"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "name": "schema-utils",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/webpack/schema-utils.git"
+  },
+  "scripts": {
+    "build": "npm-run-all -p \"build:**\"",
+    "build:code": "cross-env NODE_ENV=production babel src -d dist --copy-files",
+    "build:types": "tsc --declaration --emitDeclarationOnly --outDir declarations && prettier \"declarations/**/*.ts\" --write",
+    "clean": "del-cli dist declarations",
+    "commitlint": "commitlint --from=master",
+    "fix": "npm-run-all fix:js fmt",
+    "fix:js": "npm run lint:js -- --fix",
+    "fmt": "npm run fmt:check -- --write",
+    "fmt:check": "prettier \"{**/*,*}.{js,json,md,yml,css,ts}\" --list-different",
+    "lint": "npm-run-all lint:js lint:types fmt:check",
+    "lint:js": "eslint --cache .",
+    "lint:types": "tsc --pretty --noEmit",
+    "prebuild": "npm run clean",
+    "prepare": "npm run build && husky install",
+    "pretest": "npm run lint",
+    "release": "standard-version",
+    "security": "npm audit --production",
+    "start": "npm run build -- -w",
+    "test": "npm run test:coverage",
+    "test:coverage": "npm run test:only -- --collectCoverageFrom=\"src/**/*.js\" --coverage",
+    "test:only": "cross-env NODE_ENV=test jest",
+    "test:watch": "npm run test:only -- --watch"
+  },
+  "types": "declarations/index.d.ts",
+  "version": "3.1.1"
+}
@@ -1,32 +1,39 @@
 {
  "_args": [
    [
-      "thread-loader@2.1.3",
-      "/mnt/Foxconn/Digitalent/Deverloper/liff-push_2series"
+      "thread-loader@3.0.4",
+      "/home/node/nuxt"
    ]
  ],
-  "_from": "thread-loader@2.1.3",
-  "_id": "thread-loader@2.1.3",
+  "_from": "thread-loader@3.0.4",
+  "_id": "thread-loader@3.0.4",
  "_inBundle": false,
-  "_integrity": "sha512-wNrVKH2Lcf8ZrWxDF/khdlLlsTMczdcwPA9VEK4c2exlEPynYWxi9op3nPTo5lAnDIkE0rQEB3VBP+4Zncc9Hg==",
+  "_integrity": "sha512-ByaL2TPb+m6yArpqQUZvP+5S1mZtXsEP7nWKKlAUTm7fCml8kB5s1uI3+eHRP2bk5mVYfRSBI7FFf+tWEyLZwA==",
  "_location": "/thread-loader",
-  "_phantomChildren": {},
+  "_phantomChildren": {
+    "@types/json-schema": "7.0.11",
+    "ajv": "6.12.6",
+    "ajv-keywords": "3.5.2",
+    "big.js": "5.2.2",
+    "emojis-list": "3.0.0",
+    "json5": "2.2.1"
+  },
  "_requested": {
    "type": "version",
    "registry": true,
-    "raw": "thread-loader@2.1.3",
+    "raw": "thread-loader@3.0.4",
    "name": "thread-loader",
    "escapedName": "thread-loader",
-    "rawSpec": "2.1.3",
+    "rawSpec": "3.0.4",
    "saveSpec": null,
-    "fetchSpec": "2.1.3"
+    "fetchSpec": "3.0.4"
  },
  "_requiredBy": [
    "/@nuxt/webpack"
  ],
-  "_resolved": "https://registry.npmjs.org/thread-loader/-/thread-loader-2.1.3.tgz",
-  "_spec": "2.1.3",
-  "_where": "/mnt/Foxconn/Digitalent/Deverloper/liff-push_2series",
+  "_resolved": "https://registry.npmjs.org/thread-loader/-/thread-loader-3.0.4.tgz",
+  "_spec": "3.0.4",
+  "_where": "/home/node/nuxt",
  "author": {
    "name": "Tobias Koppers @sokra"
  },
@@ -34,80 +41,87 @@
    "url": "https://github.com/webpack-contrib/thread-loader/issues"
  },
  "dependencies": {
-    "loader-runner": "^2.3.1",
-    "loader-utils": "^1.1.0",
-    "neo-async": "^2.6.0"
+    "json-parse-better-errors": "^1.0.2",
+    "loader-runner": "^4.1.0",
+    "loader-utils": "^2.0.0",
+    "neo-async": "^2.6.2",
+    "schema-utils": "^3.0.0"
  },
  "description": "Runs the following loaders in a worker pool",
  "devDependencies": {
-    "babel-cli": "^6.26.0",
-    "babel-core": "^6.26.3",
-    "babel-jest": "^23.6.0",
-    "babel-loader": "^7.1.5",
-    "babel-plugin-transform-object-rest-spread": "^6.26.0",
-    "babel-polyfill": "^6.26.0",
-    "babel-preset-env": "^1.7.0",
-    "cross-env": "^5.2.0",
-    "css-loader": "^1.0.1",
-    "del-cli": "^1.1.0",
-    "eslint": "^5.10.0",
-    "eslint-config-webpack": "^1.2.5",
-    "eslint-plugin-import": "^2.14.0",
-    "jest": "^23.6.0",
-    "lint-staged": "^8.1.0",
-    "lodash": "^4.17.11",
-    "mini-css-extract-plugin": "^0.5.0",
-    "node-sass": "^4.11.0",
-    "nodemon": "^1.18.8",
-    "pre-commit": "^1.2.2",
-    "sass-loader": "^7.1.0",
-    "standard-version": "^4.4.0",
-    "webpack": "^4.27.1",
-    "webpack-cli": "^3.1.2",
-    "webpack-defaults": "^1.6.0"
+    "@babel/cli": "^7.12.1",
+    "@babel/core": "^7.12.3",
+    "@babel/preset-env": "^7.12.1",
+    "@commitlint/cli": "^11.0.0",
+    "@commitlint/config-conventional": "^11.0.0",
+    "@webpack-contrib/eslint-config-webpack": "^3.0.0",
+    "babel-jest": "^26.6.1",
+    "babel-loader": "^8.1.0",
+    "cross-env": "^7.0.2",
+    "css-loader": "^5.0.0",
+    "del": "^5.1.0",
+    "del-cli": "^3.0.1",
+    "eslint": "^7.12.1",
+    "eslint-config-prettier": "^6.14.0",
+    "eslint-plugin-import": "^2.22.1",
+    "husky": "^4.3.0",
+    "jest": "^26.6.1",
+    "lint-staged": "^10.5.0",
+    "lodash": "^4.17.20",
+    "memfs": "^3.2.0",
+    "mini-css-extract-plugin": "^1.6.0",
+    "nodemon": "^2.0.6",
+    "npm-run-all": "^4.1.5",
+    "postcss": "^8.2.14",
+    "postcss-font-magician": "^3.0.0",
+    "postcss-loader": "^5.2.0",
+    "prettier": "^2.1.2",
+    "sass": "^1.27.0",
+    "sass-loader": "^11.0.1",
+    "standard-version": "^9.0.0",
+    "webpack": "^5.3.0"
  },
  "engines": {
-    "node": ">= 6.9.0 <7.0.0 || >= 8.9.0"
+    "node": ">= 10.13.0"
  },
  "files": [
    "dist"
  ],
-  "homepage": "https://github.com/webpack-contrib/thread-loader",
-  "license": "MIT",
-  "lint-staged": {
-    "*.js": [
-      "eslint --fix",
-      "git add"
-    ]
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/webpack"
  },
+  "homepage": "https://github.com/webpack-contrib/thread-loader",
+  "keywords": [
+    "webpack"
+  ],
+  "license": "MIT",
  "main": "dist/cjs.js",
  "name": "thread-loader",
  "peerDependencies": {
-    "webpack": "^2.0.0 || ^3.0.0 || ^4.0.0"
+    "webpack": "^4.27.0 || ^5.0.0"
  },
-  "pre-commit": "lint-staged",
  "repository": {
    "type": "git",
    "url": "git+https://github.com/webpack-contrib/thread-loader.git"
  },
  "scripts": {
-    "appveyor:test": "npm run test",
-    "build": "cross-env NODE_ENV=production babel src -d dist --ignore 'src/**/*.test.js'",
+    "build": "cross-env NODE_ENV=production babel src -d dist --copy-files",
    "clean": "del-cli dist",
-    "lint": "eslint --cache src test",
-    "lint-staged": "lint-staged",
+    "commitlint": "commitlint --from=master",
+    "lint": "npm-run-all -l -p \"lint:**\"",
+    "lint:js": "eslint --cache .",
+    "lint:prettier": "prettier \"{**/*,*}.{js,json,md,yml,css,ts}\" --list-different",
    "prebuild": "npm run clean",
    "prepare": "npm run build",
+    "pretest": "npm run lint",
    "release": "standard-version",
    "security": "npm audit",
    "start": "npm run build -- -w",
-    "test": "jest",
-    "test:coverage": "jest --collectCoverageFrom='src/**/*.js' --coverage",
-    "test:watch": "jest --watch",
-    "travis:coverage": "npm run test:coverage -- --runInBand",
-    "travis:lint": "npm run lint && npm run security",
-    "travis:test": "npm run test -- --runInBand",
-    "webpack-defaults": "webpack-defaults"
+    "test": "npm run test:coverage",
+    "test:coverage": "npm run test:only -- --collectCoverageFrom=\"src/**/*.js\" --coverage",
+    "test:only": "cross-env NODE_ENV=test jest --forceExit",
+    "test:watch": "npm run test:only -- --watch"
  },
-  "version": "2.1.3"
+  "version": "3.0.4"
 }