got 10.5.7 → 11.0.0

package/readme.md

@@ -28,7 +28,8 @@ For browser usage, we recommend [Ky](https://github.com/sindresorhus/ky) by the
 
 - [Promise API](#api)
 - [Stream API](#streams)
-- [Pagination API (experimental)](#pagination)
+- [Pagination API](#pagination)
+- [HTTP2 support](#http2)
 - [Request cancelation](#aborting-the-request)
 - [RFC compliant caching](#cache-adapters)
 - [Follows redirects](#followredirect)
@@ -44,8 +45,8 @@ For browser usage, we recommend [Ky](https://github.com/sindresorhus/ky) by the
 - [Types](#types)
 - [Composable](documentation/advanced-creation.md#merging-instances)
 - [Plugins](documentation/lets-make-a-plugin.md)
-- [Used by 3000+ packages and 1.6M+ repos](https://github.com/sindresorhus/got/network/dependents)
-- Actively maintained
+- [Used by 4K+ packages and 1.8M+ repos](https://github.com/sindresorhus/got/network/dependents)
+- [Actively maintained](https://github.com/sindresorhus/got/graphs/contributors)
 
 ## Install
 
@@ -94,17 +95,17 @@ const pipeline = promisify(stream.pipeline);
 })();
 ```
 
-**Tip:** Using `from.pipe(to)` doesn't forward errors. If you use it, switch to [`Stream.pipeline(from, ..., to, callback)`](https://nodejs.org/api/stream.html#stream_stream_pipeline_streams_callback) instead (available from Node v10).
+**Tip:** `from.pipe(to)` doesn't forward errors. Instead, use [`stream.pipeline(from, ..., to, callback)`](https://nodejs.org/api/stream.html#stream_stream_pipeline_streams_callback).
 
 ### API
 
-It's a `GET` request by default, but can be changed by using different methods or via `options.method`.
+It's a `GET` request by default, but can be changed by using different methods or via [`options.method`](#method).
 
 **By default, Got will retry on failure. To disable this option, set [`options.retry`](#retry) to `0`.**
 
 #### got(url?, options?)
 
-Returns a Promise for a [`response` object](#response) or a [stream](#streams-1) if `options.isStream` is set to true.
+Returns a Promise giving a [Response object](#response) or a [Got Stream](#streams-1) if `options.isStream` is set to true.
 
 ##### url
 
@@ -116,8 +117,6 @@ Properties from `options` will override properties in the parsed `url`.
 
 If no protocol is specified, it will throw a `TypeError`.
 
-**Note:** this can also be an option.
-
 ##### options
 
 Type: `object`
@@ -126,17 +125,25 @@ Any of the [`https.request`](https://nodejs.org/api/https.html#https_https_reque
 
 **Note:** Legacy URL support is disabled. `options.path` is supported only for backwards compatibility. Use `options.pathname` and `options.searchParams` instead. `options.auth` has been replaced with `options.username` & `options.password`.
 
+###### method
+
+Type: `string`\
+Default: `GET`
+
+The HTTP method used to make the request.
+
 ###### prefixUrl
 
 Type: `string | URL`
 
-When specified, `prefixUrl` will be prepended to `url`. The prefix can be any valid URL, either relative or absolute. A trailing slash `/` is optional - one will be added automatically.
+When specified, `prefixUrl` will be prepended to `url`. The prefix can be any valid URL, either relative or absolute.\
+A trailing slash `/` is optional - one will be added automatically.
 
 **Note:** `prefixUrl` will be ignored if the `url` argument is a URL instance.
 
 **Note:** Leading slashes in `input` are disallowed when using this option to enforce consistency and avoid confusion. For example, when the prefix URL is `https://example.com/foo` and the input is `/bar`, there's ambiguity whether the resulting URL would become `https://example.com/foo/bar` or `https://example.com/bar`. The latter is used by browsers.
 
-**Tip:** Useful when used with [`got.extend()`](#custom-endpoints) to create niche-specific Got-instances.
+**Tip:** Useful when used with [`got.extend()`](#custom-endpoints) to create niche-specific Got instances.
 
 **Tip:** You can change `prefixUrl` using hooks as long as the URL still includes the `prefixUrl`. If the URL doesn't include it anymore, it will throw.
 
@@ -188,7 +195,9 @@ Type: `string | Buffer | stream.Readable` or [`form-data` instance](https://gith
 
 **Note #2:** If you provide this option, `got.stream()` will be read-only.
 
-**Note #3:** If you provide a payload with the `GET` or `HEAD` method, it will throw a `TypeError`.
+**Note #3:** If you provide a payload with the `GET` or `HEAD` method, it will throw a `TypeError` unless the method is `GET` and the `allowGetBody` option is set to `true`.
+
+**Note #4:** This option is not enumerable and will not be merged with the instance defaults.
 
 The `content-length` header will be automatically set if `body` is a `string` / `Buffer` / `fs.createReadStream` instance / [`form-data` instance](https://github.com/form-data/form-data), and `content-length` and `transfer-encoding` are not manually set in `options.headers`.
 
@@ -196,7 +205,8 @@ The `content-length` header will be automatically set if `body` is a `string` /
 
 Type: `object | Array | number | string | boolean | null` *(JSON-serializable values)*
 
-**Note:** If you provide this option, `got.stream()` will be read-only.
+**Note #1:** If you provide this option, `got.stream()` will be read-only.\
+**Note #2:** This option is not enumerable and will not be merged with the instance defaults.
 
 JSON body. If the `Content-Type` header is not set, it will be set to `application/json`.
 
@@ -217,7 +227,7 @@ const instance = got.extend({
 	hooks: {
 		beforeRequest: [
 			options => {
-				if (!options.context && !options.context.token) {
+				if (!options.context || !options.context.token) {
 					throw new Error('Token required');
 				}
 
@@ -248,21 +258,35 @@ Default: `'text'`
 
 The parsing method. Can be `'text'`, `'json'` or `'buffer'`.
 
-The promise also has `.text()`, `.json()` and `.buffer()` methods which sets this and the `resolveBodyOnly` option automatically.
+The promise also has `.text()`, `.json()` and `.buffer()` methods which return another Got promise for the parsed body.\
+It's like setting the options to `{responseType: 'json', resolveBodyOnly: true}` but without affecting the main Got promise.
 
 Example:
 
+```js
+(async () => {
+	const responsePromise = got(url);
+	const bufferPromise = responsePromise.buffer();
+	const jsonPromise = responsePromise.json();
+
+	const [response, buffer, json] = Promise.all([responsePromise, bufferPromise, jsonPromise]);
+	// `response` is an instance of Got Response
+	// `buffer` is an instance of Buffer
+	// `json` is an object
+})();
+```
+
 ```js
 // This
 const body = await got(url).json();
 
-// is the same as this
+// is semantically the same as this
 const body = await got(url, {responseType: 'json', resolveBodyOnly: true});
 ```
 
 ###### resolveBodyOnly
 
-Type: `string`\
+Type: `boolean`\
 Default: `false`
 
 When set to `true` the promise will return the [Response body](#body-1) instead of the [Response](#response) object.
@@ -303,15 +327,18 @@ Default: `'utf8'`
 
 To get a [`Buffer`](https://nodejs.org/api/buffer.html), you need to set [`responseType`](#responseType) to `buffer` instead.
 
+**Note:** This doesn't affect streams! Instead, you need to do `got.stream(...).setEncoding(encoding)`.
+
 ###### form
 
-Type: `object | true`
+Type: `object`
 
-**Note:** If you provide this option, `got.stream()` will be read-only.
+**Note #1:** If you provide this option, `got.stream()` will be read-only.\
+**Note #2:** This option is not enumerable and will not be merged with the instance defaults.
 
-The form body is converted to query string using [`(new URLSearchParams(object)).toString()`](https://nodejs.org/api/url.html#url_constructor_new_urlsearchparams_obj).
+The form body is converted to a query string using [`(new URLSearchParams(object)).toString()`](https://nodejs.org/api/url.html#url_constructor_new_urlsearchparams_obj).
 
-If set to `true` and the `Content-Type` header is not set, it will be set to `application/x-www-form-urlencoded`.
+If the `Content-Type` header is not present, it will be set to `application/x-www-form-urlencoded`.
 
 ###### searchParams
 
@@ -332,20 +359,6 @@ console.log(searchParams.toString());
 //=> 'key=a&key=b'
 ```
 
-And if you need a different array format, you could use the [`query-string`](https://github.com/sindresorhus/query-string) package:
-
-```js
-const got = require('got');
-const queryString = require('query-string');
-
-const searchParams = queryString.stringify({key: ['a', 'b']}, {arrayFormat: 'bracket'});
-
-got('https://example.com', {searchParams});
-
-console.log(searchParams);
-//=> 'key[]=a&key[]=b'
-```
-
 ###### timeout
 
 Type: `number | object`
@@ -410,6 +423,15 @@ Default: `true`
 
 By default, redirects will use [method rewriting](https://tools.ietf.org/html/rfc7231#section-6.4). For example, when sending a POST request and receiving a `302`, it will resend the body to the new location using the same HTTP method (`POST` in this case).
 
+###### allowGetBody
+
+Type: `boolean`\
+Default: `false`
+
+**Note:** The [RFC 7321](https://tools.ietf.org/html/rfc7231#section-4.3.1) doesn't specify any particular behavior for the GET method having a payload, therefore **it's considered an [anti-pattern](https://en.wikipedia.org/wiki/Anti-pattern)**.
+
+Set this to `true` to allow sending body for the `GET` method. However, the [HTTP/2 specification](https://tools.ietf.org/html/rfc7540#section-8.1.3) says that `An HTTP GET request includes request header fields and no payload body`, therefore when using the HTTP/2 protocol this option will have no effect. This option is only meant to interact with non-compliant servers when you have no other choice.
+
 ###### maxRedirects
 
 Type: `number`\
@@ -438,25 +460,38 @@ Default: `false`
 ###### dnsCache
 
 Type: `object`\
-Default: `false`
+Default: `new CacheableLookup()`
 
-[Cache adapter instance](#cache-adapters) for storing cached DNS data.
+An instance of [`CacheableLookup`](https://github.com/szmarczak/cacheable-lookup) used for making DNS lookups.
 
 ###### request
 
 Type: `Function`\
 Default: `http.request | https.request` *(Depending on the protocol)*
 
-Custom request function. The main purpose of this is to [support HTTP2 using a wrapper](#experimental-http2-support).
+Custom request function. The main purpose of this is to [support HTTP2 using a wrapper](https://github.com/szmarczak/http2-wrapper).
 
-###### useElectronNet
+###### http2
 
 Type: `boolean`\
 Default: `false`
 
-[**Deprecated**](https://github.com/sindresorhus/got#electron-support-has-been-deprecated)
+If set to `true`, Got will additionally accept HTTP2 requests.\
+It will choose either HTTP/1.1 or HTTP/2 depending on the ALPN protocol.
 
-When used in Electron, Got will use [`electron.net`](https://electronjs.org/docs/api/net/) instead of the Node.js `http` module. According to the Electron docs, it should be fully compatible, but it's not entirely. See [#443](https://github.com/sindresorhus/got/issues/443) and [#461](https://github.com/sindresorhus/got/issues/461).
+**Note:** Overriding `options.request` will disable HTTP2 support.
+
+**Note:** This option will default to `true` in the next upcoming major release.
+
+```js
+const got = require('got');
+
+(async () => {
+	const {headers} = await got('https://nghttp2.org/httpbin/anything', {http2: true});
+	console.log(headers.via);
+	//=> '2 nghttpx'
+})();
+```
 
 ###### throwHttpErrors
 
@@ -469,9 +504,11 @@ If this is disabled, requests that encounter an error status code will be resolv
 
 ###### agent
 
-Same as the [`agent` option](https://nodejs.org/api/http.html#http_http_request_url_options_callback) for `http.request`, but with an extra feature:
+Type: `object`
+
+An object representing `http`, `https` and `http2` keys for [`http.Agent`](https://nodejs.org/api/http.html#http_class_http_agent), [`https.Agent`](https://nodejs.org/api/https.html#https_class_https_agent) and [`http2wrapper.Agent`](https://github.com/szmarczak/http2-wrapper#new-http2agentoptions) instance. This is necessary because a request to one protocol might redirect to another. In such a scenario, Got will switch over to the right protocol agent for you.
 
-If you require different agents for different protocols, you can pass a map of agents to the `agent` option. This is necessary because a request to one protocol might redirect to another. In such a scenario, Got will switch over to the right protocol agent for you.
+If a key is not present, it will default to a global agent.
 
 ```js
 const got = require('got');
@@ -501,14 +538,16 @@ Called with plain [request options](#options), right before their normalization.
 
 See the [Request migration guide](documentation/migration-guides.md#breaking-changes) for an example.
 
-**Note:** This hook must be synchronous!
+**Note #1:** This hook must be synchronous!\
+**Note #2:** Errors in this hook will be converted into an instances of [`RequestError`](#got.requesterror).\
+**Note #3:** The options object may not have a `url` property. To modify it, use a `beforeRequest` hook instead.
 
 ###### hooks.beforeRequest
 
 Type: `Function[]`\
 Default: `[]`
 
-Called with [normalized](source/normalize-arguments.ts) [request options](#options). Got will make no further changes to the request before it is sent (except the body serialization). This is especially useful in conjunction with [`got.extend()`](#instances) when you want to create an API client that, for example, uses HMAC-signing.
+Called with [normalized](source/core/index.ts) [request options](#options). Got will make no further changes to the request before it is sent. This is especially useful in conjunction with [`got.extend()`](#instances) when you want to create an API client that, for example, uses HMAC-signing.
 
 See the [AWS section](#aws) for an example.
 
@@ -517,7 +556,7 @@ See the [AWS section](#aws) for an example.
 Type: `Function[]`\
 Default: `[]`
 
-Called with [normalized](source/normalize-arguments.ts) [request options](#options) and the redirect [response](#response). Got will make no further changes to the request. This is especially useful when you want to avoid dead sites. Example:
+Called with [normalized](source/core/index.ts) [request options](#options) and the redirect [response](#response). Got will make no further changes to the request. This is especially useful when you want to avoid dead sites. Example:
 
 ```js
 const got = require('got');
@@ -551,7 +590,7 @@ got.post('https://example.com', {
 	hooks: {
 		beforeRetry: [
 			(options, error, retryCount) => {
-				if (error.statusCode === 413) { // Payload too large
+				if (error.response.statusCode === 413) { // Payload too large
 					options.body = getNewBody();
 				}
 			}
@@ -627,7 +666,7 @@ got('https://api.github.com/some-endpoint', {
 				const {response} = error;
  				if (response && response.body) {
 					error.name = 'GitHubError';
-					error.message = `${response.body.message} (${error.statusCode})`;
+					error.message = `${response.body.message} (${response.statusCode})`;
 				}
 
  				return error;
@@ -637,49 +676,96 @@ got('https://api.github.com/some-endpoint', {
 });
 ```
 
-##### \_pagination
+##### pagination
 
 Type: `object`
 
-**Note:** This feature is marked as experimental as we're [looking for feedback](https://github.com/sindresorhus/got/issues/1052) on the API and how it works. The feature itself is stable, but the API may change based on feedback. So if you decide to try it out, we suggest locking down the `got` dependency semver range or use a lockfile.
+**Note:** We're [looking for feedback](https://github.com/sindresorhus/got/issues/1052), any ideas on how to improve the API are welcome.
 
-###### \_pagination.transform
+###### pagination.transform
 
 Type: `Function`\
 Default: `response => JSON.parse(response.body)`
 
 A function that transform [`Response`](#response) into an array of items. This is where you should do the parsing.
 
-###### \_pagination.paginate
+###### pagination.paginate
 
 Type: `Function`\
 Default: [`Link` header logic](source/index.ts)
 
-A function that returns an object representing Got options pointing to the next page. If there are no more pages, `false` should be returned.
+The function takes three arguments:
+- `response` - The current response object.
+- `allItems` - An array of the emitted items.
+- `currentItems` - Items from the current response.
+
+It should return an object representing Got options pointing to the next page. If there are no more pages, `false` should be returned.
 
-###### \_pagination.filter
+For example, if you want to stop when the response contains less items than expected, you can use something like this:
+
+```js
+const got = require('got');
+
+(async () => {
+	const limit = 10;
+
+	const items = got.paginate('https://example.com/items', {
+		searchParams: {
+			limit,
+			offset: 0
+		},
+		pagination: {
+			paginate: (response, allItems, currentItems) => {
+				const previousSearchParams = response.request.options.searchParams;
+				const {offset: previousOffset} = previousSearchParams;
+
+				if (currentItems.length < limit) {
+					return false;
+				}
+
+				return {
+					searchParams: {
+						...previousSearchParams,
+						offset: previousOffset + limit,
+					}
+				};
+			}
+		}
+	});
+
+	console.log('Items from all pages:', items);
+})();
+```
+
+###### pagination.filter
 
 Type: `Function`\
-Default: `(item, allItems) => true`
+Default: `(item, allItems, currentItems) => true`
 
 Checks whether the item should be emitted or not.
 
-###### \_pagination.shouldContinue
+###### pagination.shouldContinue
 
 Type: `Function`\
-Default: `(item, allItems) => true`
+Default: `(item, allItems, currentItems) => true`
 
 Checks whether the pagination should continue.
 
-For example, if you need to stop **before** emitting an entry with some flag, you should use `(item, allItems) => !item.flag`. If you want to stop **after** emitting the entry, you should use `(item, allItems) => allItems.some(entry => entry.flag)` instead.
+For example, if you need to stop **before** emitting an entry with some flag, you should use `(item, allItems, currentItems) => !item.flag`. If you want to stop **after** emitting the entry, you should use `(item, allItems, currentItems) => allItems.some(entry => entry.flag)` instead.
 
-###### \_pagination.countLimit
+###### pagination.countLimit
 
 Type: `number`\
 Default: `Infinity`
 
 The maximum amount of items that should be emitted.
 
+##### localAddress
+
+Type: `string`
+
+The IP address used to send the request from.
+
 #### Response
 
 The response object will typically be a [Node.js HTTP response stream](https://nodejs.org/api/http.html#http_class_http_incomingmessage), however, if returned from the cache it will be a [response-like object](https://github.com/lukechilds/responselike) which behaves in the same way.
@@ -698,6 +784,12 @@ Type: `string | object | Buffer` *(Depending on `options.responseType`)*
 
 The result of the request.
 
+##### rawBody
+
+Type: `Buffer`
+
+The raw result of the request.
+
 ##### url
 
 Type: `string`
@@ -798,7 +890,9 @@ The `response` event to get the response object of the final request.
 The `redirect` event to get the response object of a redirect. The second argument is options for the next request to the redirect location.
 
 ##### .on('uploadProgress', progress)
+##### .uploadProgress
 ##### .on('downloadProgress', progress)
+##### .downloadProgress
 
 Progress events for uploading (sending a request) and downloading (receiving a response). The `progress` argument is an object like:
 
@@ -826,9 +920,33 @@ If the `content-length` header is missing, `total` will be `undefined`.
 })();
 ```
 
-##### .on('error', error, body, response)
+##### .ip
+
+Type: `string`
+
+The remote IP address.
+
+##### .aborted
+
+Type: `boolean`
+
+Indicates whether the request has been aborted or not.
+
+##### .timings
+
+The same as `response.timings`.
+
+##### .isFromCache
+
+The same as `response.isFromCache`.
+
+##### .socket
 
-The `error` event emitted in case of a 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 a response object.
+The same as `response.socket`.
+
+##### .on('error', error)
+
+The emitted `error` is an instance of [`RequestError`](#got.requesterror).
 
 #### Pagination
 
@@ -841,7 +959,7 @@ Returns an async iterator:
 	const countLimit = 10;
 
 	const pagination = got.paginate('https://api.github.com/repos/sindresorhus/got/commits', {
-		_pagination: {countLimit}
+		pagination: {countLimit}
 	});
 
 	console.log(`Printing latest ${countLimit} Got commits (newest to oldest):`);
@@ -852,7 +970,7 @@ Returns an async iterator:
 })();
 ```
 
-See [`options._pagination`](#_pagination) for more pagination options.
+See [`options.pagination`](#pagination) for more pagination options.
 
 #### got.get(url, options?)
 #### got.post(url, options?)
@@ -861,7 +979,7 @@ See [`options._pagination`](#_pagination) for more pagination options.
 #### got.head(url, options?)
 #### got.delete(url, options?)
 
-Sets `options.method` to the method name and makes a request.
+Sets [`options.method`](#method) to the method name and makes a request.
 
 ### Instances
 
@@ -931,7 +1049,7 @@ const mergedHandlers = got.extend({
 
 ```js
 const handler = (options, next) => {
-	if (options.stream) {
+	if (options.isStream) {
 		// It's a Stream
 		return next(options);
 	}
@@ -1003,6 +1121,14 @@ Options are deeply merged to a new object. The value of each key is determined a
 	- If the parent property is a plain `object` too, both values are merged recursively into a new `object`.
 	- Otherwise, only the new value is deeply cloned.
 - If the new property is an `Array`, it overwrites the old one with a deep clone of the new property.
+- Properties that are not enumerable, such as `context`, `body`, `json`, and `form`, will not be merged.
+```js
+const a = {json: {cat: 'meow'}};
+const b = {json: {cow: 'moo'}};
+
+got.mergeOptions(a, b);
+//=> {json: {cow: 'moo'}}
+```
 - Otherwise, the new value is assigned to the key.
 
 #### got.defaults
@@ -1091,7 +1217,8 @@ const addAccessToken = (accessToken: string): BeforeRequestHook => options => {
 
 ## Errors
 
-Each error contains an `options` property which are the options Got used to create a request - just to make debugging easier.
+Each error contains an `options` property which are the options Got used to create a request - just to make debugging easier.\
+Additionaly, the errors may have `request` (Got Stream) and `response` (Got Response) properties depending on which phase of the request failed.
 
 #### got.CacheError
 
@@ -1182,10 +1309,19 @@ const got = require('got');
 })();
 ```
 
+To abort the Got Stream request, just call `stream.destroy()`.
+
+```js
+const got = require('got');
+
+const stream = got.stream(url);
+stream.destroy();
+```
+
 <a name="cache-adapters"></a>
 ## Cache
 
-Got implements [RFC 7234](http://httpwg.org/specs/rfc7234.html) compliant HTTP caching which works out of the box in-memory and is easily pluggable with a wide range of storage adapters. Fresh cache entries are served directly from the cache, and stale cache entries are revalidated with `If-None-Match`/`If-Modified-Since` headers. You can read more about the underlying cache behavior in the [`cacheable-request` documentation](https://github.com/lukechilds/cacheable-request). For DNS cache, Got uses [`cacheable-lookup`](https://github.com/szmarczak/cacheable-lookup).
+Got implements [RFC 7234](https://httpwg.org/specs/rfc7234.html) compliant HTTP caching which works out of the box in-memory and is easily pluggable with a wide range of storage adapters. Fresh cache entries are served directly from the cache, and stale cache entries are revalidated with `If-None-Match`/`If-Modified-Since` headers. You can read more about the underlying cache behavior in the [`cacheable-request` documentation](https://github.com/lukechilds/cacheable-request). For DNS cache, Got uses [`cacheable-lookup`](https://github.com/szmarczak/cacheable-lookup).
 
 You can use the JavaScript `Map` type as an in-memory cache:
 
@@ -1496,42 +1632,26 @@ const custom = got.extend({
 })();
 ```
 
-### Experimental HTTP2 support
-
-Got provides an experimental support for HTTP2 using the [`http2-wrapper`](https://github.com/szmarczak/http2-wrapper) package:
-
-```js
-const got = require('got');
-const {request} = require('http2-wrapper');
-
-const h2got = got.extend({request});
-
-(async () => {
-	const {body} = await h2got('https://nghttp2.org/httpbin/headers');
-	console.log(body);
-})();
-```
-
 ## FAQ
 
 ### Why yet another HTTP client?
 
 Got was created because the popular [`request`](https://github.com/request/request) package is bloated: [![Install size](https://packagephobia.now.sh/badge?p=request)](https://packagephobia.now.sh/result?p=request)\
-Furthermore, Got is fully written in TypeScript.
+Furthermore, Got is fully written in TypeScript and actively maintained.
 
-### Electron support has been deprecated
+### Electron support has been removed
 
-Some of the Got features may not work properly. See [#899](https://github.com/sindresorhus/got/issues/899) for more info.
+The Electron `net` module is not consistent with the Node.js `http` module. See [#899](https://github.com/sindresorhus/got/issues/899) for more info.
 
 ## Comparison
 
 |                       | `got`              | [`request`][r0]    | [`node-fetch`][n0]   | [`ky`][k0]               | [`axios`][a0]      | [`superagent`][s0]     |
 |-----------------------|:------------------:|:------------------:|:--------------------:|:------------------------:|:------------------:|:----------------------:|
-| HTTP/2 support        | :grey_question:    | :x:                | :x:                  | :x:                      | :x:                | :heavy_check_mark:\*\* |
+| HTTP/2 support        | :sparkle:          | :x:                | :x:                  | :x:                      | :x:                | :heavy_check_mark:\*\* |
 | Browser support       | :x:                | :x:                | :heavy_check_mark:\* | :heavy_check_mark:       | :heavy_check_mark: | :heavy_check_mark:     |
 | Promise API           | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark:   | :heavy_check_mark:       | :heavy_check_mark: | :heavy_check_mark:     |
 | Stream API            | :heavy_check_mark: | :heavy_check_mark: | Node.js only         | :x:                      | :x:                | :heavy_check_mark:     |
-| Pagination API        | :sparkle:          | :x:                | :x:                  | :x:                      | :x:                | :x:                    |
+| Pagination API        | :heavy_check_mark: | :x:                | :x:                  | :x:                      | :x:                | :x:                    |
 | Request cancelation   | :heavy_check_mark: | :x:                | :heavy_check_mark:   | :heavy_check_mark:       | :heavy_check_mark: | :heavy_check_mark:     |
 | RFC compliant caching | :heavy_check_mark: | :x:                | :x:                  | :x:                      | :x:                | :x:                    |
 | Cookies (out-of-box)  | :heavy_check_mark: | :heavy_check_mark: | :x:                  | :x:                      | :x:                | :x:                    |
@@ -1714,14 +1834,8 @@ Some of the Got features may not work properly. See [#899](https://github.com/si
 - [Brandon Smith](https://github.com/brandon93s)
 - [Luke Childs](https://github.com/lukechilds)
 
----
+## For enterprise
 
-<div align="center">
-	<b>
-		<a href="https://tidelift.com/subscription/pkg/npm-got?utm_source=npm-got&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
-	</b>
-	<br>
-	<sub>
-		Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
-	</sub>
-</div>
+Available as part of the Tidelift Subscription.
+
+The maintainers of `got` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-got?utm_source=npm-got&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)

package/dist/source/as-promise.d.ts

@@ -1,3 +0,0 @@
-import { CancelableRequest, NormalizedOptions } from './types';
-export declare function createRejection(error: Error): CancelableRequest<never>;
-export default function asPromise<T>(options: NormalizedOptions): CancelableRequest<T>;