chushihua

node_modules/watchpack/LICENSE

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/watchpack/README.md

@@ -0,0 +1,72 @@
+# watchpack
+
+Wrapper library for directory and file watching.
+
+[![Build Status](https://travis-ci.org/webpack/watchpack.svg?branch=master)](https://travis-ci.org/webpack/watchpack) [![Build status](https://ci.appveyor.com/api/projects/status/e5u2qvmugtv0r647/branch/master?svg=true)](https://ci.appveyor.com/project/sokra/watchpack/branch/master) [![Test coverage][coveralls-image]][coveralls-url]
+
+## Concept
+
+watchpack high level API doesn't map directly to watchers. Instead a three level architecture ensures that for each directory only a single watcher exists.
+
+* The high level API requests `DirectoryWatchers` from a `WatcherManager`, which ensures that only a single `DirectoryWatcher` per directory is created.
+* A user-faced `Watcher` can be obtained from a `DirectoryWatcher` and provides a filtered view on the `DirectoryWatcher`.
+* Reference-counting is used on the `DirectoryWatcher` and `Watcher` to decide when to close them.
+* The real watchers (currently chokidar) are created by the `DirectoryWatcher`.
+* Files are never watched directly. This should keep the watcher count low.
+* Watching can be started in the past. This way watching can start after file reading.
+* Symlinks are not followed, instead the symlink is watched.
+
+## API
+
+``` javascript
+var Watchpack = require("watchpack");
+
+var wp = new Watchpack({
+	// options:
+	aggregateTimeout: 1000
+	// fire "aggregated" event when after a change for 1000ms no additional change occurred
+	// aggregated defaults to undefined, which doesn't fire an "aggregated" event
+
+	poll: true
+	// poll: true - use polling with the default interval
+	// poll: 10000 - use polling with an interval of 10s
+	// poll defaults to undefined, which prefer native watching methods
+	// Note: enable polling when watching on a network path
+
+	ignored: /node_modules/,
+	// anymatch-compatible definition of files/paths to be ignored
+	// see https://github.com/paulmillr/chokidar#path-filtering
+});
+
+// Watchpack.prototype.watch(string[] files, string[] directories, [number startTime])
+wp.watch(listOfFiles, listOfDirectories, Date.now() - 10000);
+// starts watching these files and directories
+// calling this again will override the files and directories
+
+wp.on("change", function(filePath, mtime) {
+	// filePath: the changed file
+	// mtime: last modified time for the changed file
+});
+
+wp.on("aggregated", function(changes) {
+	// changes: an array of all changed files
+});
+
+// Watchpack.prototype.pause()
+wp.pause();
+// stops emitting events, but keeps watchers open
+// next "watch" call can reuse the watchers
+
+// Watchpack.prototype.close()
+wp.close();
+// stops emitting events and closes all watchers
+
+// Watchpack.prototype.getTimes()
+var fileTimes = wp.getTimes();
+// returns an object with all know change times for files
+// this include timestamps from files not directly watched
+// key: absolute path, value: timestamp as number
+```
+
+[coveralls-url]: https://coveralls.io/r/webpack/watchpack/
+[coveralls-image]: https://img.shields.io/coveralls/webpack/watchpack.svg

node_modules/watchpack/lib/DirectoryWatcher.js

@@ -0,0 +1,379 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+var EventEmitter = require("events").EventEmitter;
+var async = require("neo-async");
+var chokidar = require("./chokidar");
+var fs = require("graceful-fs");
+var path = require("path");
+
+var watcherManager = require("./watcherManager");
+
+var FS_ACCURACY = 1000;
+
+
+function withoutCase(str) {
+	return str.toLowerCase();
+}
+
+
+function Watcher(directoryWatcher, filePath, startTime) {
+	EventEmitter.call(this);
+	this.directoryWatcher = directoryWatcher;
+	this.path = filePath;
+	this.startTime = startTime && +startTime;
+	// TODO this.data seem to be only read, weird
+	this.data = 0;
+}
+
+Watcher.prototype = Object.create(EventEmitter.prototype);
+Watcher.prototype.constructor = Watcher;
+
+Watcher.prototype.checkStartTime = function checkStartTime(mtime, initial) {
+	if(typeof this.startTime !== "number") return !initial;
+	var startTime = this.startTime;
+	return startTime <= mtime;
+};
+
+Watcher.prototype.close = function close() {
+	this.emit("closed");
+};
+
+
+function DirectoryWatcher(directoryPath, options) {
+	EventEmitter.call(this);
+	this.options = options;
+	this.path = directoryPath;
+	this.files = Object.create(null);
+	this.directories = Object.create(null);
+	var interval = typeof options.poll === "number" ? options.poll : undefined;
+	this.watcher = chokidar.watch(directoryPath, {
+		ignoreInitial: true,
+		persistent: true,
+		followSymlinks: false,
+		depth: 0,
+		atomic: false,
+		alwaysStat: true,
+		ignorePermissionErrors: true,
+		ignored: options.ignored,
+		usePolling: options.poll ? true : undefined,
+		interval: interval,
+		binaryInterval: interval,
+		disableGlobbing: true
+	});
+	this.watcher.on("add", this.onFileAdded.bind(this));
+	this.watcher.on("addDir", this.onDirectoryAdded.bind(this));
+	this.watcher.on("change", this.onChange.bind(this));
+	this.watcher.on("unlink", this.onFileUnlinked.bind(this));
+	this.watcher.on("unlinkDir", this.onDirectoryUnlinked.bind(this));
+	this.watcher.on("error", this.onWatcherError.bind(this));
+	this.initialScan = true;
+	this.nestedWatching = false;
+	this.initialScanRemoved = [];
+	this.doInitialScan();
+	this.watchers = Object.create(null);
+	this.parentWatcher = null;
+	this.refs = 0;
+}
+module.exports = DirectoryWatcher;
+
+DirectoryWatcher.prototype = Object.create(EventEmitter.prototype);
+DirectoryWatcher.prototype.constructor = DirectoryWatcher;
+
+DirectoryWatcher.prototype.setFileTime = function setFileTime(filePath, mtime, initial, type) {
+	var now = Date.now();
+	var old = this.files[filePath];
+
+	this.files[filePath] = [initial ? Math.min(now, mtime) : now, mtime];
+
+	// we add the fs accuracy to reach the maximum possible mtime
+	if(mtime)
+		mtime = mtime + FS_ACCURACY;
+
+	if(!old) {
+		if(mtime) {
+			if(this.watchers[withoutCase(filePath)]) {
+				this.watchers[withoutCase(filePath)].forEach(function(w) {
+					if(!initial || w.checkStartTime(mtime, initial)) {
+						w.emit("change", mtime, initial ? "initial" : type);
+					}
+				});
+			}
+		}
+	} else if(!initial && mtime) {
+		if(this.watchers[withoutCase(filePath)]) {
+			this.watchers[withoutCase(filePath)].forEach(function(w) {
+				w.emit("change", mtime, type);
+			});
+		}
+	} else if(!initial && !mtime) {
+		if(this.watchers[withoutCase(filePath)]) {
+			this.watchers[withoutCase(filePath)].forEach(function(w) {
+				w.emit("remove", type);
+			});
+		}
+	}
+	if(this.watchers[withoutCase(this.path)]) {
+		this.watchers[withoutCase(this.path)].forEach(function(w) {
+			if(!initial || w.checkStartTime(mtime, initial)) {
+				w.emit("change", filePath, mtime, initial ? "initial" : type);
+			}
+		});
+	}
+};
+
+DirectoryWatcher.prototype.setDirectory = function setDirectory(directoryPath, exist, initial, type) {
+	if(directoryPath === this.path) {
+		if(!initial && this.watchers[withoutCase(this.path)]) {
+			this.watchers[withoutCase(this.path)].forEach(function(w) {
+				w.emit("change", directoryPath, w.data, initial ? "initial" : type);
+			});
+		}
+	} else {
+		var old = this.directories[directoryPath];
+		if(!old) {
+			if(exist) {
+				if(this.nestedWatching) {
+					this.createNestedWatcher(directoryPath);
+				} else {
+					this.directories[directoryPath] = true;
+				}
+				if(!initial && this.watchers[withoutCase(this.path)]) {
+					this.watchers[withoutCase(this.path)].forEach(function(w) {
+						w.emit("change", directoryPath, w.data, initial ? "initial" : type);
+					});
+				}
+				if(this.watchers[withoutCase(directoryPath) + "#directory"]) {
+					this.watchers[withoutCase(directoryPath) + "#directory"].forEach(function(w) {
+						w.emit("change", w.data, initial ? "initial" : type);
+					});
+				}
+			}
+		} else {
+			if(!exist) {
+				if(this.nestedWatching)
+					this.directories[directoryPath].close();
+				delete this.directories[directoryPath];
+				if(!initial && this.watchers[withoutCase(this.path)]) {
+					this.watchers[withoutCase(this.path)].forEach(function(w) {
+						w.emit("change", directoryPath, w.data, initial ? "initial" : type);
+					});
+				}
+				if(this.watchers[withoutCase(directoryPath) + "#directory"]) {
+					this.watchers[withoutCase(directoryPath) + "#directory"].forEach(function(w) {
+						w.emit("change", directoryPath, w.data, initial ? "initial" : type);
+					});
+				}
+			}
+		}
+	}
+};
+
+DirectoryWatcher.prototype.createNestedWatcher = function(directoryPath) {
+	this.directories[directoryPath] = watcherManager.watchDirectory(directoryPath, this.options, 1);
+	this.directories[directoryPath].on("change", function(filePath, mtime, type) {
+		if(this.watchers[withoutCase(this.path)]) {
+			this.watchers[withoutCase(this.path)].forEach(function(w) {
+				if(w.checkStartTime(mtime, false)) {
+					w.emit("change", filePath, mtime, type);
+				}
+			});
+		}
+	}.bind(this));
+};
+
+DirectoryWatcher.prototype.setNestedWatching = function(flag) {
+	if(this.nestedWatching !== !!flag) {
+		this.nestedWatching = !!flag;
+		if(this.nestedWatching) {
+			Object.keys(this.directories).forEach(function(directory) {
+				this.createNestedWatcher(directory);
+			}, this);
+		} else {
+			Object.keys(this.directories).forEach(function(directory) {
+				this.directories[directory].close();
+				this.directories[directory] = true;
+			}, this);
+		}
+	}
+};
+
+DirectoryWatcher.prototype.watch = function watch(filePath, startTime) {
+	this.watchers[withoutCase(filePath)] = this.watchers[withoutCase(filePath)] || [];
+	this.refs++;
+	var watcher = new Watcher(this, filePath, startTime);
+	watcher.on("closed", function() {
+		var idx = this.watchers[withoutCase(filePath)].indexOf(watcher);
+		this.watchers[withoutCase(filePath)].splice(idx, 1);
+		if(this.watchers[withoutCase(filePath)].length === 0) {
+			delete this.watchers[withoutCase(filePath)];
+			if(this.path === filePath)
+				this.setNestedWatching(false);
+		}
+		if(--this.refs <= 0)
+			this.close();
+	}.bind(this));
+	this.watchers[withoutCase(filePath)].push(watcher);
+	var data;
+	if(filePath === this.path) {
+		this.setNestedWatching(true);
+		data = false;
+		Object.keys(this.files).forEach(function(file) {
+			var d = this.files[file];
+			if(!data)
+				data = d;
+			else
+				data = [Math.max(data[0], d[0]), Math.max(data[1], d[1])];
+		}, this);
+	} else {
+		data = this.files[filePath];
+	}
+	process.nextTick(function() {
+		if(data) {
+			var ts = data[0] === data[1] ? data[0] + FS_ACCURACY : data[0];
+			if(ts >= startTime)
+				watcher.emit("change", data[1]);
+		} else if(this.initialScan && this.initialScanRemoved.indexOf(filePath) >= 0) {
+			watcher.emit("remove");
+		}
+	}.bind(this));
+	return watcher;
+};
+
+DirectoryWatcher.prototype.onFileAdded = function onFileAdded(filePath, stat) {
+	if(filePath.indexOf(this.path) !== 0) return;
+	if(/[\\\/]/.test(filePath.substr(this.path.length + 1))) return;
+
+	this.setFileTime(filePath, +stat.mtime || +stat.ctime || 1, false, "add");
+};
+
+DirectoryWatcher.prototype.onDirectoryAdded = function onDirectoryAdded(directoryPath /*, stat */) {
+	if(directoryPath.indexOf(this.path) !== 0) return;
+	if(/[\\\/]/.test(directoryPath.substr(this.path.length + 1))) return;
+	this.setDirectory(directoryPath, true, false, "add");
+};
+
+DirectoryWatcher.prototype.onChange = function onChange(filePath, stat) {
+	if(filePath.indexOf(this.path) !== 0) return;
+	if(/[\\\/]/.test(filePath.substr(this.path.length + 1))) return;
+	var mtime = +stat.mtime || +stat.ctime || 1;
+	ensureFsAccuracy(mtime);
+	this.setFileTime(filePath, mtime, false, "change");
+};
+
+DirectoryWatcher.prototype.onFileUnlinked = function onFileUnlinked(filePath) {
+	if(filePath.indexOf(this.path) !== 0) return;
+	if(/[\\\/]/.test(filePath.substr(this.path.length + 1))) return;
+	this.setFileTime(filePath, null, false, "unlink");
+	if(this.initialScan) {
+		this.initialScanRemoved.push(filePath);
+	}
+};
+
+DirectoryWatcher.prototype.onDirectoryUnlinked = function onDirectoryUnlinked(directoryPath) {
+	if(directoryPath.indexOf(this.path) !== 0) return;
+	if(/[\\\/]/.test(directoryPath.substr(this.path.length + 1))) return;
+	this.setDirectory(directoryPath, false, false, "unlink");
+	if(this.initialScan) {
+		this.initialScanRemoved.push(directoryPath);
+	}
+};
+
+DirectoryWatcher.prototype.onWatcherError = function onWatcherError(err) {
+	console.warn("Error from chokidar (" + this.path + "): " + err);
+};
+
+DirectoryWatcher.prototype.doInitialScan = function doInitialScan() {
+	fs.readdir(this.path, function(err, items) {
+		if(err) {
+			this.parentWatcher = watcherManager.watchFile(this.path + "#directory", this.options, 1);
+			this.parentWatcher.on("change", function(mtime, type) {
+				if(this.watchers[withoutCase(this.path)]) {
+					this.watchers[withoutCase(this.path)].forEach(function(w) {
+						w.emit("change", this.path, mtime, type);
+					}, this);
+				}
+			}.bind(this));
+			this.initialScan = false;
+			return;
+		}
+		async.forEach(items, function(item, callback) {
+			var itemPath = path.join(this.path, item);
+			fs.stat(itemPath, function(err2, stat) {
+				if(!this.initialScan) return;
+				if(err2) {
+					callback();
+					return;
+				}
+				if(stat.isFile()) {
+					if(!this.files[itemPath])
+						this.setFileTime(itemPath, +stat.mtime || +stat.ctime || 1, true);
+				} else if(stat.isDirectory()) {
+					if(!this.directories[itemPath])
+						this.setDirectory(itemPath, true, true);
+				}
+				callback();
+			}.bind(this));
+		}.bind(this), function() {
+			this.initialScan = false;
+			this.initialScanRemoved = null;
+		}.bind(this));
+	}.bind(this));
+};
+
+DirectoryWatcher.prototype.getTimes = function() {
+	var obj = Object.create(null);
+	var selfTime = 0;
+	Object.keys(this.files).forEach(function(file) {
+		var data = this.files[file];
+		var time;
+		if(data[1]) {
+			time = Math.max(data[0], data[1] + FS_ACCURACY);
+		} else {
+			time = data[0];
+		}
+		obj[file] = time;
+		if(time > selfTime)
+			selfTime = time;
+	}, this);
+	if(this.nestedWatching) {
+		Object.keys(this.directories).forEach(function(dir) {
+			var w = this.directories[dir];
+			var times = w.directoryWatcher.getTimes();
+			Object.keys(times).forEach(function(file) {
+				var time = times[file];
+				obj[file] = time;
+				if(time > selfTime)
+					selfTime = time;
+			});
+		}, this);
+		obj[this.path] = selfTime;
+	}
+	return obj;
+};
+
+DirectoryWatcher.prototype.close = function() {
+	this.initialScan = false;
+	var p = this.watcher.close();
+	if(p && p.catch) p.catch(this.onWatcherError.bind(this));
+	if(this.nestedWatching) {
+		Object.keys(this.directories).forEach(function(dir) {
+			this.directories[dir].close();
+		}, this);
+	}
+	if(this.parentWatcher) this.parentWatcher.close();
+	this.emit("closed");
+};
+
+function ensureFsAccuracy(mtime) {
+	if(!mtime) return;
+	if(FS_ACCURACY > 1 && mtime % 1 !== 0)
+		FS_ACCURACY = 1;
+	else if(FS_ACCURACY > 10 && mtime % 10 !== 0)
+		FS_ACCURACY = 10;
+	else if(FS_ACCURACY > 100 && mtime % 100 !== 0)
+		FS_ACCURACY = 100;
+}

node_modules/watchpack/lib/chokidar.js

@@ -0,0 +1,22 @@
+var v3Err;
+try {
+	module.exports = require("chokidar");
+	return;
+} catch(e) {
+	v3Err = e;
+}
+
+var v2Err;
+try {
+	module.exports = require("watchpack-chokidar2");
+	return;
+} catch(e) {
+	v2Err = e;
+}
+
+throw new Error(
+	"No version of chokidar is available. Tried chokidar@2 and chokidar@3.\n" +
+	"You could try to manually install any chokidar version.\n" +
+	"chokidar@3: " + v3Err + "\n" +
+	"chokidar@2: " + v2Err + "\n"
+)

node_modules/watchpack/lib/watcherManager.js

@@ -0,0 +1,35 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+var path = require("path");
+
+function WatcherManager() {
+	this.directoryWatchers = {};
+}
+
+WatcherManager.prototype.getDirectoryWatcher = function(directory, options) {
+	var DirectoryWatcher = require("./DirectoryWatcher");
+	options = options || {};
+	var key = directory + " " + JSON.stringify(options);
+	if(!this.directoryWatchers[key]) {
+		this.directoryWatchers[key] = new DirectoryWatcher(directory, options);
+		this.directoryWatchers[key].on("closed", function() {
+			delete this.directoryWatchers[key];
+		}.bind(this));
+	}
+	return this.directoryWatchers[key];
+};
+
+WatcherManager.prototype.watchFile = function watchFile(p, options, startTime) {
+	var directory = path.dirname(p);
+	return this.getDirectoryWatcher(directory, options).watch(p, startTime);
+};
+
+WatcherManager.prototype.watchDirectory = function watchDirectory(directory, options, startTime) {
+	return this.getDirectoryWatcher(directory, options).watch(directory, startTime);
+};
+
+module.exports = new WatcherManager();

node_modules/watchpack/lib/watchpack.js

@@ -0,0 +1,145 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+var watcherManager = require("./watcherManager");
+var EventEmitter = require("events").EventEmitter;
+
+function Watchpack(options) {
+	EventEmitter.call(this);
+	if(!options) options = {};
+	if(!options.aggregateTimeout) options.aggregateTimeout = 200;
+	this.options = options;
+	this.watcherOptions = {
+		ignored: options.ignored,
+		poll: options.poll
+	};
+	this.fileWatchers = [];
+	this.dirWatchers = [];
+	this.mtimes = Object.create(null);
+	this.paused = false;
+	this.aggregatedChanges = [];
+	this.aggregatedRemovals = [];
+	this.aggregateTimeout = 0;
+	this._onTimeout = this._onTimeout.bind(this);
+}
+
+module.exports = Watchpack;
+
+Watchpack.prototype = Object.create(EventEmitter.prototype);
+
+Watchpack.prototype.watch = function watch(files, directories, startTime) {
+	this.paused = false;
+	var oldFileWatchers = this.fileWatchers;
+	var oldDirWatchers = this.dirWatchers;
+	this.fileWatchers = files.map(function(file) {
+		return this._fileWatcher(file, watcherManager.watchFile(file, this.watcherOptions, startTime));
+	}, this);
+	this.dirWatchers = directories.map(function(dir) {
+		return this._dirWatcher(dir, watcherManager.watchDirectory(dir, this.watcherOptions, startTime));
+	}, this);
+	oldFileWatchers.forEach(function(w) {
+		w.close();
+	}, this);
+	oldDirWatchers.forEach(function(w) {
+		w.close();
+	}, this);
+};
+
+Watchpack.prototype.close = function resume() {
+	this.paused = true;
+	if(this.aggregateTimeout)
+		clearTimeout(this.aggregateTimeout);
+	this.fileWatchers.forEach(function(w) {
+		w.close();
+	}, this);
+	this.dirWatchers.forEach(function(w) {
+		w.close();
+	}, this);
+	this.fileWatchers.length = 0;
+	this.dirWatchers.length = 0;
+};
+
+Watchpack.prototype.pause = function pause() {
+	this.paused = true;
+	if(this.aggregateTimeout)
+		clearTimeout(this.aggregateTimeout);
+};
+
+function addWatchersToArray(watchers, array) {
+	watchers.forEach(function(w) {
+		if(array.indexOf(w.directoryWatcher) < 0) {
+			array.push(w.directoryWatcher);
+			addWatchersToArray(Object.keys(w.directoryWatcher.directories).reduce(function(a, dir) {
+				if(w.directoryWatcher.directories[dir] !== true)
+					a.push(w.directoryWatcher.directories[dir]);
+				return a;
+			}, []), array);
+		}
+	});
+}
+
+Watchpack.prototype.getTimes = function() {
+	var directoryWatchers = [];
+	addWatchersToArray(this.fileWatchers.concat(this.dirWatchers), directoryWatchers);
+	var obj = Object.create(null);
+	directoryWatchers.forEach(function(w) {
+		var times = w.getTimes();
+		Object.keys(times).forEach(function(file) {
+			obj[file] = times[file];
+		});
+	});
+	return obj;
+};
+
+Watchpack.prototype._fileWatcher = function _fileWatcher(file, watcher) {
+	watcher.on("change", function(mtime, type) {
+		this._onChange(file, mtime, file, type);
+	}.bind(this));
+	watcher.on("remove", function(type) {
+		this._onRemove(file, file, type);
+	}.bind(this));
+	return watcher;
+};
+
+Watchpack.prototype._dirWatcher = function _dirWatcher(item, watcher) {
+	watcher.on("change", function(file, mtime, type) {
+		this._onChange(item, mtime, file, type);
+	}.bind(this));
+	return watcher;
+};
+
+Watchpack.prototype._onChange = function _onChange(item, mtime, file) {
+	file = file || item;
+	this.mtimes[file] = mtime;
+	if(this.paused) return;
+	this.emit("change", file, mtime);
+	if(this.aggregateTimeout)
+		clearTimeout(this.aggregateTimeout);
+	if(this.aggregatedChanges.indexOf(item) < 0)
+		this.aggregatedChanges.push(item);
+	this.aggregateTimeout = setTimeout(this._onTimeout, this.options.aggregateTimeout);
+};
+
+Watchpack.prototype._onRemove = function _onRemove(item, file) {
+	file = file || item;
+	delete this.mtimes[item];
+	if(this.paused) return;
+	this.emit("remove", item);
+	if(this.aggregateTimeout)
+		clearTimeout(this.aggregateTimeout);
+	if(this.aggregatedRemovals.indexOf(item) < 0)
+		this.aggregatedRemovals.push(item);
+	this.aggregateTimeout = setTimeout(this._onTimeout, this.options.aggregateTimeout);
+};
+
+Watchpack.prototype._onTimeout = function _onTimeout() {
+	this.aggregateTimeout = 0;
+	var changes = this.aggregatedChanges;
+	var removals = this.aggregatedRemovals;
+	this.aggregatedChanges = [];
+	this.aggregatedRemovals = [];
+	this.emit("aggregated", changes, removals);
+};

node_modules/watchpack/node_modules/graceful-fs/LICENSE

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

node_modules/watchpack/node_modules/graceful-fs/README.md

@@ -0,0 +1,143 @@
+# graceful-fs
+
+graceful-fs functions as a drop-in replacement for the fs module,
+making various improvements.
+
+The improvements are meant to normalize behavior across different
+platforms and environments, and to make filesystem access more
+resilient to errors.
+
+## Improvements over [fs module](https://nodejs.org/api/fs.html)
+
+* Queues up `open` and `readdir` calls, and retries them once
+  something closes if there is an EMFILE error from too many file
+  descriptors.
+* fixes `lchmod` for Node versions prior to 0.6.2.
+* implements `fs.lutimes` if possible. Otherwise it becomes a noop.
+* ignores `EINVAL` and `EPERM` errors in `chown`, `fchown` or
+  `lchown` if the user isn't root.
+* makes `lchmod` and `lchown` become noops, if not available.
+* retries reading a file if `read` results in EAGAIN error.
+
+On Windows, it retries renaming a file for up to one second if `EACCESS`
+or `EPERM` error occurs, likely because antivirus software has locked
+the directory.
+
+## USAGE
+
+```javascript
+// use just like fs
+var fs = require('graceful-fs')
+
+// now go and do stuff with it...
+fs.readFile('some-file-or-whatever', (err, data) => {
+  // Do stuff here.
+})
+```
+
+## Sync methods
+
+This module cannot intercept or handle `EMFILE` or `ENFILE` errors from sync
+methods.  If you use sync methods which open file descriptors then you are
+responsible for dealing with any errors.
+
+This is a known limitation, not a bug.
+
+## Global Patching
+
+If you want to patch the global fs module (or any other fs-like
+module) you can do this:
+
+```javascript
+// Make sure to read the caveat below.
+var realFs = require('fs')
+var gracefulFs = require('graceful-fs')
+gracefulFs.gracefulify(realFs)
+```
+
+This should only ever be done at the top-level application layer, in
+order to delay on EMFILE errors from any fs-using dependencies.  You
+should **not** do this in a library, because it can cause unexpected
+delays in other parts of the program.
+
+## Changes
+
+This module is fairly stable at this point, and used by a lot of
+things.  That being said, because it implements a subtle behavior
+change in a core part of the node API, even modest changes can be
+extremely breaking, and the versioning is thus biased towards
+bumping the major when in doubt.
+
+The main change between major versions has been switching between
+providing a fully-patched `fs` module vs monkey-patching the node core
+builtin, and the approach by which a non-monkey-patched `fs` was
+created.
+
+The goal is to trade `EMFILE` errors for slower fs operations.  So, if
+you try to open a zillion files, rather than crashing, `open`
+operations will be queued up and wait for something else to `close`.
+
+There are advantages to each approach.  Monkey-patching the fs means
+that no `EMFILE` errors can possibly occur anywhere in your
+application, because everything is using the same core `fs` module,
+which is patched.  However, it can also obviously cause undesirable
+side-effects, especially if the module is loaded multiple times.
+
+Implementing a separate-but-identical patched `fs` module is more
+surgical (and doesn't run the risk of patching multiple times), but
+also imposes the challenge of keeping in sync with the core module.
+
+The current approach loads the `fs` module, and then creates a
+lookalike object that has all the same methods, except a few that are
+patched.  It is safe to use in all versions of Node from 0.8 through
+7.0.
+
+### v4
+
+* Do not monkey-patch the fs module.  This module may now be used as a
+  drop-in dep, and users can opt into monkey-patching the fs builtin
+  if their app requires it.
+
+### v3
+
+* Monkey-patch fs, because the eval approach no longer works on recent
+  node.
+* fixed possible type-error throw if rename fails on windows
+* verify that we *never* get EMFILE errors
+* Ignore ENOSYS from chmod/chown
+* clarify that graceful-fs must be used as a drop-in
+
+### v2.1.0
+
+* Use eval rather than monkey-patching fs.
+* readdir: Always sort the results
+* win32: requeue a file if error has an OK status
+
+### v2.0
+
+* A return to monkey patching
+* wrap process.cwd
+
+### v1.1
+
+* wrap readFile
+* Wrap fs.writeFile.
+* readdir protection
+* Don't clobber the fs builtin
+* Handle fs.read EAGAIN errors by trying again
+* Expose the curOpen counter
+* No-op lchown/lchmod if not implemented
+* fs.rename patch only for win32
+* Patch fs.rename to handle AV software on Windows
+* Close #4 Chown should not fail on einval or eperm if non-root
+* Fix isaacs/fstream#1 Only wrap fs one time
+* Fix #3 Start at 1024 max files, then back off on EMFILE
+* lutimes that doens't blow up on Linux
+* A full on-rewrite using a queue instead of just swallowing the EMFILE error
+* Wrap Read/Write streams as well
+
+### 1.0
+
+* Update engines for node 0.6
+* Be lstat-graceful on Windows
+* first

node_modules/watchpack/node_modules/graceful-fs/clone.js

@@ -0,0 +1,23 @@
+'use strict'
+
+module.exports = clone
+
+var getPrototypeOf = Object.getPrototypeOf || function (obj) {
+  return obj.__proto__
+}
+
+function clone (obj) {
+  if (obj === null || typeof obj !== 'object')
+    return obj
+
+  if (obj instanceof Object)
+    var copy = { __proto__: getPrototypeOf(obj) }
+  else
+    var copy = Object.create(null)
+
+  Object.getOwnPropertyNames(obj).forEach(function (key) {
+    Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
+  })
+
+  return copy
+}

node_modules/watchpack/node_modules/graceful-fs/graceful-fs.js

@@ -0,0 +1,448 @@
+var fs = require('fs')
+var polyfills = require('./polyfills.js')
+var legacy = require('./legacy-streams.js')
+var clone = require('./clone.js')
+
+var util = require('util')
+
+/* istanbul ignore next - node 0.x polyfill */
+var gracefulQueue
+var previousSymbol
+
+/* istanbul ignore else - node 0.x polyfill */
+if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
+  gracefulQueue = Symbol.for('graceful-fs.queue')
+  // This is used in testing by future versions
+  previousSymbol = Symbol.for('graceful-fs.previous')
+} else {
+  gracefulQueue = '___graceful-fs.queue'
+  previousSymbol = '___graceful-fs.previous'
+}
+
+function noop () {}
+
+function publishQueue(context, queue) {
+  Object.defineProperty(context, gracefulQueue, {
+    get: function() {
+      return queue
+    }
+  })
+}
+
+var debug = noop
+if (util.debuglog)
+  debug = util.debuglog('gfs4')
+else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
+  debug = function() {
+    var m = util.format.apply(util, arguments)
+    m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
+    console.error(m)
+  }
+
+// Once time initialization
+if (!fs[gracefulQueue]) {
+  // This queue can be shared by multiple loaded instances
+  var queue = global[gracefulQueue] || []
+  publishQueue(fs, queue)
+
+  // Patch fs.close/closeSync to shared queue version, because we need
+  // to retry() whenever a close happens *anywhere* in the program.
+  // This is essential when multiple graceful-fs instances are
+  // in play at the same time.
+  fs.close = (function (fs$close) {
+    function close (fd, cb) {
+      return fs$close.call(fs, fd, function (err) {
+        // This function uses the graceful-fs shared queue
+        if (!err) {
+          resetQueue()
+        }
+
+        if (typeof cb === 'function')
+          cb.apply(this, arguments)
+      })
+    }
+
+    Object.defineProperty(close, previousSymbol, {
+      value: fs$close
+    })
+    return close
+  })(fs.close)
+
+  fs.closeSync = (function (fs$closeSync) {
+    function closeSync (fd) {
+      // This function uses the graceful-fs shared queue
+      fs$closeSync.apply(fs, arguments)
+      resetQueue()
+    }
+
+    Object.defineProperty(closeSync, previousSymbol, {
+      value: fs$closeSync
+    })
+    return closeSync
+  })(fs.closeSync)
+
+  if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
+    process.on('exit', function() {
+      debug(fs[gracefulQueue])
+      require('assert').equal(fs[gracefulQueue].length, 0)
+    })
+  }
+}
+
+if (!global[gracefulQueue]) {
+  publishQueue(global, fs[gracefulQueue]);
+}
+
+module.exports = patch(clone(fs))
+if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+    module.exports = patch(fs)
+    fs.__patched = true;
+}
+
+function patch (fs) {
+  // Everything that references the open() function needs to be in here
+  polyfills(fs)
+  fs.gracefulify = patch
+
+  fs.createReadStream = createReadStream
+  fs.createWriteStream = createWriteStream
+  var fs$readFile = fs.readFile
+  fs.readFile = readFile
+  function readFile (path, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
+
+    return go$readFile(path, options, cb)
+
+    function go$readFile (path, options, cb, startTime) {
+      return fs$readFile(path, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
+
+  var fs$writeFile = fs.writeFile
+  fs.writeFile = writeFile
+  function writeFile (path, data, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
+
+    return go$writeFile(path, data, options, cb)
+
+    function go$writeFile (path, data, options, cb, startTime) {
+      return fs$writeFile(path, data, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
+
+  var fs$appendFile = fs.appendFile
+  if (fs$appendFile)
+    fs.appendFile = appendFile
+  function appendFile (path, data, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
+
+    return go$appendFile(path, data, options, cb)
+
+    function go$appendFile (path, data, options, cb, startTime) {
+      return fs$appendFile(path, data, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
+
+  var fs$copyFile = fs.copyFile
+  if (fs$copyFile)
+    fs.copyFile = copyFile
+  function copyFile (src, dest, flags, cb) {
+    if (typeof flags === 'function') {
+      cb = flags
+      flags = 0
+    }
+    return go$copyFile(src, dest, flags, cb)
+
+    function go$copyFile (src, dest, flags, cb, startTime) {
+      return fs$copyFile(src, dest, flags, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
+
+  var fs$readdir = fs.readdir
+  fs.readdir = readdir
+  var noReaddirOptionVersions = /^v[0-5]\./
+  function readdir (path, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
+
+    var go$readdir = noReaddirOptionVersions.test(process.version)
+      ? function go$readdir (path, options, cb, startTime) {
+        return fs$readdir(path, fs$readdirCallback(
+          path, options, cb, startTime
+        ))
+      }
+      : function go$readdir (path, options, cb, startTime) {
+        return fs$readdir(path, options, fs$readdirCallback(
+          path, options, cb, startTime
+        ))
+      }
+
+    return go$readdir(path, options, cb)
+
+    function fs$readdirCallback (path, options, cb, startTime) {
+      return function (err, files) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([
+            go$readdir,
+            [path, options, cb],
+            err,
+            startTime || Date.now(),
+            Date.now()
+          ])
+        else {
+          if (files && files.sort)
+            files.sort()
+
+          if (typeof cb === 'function')
+            cb.call(this, err, files)
+        }
+      }
+    }
+  }
+
+  if (process.version.substr(0, 4) === 'v0.8') {
+    var legStreams = legacy(fs)
+    ReadStream = legStreams.ReadStream
+    WriteStream = legStreams.WriteStream
+  }
+
+  var fs$ReadStream = fs.ReadStream
+  if (fs$ReadStream) {
+    ReadStream.prototype = Object.create(fs$ReadStream.prototype)
+    ReadStream.prototype.open = ReadStream$open
+  }
+
+  var fs$WriteStream = fs.WriteStream
+  if (fs$WriteStream) {
+    WriteStream.prototype = Object.create(fs$WriteStream.prototype)
+    WriteStream.prototype.open = WriteStream$open
+  }
+
+  Object.defineProperty(fs, 'ReadStream', {
+    get: function () {
+      return ReadStream
+    },
+    set: function (val) {
+      ReadStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
+  Object.defineProperty(fs, 'WriteStream', {
+    get: function () {
+      return WriteStream
+    },
+    set: function (val) {
+      WriteStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
+
+  // legacy names
+  var FileReadStream = ReadStream
+  Object.defineProperty(fs, 'FileReadStream', {
+    get: function () {
+      return FileReadStream
+    },
+    set: function (val) {
+      FileReadStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
+  var FileWriteStream = WriteStream
+  Object.defineProperty(fs, 'FileWriteStream', {
+    get: function () {
+      return FileWriteStream
+    },
+    set: function (val) {
+      FileWriteStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
+
+  function ReadStream (path, options) {
+    if (this instanceof ReadStream)
+      return fs$ReadStream.apply(this, arguments), this
+    else
+      return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
+  }
+
+  function ReadStream$open () {
+    var that = this
+    open(that.path, that.flags, that.mode, function (err, fd) {
+      if (err) {
+        if (that.autoClose)
+          that.destroy()
+
+        that.emit('error', err)
+      } else {
+        that.fd = fd
+        that.emit('open', fd)
+        that.read()
+      }
+    })
+  }
+
+  function WriteStream (path, options) {
+    if (this instanceof WriteStream)
+      return fs$WriteStream.apply(this, arguments), this
+    else
+      return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
+  }
+
+  function WriteStream$open () {
+    var that = this
+    open(that.path, that.flags, that.mode, function (err, fd) {
+      if (err) {
+        that.destroy()
+        that.emit('error', err)
+      } else {
+        that.fd = fd
+        that.emit('open', fd)
+      }
+    })
+  }
+
+  function createReadStream (path, options) {
+    return new fs.ReadStream(path, options)
+  }
+
+  function createWriteStream (path, options) {
+    return new fs.WriteStream(path, options)
+  }
+
+  var fs$open = fs.open
+  fs.open = open
+  function open (path, flags, mode, cb) {
+    if (typeof mode === 'function')
+      cb = mode, mode = null
+
+    return go$open(path, flags, mode, cb)
+
+    function go$open (path, flags, mode, cb, startTime) {
+      return fs$open(path, flags, mode, function (err, fd) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
+
+  return fs
+}
+
+function enqueue (elem) {
+  debug('ENQUEUE', elem[0].name, elem[1])
+  fs[gracefulQueue].push(elem)
+  retry()
+}
+
+// keep track of the timeout between retry() calls
+var retryTimer
+
+// reset the startTime and lastTime to now
+// this resets the start of the 60 second overall timeout as well as the
+// delay between attempts so that we'll retry these jobs sooner
+function resetQueue () {
+  var now = Date.now()
+  for (var i = 0; i < fs[gracefulQueue].length; ++i) {
+    // entries that are only a length of 2 are from an older version, don't
+    // bother modifying those since they'll be retried anyway.
+    if (fs[gracefulQueue][i].length > 2) {
+      fs[gracefulQueue][i][3] = now // startTime
+      fs[gracefulQueue][i][4] = now // lastTime
+    }
+  }
+  // call retry to make sure we're actively processing the queue
+  retry()
+}
+
+function retry () {
+  // clear the timer and remove it to help prevent unintended concurrency
+  clearTimeout(retryTimer)
+  retryTimer = undefined
+
+  if (fs[gracefulQueue].length === 0)
+    return
+
+  var elem = fs[gracefulQueue].shift()
+  var fn = elem[0]
+  var args = elem[1]
+  // these items may be unset if they were added by an older graceful-fs
+  var err = elem[2]
+  var startTime = elem[3]
+  var lastTime = elem[4]
+
+  // if we don't have a startTime we have no way of knowing if we've waited
+  // long enough, so go ahead and retry this item now
+  if (startTime === undefined) {
+    debug('RETRY', fn.name, args)
+    fn.apply(null, args)
+  } else if (Date.now() - startTime >= 60000) {
+    // it's been more than 60 seconds total, bail now
+    debug('TIMEOUT', fn.name, args)
+    var cb = args.pop()
+    if (typeof cb === 'function')
+      cb.call(null, err)
+  } else {
+    // the amount of time between the last attempt and right now
+    var sinceAttempt = Date.now() - lastTime
+    // the amount of time between when we first tried, and when we last tried
+    // rounded up to at least 1
+    var sinceStart = Math.max(lastTime - startTime, 1)
+    // backoff. wait longer than the total time we've been retrying, but only
+    // up to a maximum of 100ms
+    var desiredDelay = Math.min(sinceStart * 1.2, 100)
+    // it's been long enough since the last retry, do it again
+    if (sinceAttempt >= desiredDelay) {
+      debug('RETRY', fn.name, args)
+      fn.apply(null, args.concat([startTime]))
+    } else {
+      // if we can't do this job yet, push it to the end of the queue
+      // and let the next iteration check again
+      fs[gracefulQueue].push(elem)
+    }
+  }
+
+  // schedule our next run if one isn't already scheduled
+  if (retryTimer === undefined) {
+    retryTimer = setTimeout(retry, 0)
+  }
+}

node_modules/watchpack/node_modules/graceful-fs/legacy-streams.js

@@ -0,0 +1,118 @@
+var Stream = require('stream').Stream
+
+module.exports = legacy
+
+function legacy (fs) {
+  return {
+    ReadStream: ReadStream,
+    WriteStream: WriteStream
+  }
+
+  function ReadStream (path, options) {
+    if (!(this instanceof ReadStream)) return new ReadStream(path, options);
+
+    Stream.call(this);
+
+    var self = this;
+
+    this.path = path;
+    this.fd = null;
+    this.readable = true;
+    this.paused = false;
+
+    this.flags = 'r';
+    this.mode = 438; /*=0666*/
+    this.bufferSize = 64 * 1024;
+
+    options = options || {};
+
+    // Mixin options into this
+    var keys = Object.keys(options);
+    for (var index = 0, length = keys.length; index < length; index++) {
+      var key = keys[index];
+      this[key] = options[key];
+    }
+
+    if (this.encoding) this.setEncoding(this.encoding);
+
+    if (this.start !== undefined) {
+      if ('number' !== typeof this.start) {
+        throw TypeError('start must be a Number');
+      }
+      if (this.end === undefined) {
+        this.end = Infinity;
+      } else if ('number' !== typeof this.end) {
+        throw TypeError('end must be a Number');
+      }
+
+      if (this.start > this.end) {
+        throw new Error('start must be <= end');
+      }
+
+      this.pos = this.start;
+    }
+
+    if (this.fd !== null) {
+      process.nextTick(function() {
+        self._read();
+      });
+      return;
+    }
+
+    fs.open(this.path, this.flags, this.mode, function (err, fd) {
+      if (err) {
+        self.emit('error', err);
+        self.readable = false;
+        return;
+      }
+
+      self.fd = fd;
+      self.emit('open', fd);
+      self._read();
+    })
+  }
+
+  function WriteStream (path, options) {
+    if (!(this instanceof WriteStream)) return new WriteStream(path, options);
+
+    Stream.call(this);
+
+    this.path = path;
+    this.fd = null;
+    this.writable = true;
+
+    this.flags = 'w';
+    this.encoding = 'binary';
+    this.mode = 438; /*=0666*/
+    this.bytesWritten = 0;
+
+    options = options || {};
+
+    // Mixin options into this
+    var keys = Object.keys(options);
+    for (var index = 0, length = keys.length; index < length; index++) {
+      var key = keys[index];
+      this[key] = options[key];
+    }
+
+    if (this.start !== undefined) {
+      if ('number' !== typeof this.start) {
+        throw TypeError('start must be a Number');
+      }
+      if (this.start < 0) {
+        throw new Error('start must be >= zero');
+      }
+
+      this.pos = this.start;
+    }
+
+    this.busy = false;
+    this._queue = [];
+
+    if (this.fd === null) {
+      this._open = fs.open;
+      this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
+      this.flush();
+    }
+  }
+}

node_modules/watchpack/node_modules/graceful-fs/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "graceful-fs",
+  "description": "A drop-in replacement for fs, making various improvements.",
+  "version": "4.2.10",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/isaacs/node-graceful-fs"
+  },
+  "main": "graceful-fs.js",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "postpublish": "git push origin --follow-tags",
+    "test": "nyc --silent node test.js | tap -c -",
+    "posttest": "nyc report"
+  },
+  "keywords": [
+    "fs",
+    "module",
+    "reading",
+    "retry",
+    "retries",
+    "queue",
+    "error",
+    "errors",
+    "handling",
+    "EMFILE",
+    "EAGAIN",
+    "EINVAL",
+    "EPERM",
+    "EACCESS"
+  ],
+  "license": "ISC",
+  "devDependencies": {
+    "import-fresh": "^2.0.0",
+    "mkdirp": "^0.5.0",
+    "rimraf": "^2.2.8",
+    "tap": "^12.7.0"
+  },
+  "files": [
+    "fs.js",
+    "graceful-fs.js",
+    "legacy-streams.js",
+    "polyfills.js",
+    "clone.js"
+  ]
+}

node_modules/watchpack/node_modules/graceful-fs/polyfills.js

@@ -0,0 +1,355 @@
+var constants = require('constants')
+
+var origCwd = process.cwd
+var cwd = null
+
+var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform
+
+process.cwd = function() {
+  if (!cwd)
+    cwd = origCwd.call(process)
+  return cwd
+}
+try {
+  process.cwd()
+} catch (er) {}
+
+// This check is needed until node.js 12 is required
+if (typeof process.chdir === 'function') {
+  var chdir = process.chdir
+  process.chdir = function (d) {
+    cwd = null
+    chdir.call(process, d)
+  }
+  if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir)
+}
+
+module.exports = patch
+
+function patch (fs) {
+  // (re-)implement some things that are known busted or missing.
+
+  // lchmod, broken prior to 0.6.2
+  // back-port the fix here.
+  if (constants.hasOwnProperty('O_SYMLINK') &&
+      process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+    patchLchmod(fs)
+  }
+
+  // lutimes implementation, or no-op
+  if (!fs.lutimes) {
+    patchLutimes(fs)
+  }
+
+  // https://github.com/isaacs/node-graceful-fs/issues/4
+  // Chown should not fail on einval or eperm if non-root.
+  // It should not fail on enosys ever, as this just indicates
+  // that a fs doesn't support the intended operation.
+
+  fs.chown = chownFix(fs.chown)
+  fs.fchown = chownFix(fs.fchown)
+  fs.lchown = chownFix(fs.lchown)
+
+  fs.chmod = chmodFix(fs.chmod)
+  fs.fchmod = chmodFix(fs.fchmod)
+  fs.lchmod = chmodFix(fs.lchmod)
+
+  fs.chownSync = chownFixSync(fs.chownSync)
+  fs.fchownSync = chownFixSync(fs.fchownSync)
+  fs.lchownSync = chownFixSync(fs.lchownSync)
+
+  fs.chmodSync = chmodFixSync(fs.chmodSync)
+  fs.fchmodSync = chmodFixSync(fs.fchmodSync)
+  fs.lchmodSync = chmodFixSync(fs.lchmodSync)
+
+  fs.stat = statFix(fs.stat)
+  fs.fstat = statFix(fs.fstat)
+  fs.lstat = statFix(fs.lstat)
+
+  fs.statSync = statFixSync(fs.statSync)
+  fs.fstatSync = statFixSync(fs.fstatSync)
+  fs.lstatSync = statFixSync(fs.lstatSync)
+
+  // if lchmod/lchown do not exist, then make them no-ops
+  if (fs.chmod && !fs.lchmod) {
+    fs.lchmod = function (path, mode, cb) {
+      if (cb) process.nextTick(cb)
+    }
+    fs.lchmodSync = function () {}
+  }
+  if (fs.chown && !fs.lchown) {
+    fs.lchown = function (path, uid, gid, cb) {
+      if (cb) process.nextTick(cb)
+    }
+    fs.lchownSync = function () {}
+  }
+
+  // on Windows, A/V software can lock the directory, causing this
+  // to fail with an EACCES or EPERM if the directory contains newly
+  // created files.  Try again on failure, for up to 60 seconds.
+
+  // Set the timeout this long because some Windows Anti-Virus, such as Parity
+  // bit9, may lock files for up to a minute, causing npm package install
+  // failures. Also, take care to yield the scheduler. Windows scheduling gives
+  // CPU to a busy looping process, which can cause the program causing the lock
+  // contention to be starved of CPU by node, so the contention doesn't resolve.
+  if (platform === "win32") {
+    fs.rename = typeof fs.rename !== 'function' ? fs.rename
+    : (function (fs$rename) {
+      function rename (from, to, cb) {
+        var start = Date.now()
+        var backoff = 0;
+        fs$rename(from, to, function CB (er) {
+          if (er
+              && (er.code === "EACCES" || er.code === "EPERM")
+              && Date.now() - start < 60000) {
+            setTimeout(function() {
+              fs.stat(to, function (stater, st) {
+                if (stater && stater.code === "ENOENT")
+                  fs$rename(from, to, CB);
+                else
+                  cb(er)
+              })
+            }, backoff)
+            if (backoff < 100)
+              backoff += 10;
+            return;
+          }
+          if (cb) cb(er)
+        })
+      }
+      if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename)
+      return rename
+    })(fs.rename)
+  }
+
+  // if read() returns EAGAIN, then just try it again.
+  fs.read = typeof fs.read !== 'function' ? fs.read
+  : (function (fs$read) {
+    function read (fd, buffer, offset, length, position, callback_) {
+      var callback
+      if (callback_ && typeof callback_ === 'function') {
+        var eagCounter = 0
+        callback = function (er, _, __) {
+          if (er && er.code === 'EAGAIN' && eagCounter < 10) {
+            eagCounter ++
+            return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+          }
+          callback_.apply(this, arguments)
+        }
+      }
+      return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+    }
+
+    // This ensures `util.promisify` works as it does for native `fs.read`.
+    if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read)
+    return read
+  })(fs.read)
+
+  fs.readSync = typeof fs.readSync !== 'function' ? fs.readSync
+  : (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
+    var eagCounter = 0
+    while (true) {
+      try {
+        return fs$readSync.call(fs, fd, buffer, offset, length, position)
+      } catch (er) {
+        if (er.code === 'EAGAIN' && eagCounter < 10) {
+          eagCounter ++
+          continue
+        }
+        throw er
+      }
+    }
+  }})(fs.readSync)
+
+  function patchLchmod (fs) {
+    fs.lchmod = function (path, mode, callback) {
+      fs.open( path
+             , constants.O_WRONLY | constants.O_SYMLINK
+             , mode
+             , function (err, fd) {
+        if (err) {
+          if (callback) callback(err)
+          return
+        }
+        // prefer to return the chmod error, if one occurs,
+        // but still try to close, and report closing errors if they occur.
+        fs.fchmod(fd, mode, function (err) {
+          fs.close(fd, function(err2) {
+            if (callback) callback(err || err2)
+          })
+        })
+      })
+    }
+
+    fs.lchmodSync = function (path, mode) {
+      var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
+
+      // prefer to return the chmod error, if one occurs,
+      // but still try to close, and report closing errors if they occur.
+      var threw = true
+      var ret
+      try {
+        ret = fs.fchmodSync(fd, mode)
+        threw = false
+      } finally {
+        if (threw) {
+          try {
+            fs.closeSync(fd)
+          } catch (er) {}
+        } else {
+          fs.closeSync(fd)
+        }
+      }
+      return ret
+    }
+  }
+
+  function patchLutimes (fs) {
+    if (constants.hasOwnProperty("O_SYMLINK") && fs.futimes) {
+      fs.lutimes = function (path, at, mt, cb) {
+        fs.open(path, constants.O_SYMLINK, function (er, fd) {
+          if (er) {
+            if (cb) cb(er)
+            return
+          }
+          fs.futimes(fd, at, mt, function (er) {
+            fs.close(fd, function (er2) {
+              if (cb) cb(er || er2)
+            })
+          })
+        })
+      }
+
+      fs.lutimesSync = function (path, at, mt) {
+        var fd = fs.openSync(path, constants.O_SYMLINK)
+        var ret
+        var threw = true
+        try {
+          ret = fs.futimesSync(fd, at, mt)
+          threw = false
+        } finally {
+          if (threw) {
+            try {
+              fs.closeSync(fd)
+            } catch (er) {}
+          } else {
+            fs.closeSync(fd)
+          }
+        }
+        return ret
+      }
+
+    } else if (fs.futimes) {
+      fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
+      fs.lutimesSync = function () {}
+    }
+  }
+
+  function chmodFix (orig) {
+    if (!orig) return orig
+    return function (target, mode, cb) {
+      return orig.call(fs, target, mode, function (er) {
+        if (chownErOk(er)) er = null
+        if (cb) cb.apply(this, arguments)
+      })
+    }
+  }
+
+  function chmodFixSync (orig) {
+    if (!orig) return orig
+    return function (target, mode) {
+      try {
+        return orig.call(fs, target, mode)
+      } catch (er) {
+        if (!chownErOk(er)) throw er
+      }
+    }
+  }
+
+
+  function chownFix (orig) {
+    if (!orig) return orig
+    return function (target, uid, gid, cb) {
+      return orig.call(fs, target, uid, gid, function (er) {
+        if (chownErOk(er)) er = null
+        if (cb) cb.apply(this, arguments)
+      })
+    }
+  }
+
+  function chownFixSync (orig) {
+    if (!orig) return orig
+    return function (target, uid, gid) {
+      try {
+        return orig.call(fs, target, uid, gid)
+      } catch (er) {
+        if (!chownErOk(er)) throw er
+      }
+    }
+  }
+
+  function statFix (orig) {
+    if (!orig) return orig
+    // Older versions of Node erroneously returned signed integers for
+    // uid + gid.
+    return function (target, options, cb) {
+      if (typeof options === 'function') {
+        cb = options
+        options = null
+      }
+      function callback (er, stats) {
+        if (stats) {
+          if (stats.uid < 0) stats.uid += 0x100000000
+          if (stats.gid < 0) stats.gid += 0x100000000
+        }
+        if (cb) cb.apply(this, arguments)
+      }
+      return options ? orig.call(fs, target, options, callback)
+        : orig.call(fs, target, callback)
+    }
+  }
+
+  function statFixSync (orig) {
+    if (!orig) return orig
+    // Older versions of Node erroneously returned signed integers for
+    // uid + gid.
+    return function (target, options) {
+      var stats = options ? orig.call(fs, target, options)
+        : orig.call(fs, target)
+      if (stats) {
+        if (stats.uid < 0) stats.uid += 0x100000000
+        if (stats.gid < 0) stats.gid += 0x100000000
+      }
+      return stats;
+    }
+  }
+
+  // ENOSYS means that the fs doesn't support the op. Just ignore
+  // that, because it doesn't matter.
+  //
+  // if there's no getuid, or if getuid() is something other
+  // than 0, and the error is EINVAL or EPERM, then just ignore
+  // it.
+  //
+  // This specific case is a silent failure in cp, install, tar,
+  // and most other unix tools that manage permissions.
+  //
+  // When running as root, or if other types of errors are
+  // encountered, then it's strict.
+  function chownErOk (er) {
+    if (!er)
+      return true
+
+    if (er.code === "ENOSYS")
+      return true
+
+    var nonroot = !process.getuid || process.getuid() !== 0
+    if (nonroot) {
+      if (er.code === "EINVAL" || er.code === "EPERM")
+        return true
+    }
+
+    return false
+  }
+}

node_modules/watchpack/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "watchpack",
+  "version": "1.7.5",
+  "description": "",
+  "main": "./lib/watchpack.js",
+  "directories": {
+    "test": "test"
+  },
+  "files": [
+    "lib/"
+  ],
+  "scripts": {
+    "pretest": "npm run lint",
+    "test": "mocha",
+    "travis": "npm run cover -- --report lcovonly",
+    "lint": "eslint lib",
+    "precover": "npm run lint",
+    "cover": "istanbul cover node_modules/mocha/bin/_mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/webpack/watchpack.git"
+  },
+  "author": "Tobias Koppers @sokra",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/webpack/watchpack/issues"
+  },
+  "homepage": "https://github.com/webpack/watchpack",
+  "devDependencies": {
+    "codecov.io": "^0.1.6",
+    "coveralls": "^3.0.0",
+    "eslint": "^4.18.1",
+    "istanbul": "^0.4.3",
+    "mocha": "^5.0.1",
+    "rimraf": "^2.6.2",
+    "should": "^8.3.1"
+  },
+  "optionalDependencies": {
+    "chokidar": "^3.4.1",
+    "watchpack-chokidar2": "^2.0.1"
+  },
+  "dependencies": {
+    "graceful-fs": "^4.1.2",
+    "neo-async": "^2.5.0",
+    "chokidar": "^3.4.1",
+    "watchpack-chokidar2": "^2.0.1"
+  }
+}