schnee effeckt und fehler Korektur

node_modules/got/index.js

@@ -1,66 +1,108 @@
 'use strict';
+const EventEmitter = require('events');
+const http = require('http');
+const https = require('https');
+const PassThrough = require('stream').PassThrough;
+const urlLib = require('url');
+const querystring = require('querystring');
+const duplexer3 = require('duplexer3');
+const isStream = require('is-stream');
+const getStream = require('get-stream');
+const timedOut = require('timed-out');
+const urlParseLax = require('url-parse-lax');
+const urlToOptions = require('url-to-options');
+const lowercaseKeys = require('lowercase-keys');
+const decompressResponse = require('decompress-response');
+const isRetryAllowed = require('is-retry-allowed');
+const Buffer = require('safe-buffer').Buffer;
+const isURL = require('isurl');
+const isPlainObj = require('is-plain-obj');
+const PCancelable = require('p-cancelable');
+const pTimeout = require('p-timeout');
+const pkg = require('./package');
 
-var EventEmitter = require('events').EventEmitter;
-var http = require('http');
-var https = require('https');
-var urlLib = require('url');
-var querystring = require('querystring');
-var objectAssign = require('object-assign');
-var PassThrough = require('readable-stream').PassThrough;
-var duplexer2 = require('duplexer2');
-var isStream = require('is-stream');
-var readAllStream = require('read-all-stream');
-var timedOut = require('timed-out');
-var urlParseLax = require('url-parse-lax');
-var lowercaseKeys = require('lowercase-keys');
-var isRedirect = require('is-redirect');
-var PinkiePromise = require('pinkie-promise');
-var unzipResponse = require('unzip-response');
-var createErrorClass = require('create-error-class');
-var nodeStatusCodes = require('node-status-codes');
-var isPlainObj = require('is-plain-obj');
-var parseJson = require('parse-json');
-var isRetryAllowed = require('is-retry-allowed');
-var pkg = require('./package.json');
+const getMethodRedirectCodes = new Set([300, 301, 302, 303, 304, 305, 307, 308]);
+const allMethodRedirectCodes = new Set([300, 303, 307, 308]);
 
 function requestAsEventEmitter(opts) {
 	opts = opts || {};
 
-	var ee = new EventEmitter();
-	var redirectCount = 0;
-	var retryCount = 0;
+	const ee = new EventEmitter();
+	const requestUrl = opts.href || urlLib.resolve(urlLib.format(opts), opts.path);
+	const redirects = [];
+	let retryCount = 0;
+	let redirectUrl;
 
-	var get = function (opts) {
-		var fn = opts.protocol === 'https:' ? https : http;
+	const get = opts => {
+		if (opts.protocol !== 'http:' && opts.protocol !== 'https:') {
+			ee.emit('error', new got.UnsupportedProtocolError(opts));
+			return;
+		}
 
-		var req = fn.request(opts, function (res) {
-			var statusCode = res.statusCode;
+		let fn = opts.protocol === 'https:' ? https : http;
 
-			if (isRedirect(statusCode) && opts.followRedirect && 'location' in res.headers && (opts.method === 'GET' || opts.method === 'HEAD')) {
+		if (opts.useElectronNet && process.versions.electron) {
+			const electron = require('electron');
+			fn = electron.net || electron.remote.net;
+		}
+
+		const req = fn.request(opts, res => {
+			const statusCode = res.statusCode;
+
+			res.url = redirectUrl || requestUrl;
+			res.requestUrl = requestUrl;
+
+			const followRedirect = opts.followRedirect && 'location' in res.headers;
+			const redirectGet = followRedirect && getMethodRedirectCodes.has(statusCode);
+			const redirectAll = followRedirect && allMethodRedirectCodes.has(statusCode);
+
+			if (redirectAll || (redirectGet && (opts.method === 'GET' || opts.method === 'HEAD'))) {
 				res.resume();
 
-				if (++redirectCount > 10) {
-					ee.emit('error', new got.MaxRedirectsError(statusCode, opts), null, res);
+				if (statusCode === 303) {
+					// Server responded with "see other", indicating that the resource exists at another location,
+					// and the client should request it from that location via GET or HEAD.
+					opts.method = 'GET';
+				}
+
+				if (redirects.length >= 10) {
+					ee.emit('error', new got.MaxRedirectsError(statusCode, redirects, opts), null, res);
 					return;
 				}
 
-				var redirectUrl = urlLib.resolve(urlLib.format(opts), res.headers.location);
-				var redirectOpts = objectAssign({}, opts, urlLib.parse(redirectUrl));
+				const bufferString = Buffer.from(res.headers.location, 'binary').toString();
+
+				redirectUrl = urlLib.resolve(urlLib.format(opts), bufferString);
+
+				redirects.push(redirectUrl);
+
+				const redirectOpts = Object.assign({}, opts, urlLib.parse(redirectUrl));
 
 				ee.emit('redirect', res, redirectOpts);
 
 				get(redirectOpts);
+
 				return;
 			}
 
-			// do not write ee.bind(...) instead of function - it will break gzip in Node.js 0.10
-			setImmediate(function () {
-				ee.emit('response', typeof unzipResponse === 'function' && req.method !== 'HEAD' ? unzipResponse(res) : res);
+			setImmediate(() => {
+				const response = opts.decompress === true &&
+					typeof decompressResponse === 'function' &&
+					req.method !== 'HEAD' ? decompressResponse(res) : res;
+
+				if (!opts.decompress && ['gzip', 'deflate'].indexOf(res.headers['content-encoding']) !== -1) {
+					opts.encoding = null;
+				}
+
+				response.redirectUrls = redirects;
+
+				ee.emit('response', response);
 			});
 		});
 
-		req.once('error', function (err) {
-			var backoff = opts.retries(++retryCount, err);
+		req.once('error', err => {
+			const backoff = opts.retries(++retryCount, err);
+
 			if (backoff) {
 				setTimeout(get, backoff, opts);
 				return;
@@ -69,99 +111,114 @@ function requestAsEventEmitter(opts) {
 			ee.emit('error', new got.RequestError(err, opts));
 		});
 
-		if (opts.timeout) {
-			timedOut(req, opts.timeout);
+		if (opts.gotTimeout) {
+			timedOut(req, opts.gotTimeout);
 		}
 
-		setImmediate(ee.emit.bind(ee), 'request', req);
+		setImmediate(() => {
+			ee.emit('request', req);
+		});
 	};
 
-	get(opts);
+	setImmediate(() => {
+		get(opts);
+	});
 	return ee;
 }
 
-function asCallback(opts, cb) {
-	var ee = requestAsEventEmitter(opts);
-
-	ee.on('request', function (req) {
-		if (isStream(opts.body)) {
-			opts.body.pipe(req);
-			opts.body = undefined;
-			return;
-		}
-
-		req.end(opts.body);
-	});
-
-	ee.on('response', function (res) {
-		readAllStream(res, opts.encoding, function (err, data) {
-			var statusCode = res.statusCode;
-			var limitStatusCode = opts.followRedirect ? 299 : 399;
-
-			if (err) {
-				cb(new got.ReadError(err, opts), null, res);
-				return;
-			}
-
-			if (statusCode < 200 || statusCode > limitStatusCode) {
-				err = new got.HTTPError(statusCode, opts);
-			}
-
-			if (opts.json && data) {
-				try {
-					data = parseJson(data);
-				} catch (e) {
-					e.fileName = urlLib.format(opts);
-					err = new got.ParseError(e, statusCode, opts);
-				}
-			}
-
-			cb(err, data, res);
-		});
-	});
-
-	ee.on('error', cb);
-}
-
 function asPromise(opts) {
-	return new PinkiePromise(function (resolve, reject) {
-		asCallback(opts, function (err, data, response) {
-			if (response) {
-				response.body = data;
+	const timeoutFn = requestPromise => opts.gotTimeout && opts.gotTimeout.request ?
+		pTimeout(requestPromise, opts.gotTimeout.request, new got.RequestError({message: 'Request timed out', code: 'ETIMEDOUT'}, opts)) :
+		requestPromise;
+
+	return timeoutFn(new PCancelable((onCancel, resolve, reject) => {
+		const ee = requestAsEventEmitter(opts);
+		let cancelOnRequest = false;
+
+		onCancel(() => {
+			cancelOnRequest = true;
+		});
+
+		ee.on('request', req => {
+			if (cancelOnRequest) {
+				req.abort();
 			}
 
-			if (err) {
-				Object.defineProperty(err, 'response', {
-					value: response,
-					enumerable: false
-				});
-				reject(err);
+			onCancel(() => {
+				req.abort();
+			});
+
+			if (isStream(opts.body)) {
+				opts.body.pipe(req);
+				opts.body = undefined;
 				return;
 			}
 
-			resolve(response);
+			req.end(opts.body);
 		});
-	});
+
+		ee.on('response', res => {
+			const stream = opts.encoding === null ? getStream.buffer(res) : getStream(res, opts);
+
+			stream
+				.catch(err => reject(new got.ReadError(err, opts)))
+				.then(data => {
+					const statusCode = res.statusCode;
+					const limitStatusCode = opts.followRedirect ? 299 : 399;
+
+					res.body = data;
+
+					if (opts.json && res.body) {
+						try {
+							res.body = JSON.parse(res.body);
+						} catch (e) {
+							if (statusCode >= 200 && statusCode < 300) {
+								throw new got.ParseError(e, statusCode, opts, data);
+							}
+						}
+					}
+
+					if (statusCode !== 304 && (statusCode < 200 || statusCode > limitStatusCode)) {
+						throw new got.HTTPError(statusCode, res.headers, opts);
+					}
+
+					resolve(res);
+				})
+				.catch(err => {
+					Object.defineProperty(err, 'response', {value: res});
+					reject(err);
+				});
+		});
+
+		ee.on('error', reject);
+	}));
 }
 
 function asStream(opts) {
-	var input = new PassThrough();
-	var output = new PassThrough();
-	var proxy = duplexer2(input, output);
+	const input = new PassThrough();
+	const output = new PassThrough();
+	const proxy = duplexer3(input, output);
+	let timeout;
+
+	if (opts.gotTimeout && opts.gotTimeout.request) {
+		timeout = setTimeout(() => {
+			proxy.emit('error', new got.RequestError({message: 'Request timed out', code: 'ETIMEDOUT'}, opts));
+		}, opts.gotTimeout.request);
+	}
 
 	if (opts.json) {
 		throw new Error('got can not be used as stream when options.json is used');
 	}
 
 	if (opts.body) {
-		proxy.write = function () {
+		proxy.write = () => {
 			throw new Error('got\'s stream is not writable when options.body is used');
 		};
 	}
 
-	var ee = requestAsEventEmitter(opts);
+	const ee = requestAsEventEmitter(opts);
 
-	ee.on('request', function (req) {
+	ee.on('request', req => {
 		proxy.emit('request', req);
 
 		if (isStream(opts.body)) {
@@ -182,14 +239,15 @@ function asStream(opts) {
 		req.end();
 	});
 
-	ee.on('response', function (res) {
-		var statusCode = res.statusCode;
-		var limitStatusCode = opts.followRedirect ? 299 : 399;
+	ee.on('response', res => {
+		clearTimeout(timeout);
+
+		const statusCode = res.statusCode;
 
 		res.pipe(output);
 
-		if (statusCode < 200 || statusCode > limitStatusCode) {
-			proxy.emit('error', new got.HTTPError(statusCode, opts), null, res);
+		if (statusCode !== 304 && (statusCode < 200 || statusCode > 299)) {
+			proxy.emit('error', new got.HTTPError(statusCode, res.headers, opts), null, res);
 			return;
 		}
 
@@ -197,7 +255,6 @@ function asStream(opts) {
 	});
 
 	ee.on('redirect', proxy.emit.bind(proxy, 'redirect'));
-
 	ee.on('error', proxy.emit.bind(proxy, 'error'));
 
 	return proxy;
@@ -205,36 +262,45 @@ function asStream(opts) {
 
 function normalizeArguments(url, opts) {
 	if (typeof url !== 'string' && typeof url !== 'object') {
-		throw new Error('Parameter `url` must be a string or object, not ' + typeof url);
-	}
-
-	if (typeof url === 'string') {
+		throw new TypeError(`Parameter \`url\` must be a string or object, not ${typeof url}`);
+	} else if (typeof url === 'string') {
+		url = url.replace(/^unix:/, 'http://$&');
 		url = urlParseLax(url);
-
-		if (url.auth) {
-			throw new Error('Basic authentication must be done with auth option');
-		}
+	} else if (isURL.lenient(url)) {
+		url = urlToOptions(url);
 	}
 
-	opts = objectAssign(
-		{protocol: 'http:', path: '', retries: 5},
+	if (url.auth) {
+		throw new Error('Basic authentication must be done with auth option');
+	}
+
+	opts = Object.assign(
+		{
+			path: '',
+			retries: 2,
+			decompress: true,
+			useElectronNet: true
+		},
 		url,
+		{
+			protocol: url.protocol || 'http:' // Override both null/undefined with default protocol
+		},
 		opts
 	);
 
-	opts.headers = objectAssign({
-		'user-agent': pkg.name + '/' + pkg.version + ' (https://github.com/sindresorhus/got)',
+	opts.headers = Object.assign({
+		'user-agent': `${pkg.name}/${pkg.version} (https://github.com/sindresorhus/got)`,
 		'accept-encoding': 'gzip,deflate'
 	}, lowercaseKeys(opts.headers));
 
-	var query = opts.query;
+	const query = opts.query;
 
 	if (query) {
 		if (typeof query !== 'string') {
 			opts.query = querystring.stringify(query);
 		}
 
-		opts.path = opts.path.split('?')[0] + '?' + opts.query;
+		opts.path = `${opts.path.split('?')[0]}?${opts.query}`;
 		delete opts.query;
 	}
 
@@ -242,32 +308,41 @@ function normalizeArguments(url, opts) {
 		opts.headers.accept = 'application/json';
 	}
 
-	var body = opts.body;
-
-	if (body) {
-		if (typeof body !== 'string' && !Buffer.isBuffer(body) && !isStream(body) && !isPlainObj(body)) {
-			throw new Error('options.body must be a ReadableStream, string, Buffer or plain Object');
+	const body = opts.body;
+	if (body !== null && body !== undefined) {
+		const headers = opts.headers;
+		if (!isStream(body) && typeof body !== 'string' && !Buffer.isBuffer(body) && !(opts.form || opts.json)) {
+			throw new TypeError('options.body must be a ReadableStream, string, Buffer or plain Object');
 		}
 
-		opts.method = opts.method || 'POST';
-
-		if (isPlainObj(body)) {
-			opts.headers['content-type'] = opts.headers['content-type'] || 'application/x-www-form-urlencoded';
-			body = opts.body = querystring.stringify(body);
+		const canBodyBeStringified = isPlainObj(body) || Array.isArray(body);
+		if ((opts.form || opts.json) && !canBodyBeStringified) {
+			throw new TypeError('options.body must be a plain Object or Array when options.form or options.json is used');
 		}
 
-		if (opts.headers['content-length'] === undefined && opts.headers['transfer-encoding'] === undefined && !isStream(body)) {
-			var length = typeof body === 'string' ? Buffer.byteLength(body) : body.length;
-			opts.headers['content-length'] = length;
+		if (isStream(body) && typeof body.getBoundary === 'function') {
+			// Special case for https://github.com/form-data/form-data
+			headers['content-type'] = headers['content-type'] || `multipart/form-data; boundary=${body.getBoundary()}`;
+		} else if (opts.form && canBodyBeStringified) {
+			headers['content-type'] = headers['content-type'] || 'application/x-www-form-urlencoded';
+			opts.body = querystring.stringify(body);
+		} else if (opts.json && canBodyBeStringified) {
+			headers['content-type'] = headers['content-type'] || 'application/json';
+			opts.body = JSON.stringify(body);
 		}
+
+		if (headers['content-length'] === undefined && headers['transfer-encoding'] === undefined && !isStream(body)) {
+			const length = typeof opts.body === 'string' ? Buffer.byteLength(opts.body) : opts.body.length;
+			headers['content-length'] = length;
+		}
+
+		opts.method = (opts.method || 'POST').toUpperCase();
+	} else {
+		opts.method = (opts.method || 'GET').toUpperCase();
 	}
 
-	opts.method = opts.method || 'GET';
-
-	opts.method = opts.method.toUpperCase();
-
 	if (opts.hostname === 'unix') {
-		var matches = /(.+)\:(.+)/.exec(opts.path);
+		const matches = /(.+?):(.+)/.exec(opts.path);
 
 		if (matches) {
 			opts.socketPath = matches[1];
@@ -277,14 +352,16 @@ function normalizeArguments(url, opts) {
 	}
 
 	if (typeof opts.retries !== 'function') {
-		var retries = opts.retries;
-		opts.retries = function backoff(iter, err) {
+		const retries = opts.retries;
+
+		opts.retries = (iter, err) => {
 			if (iter > retries || !isRetryAllowed(err)) {
 				return 0;
 			}
 
-			var noise = Math.random() * 100;
-			return (1 << iter) * 1000 + noise;
+			const noise = Math.random() * 100;
+
+			return ((1 << iter) * 1000) + noise;
 		};
 	}
 
@@ -292,28 +369,29 @@ function normalizeArguments(url, opts) {
 		opts.followRedirect = true;
 	}
 
+	if (opts.timeout) {
+		if (typeof opts.timeout === 'number') {
+			opts.gotTimeout = {request: opts.timeout};
+		} else {
+			opts.gotTimeout = opts.timeout;
+		}
+		delete opts.timeout;
+	}
+
 	return opts;
 }
 
-function got(url, opts, cb) {
-	if (typeof opts === 'function') {
-		cb = opts;
-		opts = {};
-	}
-
-	if (cb) {
-		asCallback(normalizeArguments(url, opts), cb);
-		return null;
-	}
-
+function got(url, opts) {
 	try {
 		return asPromise(normalizeArguments(url, opts));
-	} catch (error) {
-		return PinkiePromise.reject(error);
+	} catch (err) {
+		return Promise.reject(err);
 	}
 }
 
-var helpers = [
+got.stream = (url, opts) => asStream(normalizeArguments(url, opts));
+
+const methods = [
 	'get',
 	'post',
 	'put',
@@ -322,71 +400,80 @@ var helpers = [
 	'delete'
 ];
 
-helpers.forEach(function (el) {
-	got[el] = function (url, opts, cb) {
-		if (typeof opts === 'function') {
-			cb = opts;
-			opts = {};
-		}
-
-		return got(url, objectAssign({}, opts, {method: el}), cb);
-	};
-});
-
-got.stream = function (url, opts, cb) {
-	if (cb || typeof opts === 'function') {
-		throw new Error('callback can not be used with stream mode');
-	}
-
-	return asStream(normalizeArguments(url, opts));
-};
-
-helpers.forEach(function (el) {
-	got.stream[el] = function (url, opts, cb) {
-		if (typeof opts === 'function') {
-			cb = opts;
-			opts = {};
-		}
-
-		return got.stream(url, objectAssign({}, opts, {method: el}), cb);
-	};
-});
-
-function stdError(error, opts) {
-	if (error.code !== undefined) {
-		this.code = error.code;
-	}
-
-	objectAssign(this, {
-		message: error.message,
-		host: opts.host,
-		hostname: opts.hostname,
-		method: opts.method,
-		path: opts.path
-	});
+for (const method of methods) {
+	got[method] = (url, opts) => got(url, Object.assign({}, opts, {method}));
+	got.stream[method] = (url, opts) => got.stream(url, Object.assign({}, opts, {method}));
 }
 
-got.RequestError = createErrorClass('RequestError', stdError);
-got.ReadError = createErrorClass('ReadError', stdError);
+class StdError extends Error {
+	constructor(message, error, opts) {
+		super(message);
+		this.name = 'StdError';
 
-got.ParseError = createErrorClass('ParseError', function (e, statusCode, opts) {
-	stdError.call(this, e, opts);
-	this.statusCode = statusCode;
-	this.statusMessage = nodeStatusCodes[this.statusCode];
-});
+		if (error.code !== undefined) {
+			this.code = error.code;
+		}
 
-got.HTTPError = createErrorClass('HTTPError', function (statusCode, opts) {
-	stdError.call(this, {}, opts);
-	this.statusCode = statusCode;
-	this.statusMessage = nodeStatusCodes[this.statusCode];
-	this.message = 'Response code ' + this.statusCode + ' (' + this.statusMessage + ')';
-});
+		Object.assign(this, {
+			host: opts.host,
+			hostname: opts.hostname,
+			method: opts.method,
+			path: opts.path,
+			protocol: opts.protocol,
+			url: opts.href
+		});
+	}
+}
 
-got.MaxRedirectsError = createErrorClass('MaxRedirectsError', function (statusCode, opts) {
-	stdError.call(this, {}, opts);
-	this.statusCode = statusCode;
-	this.statusMessage = nodeStatusCodes[this.statusCode];
-	this.message = 'Redirected 10 times. Aborting.';
-});
+got.RequestError = class extends StdError {
+	constructor(error, opts) {
+		super(error.message, error, opts);
+		this.name = 'RequestError';
+	}
+};
+
+got.ReadError = class extends StdError {
+	constructor(error, opts) {
+		super(error.message, error, opts);
+		this.name = 'ReadError';
+	}
+};
+
+got.ParseError = class extends StdError {
+	constructor(error, statusCode, opts, data) {
+		super(`${error.message} in "${urlLib.format(opts)}": \n${data.slice(0, 77)}...`, error, opts);
+		this.name = 'ParseError';
+		this.statusCode = statusCode;
+		this.statusMessage = http.STATUS_CODES[this.statusCode];
+	}
+};
+
+got.HTTPError = class extends StdError {
+	constructor(statusCode, headers, opts) {
+		const statusMessage = http.STATUS_CODES[statusCode];
+		super(`Response code ${statusCode} (${statusMessage})`, {}, opts);
+		this.name = 'HTTPError';
+		this.statusCode = statusCode;
+		this.statusMessage = statusMessage;
+		this.headers = headers;
+	}
+};
+
+got.MaxRedirectsError = class extends StdError {
+	constructor(statusCode, redirectUrls, opts) {
+		super('Redirected 10 times. Aborting.', {}, opts);
+		this.name = 'MaxRedirectsError';
+		this.statusCode = statusCode;
+		this.statusMessage = http.STATUS_CODES[this.statusCode];
+		this.redirectUrls = redirectUrls;
+	}
+};
+
+got.UnsupportedProtocolError = class extends StdError {
+	constructor(opts) {
+		super(`Unsupported protocol "${opts.protocol}"`, {}, opts);
+		this.name = 'UnsupportedProtocolError';
+	}
+};
 
 module.exports = got;

node_modules/got/node_modules/get-stream/buffer-stream.js

@@ -0,0 +1,51 @@
+'use strict';
+const PassThrough = require('stream').PassThrough;
+
+module.exports = opts => {
+	opts = Object.assign({}, opts);
+
+	const array = opts.array;
+	let encoding = opts.encoding;
+	const buffer = encoding === 'buffer';
+	let objectMode = false;
+
+	if (array) {
+		objectMode = !(encoding || buffer);
+	} else {
+		encoding = encoding || 'utf8';
+	}
+
+	if (buffer) {
+		encoding = null;
+	}
+
+	let len = 0;
+	const ret = [];
+	const stream = new PassThrough({objectMode});
+
+	if (encoding) {
+		stream.setEncoding(encoding);
+	}
+
+	stream.on('data', chunk => {
+		ret.push(chunk);
+
+		if (objectMode) {
+			len = ret.length;
+		} else {
+			len += chunk.length;
+		}
+	});
+
+	stream.getBufferedValue = () => {
+		if (array) {
+			return ret;
+		}
+
+		return buffer ? Buffer.concat(ret, len) : ret.join('');
+	};
+
+	stream.getBufferedLength = () => len;
+
+	return stream;
+};

node_modules/got/node_modules/get-stream/index.js

@@ -0,0 +1,51 @@
+'use strict';
+const bufferStream = require('./buffer-stream');
+
+function getStream(inputStream, opts) {
+	if (!inputStream) {
+		return Promise.reject(new Error('Expected a stream'));
+	}
+
+	opts = Object.assign({maxBuffer: Infinity}, opts);
+
+	const maxBuffer = opts.maxBuffer;
+	let stream;
+	let clean;
+
+	const p = new Promise((resolve, reject) => {
+		const error = err => {
+			if (err) { // null check
+				err.bufferedData = stream.getBufferedValue();
+			}
+
+			reject(err);
+		};
+
+		stream = bufferStream(opts);
+		inputStream.once('error', error);
+		inputStream.pipe(stream);
+
+		stream.on('data', () => {
+			if (stream.getBufferedLength() > maxBuffer) {
+				reject(new Error('maxBuffer exceeded'));
+			}
+		});
+		stream.once('error', error);
+		stream.on('end', resolve);
+
+		clean = () => {
+			// some streams doesn't implement the `stream.Readable` interface correctly
+			if (inputStream.unpipe) {
+				inputStream.unpipe(stream);
+			}
+		};
+	});
+
+	p.then(clean, clean);
+
+	return p.then(() => stream.getBufferedValue());
+}
+
+module.exports = getStream;
+module.exports.buffer = (stream, opts) => getStream(stream, Object.assign({}, opts, {encoding: 'buffer'}));
+module.exports.array = (stream, opts) => getStream(stream, Object.assign({}, opts, {array: true}));

node_modules/got/node_modules/get-stream/license

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+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/got/node_modules/get-stream/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "get-stream",
+  "version": "3.0.0",
+  "description": "Get a stream as a string, buffer, or array",
+  "license": "MIT",
+  "repository": "sindresorhus/get-stream",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "sindresorhus.com"
+  },
+  "engines": {
+    "node": ">=4"
+  },
+  "scripts": {
+    "test": "xo && ava"
+  },
+  "files": [
+    "index.js",
+    "buffer-stream.js"
+  ],
+  "keywords": [
+    "get",
+    "stream",
+    "promise",
+    "concat",
+    "string",
+    "str",
+    "text",
+    "buffer",
+    "read",
+    "data",
+    "consume",
+    "readable",
+    "readablestream",
+    "array",
+    "object",
+    "obj"
+  ],
+  "devDependencies": {
+    "ava": "*",
+    "into-stream": "^3.0.0",
+    "xo": "*"
+  },
+  "xo": {
+    "esnext": true
+  }
+}

node_modules/got/node_modules/get-stream/readme.md

@@ -0,0 +1,117 @@
+# get-stream [![Build Status](https://travis-ci.org/sindresorhus/get-stream.svg?branch=master)](https://travis-ci.org/sindresorhus/get-stream)
+
+> Get a stream as a string, buffer, or array
+
+
+## Install
+
+```
+$ npm install --save get-stream
+```
+
+
+## Usage
+
+```js
+const fs = require('fs');
+const getStream = require('get-stream');
+const stream = fs.createReadStream('unicorn.txt');
+
+getStream(stream).then(str => {
+	console.log(str);
+	/*
+	              ,,))))))));,
+	           __)))))))))))))),
+	\|/       -\(((((''''((((((((.
+	-*-==//////((''  .     `)))))),
+	/|\      ))| o    ;-.    '(((((                                  ,(,
+	         ( `|    /  )    ;))))'                               ,_))^;(~
+	            |   |   |   ,))((((_     _____------~~~-.        %,;(;(>';'~
+	            o_);   ;    )))(((` ~---~  `::           \      %%~~)(v;(`('~
+	                  ;    ''''````         `:       `:::|\,__,%%    );`'; ~
+	                 |   _                )     /      `:|`----'     `-'
+	           ______/\/~    |                 /        /
+	         /~;;.____/;;'  /          ___--,-(   `;;;/
+	        / //  _;______;'------~~~~~    /;;/\    /
+	       //  | |                        / ;   \;;,\
+	      (<_  | ;                      /',/-----'  _>
+	       \_| ||_                     //~;~~~~~~~~~
+	           `\_|                   (,~~
+	                                   \~\
+	                                    ~~
+	*/
+});
+```
+
+
+## API
+
+The methods returns a promise that resolves when the `end` event fires on the stream, indicating that there is no more data to be read. The stream is switched to flowing mode.
+
+### getStream(stream, [options])
+
+Get the `stream` as a string.
+
+#### options
+
+##### encoding
+
+Type: `string`<br>
+Default: `utf8`
+
+[Encoding](https://nodejs.org/api/buffer.html#buffer_buffer) of the incoming stream.
+
+##### maxBuffer
+
+Type: `number`<br>
+Default: `Infinity`
+
+Maximum length of the returned string. If it exceeds this value before the stream ends, the promise will be rejected.
+
+### getStream.buffer(stream, [options])
+
+Get the `stream` as a buffer.
+
+It honors the `maxBuffer` option as above, but it refers to byte length rather than string length.
+
+### getStream.array(stream, [options])
+
+Get the `stream` as an array of values.
+
+It honors both the `maxBuffer` and `encoding` options. The behavior changes slightly based on the encoding chosen:
+
+- When `encoding` is unset, it assumes an [object mode stream](https://nodesource.com/blog/understanding-object-streams/) and collects values emitted from `stream` unmodified. In this case `maxBuffer` refers to the number of items in the array (not the sum of their sizes).
+
+- When `encoding` is set to `buffer`, it collects an array of buffers. `maxBuffer` refers to the summed byte lengths of every buffer in the array.
+
+- When `encoding` is set to anything else, it collects an array of strings. `maxBuffer` refers to the summed character lengths of every string in the array.
+
+
+## Errors
+
+If the input stream emits an `error` event, the promise will be rejected with the error. The buffered data will be attached to the `bufferedData` property of the error.
+
+```js
+getStream(streamThatErrorsAtTheEnd('unicorn'))
+	.catch(err => {
+		console.log(err.bufferedData);
+		//=> 'unicorn'
+	});
+```
+
+
+## FAQ
+
+### How is this different from [`concat-stream`](https://github.com/maxogden/concat-stream)?
+
+This module accepts a stream instead of being one and returns a promise instead of using a callback. The API is simpler and it only supports returning a string, buffer, or array. It doesn't have a fragile type inference. You explicitly choose what you want. And it doesn't depend on the huge `readable-stream` package.
+
+
+## Related
+
+- [get-stdin](https://github.com/sindresorhus/get-stdin) - Get stdin as a string or buffer
+
+
+## License
+
+MIT © [Sindre Sorhus](https://sindresorhus.com)

node_modules/got/package.json

@@ -1,7 +1,7 @@
 {
   "name": "got",
-  "version": "5.6.0",
-  "description": "Simplified HTTP/HTTPS requests",
+  "version": "7.1.0",
+  "description": "Simplified HTTP requests",
   "license": "MIT",
   "repository": "sindresorhus/got",
   "maintainers": [
@@ -14,13 +14,15 @@
       "name": "Vsevolod Strukchinsky",
       "email": "floatdrop@gmail.com",
       "url": "github.com/floatdrop"
+    },
+    {
+      "name": "Alexander Tesfamichael",
+      "email": "alex.tesfamichael@gmail.com",
+      "url": "alextes.me"
     }
   ],
   "engines": {
-    "node": ">=0.10.0"
-  },
-  "browser": {
-    "unzip-response": false
+    "node": ">=4"
   },
   "scripts": {
     "test": "xo && nyc ava",
@@ -42,40 +44,45 @@
     "simple",
     "curl",
     "wget",
-    "fetch"
+    "fetch",
+    "net",
+    "network",
+    "electron"
   ],
   "dependencies": {
-    "create-error-class": "^3.0.1",
-    "duplexer2": "^0.1.4",
-    "is-plain-obj": "^1.0.0",
-    "is-redirect": "^1.0.0",
+    "decompress-response": "^3.2.0",
+    "duplexer3": "^0.1.4",
+    "get-stream": "^3.0.0",
+    "is-plain-obj": "^1.1.0",
     "is-retry-allowed": "^1.0.0",
     "is-stream": "^1.0.0",
+    "isurl": "^1.0.0-alpha5",
     "lowercase-keys": "^1.0.0",
-    "node-status-codes": "^1.0.0",
-    "object-assign": "^4.0.1",
-    "parse-json": "^2.1.0",
-    "pinkie-promise": "^2.0.0",
-    "read-all-stream": "^3.0.0",
-    "readable-stream": "^2.0.5",
-    "timed-out": "^2.0.0",
-    "unzip-response": "^1.0.0",
-    "url-parse-lax": "^1.0.0"
+    "p-cancelable": "^0.3.0",
+    "p-timeout": "^1.1.1",
+    "safe-buffer": "^5.0.1",
+    "timed-out": "^4.0.0",
+    "url-parse-lax": "^1.0.0",
+    "url-to-options": "^1.0.1"
   },
   "devDependencies": {
-    "ava": "^0.5.0",
+    "ava": "^0.20.0",
     "coveralls": "^2.11.4",
-    "get-port": "^2.0.0",
-    "into-stream": "^2.0.0",
-    "nyc": "^3.2.2",
+    "form-data": "^2.1.1",
+    "get-port": "^3.0.0",
+    "into-stream": "^3.0.0",
+    "nyc": "^11.0.2",
     "pem": "^1.4.4",
-    "pify": "^2.3.0",
-    "tempfile": "^1.1.1",
-    "xo": "*"
+    "pify": "^3.0.0",
+    "tempfile": "^2.0.0",
+    "tempy": "^0.1.0",
+    "universal-url": "^1.0.0-alpha",
+    "xo": "^0.18.0"
   },
-  "xo": {
-    "ignores": [
-      "test/**"
-    ]
+  "ava": {
+    "concurrency": 4
+  },
+  "browser": {
+    "decompress-response": false
   }
 }

node_modules/got/readme.md

@@ -6,15 +6,27 @@
 	<br>
 </h1>
 
-> Simplified HTTP/HTTPS requests
+> Simplified HTTP requests
 
-[![Build Status](https://travis-ci.org/sindresorhus/got.svg?branch=master)](https://travis-ci.org/sindresorhus/got) [![Coverage Status](https://coveralls.io/repos/sindresorhus/got/badge.svg?service=github&branch=master)](https://coveralls.io/github/sindresorhus/got?branch=master) [![Downloads](https://img.shields.io/npm/dm/got.svg?style=flat)](https://npmjs.com/got)
+[![Build Status](https://travis-ci.org/sindresorhus/got.svg?branch=master)](https://travis-ci.org/sindresorhus/got) [![Coverage Status](https://coveralls.io/repos/github/sindresorhus/got/badge.svg?branch=master)](https://coveralls.io/github/sindresorhus/got?branch=master) [![Downloads](https://img.shields.io/npm/dm/got.svg)](https://npmjs.com/got)
 
 A nicer interface to the built-in [`http`](http://nodejs.org/api/http.html) module.
 
-It supports following redirects, promises, streams, retries, automagically handling gzip/deflate and some convenience options.
+Created because [`request`](https://github.com/request/request) is bloated *(several megabytes!)*.
 
-Created because [`request`](https://github.com/mikeal/request) is bloated *(several megabytes!)*.
+
+## Highlights
+
+- [Promise & stream API](#api)
+- [Request cancelation](#aborting-the-request)
+- [Follows redirects](#followredirect)
+- [Retries on network failure](#retries)
+- [Handles gzip/deflate](#decompress)
+- [Timeout handling](#timeout)
+- [Errors with metadata](#errors)
+- [JSON mode](#json)
+- [WHATWG URL support](#url)
+- [Electron support](#useelectronnet)
 
 
 ## Install
@@ -27,15 +39,9 @@ $ npm install --save got
 ## Usage
 
 ```js
+const fs = require('fs');
 const got = require('got');
 
-// Callback mode
-got('todomvc.com', (error, body, response) => {
-	console.log(body);
-	//=> '<!doctype html> ...'
-});
-
-// Promise mode
 got('todomvc.com')
 	.then(response => {
 		console.log(response.body);
@@ -46,7 +52,7 @@ got('todomvc.com')
 		//=> 'Internal server error ...'
 	});
 
-// Stream mode
+// Streams
 got.stream('todomvc.com').pipe(fs.createWriteStream('index.html'));
 
 // For POST, PUT and PATCH methods got.stream returns a WritableStream
@@ -58,25 +64,27 @@ fs.createReadStream('index.html').pipe(got.stream.post('todomvc.com'));
 
 It's a `GET` request by default, but can be changed in `options`.
 
-#### got(url, [options], [callback])
+#### got(url, [options])
+
+Returns a Promise for a `response` object with a `body` property, a `url` property with the request URL or the final URL after redirects, and a `requestUrl` property with the original request URL.
 
 ##### url
 
-Type: `string`, `object`
+Type: `string` `Object`
 
-The URL to request or a [`http.request` options](https://nodejs.org/api/http.html#http_http_request_options_callback) object.
+The URL to request as simple string, a [`http.request` options](https://nodejs.org/api/http.html#http_http_request_options_callback), or a [WHATWG `URL`](https://nodejs.org/api/url.html#url_class_url).
 
 Properties from `options` will override properties in the parsed `url`.
 
 ##### options
 
-Type: `object`
+Type: `Object`
 
 Any of the [`http.request`](http://nodejs.org/api/http.html#http_http_request_options_callback) options.
 
 ###### body
 
-Type: `string`, `buffer`, `readableStream`, `object`  
+Type: `string` `Buffer` `stream.Readable`
 
 *This is mutually exclusive with stream mode.*
 
@@ -86,40 +94,55 @@ If present in `options` and `options.method` is not set, `options.method` will b
 
 If `content-length` or `transfer-encoding` is not set in `options.headers` and `body` is a string or buffer, `content-length` will be set to the body length.
 
-If `body` is a plain object, it will be stringified with [`querystring.stringify`](https://nodejs.org/api/querystring.html#querystring_querystring_stringify_obj_sep_eq_options) and sent as `application/x-www-form-urlencoded`.
-
 ###### encoding
 
-Type: `string`, `null`  
+Type: `string` `null`<br>
 Default: `'utf8'`
 
-Encoding to be used on `setEncoding` of the response data. If `null`, the body is returned as a Buffer.
+[Encoding](https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings) to be used on `setEncoding` of the response data. If `null`, the body is returned as a Buffer.
 
-###### json
+###### form
 
-Type: `boolean`  
+Type: `boolean`<br>
 Default: `false`
 
 *This is mutually exclusive with stream mode.*
 
-Parse response body with `JSON.parse` and set `accept` header to `application/json`.
+If set to `true` and `Content-Type` header is not set, it will be set to `application/x-www-form-urlencoded`.
+
+`body` must be a plain object or array and will be stringified.
+
+###### json
+
+Type: `boolean`<br>
+Default: `false`
+
+*This is mutually exclusive with stream mode.*
+
+If set to `true` and `Content-Type` header is not set, it will be set to `application/json`.
+
+Parse response body with `JSON.parse` and set `accept` header to `application/json`. If used in conjunction with the `form` option, the `body` will the stringified as querystring and the response parsed as JSON.
+
+`body` must be a plain object or array and will be stringified.
 
 ###### query
 
-Type: `string`, `object`  
+Type: `string` `Object`<br>
 
 Query string object that will be added to the request URL. This will override the query string in `url`.
 
 ###### timeout
 
-Type: `number`
+Type: `number` `Object`
 
-Milliseconds after which the request will be aborted and an error event with `ETIMEDOUT` code will be emitted.
+Milliseconds to wait for the server to end the response before aborting request with `ETIMEDOUT` error.
+
+This also accepts an object with separate `connect`, `socket`, and `request` fields for connection, socket, and entire request timeouts.
 
 ###### retries
 
-Type: `number`, `function`  
-Default: `5`
+Type: `number` `Function`<br>
+Default: `2`
 
 Number of request retries when network errors happens. Delays between retries counts with function `1000 * Math.pow(2, retry) + Math.random() * 100`, where `retry` is attempt number (starts from 0).
 
@@ -129,32 +152,42 @@ Option accepts `function` with `retry` and `error` arguments. Function must retu
 
 ###### followRedirect
 
-Type: `boolean`  
+Type: `boolean`<br>
 Default: `true`
 
 Defines if redirect responses should be followed automatically.
 
-##### callback(error, data, response)
+Note that if a `303` is sent by the server in response to any request type (`POST`, `DELETE`, etc.), got will automatically
+request the resource pointed to in the location header via `GET`. This is in accordance with [the spec](https://tools.ietf.org/html/rfc7231#section-6.4.4).
 
-Function to be called when error or data are received. If omitted, a promise will be returned.
+###### decompress
 
-###### error
+Type: `boolean`<br>
+Default: `true`
 
-`Error` object with HTTP status code as `statusCode` property.
+Decompress the response automatically.
 
-The data you requested.
+If this is disabled, a compressed response is returned as a `Buffer`. This may be useful if you want to handle decompression yourself or stream the raw compressed data.
 
-###### response
+###### useElectronNet
 
-The [response object](http://nodejs.org/api/http.html#http_http_incomingmessage).
+Type: `boolean`<br>
+Default: `true`
 
-When in stream mode, you can listen for events:
+When used in Electron, Got will automatically use [`electron.net`](https://electron.atom.io/docs/api/net/) instead of the Node.js `http` module. It should be fully compatible, but you can turn it off here if you encounter a problem. Please open an issue if you do!
+
+
+#### Streams
+
+#### got.stream(url, [options])
+
+`stream` method will return Duplex stream with additional events:
 
 ##### .on('request', request)
 
 `request` event to get the request object of the request.
 
-__Tip__: You can use `request` event to abort request:
+**Tip**: You can use `request` event to abort request:
 
 ```js
 got.stream('github.com')
@@ -173,19 +206,19 @@ got.stream('github.com')
 
 `error` event emitted in case of protocol error (like `ENOTFOUND` etc.) or status error (4xx or 5xx). The second argument is the body of the server response in case of status error. The third argument is response object.
 
-#### got.get(url, [options], [callback])
-#### got.post(url, [options], [callback])
-#### got.put(url, [options], [callback])
-#### got.patch(url, [options], [callback])
-#### got.head(url, [options], [callback])
-#### got.delete(url, [options], [callback])
+#### got.get(url, [options])
+#### got.post(url, [options])
+#### got.put(url, [options])
+#### got.patch(url, [options])
+#### got.head(url, [options])
+#### got.delete(url, [options])
 
 Sets `options.method` to the method name and makes a request.
 
 
 ## Errors
 
-Each error contains (if available) `statusCode`, `statusMessage`, `host`, `hostname`, `method` and `path` properties to make debugging easier.
+Each error contains (if available) `statusCode`, `statusMessage`, `host`, `hostname`, `method`, `path`, `protocol` and `url` properties to make debugging easier.
 
 In Promise mode, the `response` is attached to the error.
 
@@ -199,15 +232,24 @@ When reading from response stream fails.
 
 #### got.ParseError
 
-When `json` option is enabled and `JSON.parse` fails.
+When `json` option is enabled, server response code is 2xx, and `JSON.parse` fails.
 
 #### got.HTTPError
 
-When server response code is not 2xx. Contains `statusCode` and `statusMessage`.
+When server response code is not 2xx. Includes `statusCode`, `statusMessage`, and `redirectUrls` properties.
 
 #### got.MaxRedirectsError
 
-When server redirects you more than 10 times.
+When server redirects you more than 10 times. Includes a `redirectUrls` property, which is an array of the URLs Got was redirected to before giving up.
+
+#### got.UnsupportedProtocolError
+
+When given an unsupported protocol.
+
+
+## Aborting the request
+
+The promise returned by Got has a `.cancel()` function which, when called, aborts the request.
 
 
 ## Proxies
@@ -224,7 +266,7 @@ got('todomvc.com', {
 			host: 'localhost'
 		}
 	})
-}, () => {});
+});
 ```
 
 
@@ -244,6 +286,56 @@ got('google.com', {
 ```
 
 
+## Form data
+
+You can use the [`form-data`](https://github.com/form-data/form-data) module to create POST request with form data:
+
+```js
+const fs = require('fs');
+const got = require('got');
+const FormData = require('form-data');
+const form = new FormData();
+
+form.append('my_file', fs.createReadStream('/foo/bar.jpg'));
+
+got.post('google.com', {
+	body: form
+});
+```
+
+
+## OAuth
+
+You can use the [`oauth-1.0a`](https://github.com/ddo/oauth-1.0a) module to create a signed OAuth request:
+
+```js
+const got = require('got');
+const crypto  = require('crypto');
+const OAuth = require('oauth-1.0a');
+
+const oauth = OAuth({
+	consumer: {
+		key: process.env.CONSUMER_KEY,
+		secret: process.env.CONSUMER_SECRET
+	},
+	signature_method: 'HMAC-SHA1',
+	hash_function: (baseString, key) => crypto.createHmac('sha1', key).update(baseString).digest('base64')
+});
+
+const token = {
+	key: process.env.ACCESS_TOKEN,
+	secret: process.env.ACCESS_TOKEN_SECRET
+};
+
+const url = 'https://api.twitter.com/1.1/statuses/home_timeline.json';
+
+got(url, {
+	headers: oauth.toHeader(oauth.authorize({url, method: 'GET'}, token)),
+	json: true
+});
+```
+
+
 ## Unix Domain Sockets
 
 Requests can also be sent via [unix domain sockets](http://serverfault.com/questions/124517/whats-the-difference-between-unix-socket-and-tcp-ip-socket). Use the following URL scheme: `PROTOCOL://unix:SOCKET:PATH`.
@@ -259,32 +351,66 @@ got('http://unix:/var/run/docker.sock:/containers/json');
 got('unix:/var/run/docker.sock:/containers/json');
 ```
 
-## Tip
+## AWS
+
+Requests to AWS services need to have their headers signed. This can be accomplished by using the [`aws4`](https://www.npmjs.com/package/aws4) package. This is an example for querying an ["Elasticsearch Service"](https://aws.amazon.com/elasticsearch-service/) host with a signed request.
+
+```js
+const url = require('url');
+const AWS = require('aws-sdk');
+const aws4 = require('aws4');
+const got = require('got');
+const config = require('./config');
+
+// Reads keys from the environment or `~/.aws/credentials`. Could be a plain object.
+const awsConfig = new AWS.Config({ region: config.region });
+
+function request(uri, options) {
+	const awsOpts = {
+		region: awsConfig.region,
+		headers: {
+			accept: 'application/json',
+			'content-type': 'application/json'
+		},
+		method: 'GET',
+		json: true
+	};
+
+	// We need to parse the URL before passing it to `got` so `aws4` can sign the request
+	const opts = Object.assign(url.parse(uri), awsOpts, options);
+	aws4.sign(opts, awsConfig.credentials);
+
+	return got(opts);
+}
+
+request(`https://${config.host}/production/users/1`);
+
+request(`https://${config.host}/production/`, {
+	// All usual `got` options
+});
+```
+
+
+## Tips
+
+### User Agent
 
 It's a good idea to set the `'user-agent'` header so the provider can more easily see how their resource is used. By default, it's the URL to this repo.
 
 ```js
-var got = require('got');
-var pkg = require('./package.json');
+const got = require('got');
+const pkg = require('./package.json');
 
 got('todomvc.com', {
 	headers: {
-		'user-agent': 'my-module/' + pkg.version + ' (https://github.com/username/my-module)'
+		'user-agent': `my-module/${pkg.version} (https://github.com/username/my-module)`
 	}
-}, function () {});
+});
 ```
 
+### 304 Responses
 
-## Node.js 0.10.x
-
-It is a known issue with old good Node 0.10.x [`http.Agent`](https://nodejs.org/docs/v0.10.39/api/http.html#http_class_http_agent) and `agent.maxSockets`, which is set to `5`. This can cause low performance and in rare cases deadlocks. To avoid this you can set it manually:
-
-```js
-require('http').globalAgent.maxSockets = Infinity;
-require('https').globalAgent.maxSockets = Infinity;
-```
-
-This should only ever be done if you have Node version 0.10.x and at the top-level app layer.
+Bear in mind, if you send an `if-modified-since` header and receive a `304 Not Modified` response, the body will be empty. It's your responsibility to cache and retrieve the body contents.
 
 
 ## Related
@@ -295,11 +421,11 @@ This should only ever be done if you have Node version 0.10.x and at the top-lev
 
 ## Created by
 
-[![Sindre Sorhus](https://avatars.githubusercontent.com/u/170270?v=3&s=100)](http://sindresorhus.com) | [![Vsevolod Strukchinsky](https://avatars.githubusercontent.com/u/365089?v=3&s=100)](https://github.com/floatdrop)
----|---
-[Sindre Sorhus](http://sindresorhus.com) | [Vsevolod Strukchinsky](https://github.com/floatdrop)
+[![Sindre Sorhus](https://avatars.githubusercontent.com/u/170270?v=3&s=100)](https://sindresorhus.com) | [![Vsevolod Strukchinsky](https://avatars.githubusercontent.com/u/365089?v=3&s=100)](https://github.com/floatdrop) | [![Alexander Tesfamichael](https://avatars.githubusercontent.com/u/2011351?v=3&s=100)](https://alextes.me)
+---|---|---
+[Sindre Sorhus](https://sindresorhus.com) | [Vsevolod Strukchinsky](https://github.com/floatdrop) | [Alexander Tesfamichael](https://alextes.me)
 
 
 ## License
 
-MIT © [Sindre Sorhus](http://sindresorhus.com)
+MIT