update

node_modules/memory-fs/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/memory-fs/README.md

@@ -0,0 +1,29 @@
+# memory-fs
+
+A simple in-memory filesystem. Holds data in a javascript object.
+
+``` javascript
+var MemoryFileSystem = require("memory-fs");
+var fs = new MemoryFileSystem(); // Optionally pass a javascript object
+
+fs.mkdirpSync("/a/test/dir");
+fs.writeFileSync("/a/test/dir/file.txt", "Hello World");
+fs.readFileSync("/a/test/dir/file.txt"); // returns Buffer("Hello World")
+
+// Async variants too
+fs.unlink("/a/test/dir/file.txt", function(err) {
+	// ...
+});
+
+fs.readdirSync("/a/test"); // returns ["dir"]
+fs.statSync("/a/test/dir").isDirectory(); // returns true
+fs.rmdirSync("/a/test/dir");
+
+fs.mkdirpSync("C:\\use\\windows\\style\\paths");
+```
+
+## License
+
+Copyright (c) 2012-2014 Tobias Koppers
+
+MIT (http://www.opensource.org/licenses/mit-license.php)

node_modules/memory-fs/lib/MemoryFileSystem.js

@@ -0,0 +1,335 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const normalize = require("./normalize");
+const join = require("./join");
+const MemoryFileSystemError = require("./MemoryFileSystemError");
+const errors = require("errno");
+const stream = require("readable-stream");
+
+const ReadableStream = stream.Readable;
+const WritableStream = stream.Writable;
+
+function isDir(item) {
+	if(typeof item !== "object") return false;
+	return item[""] === true;
+}
+
+function isFile(item) {
+	if(typeof item !== "object") return false;
+	return !item[""];
+}
+
+function pathToArray(path) {
+	path = normalize(path);
+	const nix = /^\//.test(path);
+	if(!nix) {
+		if(!/^[A-Za-z]:/.test(path)) {
+			throw new MemoryFileSystemError(errors.code.EINVAL, path);
+		}
+		path = path.replace(/[\\\/]+/g, "\\"); // multi slashs
+		path = path.split(/[\\\/]/);
+		path[0] = path[0].toUpperCase();
+	} else {
+		path = path.replace(/\/+/g, "/"); // multi slashs
+		path = path.substr(1).split("/");
+	}
+	if(!path[path.length-1]) path.pop();
+	return path;
+}
+
+function trueFn() { return true; }
+function falseFn() { return false; }
+
+class MemoryFileSystem {
+	constructor(data) {
+		this.data = data || {};
+		this.join = join;
+		this.pathToArray = pathToArray;
+		this.normalize = normalize;
+	}
+
+	meta(_path) {
+		const path = pathToArray(_path);
+		let current = this.data;
+		let i = 0;
+		for(; i < path.length - 1; i++) {
+			if(!isDir(current[path[i]]))
+				return;
+			current = current[path[i]];
+		}
+		return current[path[i]];
+	}
+
+	existsSync(_path) {
+		return !!this.meta(_path);
+	}
+
+	statSync(_path) {
+		let current = this.meta(_path);
+		if(_path === "/" || isDir(current)) {
+			return {
+				isFile: falseFn,
+				isDirectory: trueFn,
+				isBlockDevice: falseFn,
+				isCharacterDevice: falseFn,
+				isSymbolicLink: falseFn,
+				isFIFO: falseFn,
+				isSocket: falseFn
+			};
+		} else if(isFile(current)) {
+			return {
+				isFile: trueFn,
+				isDirectory: falseFn,
+				isBlockDevice: falseFn,
+				isCharacterDevice: falseFn,
+				isSymbolicLink: falseFn,
+				isFIFO: falseFn,
+				isSocket: falseFn
+			};
+		} else {
+			throw new MemoryFileSystemError(errors.code.ENOENT, _path, "stat");
+		}
+	}
+
+	readFileSync(_path, optionsOrEncoding) {
+		const path = pathToArray(_path);
+		let current = this.data;
+		let i = 0
+		for(; i < path.length - 1; i++) {
+			if(!isDir(current[path[i]]))
+				throw new MemoryFileSystemError(errors.code.ENOENT, _path, "readFile");
+			current = current[path[i]];
+		}
+		if(!isFile(current[path[i]])) {
+			if(isDir(current[path[i]]))
+				throw new MemoryFileSystemError(errors.code.EISDIR, _path, "readFile");
+			else
+				throw new MemoryFileSystemError(errors.code.ENOENT, _path, "readFile");
+		}
+		current = current[path[i]];
+		const encoding = typeof optionsOrEncoding === "object" ? optionsOrEncoding.encoding : optionsOrEncoding;
+		return encoding ? current.toString(encoding) : current;
+	}
+
+	readdirSync(_path) {
+		if(_path === "/") return Object.keys(this.data).filter(Boolean);
+		const path = pathToArray(_path);
+		let current = this.data;
+		let i = 0;
+		for(; i < path.length - 1; i++) {
+			if(!isDir(current[path[i]]))
+				throw new MemoryFileSystemError(errors.code.ENOENT, _path, "readdir");
+			current = current[path[i]];
+		}
+		if(!isDir(current[path[i]])) {
+			if(isFile(current[path[i]]))
+				throw new MemoryFileSystemError(errors.code.ENOTDIR, _path, "readdir");
+			else
+				throw new MemoryFileSystemError(errors.code.ENOENT, _path, "readdir");
+		}
+		return Object.keys(current[path[i]]).filter(Boolean);
+	}
+
+	mkdirpSync(_path) {
+		const path = pathToArray(_path);
+		if(path.length === 0) return;
+		let current = this.data;
+		for(let i = 0; i < path.length; i++) {
+			if(isFile(current[path[i]]))
+				throw new MemoryFileSystemError(errors.code.ENOTDIR, _path, "mkdirp");
+			else if(!isDir(current[path[i]]))
+				current[path[i]] = {"":true};
+			current = current[path[i]];
+		}
+		return;
+	}
+
+	mkdirSync(_path) {
+		const path = pathToArray(_path);
+		if(path.length === 0) return;
+		let current = this.data;
+		let i = 0;
+		for(; i < path.length - 1; i++) {
+			if(!isDir(current[path[i]]))
+				throw new MemoryFileSystemError(errors.code.ENOENT, _path, "mkdir");
+			current = current[path[i]];
+		}
+		if(isDir(current[path[i]]))
+			throw new MemoryFileSystemError(errors.code.EEXIST, _path, "mkdir");
+		else if(isFile(current[path[i]]))
+			throw new MemoryFileSystemError(errors.code.ENOTDIR, _path, "mkdir");
+		current[path[i]] = {"":true};
+		return;
+	}
+
+	_remove(_path, name, testFn) {
+		const path = pathToArray(_path);
+		const operation = name === "File" ? "unlink" : "rmdir";
+		if(path.length === 0) {
+			throw new MemoryFileSystemError(errors.code.EPERM, _path, operation);
+		}
+		let current = this.data;
+		let i = 0;
+		for(; i < path.length - 1; i++) {
+			if(!isDir(current[path[i]]))
+				throw new MemoryFileSystemError(errors.code.ENOENT, _path, operation);
+			current = current[path[i]];
+		}
+		if(!testFn(current[path[i]]))
+			throw new MemoryFileSystemError(errors.code.ENOENT, _path, operation);
+		delete current[path[i]];
+		return;
+	}
+
+	rmdirSync(_path) {
+		return this._remove(_path, "Directory", isDir);
+	}
+
+	unlinkSync(_path) {
+		return this._remove(_path, "File", isFile);
+	}
+
+	readlinkSync(_path) {
+		throw new MemoryFileSystemError(errors.code.ENOSYS, _path, "readlink");
+	}
+
+	writeFileSync(_path, content, optionsOrEncoding) {
+		if(!content && !optionsOrEncoding) throw new Error("No content");
+		const path = pathToArray(_path);
+		if(path.length === 0) {
+			throw new MemoryFileSystemError(errors.code.EISDIR, _path, "writeFile");
+		}
+		let current = this.data;
+		let i = 0
+		for(; i < path.length - 1; i++) {
+			if(!isDir(current[path[i]]))
+				throw new MemoryFileSystemError(errors.code.ENOENT, _path, "writeFile");
+			current = current[path[i]];
+		}
+		if(isDir(current[path[i]]))
+			throw new MemoryFileSystemError(errors.code.EISDIR, _path, "writeFile");
+		const encoding = typeof optionsOrEncoding === "object" ? optionsOrEncoding.encoding : optionsOrEncoding;
+		current[path[i]] = optionsOrEncoding || typeof content === "string" ? new Buffer(content, encoding) : content;
+		return;
+	}
+
+	// stream methods
+	createReadStream(path, options) {
+		let stream = new ReadableStream();
+		let done = false;
+		let data;
+		try {
+			data = this.readFileSync(path);
+		} catch (e) {
+			stream._read = function() {
+				if (done) {
+					return;
+				}
+				done = true;
+				this.emit('error', e);
+				this.push(null);
+			};
+			return stream;
+		}
+		options = options || { };
+		options.start = options.start || 0;
+		options.end = options.end || data.length;
+		stream._read = function() {
+			if (done) {
+				return;
+			}
+			done = true;
+			this.push(data.slice(options.start, options.end));
+			this.push(null);
+		};
+		return stream;
+	}
+
+	createWriteStream(path) {
+		let stream = new WritableStream();
+		try {
+			// Zero the file and make sure it is writable
+			this.writeFileSync(path, new Buffer(0));
+		} catch(e) {
+			// This or setImmediate?
+			stream.once('prefinish', function() {
+				stream.emit('error', e);
+			});
+			return stream;
+		}
+		let bl = [ ], len = 0;
+		stream._write = (chunk, encoding, callback) => {
+			bl.push(chunk);
+			len += chunk.length;
+			this.writeFile(path, Buffer.concat(bl, len), callback);
+		}
+		return stream;
+	}
+
+	// async functions
+	exists(path, callback) {
+		return callback(this.existsSync(path));
+	}
+
+	writeFile(path, content, encoding, callback) {
+		if(!callback) {
+			callback = encoding;
+			encoding = undefined;
+		}
+		try {
+			this.writeFileSync(path, content, encoding);
+		} catch(e) {
+			return callback(e);
+		}
+		return callback();
+	}
+}
+
+// async functions
+
+["stat", "readdir", "mkdirp", "rmdir", "unlink", "readlink"].forEach(function(fn) {
+	MemoryFileSystem.prototype[fn] = function(path, callback) {
+		let result;
+		try {
+			result = this[fn + "Sync"](path);
+		} catch(e) {
+			setImmediate(function() {
+				callback(e);
+			});
+
+			return;
+		}
+		setImmediate(function() {
+			callback(null, result);
+		});
+	};
+});
+
+["mkdir", "readFile"].forEach(function(fn) {
+	MemoryFileSystem.prototype[fn] = function(path, optArg, callback) {
+		if(!callback) {
+			callback = optArg;
+			optArg = undefined;
+		}
+		let result;
+		try {
+			result = this[fn + "Sync"](path, optArg);
+		} catch(e) {
+			setImmediate(function() {
+				callback(e);
+			});
+
+			return;
+		}
+		setImmediate(function() {
+			callback(null, result);
+		});
+	};
+});
+
+module.exports = MemoryFileSystem;

node_modules/memory-fs/lib/MemoryFileSystemError.js

@@ -0,0 +1,31 @@
+
+"use strict";
+
+class MemoryFileSystemError extends Error {
+	constructor(err, path, operation) {
+		super(err, path);
+
+		// Set `name` and `message` before call `Error.captureStackTrace` \
+		// so that we will obtain the correct 1st line of stack, like:
+		// [Error]: [Message]
+		this.name = this.constructor.name;
+		var message = [`${err.code}:`, `${err.description},`];
+		// Add operation name and path into message, similar to node `fs` style.
+		if(operation) {
+			message.push(operation);
+		}
+		message.push(`\'${path}\'`);
+		this.message = message.join(' ');
+
+		this.code = err.code;
+		this.errno = err.errno;
+		this.path = path;
+		this.operation = operation;
+
+		if(Error.captureStackTrace) {
+			Error.captureStackTrace(this, this.constructor);
+		}
+	}
+}
+
+module.exports = MemoryFileSystemError;

node_modules/memory-fs/lib/join.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const normalize = require("./normalize");
+
+const absoluteWinRegExp = /^[A-Z]:([\\\/]|$)/i;
+const absoluteNixRegExp = /^\//i;
+
+module.exports = function join(path, request) {
+	if(!request) return normalize(path);
+	if(absoluteWinRegExp.test(request)) return normalize(request.replace(/\//g, "\\"));
+	if(absoluteNixRegExp.test(request)) return normalize(request);
+	if(path == "/") return normalize(path + request);
+	if(absoluteWinRegExp.test(path)) return normalize(path.replace(/\//g, "\\") + "\\" + request.replace(/\//g, "\\"));
+	if(absoluteNixRegExp.test(path)) return normalize(path + "/" + request);
+	return normalize(path + "/" + request);
+};

node_modules/memory-fs/lib/normalize.js

@@ -0,0 +1,99 @@
+"use strict";
+
+// eslint-disable-next-line complexity
+module.exports = function normalize(path) {
+	var parts = path.split(/(\\+|\/+)/);
+	if(parts.length === 1)
+		return path;
+	var result = [];
+	var absolutePathStart = 0;
+	for(var i = 0, sep = false; i < parts.length; i += 1, sep = !sep) {
+		var part = parts[i];
+		if(i === 0 && /^([A-Z]:)?$/i.test(part)) {
+			result.push(part);
+			absolutePathStart = 2;
+		} else if(sep) {
+			// UNC paths on Windows begin with a double backslash.
+			if (i === 1 && parts[0].length === 0 && part === "\\\\") {
+				result.push(part);
+			} else {
+				result.push(part[0]);
+			}
+		} else if(part === "..") {
+			switch(result.length) {
+				case 0:
+					// i. e. ".." => ".."
+					// i. e. "../a/b/c" => "../a/b/c"
+					result.push(part);
+					break;
+				case 2:
+					// i. e. "a/.." => ""
+					// i. e. "/.." => "/"
+					// i. e. "C:\.." => "C:\"
+					// i. e. "a/../b/c" => "b/c"
+					// i. e. "/../b/c" => "/b/c"
+					// i. e. "C:\..\a\b\c" => "C:\a\b\c"
+					if (result[0] !== ".") {
+						i += 1;
+						sep = !sep;
+						result.length = absolutePathStart;
+					} else {
+						result.length = 0;
+						result.push(part);
+					}
+					break;
+				case 4:
+					// i. e. "a/b/.." => "a"
+					// i. e. "/a/.." => "/"
+					// i. e. "C:\a\.." => "C:\"
+					// i. e. "/a/../b/c" => "/b/c"
+					if(absolutePathStart === 0) {
+						result.length -= 3;
+					} else {
+						i += 1;
+						sep = !sep;
+						result.length = 2;
+					}
+					break;
+				default:
+					// i. e. "/a/b/.." => "/a"
+					// i. e. "/a/b/../c" => "/a/c"
+					result.length -= 3;
+					break;
+			}
+		} else if(part === ".") {
+			switch(result.length) {
+				case 0:
+					// i. e. "." => "."
+					// i. e. "./a/b/c" => "./a/b/c"
+					result.push(part);
+					break;
+				case 2:
+					// i. e. "a/." => "a"
+					// i. e. "/." => "/"
+					// i. e. "C:\." => "C:\"
+					// i. e. "C:\.\a\b\c" => "C:\a\b\c"
+					if(absolutePathStart === 0) {
+						result.length -= 1;
+					} else {
+						i += 1;
+						sep = !sep;
+					}
+					break;
+				default:
+					// i. e. "a/b/." => "a/b"
+					// i. e. "/a/." => "/"
+					// i. e. "C:\a\." => "C:\"
+					// i. e. "a/./b/c" => "a/b/c"
+					// i. e. "/a/./b/c" => "/a/b/c"
+					result.length -= 1;
+					break;
+			}
+		} else if(part) {
+			result.push(part);
+		}
+	}
+	if(result.length === 1 && /^[A-Za-z]:$/.test(result[0]))
+		return result[0] + "\\";
+	return result.join("");
+};

node_modules/memory-fs/package.json

@@ -0,0 +1,78 @@
+{
+  "_args": [
+    [
+      "memory-fs@0.5.0",
+      "/Users/tatiana/selfdefined"
+    ]
+  ],
+  "_from": "memory-fs@0.5.0",
+  "_id": "memory-fs@0.5.0",
+  "_inBundle": false,
+  "_integrity": "sha512-jA0rdU5KoQMC0e6ppoNRtpp6vjFq6+NY7r8hywnC7V+1Xj/MtHwGIbB1QaK/dunyjWteJzmkpd7ooeWg10T7GA==",
+  "_location": "/memory-fs",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "memory-fs@0.5.0",
+    "name": "memory-fs",
+    "escapedName": "memory-fs",
+    "rawSpec": "0.5.0",
+    "saveSpec": null,
+    "fetchSpec": "0.5.0"
+  },
+  "_requiredBy": [
+    "/enhanced-resolve"
+  ],
+  "_resolved": "https://registry.npmjs.org/memory-fs/-/memory-fs-0.5.0.tgz",
+  "_spec": "0.5.0",
+  "_where": "/Users/tatiana/selfdefined",
+  "author": {
+    "name": "Tobias Koppers @sokra"
+  },
+  "bugs": {
+    "url": "https://github.com/webpack/memory-fs/issues"
+  },
+  "dependencies": {
+    "errno": "^0.1.3",
+    "readable-stream": "^2.0.1"
+  },
+  "description": "A simple in-memory filesystem. Holds data in a javascript object.",
+  "devDependencies": {
+    "bl": "^1.0.0",
+    "codecov.io": "^0.1.4",
+    "coveralls": "^2.11.2",
+    "eslint": "^4.0.0",
+    "istanbul": "0.4.5",
+    "mocha": "3.2.0",
+    "should": "^4.0.4"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "engines": {
+    "node": ">=4.3.0 <5.0.0 || >=5.10"
+  },
+  "files": [
+    "lib/"
+  ],
+  "homepage": "https://github.com/webpack/memory-fs",
+  "keywords": [
+    "fs",
+    "memory"
+  ],
+  "license": "MIT",
+  "main": "lib/MemoryFileSystem.js",
+  "name": "memory-fs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/webpack/memory-fs.git"
+  },
+  "scripts": {
+    "cover": "istanbul cover node_modules/mocha/bin/_mocha",
+    "lint": "eslint lib/*",
+    "test": "mocha",
+    "travis": "npm run cover -- --report lcovonly && npm run lint"
+  },
+  "version": "0.5.0"
+}