got 15.0.0 → 15.0.1

package/dist/source/as-promise/index.js

@@ -24,97 +24,99 @@ export default function asPromise(firstRequest) {
             request.retryCount = retryCount;
             request._noPipe = true;
             globalRequest = request;
-            request.once('response', async (response) => {
-                // Parse body
-                const contentEncoding = (response.headers['content-encoding'] ?? '').toLowerCase();
-                const isCompressed = compressedEncodings.has(contentEncoding);
-                const { options } = request;
-                if (isCompressed && !options.decompress) {
-                    response.body = response.rawBody;
-                }
-                else {
-                    try {
-                        response.body = parseBody(response, options.responseType, options.parseJson, options.encoding);
+            request.once('response', (response) => {
+                void (async () => {
+                    // Parse body
+                    const contentEncoding = (response.headers['content-encoding'] ?? '').toLowerCase();
+                    const isCompressed = compressedEncodings.has(contentEncoding);
+                    const { options } = request;
+                    if (isCompressed && !options.decompress) {
+                        response.body = response.rawBody;
                     }
-                    catch (error) {
-                        // Fall back to `utf8`
+                    else {
                         try {
-                            response.body = decodeUint8Array(response.rawBody);
+                            response.body = parseBody(response, options.responseType, options.parseJson, options.encoding);
                         }
                         catch (error) {
-                            request._beforeError(new ParseError(normalizeError(error), response));
-                            return;
-                        }
-                        if (isResponseOk(response)) {
-                            request._beforeError(normalizeError(error));
-                            return;
-                        }
-                    }
-                }
-                try {
-                    const hooks = options.hooks.afterResponse;
-                    for (const [index, hook] of hooks.entries()) {
-                        const previousUrl = options.url ? new URL(options.url) : undefined;
-                        const previousState = previousUrl ? snapshotCrossOriginState(options) : undefined;
-                        const requestOptions = response.request.options;
-                        const responseSnapshot = response;
-                        // @ts-expect-error TS doesn't notice that RequestPromise is a Promise
-                        // eslint-disable-next-line no-await-in-loop
-                        response = await requestOptions.trackStateMutations(async (changedState) => hook(responseSnapshot, async (updatedOptions) => {
-                            const preserveHooks = updatedOptions.preserveHooks ?? false;
-                            const reusesRequestOptions = updatedOptions === requestOptions;
-                            const hasExplicitBody = reusesRequestOptions
-                                ? changedState.has('body') || changedState.has('json') || changedState.has('form')
-                                : (Object.hasOwn(updatedOptions, 'body') && updatedOptions.body !== undefined)
-                                    || (Object.hasOwn(updatedOptions, 'json') && updatedOptions.json !== undefined)
-                                    || (Object.hasOwn(updatedOptions, 'form') && updatedOptions.form !== undefined);
-                            if (hasExplicitBody && !reusesRequestOptions) {
-                                options.clearBody();
+                            // Fall back to `utf8`
+                            try {
+                                response.body = decodeUint8Array(response.rawBody);
                             }
-                            if (!reusesRequestOptions) {
-                                options.merge(updatedOptions);
+                            catch (error) {
+                                request._beforeError(new ParseError(normalizeError(error), response));
+                                return;
                             }
-                            if (updatedOptions.url) {
-                                const nextUrl = reusesRequestOptions
-                                    ? options.url
-                                    : applyUrlOverride(options, updatedOptions.url, updatedOptions);
-                                if (previousUrl) {
-                                    if (reusesRequestOptions && !isSameOrigin(previousUrl, nextUrl)) {
-                                        options.stripUnchangedCrossOriginState(previousState, changedState, { clearBody: !hasExplicitBody });
-                                    }
-                                    else {
-                                        options.stripSensitiveHeaders(previousUrl, nextUrl, updatedOptions);
-                                        if (!isSameOrigin(previousUrl, nextUrl) && !hasExplicitBody) {
-                                            options.clearBody();
+                            if (isResponseOk(response)) {
+                                request._beforeError(normalizeError(error));
+                                return;
+                            }
+                        }
+                    }
+                    try {
+                        const hooks = options.hooks.afterResponse;
+                        for (const [index, hook] of hooks.entries()) {
+                            const previousUrl = options.url ? new URL(options.url) : undefined;
+                            const previousState = previousUrl ? snapshotCrossOriginState(options) : undefined;
+                            const requestOptions = response.request.options;
+                            const responseSnapshot = response;
+                            // @ts-expect-error TS doesn't notice that RequestPromise is a Promise
+                            // eslint-disable-next-line no-await-in-loop
+                            response = await requestOptions.trackStateMutations(async (changedState) => hook(responseSnapshot, async (updatedOptions) => {
+                                const preserveHooks = updatedOptions.preserveHooks ?? false;
+                                const reusesRequestOptions = updatedOptions === requestOptions;
+                                const hasExplicitBody = reusesRequestOptions
+                                    ? changedState.has('body') || changedState.has('json') || changedState.has('form')
+                                    : (Object.hasOwn(updatedOptions, 'body') && updatedOptions.body !== undefined)
+                                        || (Object.hasOwn(updatedOptions, 'json') && updatedOptions.json !== undefined)
+                                        || (Object.hasOwn(updatedOptions, 'form') && updatedOptions.form !== undefined);
+                                if (hasExplicitBody && !reusesRequestOptions) {
+                                    options.clearBody();
+                                }
+                                if (!reusesRequestOptions) {
+                                    options.merge(updatedOptions);
+                                }
+                                if (updatedOptions.url) {
+                                    const nextUrl = reusesRequestOptions
+                                        ? options.url
+                                        : applyUrlOverride(options, updatedOptions.url, updatedOptions);
+                                    if (previousUrl) {
+                                        if (reusesRequestOptions && !isSameOrigin(previousUrl, nextUrl)) {
+                                            options.stripUnchangedCrossOriginState(previousState, changedState, { clearBody: !hasExplicitBody });
+                                        }
+                                        else {
+                                            options.stripSensitiveHeaders(previousUrl, nextUrl, updatedOptions);
+                                            if (!isSameOrigin(previousUrl, nextUrl) && !hasExplicitBody) {
+                                                options.clearBody();
+                                            }
                                         }
                                     }
                                 }
+                                // Remove any further hooks for that request, because we'll call them anyway.
+                                // The loop continues. We don't want duplicates (asPromise recursion).
+                                // Unless preserveHooks is true, in which case we keep the remaining hooks.
+                                if (!preserveHooks) {
+                                    options.hooks.afterResponse = options.hooks.afterResponse.slice(0, index);
+                                }
+                                throw new RetryError(request);
+                            }));
+                            if (!(is.object(response) && is.number(response.statusCode) && 'body' in response)) {
+                                throw new TypeError('The `afterResponse` hook returned an invalid value');
                             }
-                            // Remove any further hooks for that request, because we'll call them anyway.
-                            // The loop continues. We don't want duplicates (asPromise recursion).
-                            // Unless preserveHooks is true, in which case we keep the remaining hooks.
-                            if (!preserveHooks) {
-                                options.hooks.afterResponse = options.hooks.afterResponse.slice(0, index);
-                            }
-                            throw new RetryError(request);
-                        }));
-                        if (!(is.object(response) && is.number(response.statusCode) && 'body' in response)) {
-                            throw new TypeError('The `afterResponse` hook returned an invalid value');
                         }
                     }
-                }
-                catch (error) {
-                    request._beforeError(normalizeError(error));
-                    return;
-                }
-                globalResponse = response;
-                if (!isResponseOk(response)) {
-                    request._beforeError(new HTTPError(response));
-                    return;
-                }
-                request.destroy();
-                promiseSettled = true;
-                resolve(request.options.resolveBodyOnly ? response.body : response);
+                    catch (error) {
+                        request._beforeError(normalizeError(error));
+                        return;
+                    }
+                    globalResponse = response;
+                    if (!isResponseOk(response)) {
+                        request._beforeError(new HTTPError(response));
+                        return;
+                    }
+                    request.destroy();
+                    promiseSettled = true;
+                    resolve(request.options.resolveBodyOnly ? response.body : response);
+                })();
             });
             let handledFinalError = false;
             const onError = (error) => {
@@ -191,7 +193,7 @@ export default function asPromise(firstRequest) {
             const { options } = globalResponse.request;
             if (responseType === 'text') {
                 const text = decodeUint8Array(globalResponse.rawBody, options.encoding);
-                return (isUtf8Encoding(options.encoding) ? text.replace(/^\uFEFF/u, '') : text);
+                return (isUtf8Encoding(options.encoding) ? text.replace(/^\u{FEFF}/v, '') : text);
             }
             return parseBody(globalResponse, responseType, options.parseJson, options.encoding);
         })();

package/dist/source/core/errors.js

@@ -41,13 +41,13 @@ export class RequestError extends Error {
         // Recover the original stacktrace
         if (is.string(error.stack) && is.string(this.stack)) {
             const indexOfMessage = this.stack.indexOf(this.message) + this.message.length;
-            const thisStackTrace = this.stack.slice(indexOfMessage).split('\n').reverse();
-            const errorStackTrace = error.stack.slice(error.stack.indexOf(error.message) + error.message.length).split('\n').reverse();
+            const thisStackTrace = this.stack.slice(indexOfMessage).split('\n').toReversed();
+            const errorStackTrace = error.stack.slice(error.stack.indexOf(error.message) + error.message.length).split('\n').toReversed();
             // Remove duplicated traces
             while (errorStackTrace.length > 0 && errorStackTrace[0] === thisStackTrace[0]) {
                 thisStackTrace.shift();
             }
-            this.stack = `${this.stack.slice(0, indexOfMessage)}${thisStackTrace.reverse().join('\n')}${errorStackTrace.reverse().join('\n')}`;
+            this.stack = `${this.stack.slice(0, indexOfMessage)}${thisStackTrace.toReversed().join('\n')}${errorStackTrace.toReversed().join('\n')}`;
         }
     }
 }

package/dist/source/core/index.js

@@ -1319,7 +1319,8 @@ export default class Request extends Duplex {
                 try {
                     const result = iterableBody.return();
                     if (result instanceof Promise) {
-                        result.catch(noop); // eslint-disable-line promise/prefer-await-to-then
+                        // eslint-disable-next-line promise/prefer-await-to-then
+                        result.catch(noop);
                     }
                 }
                 catch { }
@@ -1493,28 +1494,30 @@ export default class Request extends Duplex {
             });
             let request;
             // TODO: Fix `cacheable-response`. This is ugly.
-            const cacheRequest = cacheableStore.get(options.cache)(options, async (response) => {
-                response._readableState.autoDestroy = false;
-                if (request) {
-                    const fix = () => {
-                        // For ResponseLike objects from cache, set complete to true if not already set.
-                        // For real HTTP responses, copy from the underlying response.
-                        if (response.req) {
-                            response.complete = response.req.res.complete;
-                        }
-                        else if (response.complete === undefined) {
-                            // ResponseLike from cache should have complete = true
-                            response.complete = true;
-                        }
-                    };
-                    response.prependOnceListener('end', fix);
-                    fix();
-                    (await request).emit('cacheableResponse', response);
-                }
-                resolve(response);
+            const cacheRequest = cacheableStore.get(options.cache)(options, (response) => {
+                void (async () => {
+                    response._readableState.autoDestroy = false;
+                    if (request) {
+                        const fix = () => {
+                            // For ResponseLike objects from cache, set complete to true if not already set.
+                            // For real HTTP responses, copy from the underlying response.
+                            if (response.req) {
+                                response.complete = response.req.res.complete;
+                            }
+                            else if (response.complete === undefined) {
+                                // ResponseLike from cache should have complete = true
+                                response.complete = true;
+                            }
+                        };
+                        response.prependOnceListener('end', fix);
+                        fix();
+                        (await request).emit('cacheableResponse', response);
+                    }
+                    resolve(response);
+                })();
             });
             cacheRequest.once('error', reject);
-            cacheRequest.once('request', async (requestOrPromise) => {
+            cacheRequest.once('request', (requestOrPromise) => {
                 request = requestOrPromise;
                 resolve(request);
             });

package/dist/source/core/options.d.ts

@@ -91,20 +91,20 @@ export type Hooks = {
 
     @default []
 
-    **Note:**
+    Note:
     > - This hook must be synchronous.
 
-    **Note:**
+    Note:
     > - This is called every time options are merged.
 
-    **Note:**
+    Note:
     > - The `options` object may not have the `url` property. To modify it, use a `beforeRequest` hook instead.
 
-    **Note:**
+    Note:
     > - This hook is called when a new instance of `Options` is created.
     > - Do not confuse this with the creation of `Request` or `got(…)`.
 
-    **Note:**
+    Note:
     > - When using `got(url)` or `got(url, undefined, defaults)` this hook will **not** be called.
 
     This is especially useful in conjunction with `got.extend()` when the input needs custom handling.
@@ -183,10 +183,10 @@ export type Hooks = {
 
     @default []
 
-    **Note:**
+    Note:
     > - Got will make no further changes to the request before it is sent.
 
-    **Note:**
+    Note:
     > - Changing `options.json` or `options.form` has no effect on the request. You should change `options.body` instead. If needed, update the `options.headers` accordingly.
 
     @example
@@ -209,7 +209,7 @@ export type Hooks = {
     );
     ```
 
-    **Example using `context.retryCount`:**
+    Example using `context.retryCount`:
 
     ```
     import got from 'got';
@@ -231,7 +231,7 @@ export type Hooks = {
     });
     ```
 
-    **Tip:**
+    Tip:
     > - You can indirectly override the `request` function by early returning a [`ClientRequest`-like](https://nodejs.org/api/http.html#http_class_http_clientrequest) instance or a [`IncomingMessage`-like](https://nodejs.org/api/http.html#http_class_http_incomingmessage) instance. This is very useful when creating a custom cache mechanism.
     > - [Read more about this tip](https://github.com/sindresorhus/got/blob/main/documentation/cache.md#advanced-caching-mechanisms).
     */
@@ -241,7 +241,7 @@ export type Hooks = {
 
     @default []
 
-    **Tip:**
+    Tip:
     > - This is especially useful when you want to avoid dead sites.
 
     @example
@@ -326,13 +326,13 @@ export type Hooks = {
 
     @default []
 
-    **Note:**
+    Note:
     > - When using the Stream API, this hook is ignored.
 
-    **Note:**
+    Note:
     > - When retrying, the `beforeRequest` hook is called afterwards.
 
-    **Note:**
+    Note:
     > - If no retry occurs, the `beforeError` hook is called instead.
 
     This hook is especially useful when you want to retrieve the cause of a retry.
@@ -361,31 +361,31 @@ export type Hooks = {
 
     @default []
 
-    **Return value:**
+    Return value:
     > - `false` - Prevent caching (remaining hooks are skipped)
     > - `void`/`undefined` - Use default caching behavior (mutations take effect)
 
-    **Modifying the response:**
+    Modifying the response:
     > - Hooks can directly mutate response properties like `headers`, `statusCode`, and `statusMessage`
     > - Mutations to `response.headers` affect how the caching layer decides whether to cache the response and for how long
     > - Changes are applied to what gets cached
 
-    **Note:**
+    Note:
     > - This hook is only called when the `cache` option is enabled.
 
-    **Note:**
+    Note:
     > - This hook must be synchronous. It cannot return a Promise. If you need async logic to determine caching behavior, use a `beforeRequest` hook instead.
 
-    **Note:**
+    Note:
     > - When returning `false`, remaining hooks are skipped and the response will not be cached.
 
-    **Note:**
+    Note:
     > - Returning anything other than `false` or `undefined` will throw a TypeError.
 
-    **Note:**
+    Note:
     > - If a hook throws an error, it will be propagated and the request will fail. This is consistent with how other hooks in Got handle errors.
 
-    **Note:**
+    Note:
     > - At this stage, the response body has not been read yet - it's still a stream. Properties like `response.body` and `response.rawBody` are not available. You can only inspect/modify response headers and status code.
 
     @example
@@ -425,17 +425,17 @@ export type Hooks = {
 
     @default []
 
-    **Note:**
+    Note:
     > - When using the Stream API, this hook is ignored.
 
-    **Note:**
+    Note:
     > - Calling the `retryWithMergedOptions` function will trigger `beforeRetry` hooks. By default, remaining `afterResponse` hooks are removed to prevent duplicate execution. To preserve remaining hooks on retry, set `preserveHooks: true` in the options passed to `retryWithMergedOptions`. In case of an error, `beforeRetry` hooks will be called instead.
     Meanwhile the `init`, `beforeRequest` , `beforeRedirect` as well as already executed `afterResponse` hooks will be skipped.
 
-    **Note:**
+    Note:
     > - To preserve remaining `afterResponse` hooks after calling `retryWithMergedOptions`, set `preserveHooks: true` in the options passed to `retryWithMergedOptions`. This is useful when you want hooks to run on retried requests.
 
-    **Warning:**
+    Warning:
     > - Be cautious when using `preserveHooks: true`. If a hook unconditionally calls `retryWithMergedOptions` with `preserveHooks: true`, it will create an infinite retry loop. Always ensure hooks have proper conditional logic to avoid infinite retries.
 
     @example

package/dist/source/core/options.js

@@ -68,8 +68,8 @@ function hasCredentialInUrl(url, credential) {
 }
 export const hasExplicitCredentialInUrlChange = (changedState, url, credential) => (changedState.has(credential)
     || (changedState.has('url') && url?.[credential] !== ''));
-const hasProtocolSlashes = (value) => /^[a-z][a-z\d+.-]*:\/\//i.test(value);
-const hasHttpProtocolWithoutSlashes = (value) => /^https?:(?!\/\/)/i.test(value);
+const hasProtocolSlashes = (value) => /^[a-z][\d+\-.a-z]*:\/\//iv.test(value);
+const hasHttpProtocolWithoutSlashes = (value) => /^https?:(?!\/\/)/iv.test(value);
 export function applyUrlOverride(options, url, { username, password } = {}) {
     if (is.string(url) && options.url) {
         url = new URL(url, options.url).toString();
@@ -486,7 +486,7 @@ export default class Options {
         // would get merged. Instead we set the `searchParams` first, then
         // `url.searchParams` is overwritten as expected.
         //
-        /* eslint-disable no-unsafe-finally */
+        /* eslint-disable no-unsafe-finally -- `finally` is used intentionally here to ensure `url` is always set last, overwriting any merged searchParams */
         try {
             if (is.plainObject(input)) {
                 try {
@@ -912,16 +912,14 @@ export default class Options {
             this.#internals.cookieJar = undefined;
             return;
         }
-        let { setCookie, getCookieString } = value;
+        const { setCookie, getCookieString } = value;
         assert.function(setCookie);
         assert.function(getCookieString);
         /* istanbul ignore next: Horrible `tough-cookie` v3 check */
         if (setCookie.length === 4 && getCookieString.length === 0) {
-            setCookie = promisify(setCookie.bind(value));
-            getCookieString = promisify(getCookieString.bind(value));
             this.#internals.cookieJar = {
-                setCookie,
-                getCookieString: getCookieString,
+                setCookie: promisify(setCookie.bind(value)),
+                getCookieString: promisify(getCookieString.bind(value)),
             };
         }
         else {
@@ -1792,11 +1790,11 @@ export default class Options {
         this.#internals.resolveBodyOnly = value;
     }
     /**
-    @internal
     Returns a `Stream` instead of a `Promise`.
     Set internally by `got.stream()`.
 
     @default false
+    @internal
     */
     get isStream() {
         return this.#internals.isStream;
@@ -1945,7 +1943,7 @@ export default class Options {
         }
         let unixSocketGroups;
         if (unixSocketPath !== undefined) {
-            unixSocketGroups = /(?<socketPath>.+?):(?<path>.+)/.exec(`${url.pathname}${url.search}`)?.groups;
+            unixSocketGroups = /^(?<socketPath>[^:]+):(?<path>.+)$/v.exec(`${url.pathname}${url.search}`)?.groups;
         }
         const unixOptions = unixSocketGroups
             ? { socketPath: unixSocketGroups.socketPath, path: unixSocketGroups.path, host: '' }

package/dist/source/core/timed-out.js

@@ -81,7 +81,7 @@ export default function timedOut(request, delays, options) {
             const { socketPath } = request;
             /* istanbul ignore next: hard to test */
             if (socket.connecting) {
-                const hasPath = Boolean(socketPath ?? net.isIP(hostname ?? host ?? '') !== 0);
+                const hasPath = Boolean(socketPath ?? (net.isIP(hostname ?? host ?? '') !== 0));
                 if (hasLookup && !hasPath && socket.address().address === undefined) {
                     const cancelTimeout = addTimeout(delays.lookup, timeoutHandler, 'lookup');
                     once(socket, 'lookup', cancelTimeout);

package/dist/source/core/utils/is-unix-socket-url.d.ts

@@ -1,4 +1,4 @@
-export default function isUnixSocketURL(url: URL): boolean;
+export default function isUnixSocketUrl(url: URL): boolean;
 /**
 Extract the socket path from a UNIX socket URL.
 

package/dist/source/core/utils/is-unix-socket-url.js

@@ -1,5 +1,4 @@
-// eslint-disable-next-line @typescript-eslint/naming-convention
-export default function isUnixSocketURL(url) {
+export default function isUnixSocketUrl(url) {
     return url.protocol === 'unix:' || url.hostname === 'unix';
 }
 /**
@@ -18,8 +17,8 @@ getUnixSocketPath(new URL('http://example.com'));
 ```
 */
 export function getUnixSocketPath(url) {
-    if (!isUnixSocketURL(url)) {
+    if (!isUnixSocketUrl(url)) {
         return undefined;
     }
-    return /(?<socketPath>.+?):(?<path>.+)/.exec(`${url.pathname}${url.search}`)?.groups?.socketPath;
+    return /^(?<socketPath>[^:]+):/v.exec(`${url.pathname}${url.search}`)?.groups?.socketPath;
 }

package/dist/source/types.d.ts

@@ -59,10 +59,9 @@ export type ExtendOptions = {
     */
     mutableDefaults?: boolean;
 } & Except<OptionsInit, 'url'>;
-type OptionsInitWithoutUrl = Except<OptionsInit, 'url'>;
-export type StrictOptions = Except<OptionsInitWithoutUrl, 'responseType' | 'resolveBodyOnly'>;
-export type StreamOptions = OptionsInitWithoutUrl;
-export type OptionsWithPagination<T = unknown, R = unknown> = Merge<OptionsInitWithoutUrl, {
+export type StreamOptions = Except<OptionsInit, 'url'>;
+export type StrictOptions = Except<StreamOptions, 'responseType' | 'resolveBodyOnly'>;
+export type OptionsWithPagination<T = unknown, R = unknown> = Merge<StreamOptions, {
     pagination?: PaginationOptions<T, R>;
 }>;
 /**
@@ -188,9 +187,9 @@ export type GotRequestFunction<U extends ExtendOptions = Record<string, unknown>
     (options: OptionsOfTextResponseBodyOnly): RequestPromise<string>;
     <T>(options: OptionsOfJSONResponseBodyOnly): RequestPromise<T>;
     (options: OptionsOfBufferResponseBodyOnly): RequestPromise<Uint8Array<ArrayBuffer>>;
-    (url: string | URL, options?: OptionsInitWithoutUrl): RequestPromise | Request;
-    (options: OptionsInitWithoutUrl): RequestPromise | Request;
-    (url: undefined, options: undefined, defaults: Options): RequestPromise | Request;
+    (url: string | URL, options?: StreamOptions): RequestPromise;
+    (options: StreamOptions): RequestPromise;
+    (url: undefined, options: undefined, defaults: Options): RequestPromise;
 };
 /**
 All available HTTP request methods provided by Got.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "got",
-	"version": "15.0.0",
+	"version": "15.0.1",
 	"description": "Human-friendly and powerful HTTP request library for Node.js",
 	"license": "MIT",
 	"repository": "sindresorhus/got",

package/readme.md

@@ -254,13 +254,11 @@ By default, Got will retry on failure. To disable this option, set [`options.ret
 [s3]: https://www.npmjs.com/package/superagent
 
 <!-- COVERAGE -->
-[gc]: https://img.shields.io/coveralls/github/sindresorhus/got?color=0b9062&label
 [kc]: https://img.shields.io/codecov/c/github/sindresorhus/ky?color=0b9062&label
 [nc]: https://img.shields.io/coveralls/github/bitinn/node-fetch?color=0b9062&label
 [ac]: https://img.shields.io/coveralls/github/mzabriskie/axios?color=0b9062&label
 [sc]: https://img.shields.io/codecov/c/github/visionmedia/superagent?color=0b9062&label
 
-[g4]: https://coveralls.io/github/sindresorhus/got
 [k4]: https://codecov.io/gh/sindresorhus/ky
 [n4]: https://coveralls.io/github/bitinn/node-fetch
 [a4]: https://coveralls.io/github/mzabriskie/axios
@@ -342,7 +340,6 @@ By default, Got will retry on failure. To disable this option, set [`options.ret
 [k10]: https://github.com/sindresorhus/ky
 [n10]: https://github.com/node-fetch/node-fetch
 [a10]: https://github.com/axios/axios
-[s10]: https://github.com/visionmedia/superagent
 
 <!-- LAST COMMIT -->
 [glc]: https://img.shields.io/github/last-commit/sindresorhus/got?color=gray&label