Demo for query storing
Change-Id: I947bcac841992c3f6cfd01ab337c265b0d01cb70
diff --git a/node_modules/got/index.js b/node_modules/got/index.js
new file mode 100644
index 0000000..4c5090a
--- /dev/null
+++ b/node_modules/got/index.js
@@ -0,0 +1,479 @@
+'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');
+
+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 || {};
+
+ const ee = new EventEmitter();
+ const requestUrl = opts.href || urlLib.resolve(urlLib.format(opts), opts.path);
+ const redirects = [];
+ let retryCount = 0;
+ let redirectUrl;
+
+ const get = opts => {
+ if (opts.protocol !== 'http:' && opts.protocol !== 'https:') {
+ ee.emit('error', new got.UnsupportedProtocolError(opts));
+ return;
+ }
+
+ let fn = opts.protocol === 'https:' ? https : http;
+
+ 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 (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;
+ }
+
+ 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;
+ }
+
+ 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', err => {
+ const backoff = opts.retries(++retryCount, err);
+
+ if (backoff) {
+ setTimeout(get, backoff, opts);
+ return;
+ }
+
+ ee.emit('error', new got.RequestError(err, opts));
+ });
+
+ if (opts.gotTimeout) {
+ timedOut(req, opts.gotTimeout);
+ }
+
+ setImmediate(() => {
+ ee.emit('request', req);
+ });
+ };
+
+ setImmediate(() => {
+ get(opts);
+ });
+ return ee;
+}
+
+function asPromise(opts) {
+ 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();
+ }
+
+ onCancel(() => {
+ req.abort();
+ });
+
+ if (isStream(opts.body)) {
+ opts.body.pipe(req);
+ opts.body = undefined;
+ return;
+ }
+
+ 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) {
+ 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 = () => {
+ throw new Error('got\'s stream is not writable when options.body is used');
+ };
+ }
+
+ const ee = requestAsEventEmitter(opts);
+
+ ee.on('request', req => {
+ proxy.emit('request', req);
+
+ if (isStream(opts.body)) {
+ opts.body.pipe(req);
+ return;
+ }
+
+ if (opts.body) {
+ req.end(opts.body);
+ return;
+ }
+
+ if (opts.method === 'POST' || opts.method === 'PUT' || opts.method === 'PATCH') {
+ input.pipe(req);
+ return;
+ }
+
+ req.end();
+ });
+
+ ee.on('response', res => {
+ clearTimeout(timeout);
+
+ const statusCode = res.statusCode;
+
+ res.pipe(output);
+
+ if (statusCode !== 304 && (statusCode < 200 || statusCode > 299)) {
+ proxy.emit('error', new got.HTTPError(statusCode, res.headers, opts), null, res);
+ return;
+ }
+
+ proxy.emit('response', res);
+ });
+
+ ee.on('redirect', proxy.emit.bind(proxy, 'redirect'));
+ ee.on('error', proxy.emit.bind(proxy, 'error'));
+
+ return proxy;
+}
+
+function normalizeArguments(url, opts) {
+ if (typeof url !== 'string' && typeof url !== 'object') {
+ 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);
+ } else if (isURL.lenient(url)) {
+ url = urlToOptions(url);
+ }
+
+ 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 = Object.assign({
+ 'user-agent': `${pkg.name}/${pkg.version} (https://github.com/sindresorhus/got)`,
+ 'accept-encoding': 'gzip,deflate'
+ }, lowercaseKeys(opts.headers));
+
+ const query = opts.query;
+
+ if (query) {
+ if (typeof query !== 'string') {
+ opts.query = querystring.stringify(query);
+ }
+
+ opts.path = `${opts.path.split('?')[0]}?${opts.query}`;
+ delete opts.query;
+ }
+
+ if (opts.json && opts.headers.accept === undefined) {
+ opts.headers.accept = 'application/json';
+ }
+
+ 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');
+ }
+
+ 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 (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();
+ }
+
+ if (opts.hostname === 'unix') {
+ const matches = /(.+?):(.+)/.exec(opts.path);
+
+ if (matches) {
+ opts.socketPath = matches[1];
+ opts.path = matches[2];
+ opts.host = null;
+ }
+ }
+
+ if (typeof opts.retries !== 'function') {
+ const retries = opts.retries;
+
+ opts.retries = (iter, err) => {
+ if (iter > retries || !isRetryAllowed(err)) {
+ return 0;
+ }
+
+ const noise = Math.random() * 100;
+
+ return ((1 << iter) * 1000) + noise;
+ };
+ }
+
+ if (opts.followRedirect === undefined) {
+ 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) {
+ try {
+ return asPromise(normalizeArguments(url, opts));
+ } catch (err) {
+ return Promise.reject(err);
+ }
+}
+
+got.stream = (url, opts) => asStream(normalizeArguments(url, opts));
+
+const methods = [
+ 'get',
+ 'post',
+ 'put',
+ 'patch',
+ 'head',
+ 'delete'
+];
+
+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}));
+}
+
+class StdError extends Error {
+ constructor(message, error, opts) {
+ super(message);
+ this.name = 'StdError';
+
+ if (error.code !== undefined) {
+ this.code = error.code;
+ }
+
+ Object.assign(this, {
+ host: opts.host,
+ hostname: opts.hostname,
+ method: opts.method,
+ path: opts.path,
+ protocol: opts.protocol,
+ url: opts.href
+ });
+ }
+}
+
+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;
diff --git a/node_modules/got/license b/node_modules/got/license
new file mode 100644
index 0000000..654d0bf
--- /dev/null
+++ b/node_modules/got/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.
diff --git a/node_modules/got/package.json b/node_modules/got/package.json
new file mode 100644
index 0000000..5c94a32
--- /dev/null
+++ b/node_modules/got/package.json
@@ -0,0 +1,120 @@
+{
+ "_from": "got@^7.0.0",
+ "_id": "got@7.1.0",
+ "_inBundle": false,
+ "_integrity": "sha512-Y5WMo7xKKq1muPsxD+KmrR8DH5auG7fBdDVueZwETwV6VytKyU9OX/ddpq2/1hp1vIPvVb4T81dKQz3BivkNLw==",
+ "_location": "/got",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "got@^7.0.0",
+ "name": "got",
+ "escapedName": "got",
+ "rawSpec": "^7.0.0",
+ "saveSpec": null,
+ "fetchSpec": "^7.0.0"
+ },
+ "_requiredBy": [
+ "/download"
+ ],
+ "_resolved": "https://registry.npmjs.org/got/-/got-7.1.0.tgz",
+ "_shasum": "05450fd84094e6bbea56f451a43a9c289166385a",
+ "_spec": "got@^7.0.0",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\download",
+ "ava": {
+ "concurrency": 4
+ },
+ "browser": {
+ "decompress-response": false
+ },
+ "bugs": {
+ "url": "https://github.com/sindresorhus/got/issues"
+ },
+ "bundleDependencies": false,
+ "dependencies": {
+ "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",
+ "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"
+ },
+ "deprecated": false,
+ "description": "Simplified HTTP requests",
+ "devDependencies": {
+ "ava": "^0.20.0",
+ "coveralls": "^2.11.4",
+ "form-data": "^2.1.1",
+ "get-port": "^3.0.0",
+ "into-stream": "^3.0.0",
+ "nyc": "^11.0.2",
+ "pem": "^1.4.4",
+ "pify": "^3.0.0",
+ "tempfile": "^2.0.0",
+ "tempy": "^0.1.0",
+ "universal-url": "^1.0.0-alpha",
+ "xo": "^0.18.0"
+ },
+ "engines": {
+ "node": ">=4"
+ },
+ "files": [
+ "index.js"
+ ],
+ "homepage": "https://github.com/sindresorhus/got#readme",
+ "keywords": [
+ "http",
+ "https",
+ "get",
+ "got",
+ "url",
+ "uri",
+ "request",
+ "util",
+ "utility",
+ "simple",
+ "curl",
+ "wget",
+ "fetch",
+ "net",
+ "network",
+ "electron"
+ ],
+ "license": "MIT",
+ "maintainers": [
+ {
+ "name": "Sindre Sorhus",
+ "email": "sindresorhus@gmail.com",
+ "url": "sindresorhus.com"
+ },
+ {
+ "name": "Vsevolod Strukchinsky",
+ "email": "floatdrop@gmail.com",
+ "url": "github.com/floatdrop"
+ },
+ {
+ "name": "Alexander Tesfamichael",
+ "email": "alex.tesfamichael@gmail.com",
+ "url": "alextes.me"
+ }
+ ],
+ "name": "got",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/sindresorhus/got.git"
+ },
+ "scripts": {
+ "coveralls": "nyc report --reporter=text-lcov | coveralls",
+ "test": "xo && nyc ava"
+ },
+ "version": "7.1.0"
+}
diff --git a/node_modules/got/readme.md b/node_modules/got/readme.md
new file mode 100644
index 0000000..074530f
--- /dev/null
+++ b/node_modules/got/readme.md
@@ -0,0 +1,431 @@
+<h1 align="center">
+ <br>
+ <img width="360" src="https://rawgit.com/sindresorhus/got/master/media/logo.svg" alt="got">
+ <br>
+ <br>
+ <br>
+</h1>
+
+> Simplified HTTP requests
+
+[](https://travis-ci.org/sindresorhus/got) [](https://coveralls.io/github/sindresorhus/got?branch=master) [](https://npmjs.com/got)
+
+A nicer interface to the built-in [`http`](http://nodejs.org/api/http.html) module.
+
+Created because [`request`](https://github.com/request/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
+
+```
+$ npm install --save got
+```
+
+
+## Usage
+
+```js
+const fs = require('fs');
+const got = require('got');
+
+got('todomvc.com')
+ .then(response => {
+ console.log(response.body);
+ //=> '<!doctype html> ...'
+ })
+ .catch(error => {
+ console.log(error.response.body);
+ //=> 'Internal server error ...'
+ });
+
+// Streams
+got.stream('todomvc.com').pipe(fs.createWriteStream('index.html'));
+
+// For POST, PUT and PATCH methods got.stream returns a WritableStream
+fs.createReadStream('index.html').pipe(got.stream.post('todomvc.com'));
+```
+
+
+### API
+
+It's a `GET` request by default, but can be changed in `options`.
+
+#### 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`
+
+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`
+
+Any of the [`http.request`](http://nodejs.org/api/http.html#http_http_request_options_callback) options.
+
+###### body
+
+Type: `string` `Buffer` `stream.Readable`
+
+*This is mutually exclusive with stream mode.*
+
+Body that will be sent with a `POST` request.
+
+If present in `options` and `options.method` is not set, `options.method` will be set to `POST`.
+
+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.
+
+###### encoding
+
+Type: `string` `null`<br>
+Default: `'utf8'`
+
+[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.
+
+###### form
+
+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/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`<br>
+
+Query string object that will be added to the request URL. This will override the query string in `url`.
+
+###### timeout
+
+Type: `number` `Object`
+
+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`<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).
+
+Option accepts `function` with `retry` and `error` arguments. Function must return delay in milliseconds (`0` return value cancels retry).
+
+**Note:** if `retries` is `number`, `ENOTFOUND` and `ENETUNREACH` error will not be retried (see full list in [`is-retry-allowed`](https://github.com/floatdrop/is-retry-allowed/blob/master/index.js#L12) module).
+
+###### followRedirect
+
+Type: `boolean`<br>
+Default: `true`
+
+Defines if redirect responses should be followed automatically.
+
+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).
+
+###### decompress
+
+Type: `boolean`<br>
+Default: `true`
+
+Decompress the response automatically.
+
+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.
+
+###### useElectronNet
+
+Type: `boolean`<br>
+Default: `true`
+
+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:
+
+```js
+got.stream('github.com')
+ .on('request', req => setTimeout(() => req.abort(), 50));
+```
+
+##### .on('response', response)
+
+`response` event to get the response object of the final request.
+
+##### .on('redirect', response, nextOptions)
+
+`redirect` event to get the response object of a redirect. The second argument is options for the next request to the redirect location.
+
+##### .on('error', error, body, response)
+
+`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])
+#### 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`, `path`, `protocol` and `url` properties to make debugging easier.
+
+In Promise mode, the `response` is attached to the error.
+
+#### got.RequestError
+
+When a request fails. Contains a `code` property with error class code, like `ECONNREFUSED`.
+
+#### got.ReadError
+
+When reading from response stream fails.
+
+#### got.ParseError
+
+When `json` option is enabled, server response code is 2xx, and `JSON.parse` fails.
+
+#### got.HTTPError
+
+When server response code is not 2xx. Includes `statusCode`, `statusMessage`, and `redirectUrls` properties.
+
+#### got.MaxRedirectsError
+
+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
+
+You can use the [`tunnel`](https://github.com/koichik/node-tunnel) module with the `agent` option to work with proxies:
+
+```js
+const got = require('got');
+const tunnel = require('tunnel');
+
+got('todomvc.com', {
+ agent: tunnel.httpOverHttp({
+ proxy: {
+ host: 'localhost'
+ }
+ })
+});
+```
+
+
+## Cookies
+
+You can use the [`cookie`](https://github.com/jshttp/cookie) module to include cookies in a request:
+
+```js
+const got = require('got');
+const cookie = require('cookie');
+
+got('google.com', {
+ headers: {
+ cookie: cookie.serialize('foo', 'bar')
+ }
+});
+```
+
+
+## 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`.
+
+- `PROTOCOL` - `http` or `https` *(optional)*
+- `SOCKET` - absolute path to a unix domain socket, e.g. `/var/run/docker.sock`
+- `PATH` - request path, e.g. `/v2/keys`
+
+```js
+got('http://unix:/var/run/docker.sock:/containers/json');
+
+// or without protocol (http by default)
+got('unix:/var/run/docker.sock:/containers/json');
+```
+
+## 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
+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)`
+ }
+});
+```
+
+### 304 Responses
+
+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
+
+- [gh-got](https://github.com/sindresorhus/gh-got) - Convenience wrapper for interacting with the GitHub API
+- [travis-got](https://github.com/samverschueren/travis-got) - Convenience wrapper for interacting with the Travis API
+
+
+## Created by
+
+[](https://sindresorhus.com) | [](https://github.com/floatdrop) | [](https://alextes.me)
+---|---|---
+[Sindre Sorhus](https://sindresorhus.com) | [Vsevolod Strukchinsky](https://github.com/floatdrop) | [Alexander Tesfamichael](https://alextes.me)
+
+
+## License
+
+MIT