Updated 5 files and added 1110 files (automated)

42 files changed, 5832 insertions, 0 deletions

diff --git a/includes/external/addressbook/node_modules/got/dist/source/as-promise/index.d.ts b/includes/external/addressbook/node_modules/got/dist/source/as-promise/index.d.ts
new file mode 100644
index 0000000..e560880
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/as-promise/index.d.ts
@@ -0,0 +1,3 @@
+import Request from '../core/index.js';
+import { type CancelableRequest } from './types.js';
+export default function asPromise<T>(firstRequest?: Request): CancelableRequest<T>;
diff --git a/includes/external/addressbook/node_modules/got/dist/source/as-promise/index.js b/includes/external/addressbook/node_modules/got/dist/source/as-promise/index.js
new file mode 100644
index 0000000..d91fd09
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/as-promise/index.js
@@ -0,0 +1,158 @@
+import { EventEmitter } from 'node:events';
+import is from '@sindresorhus/is';
+import PCancelable from 'p-cancelable';
+import { HTTPError, RetryError, } from '../core/errors.js';
+import Request from '../core/index.js';
+import { parseBody, isResponseOk } from '../core/response.js';
+import proxyEvents from '../core/utils/proxy-events.js';
+import { CancelError } from './types.js';
+const proxiedRequestEvents = [
+    'request',
+    'response',
+    'redirect',
+    'uploadProgress',
+    'downloadProgress',
+];
+export default function asPromise(firstRequest) {
+    let globalRequest;
+    let globalResponse;
+    let normalizedOptions;
+    const emitter = new EventEmitter();
+    const promise = new PCancelable((resolve, reject, onCancel) => {
+        onCancel(() => {
+            globalRequest.destroy();
+        });
+        onCancel.shouldReject = false;
+        onCancel(() => {
+            reject(new CancelError(globalRequest));
+        });
+        const makeRequest = (retryCount) => {
+            // Errors when a new request is made after the promise settles.
+            // Used to detect a race condition.
+            // See https://github.com/sindresorhus/got/issues/1489
+            onCancel(() => { });
+            const request = firstRequest ?? new Request(undefined, undefined, normalizedOptions);
+            request.retryCount = retryCount;
+            request._noPipe = true;
+            globalRequest = request;
+            request.once('response', async (response) => {
+                // Parse body
+                const contentEncoding = (response.headers['content-encoding'] ?? '').toLowerCase();
+                const isCompressed = contentEncoding === 'gzip' || contentEncoding === 'deflate' || contentEncoding === 'br';
+                const { options } = request;
+                if (isCompressed && !options.decompress) {
+                    response.body = response.rawBody;
+                }
+                else {
+                    try {
+                        response.body = parseBody(response, options.responseType, options.parseJson, options.encoding);
+                    }
+                    catch (error) {
+                        // Fall back to `utf8`
+                        response.body = response.rawBody.toString();
+                        if (isResponseOk(response)) {
+                            request._beforeError(error);
+                            return;
+                        }
+                    }
+                }
+                try {
+                    const hooks = options.hooks.afterResponse;
+                    for (const [index, hook] of hooks.entries()) {
+                        // @ts-expect-error TS doesn't notice that CancelableRequest is a Promise
+                        // eslint-disable-next-line no-await-in-loop
+                        response = await hook(response, async (updatedOptions) => {
+                            options.merge(updatedOptions);
+                            options.prefixUrl = '';
+                            if (updatedOptions.url) {
+                                options.url = updatedOptions.url;
+                            }
+                            // Remove any further hooks for that request, because we'll call them anyway.
+                            // The loop continues. We don't want duplicates (asPromise recursion).
+                            options.hooks.afterResponse = options.hooks.afterResponse.slice(0, index);
+                            throw new RetryError(request);
+                        });
+                        if (!(is.object(response) && is.number(response.statusCode) && !is.nullOrUndefined(response.body))) {
+                            throw new TypeError('The `afterResponse` hook returned an invalid value');
+                        }
+                    }
+                }
+                catch (error) {
+                    request._beforeError(error);
+                    return;
+                }
+                globalResponse = response;
+                if (!isResponseOk(response)) {
+                    request._beforeError(new HTTPError(response));
+                    return;
+                }
+                request.destroy();
+                resolve(request.options.resolveBodyOnly ? response.body : response);
+            });
+            const onError = (error) => {
+                if (promise.isCanceled) {
+                    return;
+                }
+                const { options } = request;
+                if (error instanceof HTTPError && !options.throwHttpErrors) {
+                    const { response } = error;
+                    request.destroy();
+                    resolve(request.options.resolveBodyOnly ? response.body : response);
+                    return;
+                }
+                reject(error);
+            };
+            request.once('error', onError);
+            const previousBody = request.options?.body;
+            request.once('retry', (newRetryCount, error) => {
+                firstRequest = undefined;
+                const newBody = request.options.body;
+                if (previousBody === newBody && is.nodeStream(newBody)) {
+                    error.message = 'Cannot retry with consumed body stream';
+                    onError(error);
+                    return;
+                }
+                // This is needed! We need to reuse `request.options` because they can get modified!
+                // For example, by calling `promise.json()`.
+                normalizedOptions = request.options;
+                makeRequest(newRetryCount);
+            });
+            proxyEvents(request, emitter, proxiedRequestEvents);
+            if (is.undefined(firstRequest)) {
+                void request.flush();
+            }
+        };
+        makeRequest(0);
+    });
+    promise.on = (event, fn) => {
+        emitter.on(event, fn);
+        return promise;
+    };
+    promise.off = (event, fn) => {
+        emitter.off(event, fn);
+        return promise;
+    };
+    const shortcut = (responseType) => {
+        const newPromise = (async () => {
+            // Wait until downloading has ended
+            await promise;
+            const { options } = globalResponse.request;
+            return parseBody(globalResponse, responseType, options.parseJson, options.encoding);
+        })();
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        Object.defineProperties(newPromise, Object.getOwnPropertyDescriptors(promise));
+        return newPromise;
+    };
+    promise.json = () => {
+        if (globalRequest.options) {
+            const { headers } = globalRequest.options;
+            if (!globalRequest.writableFinished && !('accept' in headers)) {
+                headers.accept = 'application/json';
+            }
+        }
+        return shortcut('json');
+    };
+    promise.buffer = () => shortcut('buffer');
+    promise.text = () => shortcut('text');
+    return promise;
+}
diff --git a/includes/external/addressbook/node_modules/got/dist/source/as-promise/types.d.ts b/includes/external/addressbook/node_modules/got/dist/source/as-promise/types.d.ts
new file mode 100644
index 0000000..929ce09
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/as-promise/types.d.ts
@@ -0,0 +1,38 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Buffer } from 'node:buffer';
+import type PCancelable from 'p-cancelable';
+import { RequestError } from '../core/errors.js';
+import type Request from '../core/index.js';
+import type { RequestEvents } from '../core/index.js';
+import type { Response } from '../core/response.js';
+/**
+An error to be thrown when the request is aborted with `.cancel()`.
+*/
+export declare class CancelError extends RequestError {
+    readonly response: Response;
+    constructor(request: Request);
+    /**
+    Whether the promise is canceled.
+    */
+    get isCanceled(): boolean;
+}
+export interface CancelableRequest<T extends Response | Response['body'] = Response['body']> extends PCancelable<T>, RequestEvents<CancelableRequest<T>> {
+    /**
+    A shortcut method that gives a Promise returning a JSON object.
+
+    It is semantically the same as settings `options.resolveBodyOnly` to `true` and `options.responseType` to `'json'`.
+    */
+    json: <ReturnType>() => CancelableRequest<ReturnType>;
+    /**
+    A shortcut method that gives a Promise returning a [Buffer](https://nodejs.org/api/buffer.html).
+
+    It is semantically the same as settings `options.resolveBodyOnly` to `true` and `options.responseType` to `'buffer'`.
+    */
+    buffer: () => CancelableRequest<Buffer>;
+    /**
+    A shortcut method that gives a Promise returning a string.
+
+    It is semantically the same as settings `options.resolveBodyOnly` to `true` and `options.responseType` to `'text'`.
+    */
+    text: () => CancelableRequest<string>;
+}
diff --git a/includes/external/addressbook/node_modules/got/dist/source/as-promise/types.js b/includes/external/addressbook/node_modules/got/dist/source/as-promise/types.js
new file mode 100644
index 0000000..eda617e
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/as-promise/types.js
@@ -0,0 +1,17 @@
+import { RequestError } from '../core/errors.js';
+/**
+An error to be thrown when the request is aborted with `.cancel()`.
+*/
+export class CancelError extends RequestError {
+    constructor(request) {
+        super('Promise was canceled', {}, request);
+        this.name = 'CancelError';
+        this.code = 'ERR_CANCELED';
+    }
+    /**
+    Whether the promise is canceled.
+    */
+    get isCanceled() {
+        return true;
+    }
+}
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/calculate-retry-delay.d.ts b/includes/external/addressbook/node_modules/got/dist/source/core/calculate-retry-delay.d.ts
new file mode 100644
index 0000000..c38ae4d
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/calculate-retry-delay.d.ts
@@ -0,0 +1,4 @@
+import type { RetryFunction } from './options.js';
+type Returns<T extends (...args: any) => unknown, V> = (...args: Parameters<T>) => V;
+declare const calculateRetryDelay: Returns<RetryFunction, number>;
+export default calculateRetryDelay;
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/calculate-retry-delay.js b/includes/external/addressbook/node_modules/got/dist/source/core/calculate-retry-delay.js
new file mode 100644
index 0000000..5407da8
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/calculate-retry-delay.js
@@ -0,0 +1,29 @@
+const calculateRetryDelay = ({ attemptCount, retryOptions, error, retryAfter, computedValue, }) => {
+    if (error.name === 'RetryError') {
+        return 1;
+    }
+    if (attemptCount > retryOptions.limit) {
+        return 0;
+    }
+    const hasMethod = retryOptions.methods.includes(error.options.method);
+    const hasErrorCode = retryOptions.errorCodes.includes(error.code);
+    const hasStatusCode = error.response && retryOptions.statusCodes.includes(error.response.statusCode);
+    if (!hasMethod || (!hasErrorCode && !hasStatusCode)) {
+        return 0;
+    }
+    if (error.response) {
+        if (retryAfter) {
+            // In this case `computedValue` is `options.request.timeout`
+            if (retryAfter > computedValue) {
+                return 0;
+            }
+            return retryAfter;
+        }
+        if (error.response.statusCode === 413) {
+            return 0;
+        }
+    }
+    const noise = Math.random() * retryOptions.noise;
+    return Math.min(((2 ** (attemptCount - 1)) * 1000), retryOptions.backoffLimit) + noise;
+};
+export default calculateRetryDelay;
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/errors.d.ts b/includes/external/addressbook/node_modules/got/dist/source/core/errors.d.ts
new file mode 100644
index 0000000..735d4d2
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/errors.d.ts
@@ -0,0 +1,90 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Timings } from '@szmarczak/http-timer';
+import type Options from './options.js';
+import type { TimeoutError as TimedOutTimeoutError } from './timed-out.js';
+import type { PlainResponse, Response } from './response.js';
+import type Request from './index.js';
+type Error = NodeJS.ErrnoException;
+/**
+An error to be thrown when a request fails.
+Contains a `code` property with error class code, like `ECONNREFUSED`.
+*/
+export declare class RequestError extends Error {
+    input?: string;
+    code: string;
+    stack: string;
+    readonly options: Options;
+    readonly response?: Response;
+    readonly request?: Request;
+    readonly timings?: Timings;
+    constructor(message: string, error: Partial<Error & {
+        code?: string;
+    }>, self: Request | Options);
+}
+/**
+An error to be thrown when the server redirects you more than ten times.
+Includes a `response` property.
+*/
+export declare class MaxRedirectsError extends RequestError {
+    readonly response: Response;
+    readonly request: Request;
+    readonly timings: Timings;
+    constructor(request: Request);
+}
+/**
+An error to be thrown when the server response code is not 2xx nor 3xx if `options.followRedirect` is `true`, but always except for 304.
+Includes a `response` property.
+*/
+export declare class HTTPError extends RequestError {
+    readonly response: Response;
+    readonly request: Request;
+    readonly timings: Timings;
+    constructor(response: PlainResponse);
+}
+/**
+An error to be thrown when a cache method fails.
+For example, if the database goes down or there's a filesystem error.
+*/
+export declare class CacheError extends RequestError {
+    readonly request: Request;
+    constructor(error: Error, request: Request);
+}
+/**
+An error to be thrown when the request body is a stream and an error occurs while reading from that stream.
+*/
+export declare class UploadError extends RequestError {
+    readonly request: Request;
+    constructor(error: Error, request: Request);
+}
+/**
+An error to be thrown when the request is aborted due to a timeout.
+Includes an `event` and `timings` property.
+*/
+export declare class TimeoutError extends RequestError {
+    readonly request: Request;
+    readonly timings: Timings;
+    readonly event: string;
+    constructor(error: TimedOutTimeoutError, timings: Timings, request: Request);
+}
+/**
+An error to be thrown when reading from response stream fails.
+*/
+export declare class ReadError extends RequestError {
+    readonly request: Request;
+    readonly response: Response;
+    readonly timings: Timings;
+    constructor(error: Error, request: Request);
+}
+/**
+An error which always triggers a new retry when thrown.
+*/
+export declare class RetryError extends RequestError {
+    constructor(request: Request);
+}
+/**
+An error to be thrown when the request is aborted by AbortController.
+*/
+export declare class AbortError extends RequestError {
+    constructor(request: Request);
+}
+export {};
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/errors.js b/includes/external/addressbook/node_modules/got/dist/source/core/errors.js
new file mode 100644
index 0000000..f8e1c98
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/errors.js
@@ -0,0 +1,178 @@
+import is from '@sindresorhus/is';
+// A hacky check to prevent circular references.
+function isRequest(x) {
+    return is.object(x) && '_onResponse' in x;
+}
+/**
+An error to be thrown when a request fails.
+Contains a `code` property with error class code, like `ECONNREFUSED`.
+*/
+export class RequestError extends Error {
+    constructor(message, error, self) {
+        super(message);
+        Object.defineProperty(this, "input", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "code", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stack", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "response", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "request", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "timings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Error.captureStackTrace(this, this.constructor);
+        this.name = 'RequestError';
+        this.code = error.code ?? 'ERR_GOT_REQUEST_ERROR';
+        this.input = error.input;
+        if (isRequest(self)) {
+            Object.defineProperty(this, 'request', {
+                enumerable: false,
+                value: self,
+            });
+            Object.defineProperty(this, 'response', {
+                enumerable: false,
+                value: self.response,
+            });
+            this.options = self.options;
+        }
+        else {
+            this.options = self;
+        }
+        this.timings = this.request?.timings;
+        // 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();
+            // 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')}`;
+        }
+    }
+}
+/**
+An error to be thrown when the server redirects you more than ten times.
+Includes a `response` property.
+*/
+export class MaxRedirectsError extends RequestError {
+    constructor(request) {
+        super(`Redirected ${request.options.maxRedirects} times. Aborting.`, {}, request);
+        this.name = 'MaxRedirectsError';
+        this.code = 'ERR_TOO_MANY_REDIRECTS';
+    }
+}
+/**
+An error to be thrown when the server response code is not 2xx nor 3xx if `options.followRedirect` is `true`, but always except for 304.
+Includes a `response` property.
+*/
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export class HTTPError extends RequestError {
+    constructor(response) {
+        super(`Response code ${response.statusCode} (${response.statusMessage})`, {}, response.request);
+        this.name = 'HTTPError';
+        this.code = 'ERR_NON_2XX_3XX_RESPONSE';
+    }
+}
+/**
+An error to be thrown when a cache method fails.
+For example, if the database goes down or there's a filesystem error.
+*/
+export class CacheError extends RequestError {
+    constructor(error, request) {
+        super(error.message, error, request);
+        this.name = 'CacheError';
+        this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_CACHE_ACCESS' : this.code;
+    }
+}
+/**
+An error to be thrown when the request body is a stream and an error occurs while reading from that stream.
+*/
+export class UploadError extends RequestError {
+    constructor(error, request) {
+        super(error.message, error, request);
+        this.name = 'UploadError';
+        this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_UPLOAD' : this.code;
+    }
+}
+/**
+An error to be thrown when the request is aborted due to a timeout.
+Includes an `event` and `timings` property.
+*/
+export class TimeoutError extends RequestError {
+    constructor(error, timings, request) {
+        super(error.message, error, request);
+        Object.defineProperty(this, "timings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "event", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = 'TimeoutError';
+        this.event = error.event;
+        this.timings = timings;
+    }
+}
+/**
+An error to be thrown when reading from response stream fails.
+*/
+export class ReadError extends RequestError {
+    constructor(error, request) {
+        super(error.message, error, request);
+        this.name = 'ReadError';
+        this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_READING_RESPONSE_STREAM' : this.code;
+    }
+}
+/**
+An error which always triggers a new retry when thrown.
+*/
+export class RetryError extends RequestError {
+    constructor(request) {
+        super('Retrying', {}, request);
+        this.name = 'RetryError';
+        this.code = 'ERR_RETRYING';
+    }
+}
+/**
+An error to be thrown when the request is aborted by AbortController.
+*/
+export class AbortError extends RequestError {
+    constructor(request) {
+        super('This operation was aborted.', {}, request);
+        this.code = 'ERR_ABORTED';
+        this.name = 'AbortError';
+    }
+}
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/index.d.ts b/includes/external/addressbook/node_modules/got/dist/source/core/index.d.ts
new file mode 100644
index 0000000..c041758
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/index.d.ts
@@ -0,0 +1,191 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Duplex } from 'node:stream';
+import { URL } from 'node:url';
+import type { ClientRequest } from 'node:http';
+import type { Socket } from 'node:net';
+import type { Timings } from '@szmarczak/http-timer';
+import Options from './options.js';
+import { type PlainResponse, type Response } from './response.js';
+import { RequestError } from './errors.js';
+type Error = NodeJS.ErrnoException;
+export type Progress = {
+    percent: number;
+    transferred: number;
+    total?: number;
+};
+export type GotEventFunction<T> = 
+/**
+`request` event to get the request object of the request.
+
+ __Tip__: You can use `request` event to abort requests.
+
+@example
+```
+import got from 'got';
+
+got.stream('https://github.com')
+    .on('request', request => setTimeout(() => request.destroy(), 50));
+```
+*/
+((name: 'request', listener: (request: ClientRequest) => void) => T)
+/**
+The `response` event to get the response object of the final request.
+*/
+ & (<R extends Response>(name: 'response', listener: (response: R) => void) => T)
+/**
+The `redirect` event to get the response object of a redirect. The second argument is options for the next request to the redirect location.
+*/
+ & (<R extends Response, N extends Options>(name: 'redirect', listener: (response: R, nextOptions: N) => void) => T)
+/**
+Progress events for uploading (sending a request) and downloading (receiving a response).
+The `progress` argument is an object like:
+
+```
+{
+    percent: 0.1,
+    transferred: 1024,
+    total: 10240
+}
+```
+
+If the `content-length` header is missing, `total` will be `undefined`.
+
+@example
+```
+import got from 'got';
+
+const response = await got('https://sindresorhus.com')
+    .on('downloadProgress', progress => {
+        // Report download progress
+    })
+    .on('uploadProgress', progress => {
+        // Report upload progress
+    });
+
+console.log(response);
+```
+*/
+ & ((name: 'uploadProgress' | 'downloadProgress', listener: (progress: Progress) => void) => T)
+/**
+To enable retrying on a Got stream, it is required to have a `retry` handler attached.
+
+When this event is emitted, you should reset the stream you were writing to and prepare the body again.
+
+See `got.options.retry` for more information.
+*/
+ & ((name: 'retry', listener: (retryCount: number, error: RequestError) => void) => T);
+export type RequestEvents<T> = {
+    on: GotEventFunction<T>;
+    once: GotEventFunction<T>;
+    off: GotEventFunction<T>;
+};
+type UrlType = ConstructorParameters<typeof Options>[0];
+type OptionsType = ConstructorParameters<typeof Options>[1];
+type DefaultsType = ConstructorParameters<typeof Options>[2];
+export default class Request extends Duplex implements RequestEvents<Request> {
+    ['constructor']: typeof Request;
+    _noPipe?: boolean;
+    options: Options;
+    response?: PlainResponse;
+    requestUrl?: URL;
+    redirectUrls: URL[];
+    retryCount: number;
+    private _requestOptions;
+    private _stopRetry;
+    private _downloadedSize;
+    private _uploadedSize;
+    private _stopReading;
+    private readonly _pipedServerResponses;
+    private _request?;
+    private _responseSize?;
+    private _bodySize?;
+    private _unproxyEvents;
+    private _isFromCache?;
+    private _cannotHaveBody;
+    private _triggerRead;
+    private _jobs;
+    private _cancelTimeouts;
+    private readonly _removeListeners;
+    private _nativeResponse?;
+    private _flushed;
+    private _aborted;
+    private _requestInitialized;
+    constructor(url: UrlType, options?: OptionsType, defaults?: DefaultsType);
+    flush(): Promise<void>;
+    _beforeError(error: Error): void;
+    _read(): void;
+    _write(chunk: unknown, encoding: BufferEncoding | undefined, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+    _destroy(error: Error | null, callback: (error: Error | null) => void): void;
+    pipe<T extends NodeJS.WritableStream>(destination: T, options?: {
+        end?: boolean;
+    }): T;
+    unpipe<T extends NodeJS.WritableStream>(destination: T): this;
+    private _finalizeBody;
+    private _onResponseBase;
+    private _setRawBody;
+    private _onResponse;
+    private _onRequest;
+    private _asyncWrite;
+    private _sendBody;
+    private _prepareCache;
+    private _createCacheableRequest;
+    private _makeRequest;
+    private _error;
+    private _writeRequest;
+    /**
+    The remote IP address.
+    */
+    get ip(): string | undefined;
+    /**
+    Indicates whether the request has been aborted or not.
+    */
+    get isAborted(): boolean;
+    get socket(): Socket | undefined;
+    /**
+    Progress event for downloading (receiving a response).
+    */
+    get downloadProgress(): Progress;
+    /**
+    Progress event for uploading (sending a request).
+    */
+    get uploadProgress(): Progress;
+    /**
+    The object contains the following properties:
+
+    - `start` - Time when the request started.
+    - `socket` - Time when a socket was assigned to the request.
+    - `lookup` - Time when the DNS lookup finished.
+    - `connect` - Time when the socket successfully connected.
+    - `secureConnect` - Time when the socket securely connected.
+    - `upload` - Time when the request finished uploading.
+    - `response` - Time when the request fired `response` event.
+    - `end` - Time when the response fired `end` event.
+    - `error` - Time when the request fired `error` event.
+    - `abort` - Time when the request fired `abort` event.
+    - `phases`
+        - `wait` - `timings.socket - timings.start`
+        - `dns` - `timings.lookup - timings.socket`
+        - `tcp` - `timings.connect - timings.lookup`
+        - `tls` - `timings.secureConnect - timings.connect`
+        - `request` - `timings.upload - (timings.secureConnect || timings.connect)`
+        - `firstByte` - `timings.response - timings.upload`
+        - `download` - `timings.end - timings.response`
+        - `total` - `(timings.end || timings.error || timings.abort) - timings.start`
+
+    If something has not been measured yet, it will be `undefined`.
+
+    __Note__: The time is a `number` representing the milliseconds elapsed since the UNIX epoch.
+    */
+    get timings(): Timings | undefined;
+    /**
+    Whether the response was retrieved from the cache.
+    */
+    get isFromCache(): boolean | undefined;
+    get reusedSocket(): boolean | undefined;
+}
+export {};
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/index.js b/includes/external/addressbook/node_modules/got/dist/source/core/index.js
new file mode 100644
index 0000000..4f0bfd3
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/index.js
@@ -0,0 +1,1124 @@
+import process from 'node:process';
+import { Buffer } from 'node:buffer';
+import { Duplex } from 'node:stream';
+import { URL, URLSearchParams } from 'node:url';
+import http, { ServerResponse } from 'node:http';
+import timer from '@szmarczak/http-timer';
+import CacheableRequest, { CacheError as CacheableCacheError, } from 'cacheable-request';
+import decompressResponse from 'decompress-response';
+import is from '@sindresorhus/is';
+import { buffer as getBuffer } from 'get-stream';
+import { FormDataEncoder, isFormData as isFormDataLike } from 'form-data-encoder';
+import getBodySize from './utils/get-body-size.js';
+import isFormData from './utils/is-form-data.js';
+import proxyEvents from './utils/proxy-events.js';
+import timedOut, { TimeoutError as TimedOutTimeoutError } from './timed-out.js';
+import urlToOptions from './utils/url-to-options.js';
+import WeakableMap from './utils/weakable-map.js';
+import calculateRetryDelay from './calculate-retry-delay.js';
+import Options from './options.js';
+import { isResponseOk } from './response.js';
+import isClientRequest from './utils/is-client-request.js';
+import isUnixSocketURL from './utils/is-unix-socket-url.js';
+import { RequestError, ReadError, MaxRedirectsError, HTTPError, TimeoutError, UploadError, CacheError, AbortError, } from './errors.js';
+const supportsBrotli = is.string(process.versions.brotli);
+const methodsWithoutBody = new Set(['GET', 'HEAD']);
+const cacheableStore = new WeakableMap();
+const redirectCodes = new Set([300, 301, 302, 303, 304, 307, 308]);
+const proxiedRequestEvents = [
+    'socket',
+    'connect',
+    'continue',
+    'information',
+    'upgrade',
+];
+const noop = () => { };
+export default class Request extends Duplex {
+    constructor(url, options, defaults) {
+        super({
+            // Don't destroy immediately, as the error may be emitted on unsuccessful retry
+            autoDestroy: false,
+            // It needs to be zero because we're just proxying the data to another stream
+            highWaterMark: 0,
+        });
+        // @ts-expect-error - Ignoring for now.
+        Object.defineProperty(this, 'constructor', {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_noPipe", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // @ts-expect-error https://github.com/microsoft/TypeScript/issues/9568
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "response", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "requestUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "redirectUrls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "retryCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_stopRetry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_downloadedSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_uploadedSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_stopReading", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_pipedServerResponses", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_request", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_responseSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_bodySize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_unproxyEvents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_isFromCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_cannotHaveBody", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_triggerRead", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_cancelTimeouts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_removeListeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_nativeResponse", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_flushed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_aborted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // We need this because `this._request` if `undefined` when using cache
+        Object.defineProperty(this, "_requestInitialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._downloadedSize = 0;
+        this._uploadedSize = 0;
+        this._stopReading = false;
+        this._pipedServerResponses = new Set();
+        this._cannotHaveBody = false;
+        this._unproxyEvents = noop;
+        this._triggerRead = false;
+        this._cancelTimeouts = noop;
+        this._removeListeners = noop;
+        this._jobs = [];
+        this._flushed = false;
+        this._requestInitialized = false;
+        this._aborted = false;
+        this.redirectUrls = [];
+        this.retryCount = 0;
+        this._stopRetry = noop;
+        this.on('pipe', source => {
+            if (source.headers) {
+                Object.assign(this.options.headers, source.headers);
+            }
+        });
+        this.on('newListener', event => {
+            if (event === 'retry' && this.listenerCount('retry') > 0) {
+                throw new Error('A retry listener has been attached already.');
+            }
+        });
+        try {
+            this.options = new Options(url, options, defaults);
+            if (!this.options.url) {
+                if (this.options.prefixUrl === '') {
+                    throw new TypeError('Missing `url` property');
+                }
+                this.options.url = '';
+            }
+            this.requestUrl = this.options.url;
+        }
+        catch (error) {
+            const { options } = error;
+            if (options) {
+                this.options = options;
+            }
+            this.flush = async () => {
+                this.flush = async () => { };
+                this.destroy(error);
+            };
+            return;
+        }
+        // Important! If you replace `body` in a handler with another stream, make sure it's readable first.
+        // The below is run only once.
+        const { body } = this.options;
+        if (is.nodeStream(body)) {
+            body.once('error', error => {
+                if (this._flushed) {
+                    this._beforeError(new UploadError(error, this));
+                }
+                else {
+                    this.flush = async () => {
+                        this.flush = async () => { };
+                        this._beforeError(new UploadError(error, this));
+                    };
+                }
+            });
+        }
+        if (this.options.signal) {
+            const abort = () => {
+                this.destroy(new AbortError(this));
+            };
+            if (this.options.signal.aborted) {
+                abort();
+            }
+            else {
+                this.options.signal.addEventListener('abort', abort);
+                this._removeListeners = () => {
+                    this.options.signal.removeEventListener('abort', abort);
+                };
+            }
+        }
+    }
+    async flush() {
+        if (this._flushed) {
+            return;
+        }
+        this._flushed = true;
+        try {
+            await this._finalizeBody();
+            if (this.destroyed) {
+                return;
+            }
+            await this._makeRequest();
+            if (this.destroyed) {
+                this._request?.destroy();
+                return;
+            }
+            // Queued writes etc.
+            for (const job of this._jobs) {
+                job();
+            }
+            // Prevent memory leak
+            this._jobs.length = 0;
+            this._requestInitialized = true;
+        }
+        catch (error) {
+            this._beforeError(error);
+        }
+    }
+    _beforeError(error) {
+        if (this._stopReading) {
+            return;
+        }
+        const { response, options } = this;
+        const attemptCount = this.retryCount + (error.name === 'RetryError' ? 0 : 1);
+        this._stopReading = true;
+        if (!(error instanceof RequestError)) {
+            error = new RequestError(error.message, error, this);
+        }
+        const typedError = error;
+        void (async () => {
+            // Node.js parser is really weird.
+            // It emits post-request Parse Errors on the same instance as previous request. WTF.
+            // Therefore we need to check if it has been destroyed as well.
+            //
+            // Furthermore, Node.js 16 `response.destroy()` doesn't immediately destroy the socket,
+            // but makes the response unreadable. So we additionally need to check `response.readable`.
+            if (response?.readable && !response.rawBody && !this._request?.socket?.destroyed) {
+                // @types/node has incorrect typings. `setEncoding` accepts `null` as well.
+                response.setEncoding(this.readableEncoding);
+                const success = await this._setRawBody(response);
+                if (success) {
+                    response.body = response.rawBody.toString();
+                }
+            }
+            if (this.listenerCount('retry') !== 0) {
+                let backoff;
+                try {
+                    let retryAfter;
+                    if (response && 'retry-after' in response.headers) {
+                        retryAfter = Number(response.headers['retry-after']);
+                        if (Number.isNaN(retryAfter)) {
+                            retryAfter = Date.parse(response.headers['retry-after']) - Date.now();
+                            if (retryAfter <= 0) {
+                                retryAfter = 1;
+                            }
+                        }
+                        else {
+                            retryAfter *= 1000;
+                        }
+                    }
+                    const retryOptions = options.retry;
+                    backoff = await retryOptions.calculateDelay({
+                        attemptCount,
+                        retryOptions,
+                        error: typedError,
+                        retryAfter,
+                        computedValue: calculateRetryDelay({
+                            attemptCount,
+                            retryOptions,
+                            error: typedError,
+                            retryAfter,
+                            computedValue: retryOptions.maxRetryAfter ?? options.timeout.request ?? Number.POSITIVE_INFINITY,
+                        }),
+                    });
+                }
+                catch (error_) {
+                    void this._error(new RequestError(error_.message, error_, this));
+                    return;
+                }
+                if (backoff) {
+                    await new Promise(resolve => {
+                        const timeout = setTimeout(resolve, backoff);
+                        this._stopRetry = () => {
+                            clearTimeout(timeout);
+                            resolve();
+                        };
+                    });
+                    // Something forced us to abort the retry
+                    if (this.destroyed) {
+                        return;
+                    }
+                    try {
+                        for (const hook of this.options.hooks.beforeRetry) {
+                            // eslint-disable-next-line no-await-in-loop
+                            await hook(typedError, this.retryCount + 1);
+                        }
+                    }
+                    catch (error_) {
+                        void this._error(new RequestError(error_.message, error, this));
+                        return;
+                    }
+                    // Something forced us to abort the retry
+                    if (this.destroyed) {
+                        return;
+                    }
+                    this.destroy();
+                    this.emit('retry', this.retryCount + 1, error, (updatedOptions) => {
+                        const request = new Request(options.url, updatedOptions, options);
+                        request.retryCount = this.retryCount + 1;
+                        process.nextTick(() => {
+                            void request.flush();
+                        });
+                        return request;
+                    });
+                    return;
+                }
+            }
+            void this._error(typedError);
+        })();
+    }
+    _read() {
+        this._triggerRead = true;
+        const { response } = this;
+        if (response && !this._stopReading) {
+            // We cannot put this in the `if` above
+            // because `.read()` also triggers the `end` event
+            if (response.readableLength) {
+                this._triggerRead = false;
+            }
+            let data;
+            while ((data = response.read()) !== null) {
+                this._downloadedSize += data.length; // eslint-disable-line @typescript-eslint/restrict-plus-operands
+                const progress = this.downloadProgress;
+                if (progress.percent < 1) {
+                    this.emit('downloadProgress', progress);
+                }
+                this.push(data);
+            }
+        }
+    }
+    _write(chunk, encoding, callback) {
+        const write = () => {
+            this._writeRequest(chunk, encoding, callback);
+        };
+        if (this._requestInitialized) {
+            write();
+        }
+        else {
+            this._jobs.push(write);
+        }
+    }
+    _final(callback) {
+        const endRequest = () => {
+            // We need to check if `this._request` is present,
+            // because it isn't when we use cache.
+            if (!this._request || this._request.destroyed) {
+                callback();
+                return;
+            }
+            this._request.end((error) => {
+                // The request has been destroyed before `_final` finished.
+                // See https://github.com/nodejs/node/issues/39356
+                if (this._request._writableState?.errored) {
+                    return;
+                }
+                if (!error) {
+                    this._bodySize = this._uploadedSize;
+                    this.emit('uploadProgress', this.uploadProgress);
+                    this._request.emit('upload-complete');
+                }
+                callback(error);
+            });
+        };
+        if (this._requestInitialized) {
+            endRequest();
+        }
+        else {
+            this._jobs.push(endRequest);
+        }
+    }
+    _destroy(error, callback) {
+        this._stopReading = true;
+        this.flush = async () => { };
+        // Prevent further retries
+        this._stopRetry();
+        this._cancelTimeouts();
+        this._removeListeners();
+        if (this.options) {
+            const { body } = this.options;
+            if (is.nodeStream(body)) {
+                body.destroy();
+            }
+        }
+        if (this._request) {
+            this._request.destroy();
+        }
+        if (error !== null && !is.undefined(error) && !(error instanceof RequestError)) {
+            error = new RequestError(error.message, error, this);
+        }
+        callback(error);
+    }
+    pipe(destination, options) {
+        if (destination instanceof ServerResponse) {
+            this._pipedServerResponses.add(destination);
+        }
+        return super.pipe(destination, options);
+    }
+    unpipe(destination) {
+        if (destination instanceof ServerResponse) {
+            this._pipedServerResponses.delete(destination);
+        }
+        super.unpipe(destination);
+        return this;
+    }
+    async _finalizeBody() {
+        const { options } = this;
+        const { headers } = options;
+        const isForm = !is.undefined(options.form);
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        const isJSON = !is.undefined(options.json);
+        const isBody = !is.undefined(options.body);
+        const cannotHaveBody = methodsWithoutBody.has(options.method) && !(options.method === 'GET' && options.allowGetBody);
+        this._cannotHaveBody = cannotHaveBody;
+        if (isForm || isJSON || isBody) {
+            if (cannotHaveBody) {
+                throw new TypeError(`The \`${options.method}\` method cannot be used with a body`);
+            }
+            // Serialize body
+            const noContentType = !is.string(headers['content-type']);
+            if (isBody) {
+                // Body is spec-compliant FormData
+                if (isFormDataLike(options.body)) {
+                    const encoder = new FormDataEncoder(options.body);
+                    if (noContentType) {
+                        headers['content-type'] = encoder.headers['Content-Type'];
+                    }
+                    if ('Content-Length' in encoder.headers) {
+                        headers['content-length'] = encoder.headers['Content-Length'];
+                    }
+                    options.body = encoder.encode();
+                }
+                // Special case for https://github.com/form-data/form-data
+                if (isFormData(options.body) && noContentType) {
+                    headers['content-type'] = `multipart/form-data; boundary=${options.body.getBoundary()}`;
+                }
+            }
+            else if (isForm) {
+                if (noContentType) {
+                    headers['content-type'] = 'application/x-www-form-urlencoded';
+                }
+                const { form } = options;
+                options.form = undefined;
+                options.body = (new URLSearchParams(form)).toString();
+            }
+            else {
+                if (noContentType) {
+                    headers['content-type'] = 'application/json';
+                }
+                const { json } = options;
+                options.json = undefined;
+                options.body = options.stringifyJson(json);
+            }
+            const uploadBodySize = await getBodySize(options.body, options.headers);
+            // See https://tools.ietf.org/html/rfc7230#section-3.3.2
+            // A user agent SHOULD send a Content-Length in a request message when
+            // no Transfer-Encoding is sent and the request method defines a meaning
+            // for an enclosed payload body.  For example, a Content-Length header
+            // field is normally sent in a POST request even when the value is 0
+            // (indicating an empty payload body).  A user agent SHOULD NOT send a
+            // Content-Length header field when the request message does not contain
+            // a payload body and the method semantics do not anticipate such a
+            // body.
+            if (is.undefined(headers['content-length']) && is.undefined(headers['transfer-encoding']) && !cannotHaveBody && !is.undefined(uploadBodySize)) {
+                headers['content-length'] = String(uploadBodySize);
+            }
+        }
+        if (options.responseType === 'json' && !('accept' in options.headers)) {
+            options.headers.accept = 'application/json';
+        }
+        this._bodySize = Number(headers['content-length']) || undefined;
+    }
+    async _onResponseBase(response) {
+        // This will be called e.g. when using cache so we need to check if this request has been aborted.
+        if (this.isAborted) {
+            return;
+        }
+        const { options } = this;
+        const { url } = options;
+        this._nativeResponse = response;
+        if (options.decompress) {
+            response = decompressResponse(response);
+        }
+        const statusCode = response.statusCode;
+        const typedResponse = response;
+        typedResponse.statusMessage = typedResponse.statusMessage ?? http.STATUS_CODES[statusCode];
+        typedResponse.url = options.url.toString();
+        typedResponse.requestUrl = this.requestUrl;
+        typedResponse.redirectUrls = this.redirectUrls;
+        typedResponse.request = this;
+        typedResponse.isFromCache = this._nativeResponse.fromCache ?? false;
+        typedResponse.ip = this.ip;
+        typedResponse.retryCount = this.retryCount;
+        typedResponse.ok = isResponseOk(typedResponse);
+        this._isFromCache = typedResponse.isFromCache;
+        this._responseSize = Number(response.headers['content-length']) || undefined;
+        this.response = typedResponse;
+        response.once('end', () => {
+            this._responseSize = this._downloadedSize;
+            this.emit('downloadProgress', this.downloadProgress);
+        });
+        response.once('error', (error) => {
+            this._aborted = true;
+            // Force clean-up, because some packages don't do this.
+            // TODO: Fix decompress-response
+            response.destroy();
+            this._beforeError(new ReadError(error, this));
+        });
+        response.once('aborted', () => {
+            this._aborted = true;
+            this._beforeError(new ReadError({
+                name: 'Error',
+                message: 'The server aborted pending request',
+                code: 'ECONNRESET',
+            }, this));
+        });
+        this.emit('downloadProgress', this.downloadProgress);
+        const rawCookies = response.headers['set-cookie'];
+        if (is.object(options.cookieJar) && rawCookies) {
+            let promises = rawCookies.map(async (rawCookie) => options.cookieJar.setCookie(rawCookie, url.toString()));
+            if (options.ignoreInvalidCookies) {
+                promises = promises.map(async (promise) => {
+                    try {
+                        await promise;
+                    }
+                    catch { }
+                });
+            }
+            try {
+                await Promise.all(promises);
+            }
+            catch (error) {
+                this._beforeError(error);
+                return;
+            }
+        }
+        // The above is running a promise, therefore we need to check if this request has been aborted yet again.
+        if (this.isAborted) {
+            return;
+        }
+        if (options.followRedirect && response.headers.location && redirectCodes.has(statusCode)) {
+            // We're being redirected, we don't care about the response.
+            // It'd be best to abort the request, but we can't because
+            // we would have to sacrifice the TCP connection. We don't want that.
+            response.resume();
+            this._cancelTimeouts();
+            this._unproxyEvents();
+            if (this.redirectUrls.length >= options.maxRedirects) {
+                this._beforeError(new MaxRedirectsError(this));
+                return;
+            }
+            this._request = undefined;
+            const updatedOptions = new Options(undefined, undefined, this.options);
+            const serverRequestedGet = statusCode === 303 && updatedOptions.method !== 'GET' && updatedOptions.method !== 'HEAD';
+            const canRewrite = statusCode !== 307 && statusCode !== 308;
+            const userRequestedGet = updatedOptions.methodRewriting && canRewrite;
+            if (serverRequestedGet || userRequestedGet) {
+                updatedOptions.method = 'GET';
+                updatedOptions.body = undefined;
+                updatedOptions.json = undefined;
+                updatedOptions.form = undefined;
+                delete updatedOptions.headers['content-length'];
+            }
+            try {
+                // We need this in order to support UTF-8
+                const redirectBuffer = Buffer.from(response.headers.location, 'binary').toString();
+                const redirectUrl = new URL(redirectBuffer, url);
+                if (!isUnixSocketURL(url) && isUnixSocketURL(redirectUrl)) {
+                    this._beforeError(new RequestError('Cannot redirect to UNIX socket', {}, this));
+                    return;
+                }
+                // Redirecting to a different site, clear sensitive data.
+                if (redirectUrl.hostname !== url.hostname || redirectUrl.port !== url.port) {
+                    if ('host' in updatedOptions.headers) {
+                        delete updatedOptions.headers.host;
+                    }
+                    if ('cookie' in updatedOptions.headers) {
+                        delete updatedOptions.headers.cookie;
+                    }
+                    if ('authorization' in updatedOptions.headers) {
+                        delete updatedOptions.headers.authorization;
+                    }
+                    if (updatedOptions.username || updatedOptions.password) {
+                        updatedOptions.username = '';
+                        updatedOptions.password = '';
+                    }
+                }
+                else {
+                    redirectUrl.username = updatedOptions.username;
+                    redirectUrl.password = updatedOptions.password;
+                }
+                this.redirectUrls.push(redirectUrl);
+                updatedOptions.prefixUrl = '';
+                updatedOptions.url = redirectUrl;
+                for (const hook of updatedOptions.hooks.beforeRedirect) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await hook(updatedOptions, typedResponse);
+                }
+                this.emit('redirect', updatedOptions, typedResponse);
+                this.options = updatedOptions;
+                await this._makeRequest();
+            }
+            catch (error) {
+                this._beforeError(error);
+                return;
+            }
+            return;
+        }
+        // `HTTPError`s always have `error.response.body` defined.
+        // Therefore we cannot retry if `options.throwHttpErrors` is false.
+        // On the last retry, if `options.throwHttpErrors` is false, we would need to return the body,
+        // but that wouldn't be possible since the body would be already read in `error.response.body`.
+        if (options.isStream && options.throwHttpErrors && !isResponseOk(typedResponse)) {
+            this._beforeError(new HTTPError(typedResponse));
+            return;
+        }
+        response.on('readable', () => {
+            if (this._triggerRead) {
+                this._read();
+            }
+        });
+        this.on('resume', () => {
+            response.resume();
+        });
+        this.on('pause', () => {
+            response.pause();
+        });
+        response.once('end', () => {
+            this.push(null);
+        });
+        if (this._noPipe) {
+            const success = await this._setRawBody();
+            if (success) {
+                this.emit('response', response);
+            }
+            return;
+        }
+        this.emit('response', response);
+        for (const destination of this._pipedServerResponses) {
+            if (destination.headersSent) {
+                continue;
+            }
+            // eslint-disable-next-line guard-for-in
+            for (const key in response.headers) {
+                const isAllowed = options.decompress ? key !== 'content-encoding' : true;
+                const value = response.headers[key];
+                if (isAllowed) {
+                    destination.setHeader(key, value);
+                }
+            }
+            destination.statusCode = statusCode;
+        }
+    }
+    async _setRawBody(from = this) {
+        if (from.readableEnded) {
+            return false;
+        }
+        try {
+            // Errors are emitted via the `error` event
+            const rawBody = await getBuffer(from);
+            // On retry Request is destroyed with no error, therefore the above will successfully resolve.
+            // So in order to check if this was really successfull, we need to check if it has been properly ended.
+            if (!this.isAborted) {
+                this.response.rawBody = rawBody;
+                return true;
+            }
+        }
+        catch { }
+        return false;
+    }
+    async _onResponse(response) {
+        try {
+            await this._onResponseBase(response);
+        }
+        catch (error) {
+            /* istanbul ignore next: better safe than sorry */
+            this._beforeError(error);
+        }
+    }
+    _onRequest(request) {
+        const { options } = this;
+        const { timeout, url } = options;
+        timer(request);
+        if (this.options.http2) {
+            // Unset stream timeout, as the `timeout` option was used only for connection timeout.
+            request.setTimeout(0);
+        }
+        this._cancelTimeouts = timedOut(request, timeout, url);
+        const responseEventName = options.cache ? 'cacheableResponse' : 'response';
+        request.once(responseEventName, (response) => {
+            void this._onResponse(response);
+        });
+        request.once('error', (error) => {
+            this._aborted = true;
+            // Force clean-up, because some packages (e.g. nock) don't do this.
+            request.destroy();
+            error = error instanceof TimedOutTimeoutError ? new TimeoutError(error, this.timings, this) : new RequestError(error.message, error, this);
+            this._beforeError(error);
+        });
+        this._unproxyEvents = proxyEvents(request, this, proxiedRequestEvents);
+        this._request = request;
+        this.emit('uploadProgress', this.uploadProgress);
+        this._sendBody();
+        this.emit('request', request);
+    }
+    async _asyncWrite(chunk) {
+        return new Promise((resolve, reject) => {
+            super.write(chunk, error => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    _sendBody() {
+        // Send body
+        const { body } = this.options;
+        const currentRequest = this.redirectUrls.length === 0 ? this : this._request ?? this;
+        if (is.nodeStream(body)) {
+            body.pipe(currentRequest);
+        }
+        else if (is.generator(body) || is.asyncGenerator(body)) {
+            (async () => {
+                try {
+                    for await (const chunk of body) {
+                        await this._asyncWrite(chunk);
+                    }
+                    super.end();
+                }
+                catch (error) {
+                    this._beforeError(error);
+                }
+            })();
+        }
+        else if (!is.undefined(body)) {
+            this._writeRequest(body, undefined, () => { });
+            currentRequest.end();
+        }
+        else if (this._cannotHaveBody || this._noPipe) {
+            currentRequest.end();
+        }
+    }
+    _prepareCache(cache) {
+        if (!cacheableStore.has(cache)) {
+            const cacheableRequest = new CacheableRequest(((requestOptions, handler) => {
+                const result = requestOptions._request(requestOptions, handler);
+                // TODO: remove this when `cacheable-request` supports async request functions.
+                if (is.promise(result)) {
+                    // We only need to implement the error handler in order to support HTTP2 caching.
+                    // The result will be a promise anyway.
+                    // @ts-expect-error ignore
+                    // eslint-disable-next-line @typescript-eslint/promise-function-async
+                    result.once = (event, handler) => {
+                        if (event === 'error') {
+                            (async () => {
+                                try {
+                                    await result;
+                                }
+                                catch (error) {
+                                    handler(error);
+                                }
+                            })();
+                        }
+                        else if (event === 'abort') {
+                            // The empty catch is needed here in case when
+                            // it rejects before it's `await`ed in `_makeRequest`.
+                            (async () => {
+                                try {
+                                    const request = (await result);
+                                    request.once('abort', handler);
+                                }
+                                catch { }
+                            })();
+                        }
+                        else {
+                            /* istanbul ignore next: safety check */
+                            throw new Error(`Unknown HTTP2 promise event: ${event}`);
+                        }
+                        return result;
+                    };
+                }
+                return result;
+            }), cache);
+            cacheableStore.set(cache, cacheableRequest.request());
+        }
+    }
+    async _createCacheableRequest(url, options) {
+        return new Promise((resolve, reject) => {
+            // TODO: Remove `utils/url-to-options.ts` when `cacheable-request` is fixed
+            Object.assign(options, urlToOptions(url));
+            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 = () => {
+                        if (response.req) {
+                            response.complete = response.req.res.complete;
+                        }
+                    };
+                    response.prependOnceListener('end', fix);
+                    fix();
+                    (await request).emit('cacheableResponse', response);
+                }
+                resolve(response);
+            });
+            cacheRequest.once('error', reject);
+            cacheRequest.once('request', async (requestOrPromise) => {
+                request = requestOrPromise;
+                resolve(request);
+            });
+        });
+    }
+    async _makeRequest() {
+        const { options } = this;
+        const { headers, username, password } = options;
+        const cookieJar = options.cookieJar;
+        for (const key in headers) {
+            if (is.undefined(headers[key])) {
+                // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+                delete headers[key];
+            }
+            else if (is.null_(headers[key])) {
+                throw new TypeError(`Use \`undefined\` instead of \`null\` to delete the \`${key}\` header`);
+            }
+        }
+        if (options.decompress && is.undefined(headers['accept-encoding'])) {
+            headers['accept-encoding'] = supportsBrotli ? 'gzip, deflate, br' : 'gzip, deflate';
+        }
+        if (username || password) {
+            const credentials = Buffer.from(`${username}:${password}`).toString('base64');
+            headers.authorization = `Basic ${credentials}`;
+        }
+        // Set cookies
+        if (cookieJar) {
+            const cookieString = await cookieJar.getCookieString(options.url.toString());
+            if (is.nonEmptyString(cookieString)) {
+                headers.cookie = cookieString;
+            }
+        }
+        // Reset `prefixUrl`
+        options.prefixUrl = '';
+        let request;
+        for (const hook of options.hooks.beforeRequest) {
+            // eslint-disable-next-line no-await-in-loop
+            const result = await hook(options);
+            if (!is.undefined(result)) {
+                // @ts-expect-error Skip the type mismatch to support abstract responses
+                request = () => result;
+                break;
+            }
+        }
+        if (!request) {
+            request = options.getRequestFunction();
+        }
+        const url = options.url;
+        this._requestOptions = options.createNativeRequestOptions();
+        if (options.cache) {
+            this._requestOptions._request = request;
+            this._requestOptions.cache = options.cache;
+            this._requestOptions.body = options.body;
+            this._prepareCache(options.cache);
+        }
+        // Cache support
+        const fn = options.cache ? this._createCacheableRequest : request;
+        try {
+            // We can't do `await fn(...)`,
+            // because stream `error` event can be emitted before `Promise.resolve()`.
+            let requestOrResponse = fn(url, this._requestOptions);
+            if (is.promise(requestOrResponse)) {
+                requestOrResponse = await requestOrResponse;
+            }
+            // Fallback
+            if (is.undefined(requestOrResponse)) {
+                requestOrResponse = options.getFallbackRequestFunction()(url, this._requestOptions);
+                if (is.promise(requestOrResponse)) {
+                    requestOrResponse = await requestOrResponse;
+                }
+            }
+            if (isClientRequest(requestOrResponse)) {
+                this._onRequest(requestOrResponse);
+            }
+            else if (this.writable) {
+                this.once('finish', () => {
+                    void this._onResponse(requestOrResponse);
+                });
+                this._sendBody();
+            }
+            else {
+                void this._onResponse(requestOrResponse);
+            }
+        }
+        catch (error) {
+            if (error instanceof CacheableCacheError) {
+                throw new CacheError(error, this);
+            }
+            throw error;
+        }
+    }
+    async _error(error) {
+        try {
+            if (error instanceof HTTPError && !this.options.throwHttpErrors) {
+                // This branch can be reached only when using the Promise API
+                // Skip calling the hooks on purpose.
+                // See https://github.com/sindresorhus/got/issues/2103
+            }
+            else {
+                for (const hook of this.options.hooks.beforeError) {
+                    // eslint-disable-next-line no-await-in-loop
+                    error = await hook(error);
+                }
+            }
+        }
+        catch (error_) {
+            error = new RequestError(error_.message, error_, this);
+        }
+        this.destroy(error);
+    }
+    _writeRequest(chunk, encoding, callback) {
+        if (!this._request || this._request.destroyed) {
+            // Probably the `ClientRequest` instance will throw
+            return;
+        }
+        this._request.write(chunk, encoding, (error) => {
+            // The `!destroyed` check is required to prevent `uploadProgress` being emitted after the stream was destroyed
+            if (!error && !this._request.destroyed) {
+                this._uploadedSize += Buffer.byteLength(chunk, encoding);
+                const progress = this.uploadProgress;
+                if (progress.percent < 1) {
+                    this.emit('uploadProgress', progress);
+                }
+            }
+            callback(error);
+        });
+    }
+    /**
+    The remote IP address.
+    */
+    get ip() {
+        return this.socket?.remoteAddress;
+    }
+    /**
+    Indicates whether the request has been aborted or not.
+    */
+    get isAborted() {
+        return this._aborted;
+    }
+    get socket() {
+        return this._request?.socket ?? undefined;
+    }
+    /**
+    Progress event for downloading (receiving a response).
+    */
+    get downloadProgress() {
+        let percent;
+        if (this._responseSize) {
+            percent = this._downloadedSize / this._responseSize;
+        }
+        else if (this._responseSize === this._downloadedSize) {
+            percent = 1;
+        }
+        else {
+            percent = 0;
+        }
+        return {
+            percent,
+            transferred: this._downloadedSize,
+            total: this._responseSize,
+        };
+    }
+    /**
+    Progress event for uploading (sending a request).
+    */
+    get uploadProgress() {
+        let percent;
+        if (this._bodySize) {
+            percent = this._uploadedSize / this._bodySize;
+        }
+        else if (this._bodySize === this._uploadedSize) {
+            percent = 1;
+        }
+        else {
+            percent = 0;
+        }
+        return {
+            percent,
+            transferred: this._uploadedSize,
+            total: this._bodySize,
+        };
+    }
+    /**
+    The object contains the following properties:
+
+    - `start` - Time when the request started.
+    - `socket` - Time when a socket was assigned to the request.
+    - `lookup` - Time when the DNS lookup finished.
+    - `connect` - Time when the socket successfully connected.
+    - `secureConnect` - Time when the socket securely connected.
+    - `upload` - Time when the request finished uploading.
+    - `response` - Time when the request fired `response` event.
+    - `end` - Time when the response fired `end` event.
+    - `error` - Time when the request fired `error` event.
+    - `abort` - Time when the request fired `abort` event.
+    - `phases`
+        - `wait` - `timings.socket - timings.start`
+        - `dns` - `timings.lookup - timings.socket`
+        - `tcp` - `timings.connect - timings.lookup`
+        - `tls` - `timings.secureConnect - timings.connect`
+        - `request` - `timings.upload - (timings.secureConnect || timings.connect)`
+        - `firstByte` - `timings.response - timings.upload`
+        - `download` - `timings.end - timings.response`
+        - `total` - `(timings.end || timings.error || timings.abort) - timings.start`
+
+    If something has not been measured yet, it will be `undefined`.
+
+    __Note__: The time is a `number` representing the milliseconds elapsed since the UNIX epoch.
+    */
+    get timings() {
+        return this._request?.timings;
+    }
+    /**
+    Whether the response was retrieved from the cache.
+    */
+    get isFromCache() {
+        return this._isFromCache;
+    }
+    get reusedSocket() {
+        return this._request?.reusedSocket;
+    }
+}
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/options.d.ts b/includes/external/addressbook/node_modules/got/dist/source/core/options.d.ts
new file mode 100644
index 0000000..e6d6788
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/options.d.ts
@@ -0,0 +1,1255 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Buffer } from 'node:buffer';
+import { URL, URLSearchParams } from 'node:url';
+import { checkServerIdentity } from 'node:tls';
+import http from 'node:http';
+import https from 'node:https';
+import type { Readable } from 'node:stream';
+import type { Socket } from 'node:net';
+import type { SecureContextOptions, DetailedPeerCertificate } from 'node:tls';
+import type { Agent as HttpAgent, ClientRequest } from 'node:http';
+import type { RequestOptions as HttpsRequestOptions, Agent as HttpsAgent } from 'node:https';
+import CacheableLookup from 'cacheable-lookup';
+import http2wrapper, { type ClientHttp2Session } from 'http2-wrapper';
+import type { FormDataLike } from 'form-data-encoder';
+import type { StorageAdapter } from 'cacheable-request';
+import type ResponseLike from 'responselike';
+import type { IncomingMessageWithTimings } from '@szmarczak/http-timer';
+import type { CancelableRequest } from '../as-promise/types.js';
+import type { PlainResponse, Response } from './response.js';
+import type { RequestError } from './errors.js';
+import type { Delays } from './timed-out.js';
+type Promisable<T> = T | Promise<T>;
+export type DnsLookupIpVersion = undefined | 4 | 6;
+type Except<ObjectType, KeysType extends keyof ObjectType> = Pick<ObjectType, Exclude<keyof ObjectType, KeysType>>;
+export type NativeRequestOptions = HttpsRequestOptions & CacheOptions & {
+    checkServerIdentity?: CheckServerIdentityFunction;
+};
+type AcceptableResponse = IncomingMessageWithTimings | ResponseLike;
+type AcceptableRequestResult = Promisable<AcceptableResponse | ClientRequest> | undefined;
+export type RequestFunction = (url: URL, options: NativeRequestOptions, callback?: (response: AcceptableResponse) => void) => AcceptableRequestResult;
+export type Agents = {
+    http?: HttpAgent | false;
+    https?: HttpsAgent | false;
+    http2?: unknown | false;
+};
+export type Headers = Record<string, string | string[] | undefined>;
+export type ToughCookieJar = {
+    getCookieString: ((currentUrl: string, options: Record<string, unknown>, cb: (error: Error | null, cookies: string) => void) => void) & ((url: string, callback: (error: Error | null, cookieHeader: string) => void) => void);
+    setCookie: ((cookieOrString: unknown, currentUrl: string, options: Record<string, unknown>, cb: (error: Error | null, cookie: unknown) => void) => void) & ((rawCookie: string, url: string, callback: (error: Error | null, result: unknown) => void) => void);
+};
+export type PromiseCookieJar = {
+    getCookieString: (url: string) => Promise<string>;
+    setCookie: (rawCookie: string, url: string) => Promise<unknown>;
+};
+export type InitHook = (init: OptionsInit, self: Options) => void;
+export type BeforeRequestHook = (options: Options) => Promisable<void | Response | ResponseLike>;
+export type BeforeRedirectHook = (updatedOptions: Options, plainResponse: PlainResponse) => Promisable<void>;
+export type BeforeErrorHook = (error: RequestError) => Promisable<RequestError>;
+export type BeforeRetryHook = (error: RequestError, retryCount: number) => Promisable<void>;
+export type AfterResponseHook<ResponseType = unknown> = (response: Response<ResponseType>, retryWithMergedOptions: (options: OptionsInit) => never) => Promisable<Response | CancelableRequest<Response>>;
+/**
+All available hooks of Got.
+*/
+export type Hooks = {
+    /**
+    Called with the plain request options, right before their normalization.
+
+    The second argument represents the current `Options` instance.
+
+    @default []
+
+    **Note:**
+    > - This hook must be synchronous.
+
+    **Note:**
+    > - This is called every time options are merged.
+
+    **Note:**
+    > - The `options` object may not have the `url` property. To modify it, use a `beforeRequest` hook instead.
+
+    **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:**
+    > - 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.
+
+    For example, this can be used to fix typos to migrate from older versions faster.
+
+    @example
+    ```
+    import got from 'got';
+
+    const instance = got.extend({
+        hooks: {
+            init: [
+                plain => {
+                    if ('followRedirects' in plain) {
+                        plain.followRedirect = plain.followRedirects;
+                        delete plain.followRedirects;
+                    }
+                }
+            ]
+        }
+    });
+
+    // Normally, the following would throw:
+    const response = await instance(
+        'https://example.com',
+        {
+            followRedirects: true
+        }
+    );
+
+    // There is no option named `followRedirects`, but we correct it in an `init` hook.
+    ```
+
+    Or you can create your own option and store it in a context:
+
+    ```
+    import got from 'got';
+
+    const instance = got.extend({
+        hooks: {
+            init: [
+                (plain, options) => {
+                    if ('secret' in plain) {
+                        options.context.secret = plain.secret;
+                        delete plain.secret;
+                    }
+                }
+            ],
+            beforeRequest: [
+                options => {
+                    options.headers.secret = options.context.secret;
+                }
+            ]
+        }
+    });
+
+    const {headers} = await instance(
+        'https://httpbin.org/anything',
+        {
+            secret: 'passphrase'
+        }
+    ).json();
+
+    console.log(headers.Secret);
+    //=> 'passphrase'
+    ```
+    */
+    init: InitHook[];
+    /**
+    Called right before making the request with `options.createNativeRequestOptions()`.
+
+    This hook is especially useful in conjunction with `got.extend()` when you want to sign your request.
+
+    @default []
+
+    **Note:**
+    > - Got will make no further changes to the request before it is sent.
+
+    **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
+    ```
+    import got from 'got';
+
+    const response = await got.post(
+        'https://httpbin.org/anything',
+        {
+            json: {payload: 'old'},
+            hooks: {
+                beforeRequest: [
+                    options => {
+                        options.body = JSON.stringify({payload: 'new'});
+                        options.headers['content-length'] = options.body.length.toString();
+                    }
+                ]
+            }
+        }
+    );
+    ```
+
+    **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).
+    */
+    beforeRequest: BeforeRequestHook[];
+    /**
+    The equivalent of `beforeRequest` but when redirecting.
+
+    @default []
+
+    **Tip:**
+    > - This is especially useful when you want to avoid dead sites.
+
+    @example
+    ```
+    import got from 'got';
+
+    const response = await got('https://example.com', {
+        hooks: {
+            beforeRedirect: [
+                (options, response) => {
+                    if (options.hostname === 'deadSite') {
+                        options.hostname = 'fallbackSite';
+                    }
+                }
+            ]
+        }
+    });
+    ```
+    */
+    beforeRedirect: BeforeRedirectHook[];
+    /**
+    Called with a `RequestError` instance. The error is passed to the hook right before it's thrown.
+
+    This is especially useful when you want to have more detailed errors.
+
+    @default []
+
+    ```
+    import got from 'got';
+
+    await got('https://api.github.com/repos/sindresorhus/got/commits', {
+        responseType: 'json',
+        hooks: {
+            beforeError: [
+                error => {
+                    const {response} = error;
+                    if (response && response.body) {
+                        error.name = 'GitHubError';
+                        error.message = `${response.body.message} (${response.statusCode})`;
+                    }
+
+                    return error;
+                }
+            ]
+        }
+    });
+    ```
+    */
+    beforeError: BeforeErrorHook[];
+    /**
+    The equivalent of `beforeError` but when retrying. Additionally, there is a second argument `retryCount`, the current retry number.
+
+    @default []
+
+    **Note:**
+    > - When using the Stream API, this hook is ignored.
+
+    **Note:**
+    > - When retrying, the `beforeRequest` hook is called afterwards.
+
+    **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.
+
+    @example
+    ```
+    import got from 'got';
+
+    await got('https://httpbin.org/status/500', {
+        hooks: {
+            beforeRetry: [
+                (error, retryCount) => {
+                    console.log(`Retrying [${retryCount}]: ${error.code}`);
+                    // Retrying [1]: ERR_NON_2XX_3XX_RESPONSE
+                }
+            ]
+        }
+    });
+    ```
+    */
+    beforeRetry: BeforeRetryHook[];
+    /**
+    Each function should return the response. This is especially useful when you want to refresh an access token.
+
+    @default []
+
+    **Note:**
+    > - When using the Stream API, this hook is ignored.
+
+    **Note:**
+    > - Calling the `retryWithMergedOptions` function will trigger `beforeRetry` hooks. If the retry is successful, all remaining `afterResponse` hooks will be called. 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.
+
+    @example
+    ```
+    import got from 'got';
+
+    const instance = got.extend({
+        hooks: {
+            afterResponse: [
+                (response, retryWithMergedOptions) => {
+                    // Unauthorized
+                    if (response.statusCode === 401) {
+                        // Refresh the access token
+                        const updatedOptions = {
+                            headers: {
+                                token: getNewToken()
+                            }
+                        };
+
+                        // Update the defaults
+                        instance.defaults.options.merge(updatedOptions);
+
+                        // Make a new retry
+                        return retryWithMergedOptions(updatedOptions);
+                    }
+
+                    // No changes otherwise
+                    return response;
+                }
+            ],
+            beforeRetry: [
+                error => {
+                    // This will be called on `retryWithMergedOptions(...)`
+                }
+            ]
+        },
+        mutableDefaults: true
+    });
+    ```
+    */
+    afterResponse: AfterResponseHook[];
+};
+export type ParseJsonFunction = (text: string) => unknown;
+export type StringifyJsonFunction = (object: unknown) => string;
+/**
+All available HTTP request methods provided by Got.
+*/
+export type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'HEAD' | 'DELETE' | 'OPTIONS' | 'TRACE' | 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options' | 'trace';
+export type RetryObject = {
+    attemptCount: number;
+    retryOptions: RetryOptions;
+    error: RequestError;
+    computedValue: number;
+    retryAfter?: number;
+};
+export type RetryFunction = (retryObject: RetryObject) => Promisable<number>;
+/**
+An object representing `limit`, `calculateDelay`, `methods`, `statusCodes`, `maxRetryAfter` and `errorCodes` fields for maximum retry count, retry handler, allowed methods, allowed status codes, maximum [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) time and allowed error codes.
+
+Delays between retries counts with function `1000 * Math.pow(2, retry) + Math.random() * 100`, where `retry` is attempt number (starts from 1).
+
+The `calculateDelay` property is a `function` that receives an object with `attemptCount`, `retryOptions`, `error` and `computedValue` properties for current retry count, the retry options, error and default computed value.
+The function must return a delay in milliseconds (or a Promise resolving with it) (`0` return value cancels retry).
+
+By default, it retries *only* on the specified methods, status codes, and on these network errors:
+- `ETIMEDOUT`: One of the [timeout](#timeout) limits were reached.
+- `ECONNRESET`: Connection was forcibly closed by a peer.
+- `EADDRINUSE`: Could not bind to any free port.
+- `ECONNREFUSED`: Connection was refused by the server.
+- `EPIPE`: The remote side of the stream being written has been closed.
+- `ENOTFOUND`: Couldn't resolve the hostname to an IP address.
+- `ENETUNREACH`: No internet connection.
+- `EAI_AGAIN`: DNS lookup timed out.
+
+__Note:__ Got does not retry on `POST` by default.
+__Note:__ If `maxRetryAfter` is set to `undefined`, it will use `options.timeout`.
+__Note:__ If [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) header is greater than `maxRetryAfter`, it will cancel the request.
+*/
+export type RetryOptions = {
+    limit: number;
+    methods: Method[];
+    statusCodes: number[];
+    errorCodes: string[];
+    calculateDelay: RetryFunction;
+    backoffLimit: number;
+    noise: number;
+    maxRetryAfter?: number;
+};
+export type CreateConnectionFunction = (options: NativeRequestOptions, oncreate: (error: NodeJS.ErrnoException, socket: Socket) => void) => Socket;
+export type CheckServerIdentityFunction = (hostname: string, certificate: DetailedPeerCertificate) => NodeJS.ErrnoException | void;
+export type CacheOptions = {
+    shared?: boolean;
+    cacheHeuristic?: number;
+    immutableMinTimeToLive?: number;
+    ignoreCargoCult?: boolean;
+};
+type PfxObject = {
+    buffer: string | Buffer;
+    passphrase?: string | undefined;
+};
+type PfxType = string | Buffer | Array<string | Buffer | PfxObject> | undefined;
+export type HttpsOptions = {
+    alpnProtocols?: string[];
+    rejectUnauthorized?: NativeRequestOptions['rejectUnauthorized'];
+    checkServerIdentity?: CheckServerIdentityFunction;
+    /**
+    Override the default Certificate Authorities ([from Mozilla](https://ccadb-public.secure.force.com/mozilla/IncludedCACertificateReport)).
+
+    @example
+    ```
+    // Single Certificate Authority
+    await got('https://example.com', {
+        https: {
+            certificateAuthority: fs.readFileSync('./my_ca.pem')
+        }
+    });
+    ```
+    */
+    certificateAuthority?: SecureContextOptions['ca'];
+    /**
+    Private keys in [PEM](https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail) format.
+
+    [PEM](https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail) allows the option of private keys being encrypted.
+    Encrypted keys will be decrypted with `options.https.passphrase`.
+
+    Multiple keys with different passphrases can be provided as an array of `{pem: <string | Buffer>, passphrase: <string>}`
+    */
+    key?: SecureContextOptions['key'];
+    /**
+    [Certificate chains](https://en.wikipedia.org/wiki/X.509#Certificate_chains_and_cross-certification) in [PEM](https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail) format.
+
+    One cert chain should be provided per private key (`options.https.key`).
+
+    When providing multiple cert chains, they do not have to be in the same order as their private keys in `options.https.key`.
+
+    If the intermediate certificates are not provided, the peer will not be able to validate the certificate, and the handshake will fail.
+    */
+    certificate?: SecureContextOptions['cert'];
+    /**
+    The passphrase to decrypt the `options.https.key` (if different keys have different passphrases refer to `options.https.key` documentation).
+    */
+    passphrase?: SecureContextOptions['passphrase'];
+    pfx?: PfxType;
+    ciphers?: SecureContextOptions['ciphers'];
+    honorCipherOrder?: SecureContextOptions['honorCipherOrder'];
+    minVersion?: SecureContextOptions['minVersion'];
+    maxVersion?: SecureContextOptions['maxVersion'];
+    signatureAlgorithms?: SecureContextOptions['sigalgs'];
+    tlsSessionLifetime?: SecureContextOptions['sessionTimeout'];
+    dhparam?: SecureContextOptions['dhparam'];
+    ecdhCurve?: SecureContextOptions['ecdhCurve'];
+    certificateRevocationLists?: SecureContextOptions['crl'];
+};
+export type PaginateData<BodyType, ElementType> = {
+    response: Response<BodyType>;
+    currentItems: ElementType[];
+    allItems: ElementType[];
+};
+export type FilterData<ElementType> = {
+    item: ElementType;
+    currentItems: ElementType[];
+    allItems: ElementType[];
+};
+/**
+All options accepted by `got.paginate()`.
+*/
+export type PaginationOptions<ElementType, BodyType> = {
+    /**
+    A function that transform [`Response`](#response) into an array of items.
+    This is where you should do the parsing.
+
+    @default response => JSON.parse(response.body)
+    */
+    transform?: (response: Response<BodyType>) => Promise<ElementType[]> | ElementType[];
+    /**
+    Checks whether the item should be emitted or not.
+
+    @default ({item, currentItems, allItems}) => true
+    */
+    filter?: (data: FilterData<ElementType>) => boolean;
+    /**
+    The function takes an object with the following properties:
+    - `response` - The current response object.
+    - `currentItems` - Items from the current response.
+    - `allItems` - An empty array, unless `pagination.stackAllItems` is set to `true`, in which case, it's an array of the emitted items.
+
+    It should return an object representing Got options pointing to the next page. The options are merged automatically with the previous request, therefore the options returned `pagination.paginate(...)` must reflect changes only. If there are no more pages, `false` should be returned.
+
+    @example
+    ```
+    import got from 'got';
+
+    const limit = 10;
+
+    const items = got.paginate('https://example.com/items', {
+        searchParams: {
+            limit,
+            offset: 0
+        },
+        pagination: {
+            paginate: ({response, currentItems}) => {
+                const previousSearchParams = response.request.options.searchParams;
+                const previousOffset = previousSearchParams.get('offset');
+
+                if (currentItems.length < limit) {
+                    return false;
+                }
+
+                return {
+                    searchParams: {
+                        ...previousSearchParams,
+                        offset: Number(previousOffset) + limit,
+                    }
+                };
+            }
+        }
+    });
+
+    console.log('Items from all pages:', items);
+    ```
+    */
+    paginate?: (data: PaginateData<BodyType, ElementType>) => OptionsInit | false;
+    /**
+    Checks whether the pagination should continue.
+
+    For example, if you need to stop **before** emitting an entry with some flag, you should use `({item}) => !item.flag`.
+
+    If you want to stop **after** emitting the entry, you should use
+    `({item, allItems}) => allItems.some(item => item.flag)` instead.
+
+    @default ({item, currentItems, allItems}) => true
+    */
+    shouldContinue?: (data: FilterData<ElementType>) => boolean;
+    /**
+    The maximum amount of items that should be emitted.
+
+    @default Infinity
+    */
+    countLimit?: number;
+    /**
+    Milliseconds to wait before the next request is triggered.
+
+    @default 0
+    */
+    backoff?: number;
+    /**
+    The maximum amount of request that should be triggered.
+    Retries on failure are not counted towards this limit.
+
+    For example, it can be helpful during development to avoid an infinite number of requests.
+
+    @default 10000
+    */
+    requestLimit?: number;
+    /**
+    Defines how the property `allItems` in `pagination.paginate`, `pagination.filter` and `pagination.shouldContinue` is managed.
+
+    By default, the property `allItems` is always an empty array. This setting can be helpful to save on memory usage when working with a large dataset.
+
+    When set to `true`, the property `allItems` is an array of the emitted items.
+
+    @default false
+    */
+    stackAllItems?: boolean;
+};
+export type SearchParameters = Record<string, string | number | boolean | null | undefined>;
+/**
+All parsing methods supported by Got.
+*/
+export type ResponseType = 'json' | 'buffer' | 'text';
+type OptionsToSkip = 'searchParameters' | 'followRedirects' | 'auth' | 'toJSON' | 'merge' | 'createNativeRequestOptions' | 'getRequestFunction' | 'getFallbackRequestFunction' | 'freeze';
+export type InternalsType = Except<Options, OptionsToSkip>;
+export type OptionsError = NodeJS.ErrnoException & {
+    options?: Options;
+};
+export type OptionsInit = Except<Partial<InternalsType>, 'hooks' | 'retry'> & {
+    hooks?: Partial<Hooks>;
+    retry?: Partial<RetryOptions>;
+};
+export default class Options {
+    private _unixOptions?;
+    private _internals;
+    private _merging;
+    private readonly _init;
+    constructor(input?: string | URL | OptionsInit, options?: OptionsInit, defaults?: Options);
+    merge(options?: OptionsInit | Options): void;
+    /**
+    Custom request function.
+    The main purpose of this is to [support HTTP2 using a wrapper](https://github.com/szmarczak/http2-wrapper).
+
+    @default http.request | https.request
+    */
+    get request(): RequestFunction | undefined;
+    set request(value: RequestFunction | undefined);
+    /**
+    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 a key is not present, it will default to a global agent.
+
+    @example
+    ```
+    import got from 'got';
+    import HttpAgent from 'agentkeepalive';
+
+    const {HttpsAgent} = HttpAgent;
+
+    await got('https://sindresorhus.com', {
+        agent: {
+            http: new HttpAgent(),
+            https: new HttpsAgent()
+        }
+    });
+    ```
+    */
+    get agent(): Agents;
+    set agent(value: Agents);
+    get h2session(): ClientHttp2Session | undefined;
+    set h2session(value: ClientHttp2Session | undefined);
+    /**
+    Decompress the response automatically.
+
+    This will set the `accept-encoding` header to `gzip, deflate, br` unless you set it yourself.
+
+    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.
+
+    @default true
+    */
+    get decompress(): boolean;
+    set decompress(value: boolean);
+    /**
+    Milliseconds to wait for the server to end the response before aborting the request with `got.TimeoutError` error (a.k.a. `request` property).
+    By default, there's no timeout.
+
+    This also accepts an `object` with the following fields to constrain the duration of each phase of the request lifecycle:
+
+    - `lookup` starts when a socket is assigned and ends when the hostname has been resolved.
+        Does not apply when using a Unix domain socket.
+    - `connect` starts when `lookup` completes (or when the socket is assigned if lookup does not apply to the request) and ends when the socket is connected.
+    - `secureConnect` starts when `connect` completes and ends when the handshaking process completes (HTTPS only).
+    - `socket` starts when the socket is connected. See [request.setTimeout](https://nodejs.org/api/http.html#http_request_settimeout_timeout_callback).
+    - `response` starts when the request has been written to the socket and ends when the response headers are received.
+    - `send` starts when the socket is connected and ends with the request has been written to the socket.
+    - `request` starts when the request is initiated and ends when the response's end event fires.
+    */
+    get timeout(): Delays;
+    set timeout(value: Delays);
+    /**
+    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()` 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.
+
+    @example
+    ```
+    import got from 'got';
+
+    await got('unicorn', {prefixUrl: 'https://cats.com'});
+    //=> 'https://cats.com/unicorn'
+
+    const instance = got.extend({
+        prefixUrl: 'https://google.com'
+    });
+
+    await instance('unicorn', {
+        hooks: {
+            beforeRequest: [
+                options => {
+                    options.prefixUrl = 'https://cats.com';
+                }
+            ]
+        }
+    });
+    //=> 'https://cats.com/unicorn'
+    ```
+    */
+    get prefixUrl(): string | URL;
+    set prefixUrl(value: string | URL);
+    /**
+    __Note #1__: The `body` option cannot be used with the `json` or `form` option.
+
+    __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` 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` / [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) / [`form-data` instance](https://github.com/form-data/form-data), and `content-length` and `transfer-encoding` are not manually set in `options.headers`.
+
+    Since Got 12, the `content-length` is not automatically set when `body` is a `fs.createReadStream`.
+    */
+    get body(): string | Buffer | Readable | Generator | AsyncGenerator | FormDataLike | undefined;
+    set body(value: string | Buffer | Readable | Generator | AsyncGenerator | FormDataLike | undefined);
+    /**
+    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 the `Content-Type` header is not present, it will be set to `application/x-www-form-urlencoded`.
+
+    __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.
+    */
+    get form(): Record<string, any> | undefined;
+    set form(value: Record<string, any> | undefined);
+    /**
+    JSON body. If the `Content-Type` header is not set, it will be set to `application/json`.
+
+    __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.
+    */
+    get json(): unknown;
+    set json(value: unknown);
+    /**
+    The URL to request, as a string, a [`https.request` options object](https://nodejs.org/api/https.html#https_https_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`.
+
+    If no protocol is specified, it will throw a `TypeError`.
+
+    __Note__: The query string is **not** parsed as search params.
+
+    @example
+    ```
+    await got('https://example.com/?query=a b'); //=> https://example.com/?query=a%20b
+    await got('https://example.com/', {searchParams: {query: 'a b'}}); //=> https://example.com/?query=a+b
+
+    // The query string is overridden by `searchParams`
+    await got('https://example.com/?query=a b', {searchParams: {query: 'a b'}}); //=> https://example.com/?query=a+b
+    ```
+    */
+    get url(): string | URL | undefined;
+    set url(value: string | URL | undefined);
+    /**
+    Cookie support. You don't have to care about parsing or how to store them.
+
+    __Note__: If you provide this option, `options.headers.cookie` will be overridden.
+    */
+    get cookieJar(): PromiseCookieJar | ToughCookieJar | undefined;
+    set cookieJar(value: PromiseCookieJar | ToughCookieJar | undefined);
+    /**
+    You can abort the `request` using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
+
+    *Requires Node.js 16 or later.*
+
+    @example
+    ```
+    import got from 'got';
+
+    const abortController = new AbortController();
+
+    const request = got('https://httpbin.org/anything', {
+        signal: abortController.signal
+    });
+
+    setTimeout(() => {
+        abortController.abort();
+    }, 100);
+    ```
+    */
+    get signal(): any | undefined;
+    set signal(value: any | undefined);
+    /**
+    Ignore invalid cookies instead of throwing an error.
+    Only useful when the `cookieJar` option has been set. Not recommended.
+
+    @default false
+    */
+    get ignoreInvalidCookies(): boolean;
+    set ignoreInvalidCookies(value: boolean);
+    /**
+    Query string that will be added to the request URL.
+    This will override the query string in `url`.
+
+    If you need to pass in an array, you can do it using a `URLSearchParams` instance.
+
+    @example
+    ```
+    import got from 'got';
+
+    const searchParams = new URLSearchParams([['key', 'a'], ['key', 'b']]);
+
+    await got('https://example.com', {searchParams});
+
+    console.log(searchParams.toString());
+    //=> 'key=a&key=b'
+    ```
+    */
+    get searchParams(): string | SearchParameters | URLSearchParams | undefined;
+    set searchParams(value: string | SearchParameters | URLSearchParams | undefined);
+    get searchParameters(): unknown;
+    set searchParameters(_value: unknown);
+    get dnsLookup(): CacheableLookup['lookup'] | undefined;
+    set dnsLookup(value: CacheableLookup['lookup'] | undefined);
+    /**
+    An instance of [`CacheableLookup`](https://github.com/szmarczak/cacheable-lookup) used for making DNS lookups.
+    Useful when making lots of requests to different *public* hostnames.
+
+    `CacheableLookup` uses `dns.resolver4(..)` and `dns.resolver6(...)` under the hood and fall backs to `dns.lookup(...)` when the first two fail, which may lead to additional delay.
+
+    __Note__: This should stay disabled when making requests to internal hostnames such as `localhost`, `database.local` etc.
+
+    @default false
+    */
+    get dnsCache(): CacheableLookup | boolean | undefined;
+    set dnsCache(value: CacheableLookup | boolean | undefined);
+    /**
+    User data. `context` is shallow merged and enumerable. If it contains non-enumerable properties they will NOT be merged.
+
+    @example
+    ```
+    import got from 'got';
+
+    const instance = got.extend({
+        hooks: {
+            beforeRequest: [
+                options => {
+                    if (!options.context || !options.context.token) {
+                        throw new Error('Token required');
+                    }
+
+                    options.headers.token = options.context.token;
+                }
+            ]
+        }
+    });
+
+    const context = {
+        token: 'secret'
+    };
+
+    const response = await instance('https://httpbin.org/headers', {context});
+
+    // Let's see the headers
+    console.log(response.body);
+    ```
+    */
+    get context(): Record<string, unknown>;
+    set context(value: Record<string, unknown>);
+    /**
+    Hooks allow modifications during the request lifecycle.
+    Hook functions may be async and are run serially.
+    */
+    get hooks(): Hooks;
+    set hooks(value: Hooks);
+    /**
+    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). You can optionally turn on this behavior also for other redirect codes - see `methodRewriting`.
+
+    @default true
+    */
+    get followRedirect(): boolean;
+    set followRedirect(value: boolean);
+    get followRedirects(): unknown;
+    set followRedirects(_value: unknown);
+    /**
+    If exceeded, the request will be aborted and a `MaxRedirectsError` will be thrown.
+
+    @default 10
+    */
+    get maxRedirects(): number;
+    set maxRedirects(value: number);
+    /**
+    A cache adapter instance for storing cached response data.
+
+    @default false
+    */
+    get cache(): string | StorageAdapter | boolean | undefined;
+    set cache(value: string | StorageAdapter | boolean | undefined);
+    /**
+    Determines if a `got.HTTPError` is thrown for unsuccessful responses.
+
+    If this is disabled, requests that encounter an error status code will be resolved with the `response` instead of throwing.
+    This may be useful if you are checking for resource availability and are expecting error responses.
+
+    @default true
+    */
+    get throwHttpErrors(): boolean;
+    set throwHttpErrors(value: boolean);
+    get username(): string;
+    set username(value: string);
+    get password(): string;
+    set password(value: string);
+    /**
+    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.
+
+    __Note__: This option requires Node.js 15.10.0 or newer as HTTP/2 support on older Node.js versions is very buggy.
+
+    __Note__: Overriding `options.request` will disable HTTP2 support.
+
+    @default false
+
+    @example
+    ```
+    import got from 'got';
+
+    const {headers} = await got('https://nghttp2.org/httpbin/anything', {http2: true});
+
+    console.log(headers.via);
+    //=> '2 nghttpx'
+    ```
+    */
+    get http2(): boolean;
+    set http2(value: boolean);
+    /**
+    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.
+
+    __Note__: The [RFC 7231](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)__.
+
+    @default false
+    */
+    get allowGetBody(): boolean;
+    set allowGetBody(value: boolean);
+    /**
+    Request headers.
+
+    Existing headers will be overwritten. Headers set to `undefined` will be omitted.
+
+    @default {}
+    */
+    get headers(): Headers;
+    set headers(value: Headers);
+    /**
+    Specifies if the HTTP request method should be [rewritten as `GET`](https://tools.ietf.org/html/rfc7231#section-6.4) on redirects.
+
+    As the [specification](https://tools.ietf.org/html/rfc7231#section-6.4) prefers to rewrite the HTTP method only on `303` responses, this is Got's default behavior.
+    Setting `methodRewriting` to `true` will also rewrite `301` and `302` responses, as allowed by the spec. This is the behavior followed by `curl` and browsers.
+
+    __Note__: Got never performs method rewriting on `307` and `308` responses, as this is [explicitly prohibited by the specification](https://www.rfc-editor.org/rfc/rfc7231#section-6.4.7).
+
+    @default false
+    */
+    get methodRewriting(): boolean;
+    set methodRewriting(value: boolean);
+    /**
+    Indicates which DNS record family to use.
+
+    Values:
+    - `undefined`: IPv4 (if present) or IPv6
+    - `4`: Only IPv4
+    - `6`: Only IPv6
+
+    @default undefined
+    */
+    get dnsLookupIpVersion(): DnsLookupIpVersion;
+    set dnsLookupIpVersion(value: DnsLookupIpVersion);
+    /**
+    A function used to parse JSON responses.
+
+    @example
+    ```
+    import got from 'got';
+    import Bourne from '@hapi/bourne';
+
+    const parsed = await got('https://example.com', {
+        parseJson: text => Bourne.parse(text)
+    }).json();
+
+    console.log(parsed);
+    ```
+    */
+    get parseJson(): ParseJsonFunction;
+    set parseJson(value: ParseJsonFunction);
+    /**
+    A function used to stringify the body of JSON requests.
+
+    @example
+    ```
+    import got from 'got';
+
+    await got.post('https://example.com', {
+        stringifyJson: object => JSON.stringify(object, (key, value) => {
+            if (key.startsWith('_')) {
+                return;
+            }
+
+            return value;
+        }),
+        json: {
+            some: 'payload',
+            _ignoreMe: 1234
+        }
+    });
+    ```
+
+    @example
+    ```
+    import got from 'got';
+
+    await got.post('https://example.com', {
+        stringifyJson: object => JSON.stringify(object, (key, value) => {
+            if (typeof value === 'number') {
+                return value.toString();
+            }
+
+            return value;
+        }),
+        json: {
+            some: 'payload',
+            number: 1
+        }
+    });
+    ```
+    */
+    get stringifyJson(): StringifyJsonFunction;
+    set stringifyJson(value: StringifyJsonFunction);
+    /**
+    An object representing `limit`, `calculateDelay`, `methods`, `statusCodes`, `maxRetryAfter` and `errorCodes` fields for maximum retry count, retry handler, allowed methods, allowed status codes, maximum [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) time and allowed error codes.
+
+    Delays between retries counts with function `1000 * Math.pow(2, retry) + Math.random() * 100`, where `retry` is attempt number (starts from 1).
+
+    The `calculateDelay` property is a `function` that receives an object with `attemptCount`, `retryOptions`, `error` and `computedValue` properties for current retry count, the retry options, error and default computed value.
+    The function must return a delay in milliseconds (or a Promise resolving with it) (`0` return value cancels retry).
+
+    By default, it retries *only* on the specified methods, status codes, and on these network errors:
+
+    - `ETIMEDOUT`: One of the [timeout](#timeout) limits were reached.
+    - `ECONNRESET`: Connection was forcibly closed by a peer.
+    - `EADDRINUSE`: Could not bind to any free port.
+    - `ECONNREFUSED`: Connection was refused by the server.
+    - `EPIPE`: The remote side of the stream being written has been closed.
+    - `ENOTFOUND`: Couldn't resolve the hostname to an IP address.
+    - `ENETUNREACH`: No internet connection.
+    - `EAI_AGAIN`: DNS lookup timed out.
+
+    __Note__: If `maxRetryAfter` is set to `undefined`, it will use `options.timeout`.
+    __Note__: If [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) header is greater than `maxRetryAfter`, it will cancel the request.
+    */
+    get retry(): Partial<RetryOptions>;
+    set retry(value: Partial<RetryOptions>);
+    /**
+    From `http.RequestOptions`.
+
+    The IP address used to send the request from.
+    */
+    get localAddress(): string | undefined;
+    set localAddress(value: string | undefined);
+    /**
+    The HTTP method used to make the request.
+
+    @default 'GET'
+    */
+    get method(): Method;
+    set method(value: Method);
+    get createConnection(): CreateConnectionFunction | undefined;
+    set createConnection(value: CreateConnectionFunction | undefined);
+    /**
+    From `http-cache-semantics`
+
+    @default {}
+    */
+    get cacheOptions(): CacheOptions;
+    set cacheOptions(value: CacheOptions);
+    /**
+    Options for the advanced HTTPS API.
+    */
+    get https(): HttpsOptions;
+    set https(value: HttpsOptions);
+    /**
+    [Encoding](https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings) to be used on `setEncoding` of the response data.
+
+    To get a [`Buffer`](https://nodejs.org/api/buffer.html), you need to set `responseType` to `buffer` instead.
+    Don't set this option to `null`.
+
+    __Note__: This doesn't affect streams! Instead, you need to do `got.stream(...).setEncoding(encoding)`.
+
+    @default 'utf-8'
+    */
+    get encoding(): BufferEncoding | undefined;
+    set encoding(value: BufferEncoding | undefined);
+    /**
+    When set to `true` the promise will return the Response body instead of the Response object.
+
+    @default false
+    */
+    get resolveBodyOnly(): boolean;
+    set resolveBodyOnly(value: boolean);
+    /**
+    Returns a `Stream` instead of a `Promise`.
+    This is equivalent to calling `got.stream(url, options?)`.
+
+    @default false
+    */
+    get isStream(): boolean;
+    set isStream(value: boolean);
+    /**
+    The parsing method.
+
+    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.
+
+    __Note__: When using streams, this option is ignored.
+
+    @example
+    ```
+    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
+    ```
+
+    @example
+    ```
+    // This
+    const body = await got(url).json();
+
+    // is semantically the same as this
+    const body = await got(url, {responseType: 'json', resolveBodyOnly: true});
+    ```
+    */
+    get responseType(): ResponseType;
+    set responseType(value: ResponseType);
+    get pagination(): PaginationOptions<unknown, unknown>;
+    set pagination(value: PaginationOptions<unknown, unknown>);
+    get auth(): unknown;
+    set auth(_value: unknown);
+    get setHost(): boolean;
+    set setHost(value: boolean);
+    get maxHeaderSize(): number | undefined;
+    set maxHeaderSize(value: number | undefined);
+    get enableUnixSockets(): boolean;
+    set enableUnixSockets(value: boolean);
+    toJSON(): {
+        headers: Headers;
+        timeout: Delays;
+        request: RequestFunction | undefined;
+        username: string;
+        password: string;
+        json: unknown;
+        retry: Partial<RetryOptions>;
+        agent: Agents;
+        h2session: http2wrapper.ClientHttp2Session | undefined;
+        decompress: boolean;
+        prefixUrl: string | URL;
+        body: string | Readable | Buffer | Generator<unknown, any, unknown> | AsyncGenerator<unknown, any, unknown> | FormDataLike | undefined;
+        form: Record<string, any> | undefined;
+        url: string | URL | undefined;
+        cookieJar: PromiseCookieJar | ToughCookieJar | undefined;
+        signal: any;
+        ignoreInvalidCookies: boolean;
+        searchParams: string | SearchParameters | URLSearchParams | undefined;
+        dnsLookup: {
+            (hostname: string, family: import("cacheable-lookup").IPFamily, callback: (error: NodeJS.ErrnoException | null, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
+            (hostname: string, callback: (error: NodeJS.ErrnoException | null, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
+            (hostname: string, options: import("cacheable-lookup").LookupOptions & {
+                all: true;
+            }, callback: (error: NodeJS.ErrnoException | null, result: readonly import("cacheable-lookup").EntryObject[]) => void): void;
+            (hostname: string, options: import("cacheable-lookup").LookupOptions, callback: (error: NodeJS.ErrnoException | null, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
+        } | undefined;
+        dnsCache: boolean | CacheableLookup | undefined;
+        context: Record<string, unknown>;
+        hooks: Hooks;
+        followRedirect: boolean;
+        maxRedirects: number;
+        cache: string | boolean | StorageAdapter | undefined;
+        throwHttpErrors: boolean;
+        http2: boolean;
+        allowGetBody: boolean;
+        methodRewriting: boolean;
+        dnsLookupIpVersion: DnsLookupIpVersion;
+        parseJson: ParseJsonFunction;
+        stringifyJson: StringifyJsonFunction;
+        localAddress: string | undefined;
+        method: Method;
+        createConnection: CreateConnectionFunction | undefined;
+        cacheOptions: CacheOptions;
+        https: HttpsOptions;
+        encoding: BufferEncoding | undefined;
+        resolveBodyOnly: boolean;
+        isStream: boolean;
+        responseType: ResponseType;
+        pagination: PaginationOptions<unknown, unknown>;
+        setHost: boolean;
+        maxHeaderSize: number | undefined;
+        enableUnixSockets: boolean;
+    };
+    createNativeRequestOptions(): {
+        ALPNProtocols: string[] | undefined;
+        ca: string | Buffer | (string | Buffer)[] | undefined;
+        cert: string | Buffer | (string | Buffer)[] | undefined;
+        key: string | Buffer | (string | Buffer | import("tls").KeyObject)[] | undefined;
+        passphrase: string | undefined;
+        pfx: PfxType;
+        rejectUnauthorized: boolean | undefined;
+        checkServerIdentity: typeof checkServerIdentity | CheckServerIdentityFunction;
+        ciphers: string | undefined;
+        honorCipherOrder: boolean | undefined;
+        minVersion: import("tls").SecureVersion | undefined;
+        maxVersion: import("tls").SecureVersion | undefined;
+        sigalgs: string | undefined;
+        sessionTimeout: number | undefined;
+        dhparam: string | Buffer | undefined;
+        ecdhCurve: string | undefined;
+        crl: string | Buffer | (string | Buffer)[] | undefined;
+        lookup: {
+            (hostname: string, family: import("cacheable-lookup").IPFamily, callback: (error: NodeJS.ErrnoException | null, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
+            (hostname: string, callback: (error: NodeJS.ErrnoException | null, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
+            (hostname: string, options: import("cacheable-lookup").LookupOptions & {
+                all: true;
+            }, callback: (error: NodeJS.ErrnoException | null, result: readonly import("cacheable-lookup").EntryObject[]) => void): void;
+            (hostname: string, options: import("cacheable-lookup").LookupOptions, callback: (error: NodeJS.ErrnoException | null, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
+        } | undefined;
+        family: DnsLookupIpVersion;
+        agent: false | Agents | http.Agent | undefined;
+        setHost: boolean;
+        method: Method;
+        maxHeaderSize: number | undefined;
+        localAddress: string | undefined;
+        headers: Headers;
+        createConnection: CreateConnectionFunction | undefined;
+        timeout: number | undefined;
+        h2session: http2wrapper.ClientHttp2Session | undefined;
+        _defaultAgent?: http.Agent | undefined;
+        auth?: string | null | undefined;
+        defaultPort?: string | number | undefined;
+        hints?: number | undefined;
+        host?: string | null | undefined;
+        hostname?: string | null | undefined;
+        insecureHTTPParser?: boolean | undefined;
+        localPort?: number | undefined;
+        path?: string | null | undefined;
+        port?: string | number | null | undefined;
+        protocol?: string | null | undefined;
+        signal?: AbortSignal | undefined;
+        socketPath?: string | undefined;
+        uniqueHeaders?: (string | string[])[] | undefined;
+        clientCertEngine?: string | undefined;
+        privateKeyEngine?: string | undefined;
+        privateKeyIdentifier?: string | undefined;
+        secureOptions?: number | undefined;
+        secureProtocol?: string | undefined;
+        sessionIdContext?: string | undefined;
+        ticketKeys?: Buffer | undefined;
+        servername?: string | undefined;
+        shared?: boolean | undefined;
+        cacheHeuristic?: number | undefined;
+        immutableMinTimeToLive?: number | undefined;
+        ignoreCargoCult?: boolean | undefined;
+    };
+    getRequestFunction(): RequestFunction | typeof https.request | undefined;
+    getFallbackRequestFunction(): RequestFunction | typeof https.request | undefined;
+    freeze(): void;
+}
+export {};
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/options.js b/includes/external/addressbook/node_modules/got/dist/source/core/options.js
new file mode 100644
index 0000000..571c4a0
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/options.js
@@ -0,0 +1,1653 @@
+import process from 'node:process';
+import { promisify, inspect } from 'node:util';
+import { URL, URLSearchParams } from 'node:url';
+import { checkServerIdentity } from 'node:tls';
+// DO NOT use destructuring for `https.request` and `http.request` as it's not compatible with `nock`.
+import http from 'node:http';
+import https from 'node:https';
+import is, { assert } from '@sindresorhus/is';
+import lowercaseKeys from 'lowercase-keys';
+import CacheableLookup from 'cacheable-lookup';
+import http2wrapper from 'http2-wrapper';
+import { isFormData } from 'form-data-encoder';
+import parseLinkHeader from './parse-link-header.js';
+const [major, minor] = process.versions.node.split('.').map(Number);
+function validateSearchParameters(searchParameters) {
+    // eslint-disable-next-line guard-for-in
+    for (const key in searchParameters) {
+        const value = searchParameters[key];
+        assert.any([is.string, is.number, is.boolean, is.null_, is.undefined], value);
+    }
+}
+const globalCache = new Map();
+let globalDnsCache;
+const getGlobalDnsCache = () => {
+    if (globalDnsCache) {
+        return globalDnsCache;
+    }
+    globalDnsCache = new CacheableLookup();
+    return globalDnsCache;
+};
+const defaultInternals = {
+    request: undefined,
+    agent: {
+        http: undefined,
+        https: undefined,
+        http2: undefined,
+    },
+    h2session: undefined,
+    decompress: true,
+    timeout: {
+        connect: undefined,
+        lookup: undefined,
+        read: undefined,
+        request: undefined,
+        response: undefined,
+        secureConnect: undefined,
+        send: undefined,
+        socket: undefined,
+    },
+    prefixUrl: '',
+    body: undefined,
+    form: undefined,
+    json: undefined,
+    cookieJar: undefined,
+    ignoreInvalidCookies: false,
+    searchParams: undefined,
+    dnsLookup: undefined,
+    dnsCache: undefined,
+    context: {},
+    hooks: {
+        init: [],
+        beforeRequest: [],
+        beforeError: [],
+        beforeRedirect: [],
+        beforeRetry: [],
+        afterResponse: [],
+    },
+    followRedirect: true,
+    maxRedirects: 10,
+    cache: undefined,
+    throwHttpErrors: true,
+    username: '',
+    password: '',
+    http2: false,
+    allowGetBody: false,
+    headers: {
+        'user-agent': 'got (https://github.com/sindresorhus/got)',
+    },
+    methodRewriting: false,
+    dnsLookupIpVersion: undefined,
+    parseJson: JSON.parse,
+    stringifyJson: JSON.stringify,
+    retry: {
+        limit: 2,
+        methods: [
+            'GET',
+            'PUT',
+            'HEAD',
+            'DELETE',
+            'OPTIONS',
+            'TRACE',
+        ],
+        statusCodes: [
+            408,
+            413,
+            429,
+            500,
+            502,
+            503,
+            504,
+            521,
+            522,
+            524,
+        ],
+        errorCodes: [
+            'ETIMEDOUT',
+            'ECONNRESET',
+            'EADDRINUSE',
+            'ECONNREFUSED',
+            'EPIPE',
+            'ENOTFOUND',
+            'ENETUNREACH',
+            'EAI_AGAIN',
+        ],
+        maxRetryAfter: undefined,
+        calculateDelay: ({ computedValue }) => computedValue,
+        backoffLimit: Number.POSITIVE_INFINITY,
+        noise: 100,
+    },
+    localAddress: undefined,
+    method: 'GET',
+    createConnection: undefined,
+    cacheOptions: {
+        shared: undefined,
+        cacheHeuristic: undefined,
+        immutableMinTimeToLive: undefined,
+        ignoreCargoCult: undefined,
+    },
+    https: {
+        alpnProtocols: undefined,
+        rejectUnauthorized: undefined,
+        checkServerIdentity: undefined,
+        certificateAuthority: undefined,
+        key: undefined,
+        certificate: undefined,
+        passphrase: undefined,
+        pfx: undefined,
+        ciphers: undefined,
+        honorCipherOrder: undefined,
+        minVersion: undefined,
+        maxVersion: undefined,
+        signatureAlgorithms: undefined,
+        tlsSessionLifetime: undefined,
+        dhparam: undefined,
+        ecdhCurve: undefined,
+        certificateRevocationLists: undefined,
+    },
+    encoding: undefined,
+    resolveBodyOnly: false,
+    isStream: false,
+    responseType: 'text',
+    url: undefined,
+    pagination: {
+        transform(response) {
+            if (response.request.options.responseType === 'json') {
+                return response.body;
+            }
+            return JSON.parse(response.body);
+        },
+        paginate({ response }) {
+            const rawLinkHeader = response.headers.link;
+            if (typeof rawLinkHeader !== 'string' || rawLinkHeader.trim() === '') {
+                return false;
+            }
+            const parsed = parseLinkHeader(rawLinkHeader);
+            const next = parsed.find(entry => entry.parameters.rel === 'next' || entry.parameters.rel === '"next"');
+            if (next) {
+                return {
+                    url: new URL(next.reference, response.url),
+                };
+            }
+            return false;
+        },
+        filter: () => true,
+        shouldContinue: () => true,
+        countLimit: Number.POSITIVE_INFINITY,
+        backoff: 0,
+        requestLimit: 10000,
+        stackAllItems: false,
+    },
+    setHost: true,
+    maxHeaderSize: undefined,
+    signal: undefined,
+    enableUnixSockets: true,
+};
+const cloneInternals = (internals) => {
+    const { hooks, retry } = internals;
+    const result = {
+        ...internals,
+        context: { ...internals.context },
+        cacheOptions: { ...internals.cacheOptions },
+        https: { ...internals.https },
+        agent: { ...internals.agent },
+        headers: { ...internals.headers },
+        retry: {
+            ...retry,
+            errorCodes: [...retry.errorCodes],
+            methods: [...retry.methods],
+            statusCodes: [...retry.statusCodes],
+        },
+        timeout: { ...internals.timeout },
+        hooks: {
+            init: [...hooks.init],
+            beforeRequest: [...hooks.beforeRequest],
+            beforeError: [...hooks.beforeError],
+            beforeRedirect: [...hooks.beforeRedirect],
+            beforeRetry: [...hooks.beforeRetry],
+            afterResponse: [...hooks.afterResponse],
+        },
+        searchParams: internals.searchParams ? new URLSearchParams(internals.searchParams) : undefined,
+        pagination: { ...internals.pagination },
+    };
+    if (result.url !== undefined) {
+        result.prefixUrl = '';
+    }
+    return result;
+};
+const cloneRaw = (raw) => {
+    const { hooks, retry } = raw;
+    const result = { ...raw };
+    if (is.object(raw.context)) {
+        result.context = { ...raw.context };
+    }
+    if (is.object(raw.cacheOptions)) {
+        result.cacheOptions = { ...raw.cacheOptions };
+    }
+    if (is.object(raw.https)) {
+        result.https = { ...raw.https };
+    }
+    if (is.object(raw.cacheOptions)) {
+        result.cacheOptions = { ...result.cacheOptions };
+    }
+    if (is.object(raw.agent)) {
+        result.agent = { ...raw.agent };
+    }
+    if (is.object(raw.headers)) {
+        result.headers = { ...raw.headers };
+    }
+    if (is.object(retry)) {
+        result.retry = { ...retry };
+        if (is.array(retry.errorCodes)) {
+            result.retry.errorCodes = [...retry.errorCodes];
+        }
+        if (is.array(retry.methods)) {
+            result.retry.methods = [...retry.methods];
+        }
+        if (is.array(retry.statusCodes)) {
+            result.retry.statusCodes = [...retry.statusCodes];
+        }
+    }
+    if (is.object(raw.timeout)) {
+        result.timeout = { ...raw.timeout };
+    }
+    if (is.object(hooks)) {
+        result.hooks = {
+            ...hooks,
+        };
+        if (is.array(hooks.init)) {
+            result.hooks.init = [...hooks.init];
+        }
+        if (is.array(hooks.beforeRequest)) {
+            result.hooks.beforeRequest = [...hooks.beforeRequest];
+        }
+        if (is.array(hooks.beforeError)) {
+            result.hooks.beforeError = [...hooks.beforeError];
+        }
+        if (is.array(hooks.beforeRedirect)) {
+            result.hooks.beforeRedirect = [...hooks.beforeRedirect];
+        }
+        if (is.array(hooks.beforeRetry)) {
+            result.hooks.beforeRetry = [...hooks.beforeRetry];
+        }
+        if (is.array(hooks.afterResponse)) {
+            result.hooks.afterResponse = [...hooks.afterResponse];
+        }
+    }
+    // TODO: raw.searchParams
+    if (is.object(raw.pagination)) {
+        result.pagination = { ...raw.pagination };
+    }
+    return result;
+};
+const getHttp2TimeoutOption = (internals) => {
+    const delays = [internals.timeout.socket, internals.timeout.connect, internals.timeout.lookup, internals.timeout.request, internals.timeout.secureConnect].filter(delay => typeof delay === 'number');
+    if (delays.length > 0) {
+        return Math.min(...delays);
+    }
+    return undefined;
+};
+const init = (options, withOptions, self) => {
+    const initHooks = options.hooks?.init;
+    if (initHooks) {
+        for (const hook of initHooks) {
+            hook(withOptions, self);
+        }
+    }
+};
+export default class Options {
+    constructor(input, options, defaults) {
+        Object.defineProperty(this, "_unixOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_internals", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_merging", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_init", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        assert.any([is.string, is.urlInstance, is.object, is.undefined], input);
+        assert.any([is.object, is.undefined], options);
+        assert.any([is.object, is.undefined], defaults);
+        if (input instanceof Options || options instanceof Options) {
+            throw new TypeError('The defaults must be passed as the third argument');
+        }
+        this._internals = cloneInternals(defaults?._internals ?? defaults ?? defaultInternals);
+        this._init = [...(defaults?._init ?? [])];
+        this._merging = false;
+        this._unixOptions = undefined;
+        // This rule allows `finally` to be considered more important.
+        // Meaning no matter the error thrown in the `try` block,
+        // if `finally` throws then the `finally` error will be thrown.
+        //
+        // Yes, we want this. If we set `url` first, then the `url.searchParams`
+        // would get merged. Instead we set the `searchParams` first, then
+        // `url.searchParams` is overwritten as expected.
+        //
+        /* eslint-disable no-unsafe-finally */
+        try {
+            if (is.plainObject(input)) {
+                try {
+                    this.merge(input);
+                    this.merge(options);
+                }
+                finally {
+                    this.url = input.url;
+                }
+            }
+            else {
+                try {
+                    this.merge(options);
+                }
+                finally {
+                    if (options?.url !== undefined) {
+                        if (input === undefined) {
+                            this.url = options.url;
+                        }
+                        else {
+                            throw new TypeError('The `url` option is mutually exclusive with the `input` argument');
+                        }
+                    }
+                    else if (input !== undefined) {
+                        this.url = input;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            error.options = this;
+            throw error;
+        }
+        /* eslint-enable no-unsafe-finally */
+    }
+    merge(options) {
+        if (!options) {
+            return;
+        }
+        if (options instanceof Options) {
+            for (const init of options._init) {
+                this.merge(init);
+            }
+            return;
+        }
+        options = cloneRaw(options);
+        init(this, options, this);
+        init(options, options, this);
+        this._merging = true;
+        // Always merge `isStream` first
+        if ('isStream' in options) {
+            this.isStream = options.isStream;
+        }
+        try {
+            let push = false;
+            for (const key in options) {
+                // `got.extend()` options
+                if (key === 'mutableDefaults' || key === 'handlers') {
+                    continue;
+                }
+                // Never merge `url`
+                if (key === 'url') {
+                    continue;
+                }
+                if (!(key in this)) {
+                    throw new Error(`Unexpected option: ${key}`);
+                }
+                // @ts-expect-error Type 'unknown' is not assignable to type 'never'.
+                this[key] = options[key];
+                push = true;
+            }
+            if (push) {
+                this._init.push(options);
+            }
+        }
+        finally {
+            this._merging = false;
+        }
+    }
+    /**
+    Custom request function.
+    The main purpose of this is to [support HTTP2 using a wrapper](https://github.com/szmarczak/http2-wrapper).
+
+    @default http.request | https.request
+    */
+    get request() {
+        return this._internals.request;
+    }
+    set request(value) {
+        assert.any([is.function_, is.undefined], value);
+        this._internals.request = value;
+    }
+    /**
+    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 a key is not present, it will default to a global agent.
+
+    @example
+    ```
+    import got from 'got';
+    import HttpAgent from 'agentkeepalive';
+
+    const {HttpsAgent} = HttpAgent;
+
+    await got('https://sindresorhus.com', {
+        agent: {
+            http: new HttpAgent(),
+            https: new HttpsAgent()
+        }
+    });
+    ```
+    */
+    get agent() {
+        return this._internals.agent;
+    }
+    set agent(value) {
+        assert.plainObject(value);
+        // eslint-disable-next-line guard-for-in
+        for (const key in value) {
+            if (!(key in this._internals.agent)) {
+                throw new TypeError(`Unexpected agent option: ${key}`);
+            }
+            // @ts-expect-error - No idea why `value[key]` doesn't work here.
+            assert.any([is.object, is.undefined], value[key]);
+        }
+        if (this._merging) {
+            Object.assign(this._internals.agent, value);
+        }
+        else {
+            this._internals.agent = { ...value };
+        }
+    }
+    get h2session() {
+        return this._internals.h2session;
+    }
+    set h2session(value) {
+        this._internals.h2session = value;
+    }
+    /**
+    Decompress the response automatically.
+
+    This will set the `accept-encoding` header to `gzip, deflate, br` unless you set it yourself.
+
+    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.
+
+    @default true
+    */
+    get decompress() {
+        return this._internals.decompress;
+    }
+    set decompress(value) {
+        assert.boolean(value);
+        this._internals.decompress = value;
+    }
+    /**
+    Milliseconds to wait for the server to end the response before aborting the request with `got.TimeoutError` error (a.k.a. `request` property).
+    By default, there's no timeout.
+
+    This also accepts an `object` with the following fields to constrain the duration of each phase of the request lifecycle:
+
+    - `lookup` starts when a socket is assigned and ends when the hostname has been resolved.
+        Does not apply when using a Unix domain socket.
+    - `connect` starts when `lookup` completes (or when the socket is assigned if lookup does not apply to the request) and ends when the socket is connected.
+    - `secureConnect` starts when `connect` completes and ends when the handshaking process completes (HTTPS only).
+    - `socket` starts when the socket is connected. See [request.setTimeout](https://nodejs.org/api/http.html#http_request_settimeout_timeout_callback).
+    - `response` starts when the request has been written to the socket and ends when the response headers are received.
+    - `send` starts when the socket is connected and ends with the request has been written to the socket.
+    - `request` starts when the request is initiated and ends when the response's end event fires.
+    */
+    get timeout() {
+        // We always return `Delays` here.
+        // It has to be `Delays | number`, otherwise TypeScript will error because the getter and the setter have incompatible types.
+        return this._internals.timeout;
+    }
+    set timeout(value) {
+        assert.plainObject(value);
+        // eslint-disable-next-line guard-for-in
+        for (const key in value) {
+            if (!(key in this._internals.timeout)) {
+                throw new Error(`Unexpected timeout option: ${key}`);
+            }
+            // @ts-expect-error - No idea why `value[key]` doesn't work here.
+            assert.any([is.number, is.undefined], value[key]);
+        }
+        if (this._merging) {
+            Object.assign(this._internals.timeout, value);
+        }
+        else {
+            this._internals.timeout = { ...value };
+        }
+    }
+    /**
+    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()` 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.
+
+    @example
+    ```
+    import got from 'got';
+
+    await got('unicorn', {prefixUrl: 'https://cats.com'});
+    //=> 'https://cats.com/unicorn'
+
+    const instance = got.extend({
+        prefixUrl: 'https://google.com'
+    });
+
+    await instance('unicorn', {
+        hooks: {
+            beforeRequest: [
+                options => {
+                    options.prefixUrl = 'https://cats.com';
+                }
+            ]
+        }
+    });
+    //=> 'https://cats.com/unicorn'
+    ```
+    */
+    get prefixUrl() {
+        // We always return `string` here.
+        // It has to be `string | URL`, otherwise TypeScript will error because the getter and the setter have incompatible types.
+        return this._internals.prefixUrl;
+    }
+    set prefixUrl(value) {
+        assert.any([is.string, is.urlInstance], value);
+        if (value === '') {
+            this._internals.prefixUrl = '';
+            return;
+        }
+        value = value.toString();
+        if (!value.endsWith('/')) {
+            value += '/';
+        }
+        if (this._internals.prefixUrl && this._internals.url) {
+            const { href } = this._internals.url;
+            this._internals.url.href = value + href.slice(this._internals.prefixUrl.length);
+        }
+        this._internals.prefixUrl = value;
+    }
+    /**
+    __Note #1__: The `body` option cannot be used with the `json` or `form` option.
+
+    __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` 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` / [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) / [`form-data` instance](https://github.com/form-data/form-data), and `content-length` and `transfer-encoding` are not manually set in `options.headers`.
+
+    Since Got 12, the `content-length` is not automatically set when `body` is a `fs.createReadStream`.
+    */
+    get body() {
+        return this._internals.body;
+    }
+    set body(value) {
+        assert.any([is.string, is.buffer, is.nodeStream, is.generator, is.asyncGenerator, isFormData, is.undefined], value);
+        if (is.nodeStream(value)) {
+            assert.truthy(value.readable);
+        }
+        if (value !== undefined) {
+            assert.undefined(this._internals.form);
+            assert.undefined(this._internals.json);
+        }
+        this._internals.body = value;
+    }
+    /**
+    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 the `Content-Type` header is not present, it will be set to `application/x-www-form-urlencoded`.
+
+    __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.
+    */
+    get form() {
+        return this._internals.form;
+    }
+    set form(value) {
+        assert.any([is.plainObject, is.undefined], value);
+        if (value !== undefined) {
+            assert.undefined(this._internals.body);
+            assert.undefined(this._internals.json);
+        }
+        this._internals.form = value;
+    }
+    /**
+    JSON body. If the `Content-Type` header is not set, it will be set to `application/json`.
+
+    __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.
+    */
+    get json() {
+        return this._internals.json;
+    }
+    set json(value) {
+        if (value !== undefined) {
+            assert.undefined(this._internals.body);
+            assert.undefined(this._internals.form);
+        }
+        this._internals.json = value;
+    }
+    /**
+    The URL to request, as a string, a [`https.request` options object](https://nodejs.org/api/https.html#https_https_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`.
+
+    If no protocol is specified, it will throw a `TypeError`.
+
+    __Note__: The query string is **not** parsed as search params.
+
+    @example
+    ```
+    await got('https://example.com/?query=a b'); //=> https://example.com/?query=a%20b
+    await got('https://example.com/', {searchParams: {query: 'a b'}}); //=> https://example.com/?query=a+b
+
+    // The query string is overridden by `searchParams`
+    await got('https://example.com/?query=a b', {searchParams: {query: 'a b'}}); //=> https://example.com/?query=a+b
+    ```
+    */
+    get url() {
+        return this._internals.url;
+    }
+    set url(value) {
+        assert.any([is.string, is.urlInstance, is.undefined], value);
+        if (value === undefined) {
+            this._internals.url = undefined;
+            return;
+        }
+        if (is.string(value) && value.startsWith('/')) {
+            throw new Error('`url` must not start with a slash');
+        }
+        const urlString = `${this.prefixUrl}${value.toString()}`;
+        const url = new URL(urlString);
+        this._internals.url = url;
+        if (url.protocol === 'unix:') {
+            url.href = `http://unix${url.pathname}${url.search}`;
+        }
+        if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+            const error = new Error(`Unsupported protocol: ${url.protocol}`);
+            error.code = 'ERR_UNSUPPORTED_PROTOCOL';
+            throw error;
+        }
+        if (this._internals.username) {
+            url.username = this._internals.username;
+            this._internals.username = '';
+        }
+        if (this._internals.password) {
+            url.password = this._internals.password;
+            this._internals.password = '';
+        }
+        if (this._internals.searchParams) {
+            url.search = this._internals.searchParams.toString();
+            this._internals.searchParams = undefined;
+        }
+        if (url.hostname === 'unix') {
+            if (!this._internals.enableUnixSockets) {
+                throw new Error('Using UNIX domain sockets but option `enableUnixSockets` is not enabled');
+            }
+            const matches = /(?<socketPath>.+?):(?<path>.+)/.exec(`${url.pathname}${url.search}`);
+            if (matches?.groups) {
+                const { socketPath, path } = matches.groups;
+                this._unixOptions = {
+                    socketPath,
+                    path,
+                    host: '',
+                };
+            }
+            else {
+                this._unixOptions = undefined;
+            }
+            return;
+        }
+        this._unixOptions = undefined;
+    }
+    /**
+    Cookie support. You don't have to care about parsing or how to store them.
+
+    __Note__: If you provide this option, `options.headers.cookie` will be overridden.
+    */
+    get cookieJar() {
+        return this._internals.cookieJar;
+    }
+    set cookieJar(value) {
+        assert.any([is.object, is.undefined], value);
+        if (value === undefined) {
+            this._internals.cookieJar = undefined;
+            return;
+        }
+        let { 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,
+            };
+        }
+        else {
+            this._internals.cookieJar = value;
+        }
+    }
+    /**
+    You can abort the `request` using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
+
+    *Requires Node.js 16 or later.*
+
+    @example
+    ```
+    import got from 'got';
+
+    const abortController = new AbortController();
+
+    const request = got('https://httpbin.org/anything', {
+        signal: abortController.signal
+    });
+
+    setTimeout(() => {
+        abortController.abort();
+    }, 100);
+    ```
+    */
+    // TODO: Replace `any` with `AbortSignal` when targeting Node 16.
+    get signal() {
+        return this._internals.signal;
+    }
+    // TODO: Replace `any` with `AbortSignal` when targeting Node 16.
+    set signal(value) {
+        assert.object(value);
+        this._internals.signal = value;
+    }
+    /**
+    Ignore invalid cookies instead of throwing an error.
+    Only useful when the `cookieJar` option has been set. Not recommended.
+
+    @default false
+    */
+    get ignoreInvalidCookies() {
+        return this._internals.ignoreInvalidCookies;
+    }
+    set ignoreInvalidCookies(value) {
+        assert.boolean(value);
+        this._internals.ignoreInvalidCookies = value;
+    }
+    /**
+    Query string that will be added to the request URL.
+    This will override the query string in `url`.
+
+    If you need to pass in an array, you can do it using a `URLSearchParams` instance.
+
+    @example
+    ```
+    import got from 'got';
+
+    const searchParams = new URLSearchParams([['key', 'a'], ['key', 'b']]);
+
+    await got('https://example.com', {searchParams});
+
+    console.log(searchParams.toString());
+    //=> 'key=a&key=b'
+    ```
+    */
+    get searchParams() {
+        if (this._internals.url) {
+            return this._internals.url.searchParams;
+        }
+        if (this._internals.searchParams === undefined) {
+            this._internals.searchParams = new URLSearchParams();
+        }
+        return this._internals.searchParams;
+    }
+    set searchParams(value) {
+        assert.any([is.string, is.object, is.undefined], value);
+        const url = this._internals.url;
+        if (value === undefined) {
+            this._internals.searchParams = undefined;
+            if (url) {
+                url.search = '';
+            }
+            return;
+        }
+        const searchParameters = this.searchParams;
+        let updated;
+        if (is.string(value)) {
+            updated = new URLSearchParams(value);
+        }
+        else if (value instanceof URLSearchParams) {
+            updated = value;
+        }
+        else {
+            validateSearchParameters(value);
+            updated = new URLSearchParams();
+            // eslint-disable-next-line guard-for-in
+            for (const key in value) {
+                const entry = value[key];
+                if (entry === null) {
+                    updated.append(key, '');
+                }
+                else if (entry === undefined) {
+                    searchParameters.delete(key);
+                }
+                else {
+                    updated.append(key, entry);
+                }
+            }
+        }
+        if (this._merging) {
+            // These keys will be replaced
+            for (const key of updated.keys()) {
+                searchParameters.delete(key);
+            }
+            for (const [key, value] of updated) {
+                searchParameters.append(key, value);
+            }
+        }
+        else if (url) {
+            url.search = searchParameters.toString();
+        }
+        else {
+            this._internals.searchParams = searchParameters;
+        }
+    }
+    get searchParameters() {
+        throw new Error('The `searchParameters` option does not exist. Use `searchParams` instead.');
+    }
+    set searchParameters(_value) {
+        throw new Error('The `searchParameters` option does not exist. Use `searchParams` instead.');
+    }
+    get dnsLookup() {
+        return this._internals.dnsLookup;
+    }
+    set dnsLookup(value) {
+        assert.any([is.function_, is.undefined], value);
+        this._internals.dnsLookup = value;
+    }
+    /**
+    An instance of [`CacheableLookup`](https://github.com/szmarczak/cacheable-lookup) used for making DNS lookups.
+    Useful when making lots of requests to different *public* hostnames.
+
+    `CacheableLookup` uses `dns.resolver4(..)` and `dns.resolver6(...)` under the hood and fall backs to `dns.lookup(...)` when the first two fail, which may lead to additional delay.
+
+    __Note__: This should stay disabled when making requests to internal hostnames such as `localhost`, `database.local` etc.
+
+    @default false
+    */
+    get dnsCache() {
+        return this._internals.dnsCache;
+    }
+    set dnsCache(value) {
+        assert.any([is.object, is.boolean, is.undefined], value);
+        if (value === true) {
+            this._internals.dnsCache = getGlobalDnsCache();
+        }
+        else if (value === false) {
+            this._internals.dnsCache = undefined;
+        }
+        else {
+            this._internals.dnsCache = value;
+        }
+    }
+    /**
+    User data. `context` is shallow merged and enumerable. If it contains non-enumerable properties they will NOT be merged.
+
+    @example
+    ```
+    import got from 'got';
+
+    const instance = got.extend({
+        hooks: {
+            beforeRequest: [
+                options => {
+                    if (!options.context || !options.context.token) {
+                        throw new Error('Token required');
+                    }
+
+                    options.headers.token = options.context.token;
+                }
+            ]
+        }
+    });
+
+    const context = {
+        token: 'secret'
+    };
+
+    const response = await instance('https://httpbin.org/headers', {context});
+
+    // Let's see the headers
+    console.log(response.body);
+    ```
+    */
+    get context() {
+        return this._internals.context;
+    }
+    set context(value) {
+        assert.object(value);
+        if (this._merging) {
+            Object.assign(this._internals.context, value);
+        }
+        else {
+            this._internals.context = { ...value };
+        }
+    }
+    /**
+    Hooks allow modifications during the request lifecycle.
+    Hook functions may be async and are run serially.
+    */
+    get hooks() {
+        return this._internals.hooks;
+    }
+    set hooks(value) {
+        assert.object(value);
+        // eslint-disable-next-line guard-for-in
+        for (const knownHookEvent in value) {
+            if (!(knownHookEvent in this._internals.hooks)) {
+                throw new Error(`Unexpected hook event: ${knownHookEvent}`);
+            }
+            const typedKnownHookEvent = knownHookEvent;
+            const hooks = value[typedKnownHookEvent];
+            assert.any([is.array, is.undefined], hooks);
+            if (hooks) {
+                for (const hook of hooks) {
+                    assert.function_(hook);
+                }
+            }
+            if (this._merging) {
+                if (hooks) {
+                    // @ts-expect-error FIXME
+                    this._internals.hooks[typedKnownHookEvent].push(...hooks);
+                }
+            }
+            else {
+                if (!hooks) {
+                    throw new Error(`Missing hook event: ${knownHookEvent}`);
+                }
+                // @ts-expect-error FIXME
+                this._internals.hooks[knownHookEvent] = [...hooks];
+            }
+        }
+    }
+    /**
+    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). You can optionally turn on this behavior also for other redirect codes - see `methodRewriting`.
+
+    @default true
+    */
+    get followRedirect() {
+        return this._internals.followRedirect;
+    }
+    set followRedirect(value) {
+        assert.boolean(value);
+        this._internals.followRedirect = value;
+    }
+    get followRedirects() {
+        throw new TypeError('The `followRedirects` option does not exist. Use `followRedirect` instead.');
+    }
+    set followRedirects(_value) {
+        throw new TypeError('The `followRedirects` option does not exist. Use `followRedirect` instead.');
+    }
+    /**
+    If exceeded, the request will be aborted and a `MaxRedirectsError` will be thrown.
+
+    @default 10
+    */
+    get maxRedirects() {
+        return this._internals.maxRedirects;
+    }
+    set maxRedirects(value) {
+        assert.number(value);
+        this._internals.maxRedirects = value;
+    }
+    /**
+    A cache adapter instance for storing cached response data.
+
+    @default false
+    */
+    get cache() {
+        return this._internals.cache;
+    }
+    set cache(value) {
+        assert.any([is.object, is.string, is.boolean, is.undefined], value);
+        if (value === true) {
+            this._internals.cache = globalCache;
+        }
+        else if (value === false) {
+            this._internals.cache = undefined;
+        }
+        else {
+            this._internals.cache = value;
+        }
+    }
+    /**
+    Determines if a `got.HTTPError` is thrown for unsuccessful responses.
+
+    If this is disabled, requests that encounter an error status code will be resolved with the `response` instead of throwing.
+    This may be useful if you are checking for resource availability and are expecting error responses.
+
+    @default true
+    */
+    get throwHttpErrors() {
+        return this._internals.throwHttpErrors;
+    }
+    set throwHttpErrors(value) {
+        assert.boolean(value);
+        this._internals.throwHttpErrors = value;
+    }
+    get username() {
+        const url = this._internals.url;
+        const value = url ? url.username : this._internals.username;
+        return decodeURIComponent(value);
+    }
+    set username(value) {
+        assert.string(value);
+        const url = this._internals.url;
+        const fixedValue = encodeURIComponent(value);
+        if (url) {
+            url.username = fixedValue;
+        }
+        else {
+            this._internals.username = fixedValue;
+        }
+    }
+    get password() {
+        const url = this._internals.url;
+        const value = url ? url.password : this._internals.password;
+        return decodeURIComponent(value);
+    }
+    set password(value) {
+        assert.string(value);
+        const url = this._internals.url;
+        const fixedValue = encodeURIComponent(value);
+        if (url) {
+            url.password = fixedValue;
+        }
+        else {
+            this._internals.password = fixedValue;
+        }
+    }
+    /**
+    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.
+
+    __Note__: This option requires Node.js 15.10.0 or newer as HTTP/2 support on older Node.js versions is very buggy.
+
+    __Note__: Overriding `options.request` will disable HTTP2 support.
+
+    @default false
+
+    @example
+    ```
+    import got from 'got';
+
+    const {headers} = await got('https://nghttp2.org/httpbin/anything', {http2: true});
+
+    console.log(headers.via);
+    //=> '2 nghttpx'
+    ```
+    */
+    get http2() {
+        return this._internals.http2;
+    }
+    set http2(value) {
+        assert.boolean(value);
+        this._internals.http2 = value;
+    }
+    /**
+    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.
+
+    __Note__: The [RFC 7231](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)__.
+
+    @default false
+    */
+    get allowGetBody() {
+        return this._internals.allowGetBody;
+    }
+    set allowGetBody(value) {
+        assert.boolean(value);
+        this._internals.allowGetBody = value;
+    }
+    /**
+    Request headers.
+
+    Existing headers will be overwritten. Headers set to `undefined` will be omitted.
+
+    @default {}
+    */
+    get headers() {
+        return this._internals.headers;
+    }
+    set headers(value) {
+        assert.plainObject(value);
+        if (this._merging) {
+            Object.assign(this._internals.headers, lowercaseKeys(value));
+        }
+        else {
+            this._internals.headers = lowercaseKeys(value);
+        }
+    }
+    /**
+    Specifies if the HTTP request method should be [rewritten as `GET`](https://tools.ietf.org/html/rfc7231#section-6.4) on redirects.
+
+    As the [specification](https://tools.ietf.org/html/rfc7231#section-6.4) prefers to rewrite the HTTP method only on `303` responses, this is Got's default behavior.
+    Setting `methodRewriting` to `true` will also rewrite `301` and `302` responses, as allowed by the spec. This is the behavior followed by `curl` and browsers.
+
+    __Note__: Got never performs method rewriting on `307` and `308` responses, as this is [explicitly prohibited by the specification](https://www.rfc-editor.org/rfc/rfc7231#section-6.4.7).
+
+    @default false
+    */
+    get methodRewriting() {
+        return this._internals.methodRewriting;
+    }
+    set methodRewriting(value) {
+        assert.boolean(value);
+        this._internals.methodRewriting = value;
+    }
+    /**
+    Indicates which DNS record family to use.
+
+    Values:
+    - `undefined`: IPv4 (if present) or IPv6
+    - `4`: Only IPv4
+    - `6`: Only IPv6
+
+    @default undefined
+    */
+    get dnsLookupIpVersion() {
+        return this._internals.dnsLookupIpVersion;
+    }
+    set dnsLookupIpVersion(value) {
+        if (value !== undefined && value !== 4 && value !== 6) {
+            throw new TypeError(`Invalid DNS lookup IP version: ${value}`);
+        }
+        this._internals.dnsLookupIpVersion = value;
+    }
+    /**
+    A function used to parse JSON responses.
+
+    @example
+    ```
+    import got from 'got';
+    import Bourne from '@hapi/bourne';
+
+    const parsed = await got('https://example.com', {
+        parseJson: text => Bourne.parse(text)
+    }).json();
+
+    console.log(parsed);
+    ```
+    */
+    get parseJson() {
+        return this._internals.parseJson;
+    }
+    set parseJson(value) {
+        assert.function_(value);
+        this._internals.parseJson = value;
+    }
+    /**
+    A function used to stringify the body of JSON requests.
+
+    @example
+    ```
+    import got from 'got';
+
+    await got.post('https://example.com', {
+        stringifyJson: object => JSON.stringify(object, (key, value) => {
+            if (key.startsWith('_')) {
+                return;
+            }
+
+            return value;
+        }),
+        json: {
+            some: 'payload',
+            _ignoreMe: 1234
+        }
+    });
+    ```
+
+    @example
+    ```
+    import got from 'got';
+
+    await got.post('https://example.com', {
+        stringifyJson: object => JSON.stringify(object, (key, value) => {
+            if (typeof value === 'number') {
+                return value.toString();
+            }
+
+            return value;
+        }),
+        json: {
+            some: 'payload',
+            number: 1
+        }
+    });
+    ```
+    */
+    get stringifyJson() {
+        return this._internals.stringifyJson;
+    }
+    set stringifyJson(value) {
+        assert.function_(value);
+        this._internals.stringifyJson = value;
+    }
+    /**
+    An object representing `limit`, `calculateDelay`, `methods`, `statusCodes`, `maxRetryAfter` and `errorCodes` fields for maximum retry count, retry handler, allowed methods, allowed status codes, maximum [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) time and allowed error codes.
+
+    Delays between retries counts with function `1000 * Math.pow(2, retry) + Math.random() * 100`, where `retry` is attempt number (starts from 1).
+
+    The `calculateDelay` property is a `function` that receives an object with `attemptCount`, `retryOptions`, `error` and `computedValue` properties for current retry count, the retry options, error and default computed value.
+    The function must return a delay in milliseconds (or a Promise resolving with it) (`0` return value cancels retry).
+
+    By default, it retries *only* on the specified methods, status codes, and on these network errors:
+
+    - `ETIMEDOUT`: One of the [timeout](#timeout) limits were reached.
+    - `ECONNRESET`: Connection was forcibly closed by a peer.
+    - `EADDRINUSE`: Could not bind to any free port.
+    - `ECONNREFUSED`: Connection was refused by the server.
+    - `EPIPE`: The remote side of the stream being written has been closed.
+    - `ENOTFOUND`: Couldn't resolve the hostname to an IP address.
+    - `ENETUNREACH`: No internet connection.
+    - `EAI_AGAIN`: DNS lookup timed out.
+
+    __Note__: If `maxRetryAfter` is set to `undefined`, it will use `options.timeout`.
+    __Note__: If [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) header is greater than `maxRetryAfter`, it will cancel the request.
+    */
+    get retry() {
+        return this._internals.retry;
+    }
+    set retry(value) {
+        assert.plainObject(value);
+        assert.any([is.function_, is.undefined], value.calculateDelay);
+        assert.any([is.number, is.undefined], value.maxRetryAfter);
+        assert.any([is.number, is.undefined], value.limit);
+        assert.any([is.array, is.undefined], value.methods);
+        assert.any([is.array, is.undefined], value.statusCodes);
+        assert.any([is.array, is.undefined], value.errorCodes);
+        assert.any([is.number, is.undefined], value.noise);
+        if (value.noise && Math.abs(value.noise) > 100) {
+            throw new Error(`The maximum acceptable retry noise is +/- 100ms, got ${value.noise}`);
+        }
+        for (const key in value) {
+            if (!(key in this._internals.retry)) {
+                throw new Error(`Unexpected retry option: ${key}`);
+            }
+        }
+        if (this._merging) {
+            Object.assign(this._internals.retry, value);
+        }
+        else {
+            this._internals.retry = { ...value };
+        }
+        const { retry } = this._internals;
+        retry.methods = [...new Set(retry.methods.map(method => method.toUpperCase()))];
+        retry.statusCodes = [...new Set(retry.statusCodes)];
+        retry.errorCodes = [...new Set(retry.errorCodes)];
+    }
+    /**
+    From `http.RequestOptions`.
+
+    The IP address used to send the request from.
+    */
+    get localAddress() {
+        return this._internals.localAddress;
+    }
+    set localAddress(value) {
+        assert.any([is.string, is.undefined], value);
+        this._internals.localAddress = value;
+    }
+    /**
+    The HTTP method used to make the request.
+
+    @default 'GET'
+    */
+    get method() {
+        return this._internals.method;
+    }
+    set method(value) {
+        assert.string(value);
+        this._internals.method = value.toUpperCase();
+    }
+    get createConnection() {
+        return this._internals.createConnection;
+    }
+    set createConnection(value) {
+        assert.any([is.function_, is.undefined], value);
+        this._internals.createConnection = value;
+    }
+    /**
+    From `http-cache-semantics`
+
+    @default {}
+    */
+    get cacheOptions() {
+        return this._internals.cacheOptions;
+    }
+    set cacheOptions(value) {
+        assert.plainObject(value);
+        assert.any([is.boolean, is.undefined], value.shared);
+        assert.any([is.number, is.undefined], value.cacheHeuristic);
+        assert.any([is.number, is.undefined], value.immutableMinTimeToLive);
+        assert.any([is.boolean, is.undefined], value.ignoreCargoCult);
+        for (const key in value) {
+            if (!(key in this._internals.cacheOptions)) {
+                throw new Error(`Cache option \`${key}\` does not exist`);
+            }
+        }
+        if (this._merging) {
+            Object.assign(this._internals.cacheOptions, value);
+        }
+        else {
+            this._internals.cacheOptions = { ...value };
+        }
+    }
+    /**
+    Options for the advanced HTTPS API.
+    */
+    get https() {
+        return this._internals.https;
+    }
+    set https(value) {
+        assert.plainObject(value);
+        assert.any([is.boolean, is.undefined], value.rejectUnauthorized);
+        assert.any([is.function_, is.undefined], value.checkServerIdentity);
+        assert.any([is.string, is.object, is.array, is.undefined], value.certificateAuthority);
+        assert.any([is.string, is.object, is.array, is.undefined], value.key);
+        assert.any([is.string, is.object, is.array, is.undefined], value.certificate);
+        assert.any([is.string, is.undefined], value.passphrase);
+        assert.any([is.string, is.buffer, is.array, is.undefined], value.pfx);
+        assert.any([is.array, is.undefined], value.alpnProtocols);
+        assert.any([is.string, is.undefined], value.ciphers);
+        assert.any([is.string, is.buffer, is.undefined], value.dhparam);
+        assert.any([is.string, is.undefined], value.signatureAlgorithms);
+        assert.any([is.string, is.undefined], value.minVersion);
+        assert.any([is.string, is.undefined], value.maxVersion);
+        assert.any([is.boolean, is.undefined], value.honorCipherOrder);
+        assert.any([is.number, is.undefined], value.tlsSessionLifetime);
+        assert.any([is.string, is.undefined], value.ecdhCurve);
+        assert.any([is.string, is.buffer, is.array, is.undefined], value.certificateRevocationLists);
+        for (const key in value) {
+            if (!(key in this._internals.https)) {
+                throw new Error(`HTTPS option \`${key}\` does not exist`);
+            }
+        }
+        if (this._merging) {
+            Object.assign(this._internals.https, value);
+        }
+        else {
+            this._internals.https = { ...value };
+        }
+    }
+    /**
+    [Encoding](https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings) to be used on `setEncoding` of the response data.
+
+    To get a [`Buffer`](https://nodejs.org/api/buffer.html), you need to set `responseType` to `buffer` instead.
+    Don't set this option to `null`.
+
+    __Note__: This doesn't affect streams! Instead, you need to do `got.stream(...).setEncoding(encoding)`.
+
+    @default 'utf-8'
+    */
+    get encoding() {
+        return this._internals.encoding;
+    }
+    set encoding(value) {
+        if (value === null) {
+            throw new TypeError('To get a Buffer, set `options.responseType` to `buffer` instead');
+        }
+        assert.any([is.string, is.undefined], value);
+        this._internals.encoding = value;
+    }
+    /**
+    When set to `true` the promise will return the Response body instead of the Response object.
+
+    @default false
+    */
+    get resolveBodyOnly() {
+        return this._internals.resolveBodyOnly;
+    }
+    set resolveBodyOnly(value) {
+        assert.boolean(value);
+        this._internals.resolveBodyOnly = value;
+    }
+    /**
+    Returns a `Stream` instead of a `Promise`.
+    This is equivalent to calling `got.stream(url, options?)`.
+
+    @default false
+    */
+    get isStream() {
+        return this._internals.isStream;
+    }
+    set isStream(value) {
+        assert.boolean(value);
+        this._internals.isStream = value;
+    }
+    /**
+    The parsing method.
+
+    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.
+
+    __Note__: When using streams, this option is ignored.
+
+    @example
+    ```
+    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
+    ```
+
+    @example
+    ```
+    // This
+    const body = await got(url).json();
+
+    // is semantically the same as this
+    const body = await got(url, {responseType: 'json', resolveBodyOnly: true});
+    ```
+    */
+    get responseType() {
+        return this._internals.responseType;
+    }
+    set responseType(value) {
+        if (value === undefined) {
+            this._internals.responseType = 'text';
+            return;
+        }
+        if (value !== 'text' && value !== 'buffer' && value !== 'json') {
+            throw new Error(`Invalid \`responseType\` option: ${value}`);
+        }
+        this._internals.responseType = value;
+    }
+    get pagination() {
+        return this._internals.pagination;
+    }
+    set pagination(value) {
+        assert.object(value);
+        if (this._merging) {
+            Object.assign(this._internals.pagination, value);
+        }
+        else {
+            this._internals.pagination = value;
+        }
+    }
+    get auth() {
+        throw new Error('Parameter `auth` is deprecated. Use `username` / `password` instead.');
+    }
+    set auth(_value) {
+        throw new Error('Parameter `auth` is deprecated. Use `username` / `password` instead.');
+    }
+    get setHost() {
+        return this._internals.setHost;
+    }
+    set setHost(value) {
+        assert.boolean(value);
+        this._internals.setHost = value;
+    }
+    get maxHeaderSize() {
+        return this._internals.maxHeaderSize;
+    }
+    set maxHeaderSize(value) {
+        assert.any([is.number, is.undefined], value);
+        this._internals.maxHeaderSize = value;
+    }
+    get enableUnixSockets() {
+        return this._internals.enableUnixSockets;
+    }
+    set enableUnixSockets(value) {
+        assert.boolean(value);
+        this._internals.enableUnixSockets = value;
+    }
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    toJSON() {
+        return { ...this._internals };
+    }
+    [Symbol.for('nodejs.util.inspect.custom')](_depth, options) {
+        return inspect(this._internals, options);
+    }
+    createNativeRequestOptions() {
+        const internals = this._internals;
+        const url = internals.url;
+        let agent;
+        if (url.protocol === 'https:') {
+            agent = internals.http2 ? internals.agent : internals.agent.https;
+        }
+        else {
+            agent = internals.agent.http;
+        }
+        const { https } = internals;
+        let { pfx } = https;
+        if (is.array(pfx) && is.plainObject(pfx[0])) {
+            pfx = pfx.map(object => ({
+                buf: object.buffer,
+                passphrase: object.passphrase,
+            }));
+        }
+        return {
+            ...internals.cacheOptions,
+            ...this._unixOptions,
+            // HTTPS options
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            ALPNProtocols: https.alpnProtocols,
+            ca: https.certificateAuthority,
+            cert: https.certificate,
+            key: https.key,
+            passphrase: https.passphrase,
+            pfx: https.pfx,
+            rejectUnauthorized: https.rejectUnauthorized,
+            checkServerIdentity: https.checkServerIdentity ?? checkServerIdentity,
+            ciphers: https.ciphers,
+            honorCipherOrder: https.honorCipherOrder,
+            minVersion: https.minVersion,
+            maxVersion: https.maxVersion,
+            sigalgs: https.signatureAlgorithms,
+            sessionTimeout: https.tlsSessionLifetime,
+            dhparam: https.dhparam,
+            ecdhCurve: https.ecdhCurve,
+            crl: https.certificateRevocationLists,
+            // HTTP options
+            lookup: internals.dnsLookup ?? internals.dnsCache?.lookup,
+            family: internals.dnsLookupIpVersion,
+            agent,
+            setHost: internals.setHost,
+            method: internals.method,
+            maxHeaderSize: internals.maxHeaderSize,
+            localAddress: internals.localAddress,
+            headers: internals.headers,
+            createConnection: internals.createConnection,
+            timeout: internals.http2 ? getHttp2TimeoutOption(internals) : undefined,
+            // HTTP/2 options
+            h2session: internals.h2session,
+        };
+    }
+    getRequestFunction() {
+        const url = this._internals.url;
+        const { request } = this._internals;
+        if (!request && url) {
+            return this.getFallbackRequestFunction();
+        }
+        return request;
+    }
+    getFallbackRequestFunction() {
+        const url = this._internals.url;
+        if (!url) {
+            return;
+        }
+        if (url.protocol === 'https:') {
+            if (this._internals.http2) {
+                if (major < 15 || (major === 15 && minor < 10)) {
+                    const error = new Error('To use the `http2` option, install Node.js 15.10.0 or above');
+                    error.code = 'EUNSUPPORTED';
+                    throw error;
+                }
+                return http2wrapper.auto;
+            }
+            return https.request;
+        }
+        return http.request;
+    }
+    freeze() {
+        const options = this._internals;
+        Object.freeze(options);
+        Object.freeze(options.hooks);
+        Object.freeze(options.hooks.afterResponse);
+        Object.freeze(options.hooks.beforeError);
+        Object.freeze(options.hooks.beforeRedirect);
+        Object.freeze(options.hooks.beforeRequest);
+        Object.freeze(options.hooks.beforeRetry);
+        Object.freeze(options.hooks.init);
+        Object.freeze(options.https);
+        Object.freeze(options.cacheOptions);
+        Object.freeze(options.agent);
+        Object.freeze(options.headers);
+        Object.freeze(options.timeout);
+        Object.freeze(options.retry);
+        Object.freeze(options.retry.errorCodes);
+        Object.freeze(options.retry.methods);
+        Object.freeze(options.retry.statusCodes);
+    }
+}
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/parse-link-header.d.ts b/includes/external/addressbook/node_modules/got/dist/source/core/parse-link-header.d.ts
new file mode 100644
index 0000000..595e561
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/parse-link-header.d.ts
@@ -0,0 +1,4 @@
+export default function parseLinkHeader(link: string): {
+    reference: string;
+    parameters: Record<string, string>;
+}[];
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/parse-link-header.js b/includes/external/addressbook/node_modules/got/dist/source/core/parse-link-header.js
new file mode 100644
index 0000000..898a6a2
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/parse-link-header.js
@@ -0,0 +1,33 @@
+export default function parseLinkHeader(link) {
+    const parsed = [];
+    const items = link.split(',');
+    for (const item of items) {
+        // https://tools.ietf.org/html/rfc5988#section-5
+        const [rawUriReference, ...rawLinkParameters] = item.split(';');
+        const trimmedUriReference = rawUriReference.trim();
+        // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
+        if (trimmedUriReference[0] !== '<' || trimmedUriReference[trimmedUriReference.length - 1] !== '>') {
+            throw new Error(`Invalid format of the Link header reference: ${trimmedUriReference}`);
+        }
+        const reference = trimmedUriReference.slice(1, -1);
+        const parameters = {};
+        if (rawLinkParameters.length === 0) {
+            throw new Error(`Unexpected end of Link header parameters: ${rawLinkParameters.join(';')}`);
+        }
+        for (const rawParameter of rawLinkParameters) {
+            const trimmedRawParameter = rawParameter.trim();
+            const center = trimmedRawParameter.indexOf('=');
+            if (center === -1) {
+                throw new Error(`Failed to parse Link header: ${link}`);
+            }
+            const name = trimmedRawParameter.slice(0, center).trim();
+            const value = trimmedRawParameter.slice(center + 1).trim();
+            parameters[name] = value;
+        }
+        parsed.push({
+            reference,
+            parameters,
+        });
+    }
+    return parsed;
+}
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/response.d.ts b/includes/external/addressbook/node_modules/got/dist/source/core/response.d.ts
new file mode 100644
index 0000000..4ea3629
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/response.d.ts
@@ -0,0 +1,110 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Buffer } from 'node:buffer';
+import type { URL } from 'node:url';
+import type { IncomingMessageWithTimings, Timings } from '@szmarczak/http-timer';
+import { RequestError } from './errors.js';
+import type { ParseJsonFunction, ResponseType } from './options.js';
+import type Request from './index.js';
+export type PlainResponse = {
+    /**
+    The original request URL.
+    */
+    requestUrl: URL;
+    /**
+    The redirect URLs.
+    */
+    redirectUrls: URL[];
+    /**
+    - `options` - The Got options that were set on this request.
+
+    __Note__: This is not a [http.ClientRequest](https://nodejs.org/api/http.html#http_class_http_clientrequest).
+    */
+    request: Request;
+    /**
+    The remote IP address.
+
+    This is hopefully a temporary limitation, see [lukechilds/cacheable-request#86](https://github.com/lukechilds/cacheable-request/issues/86).
+
+    __Note__: Not available when the response is cached.
+    */
+    ip?: string;
+    /**
+    Whether the response was retrieved from the cache.
+    */
+    isFromCache: boolean;
+    /**
+    The status code of the response.
+    */
+    statusCode: number;
+    /**
+    The request URL or the final URL after redirects.
+    */
+    url: string;
+    /**
+    The object contains the following properties:
+
+    - `start` - Time when the request started.
+    - `socket` - Time when a socket was assigned to the request.
+    - `lookup` - Time when the DNS lookup finished.
+    - `connect` - Time when the socket successfully connected.
+    - `secureConnect` - Time when the socket securely connected.
+    - `upload` - Time when the request finished uploading.
+    - `response` - Time when the request fired `response` event.
+    - `end` - Time when the response fired `end` event.
+    - `error` - Time when the request fired `error` event.
+    - `abort` - Time when the request fired `abort` event.
+    - `phases`
+        - `wait` - `timings.socket - timings.start`
+        - `dns` - `timings.lookup - timings.socket`
+        - `tcp` - `timings.connect - timings.lookup`
+        - `tls` - `timings.secureConnect - timings.connect`
+        - `request` - `timings.upload - (timings.secureConnect || timings.connect)`
+        - `firstByte` - `timings.response - timings.upload`
+        - `download` - `timings.end - timings.response`
+        - `total` - `(timings.end || timings.error || timings.abort) - timings.start`
+
+    If something has not been measured yet, it will be `undefined`.
+
+    __Note__: The time is a `number` representing the milliseconds elapsed since the UNIX epoch.
+    */
+    timings: Timings;
+    /**
+    The number of times the request was retried.
+    */
+    retryCount: number;
+    /**
+    The raw result of the request.
+    */
+    rawBody?: Buffer;
+    /**
+    The result of the request.
+    */
+    body?: unknown;
+    /**
+    Whether the response was successful.
+
+    __Note__: Got throws automatically when `response.ok` is `false` and `throwHttpErrors` is `true`.
+    */
+    ok: boolean;
+} & IncomingMessageWithTimings;
+export type Response<T = unknown> = {
+    /**
+    The result of the request.
+    */
+    body: T;
+    /**
+    The raw result of the request.
+    */
+    rawBody: Buffer;
+} & PlainResponse;
+export declare const isResponseOk: (response: PlainResponse) => boolean;
+/**
+An error to be thrown when server response code is 2xx, and parsing body fails.
+Includes a `response` property.
+*/
+export declare class ParseError extends RequestError {
+    readonly response: Response;
+    constructor(error: Error, response: Response);
+}
+export declare const parseBody: (response: Response, responseType: ResponseType, parseJson: ParseJsonFunction, encoding?: BufferEncoding) => unknown;
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/response.js b/includes/external/addressbook/node_modules/got/dist/source/core/response.js
new file mode 100644
index 0000000..06c4610
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/response.js
@@ -0,0 +1,39 @@
+import { RequestError } from './errors.js';
+export const isResponseOk = (response) => {
+    const { statusCode } = response;
+    const limitStatusCode = response.request.options.followRedirect ? 299 : 399;
+    return (statusCode >= 200 && statusCode <= limitStatusCode) || statusCode === 304;
+};
+/**
+An error to be thrown when server response code is 2xx, and parsing body fails.
+Includes a `response` property.
+*/
+export class ParseError extends RequestError {
+    constructor(error, response) {
+        const { options } = response.request;
+        super(`${error.message} in "${options.url.toString()}"`, error, response.request);
+        this.name = 'ParseError';
+        this.code = 'ERR_BODY_PARSE_FAILURE';
+    }
+}
+export const parseBody = (response, responseType, parseJson, encoding) => {
+    const { rawBody } = response;
+    try {
+        if (responseType === 'text') {
+            return rawBody.toString(encoding);
+        }
+        if (responseType === 'json') {
+            return rawBody.length === 0 ? '' : parseJson(rawBody.toString(encoding));
+        }
+        if (responseType === 'buffer') {
+            return rawBody;
+        }
+    }
+    catch (error) {
+        throw new ParseError(error, response);
+    }
+    throw new ParseError({
+        message: `Unknown body type '${responseType}'`,
+        name: 'Error',
+    }, response);
+};
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/timed-out.d.ts b/includes/external/addressbook/node_modules/got/dist/source/core/timed-out.d.ts
new file mode 100644
index 0000000..845684c
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/timed-out.d.ts
@@ -0,0 +1,30 @@
+import type { ClientRequest } from 'node:http';
+declare const reentry: unique symbol;
+type TimedOutOptions = {
+    host?: string;
+    hostname?: string;
+    protocol?: string;
+};
+export type Delays = {
+    lookup?: number;
+    socket?: number;
+    connect?: number;
+    secureConnect?: number;
+    send?: number;
+    response?: number;
+    read?: number;
+    request?: number;
+};
+export type ErrorCode = 'ETIMEDOUT' | 'ECONNRESET' | 'EADDRINUSE' | 'ECONNREFUSED' | 'EPIPE' | 'ENOTFOUND' | 'ENETUNREACH' | 'EAI_AGAIN';
+export declare class TimeoutError extends Error {
+    event: string;
+    code: ErrorCode;
+    constructor(threshold: number, event: string);
+}
+export default function timedOut(request: ClientRequest, delays: Delays, options: TimedOutOptions): () => void;
+declare module 'http' {
+    interface ClientRequest {
+        [reentry]?: boolean;
+    }
+}
+export {};
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/timed-out.js b/includes/external/addressbook/node_modules/got/dist/source/core/timed-out.js
new file mode 100644
index 0000000..500f748
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/timed-out.js
@@ -0,0 +1,138 @@
+import net from 'node:net';
+import unhandler from './utils/unhandle.js';
+const reentry = Symbol('reentry');
+const noop = () => { };
+export class TimeoutError extends Error {
+    constructor(threshold, event) {
+        super(`Timeout awaiting '${event}' for ${threshold}ms`);
+        Object.defineProperty(this, "event", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: event
+        });
+        Object.defineProperty(this, "code", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = 'TimeoutError';
+        this.code = 'ETIMEDOUT';
+    }
+}
+export default function timedOut(request, delays, options) {
+    if (reentry in request) {
+        return noop;
+    }
+    request[reentry] = true;
+    const cancelers = [];
+    const { once, unhandleAll } = unhandler();
+    const addTimeout = (delay, callback, event) => {
+        const timeout = setTimeout(callback, delay, delay, event);
+        timeout.unref?.();
+        const cancel = () => {
+            clearTimeout(timeout);
+        };
+        cancelers.push(cancel);
+        return cancel;
+    };
+    const { host, hostname } = options;
+    const timeoutHandler = (delay, event) => {
+        request.destroy(new TimeoutError(delay, event));
+    };
+    const cancelTimeouts = () => {
+        for (const cancel of cancelers) {
+            cancel();
+        }
+        unhandleAll();
+    };
+    request.once('error', error => {
+        cancelTimeouts();
+        // Save original behavior
+        /* istanbul ignore next */
+        if (request.listenerCount('error') === 0) {
+            throw error;
+        }
+    });
+    if (typeof delays.request !== 'undefined') {
+        const cancelTimeout = addTimeout(delays.request, timeoutHandler, 'request');
+        once(request, 'response', (response) => {
+            once(response, 'end', cancelTimeout);
+        });
+    }
+    if (typeof delays.socket !== 'undefined') {
+        const { socket } = delays;
+        const socketTimeoutHandler = () => {
+            timeoutHandler(socket, 'socket');
+        };
+        request.setTimeout(socket, socketTimeoutHandler);
+        // `request.setTimeout(0)` causes a memory leak.
+        // We can just remove the listener and forget about the timer - it's unreffed.
+        // See https://github.com/sindresorhus/got/issues/690
+        cancelers.push(() => {
+            request.removeListener('timeout', socketTimeoutHandler);
+        });
+    }
+    const hasLookup = typeof delays.lookup !== 'undefined';
+    const hasConnect = typeof delays.connect !== 'undefined';
+    const hasSecureConnect = typeof delays.secureConnect !== 'undefined';
+    const hasSend = typeof delays.send !== 'undefined';
+    if (hasLookup || hasConnect || hasSecureConnect || hasSend) {
+        once(request, 'socket', (socket) => {
+            const { socketPath } = request;
+            /* istanbul ignore next: hard to test */
+            if (socket.connecting) {
+                const hasPath = Boolean(socketPath ?? net.isIP(hostname ?? host ?? '') !== 0);
+                if (hasLookup && !hasPath && typeof socket.address().address === 'undefined') {
+                    const cancelTimeout = addTimeout(delays.lookup, timeoutHandler, 'lookup');
+                    once(socket, 'lookup', cancelTimeout);
+                }
+                if (hasConnect) {
+                    const timeConnect = () => addTimeout(delays.connect, timeoutHandler, 'connect');
+                    if (hasPath) {
+                        once(socket, 'connect', timeConnect());
+                    }
+                    else {
+                        once(socket, 'lookup', (error) => {
+                            if (error === null) {
+                                once(socket, 'connect', timeConnect());
+                            }
+                        });
+                    }
+                }
+                if (hasSecureConnect && options.protocol === 'https:') {
+                    once(socket, 'connect', () => {
+                        const cancelTimeout = addTimeout(delays.secureConnect, timeoutHandler, 'secureConnect');
+                        once(socket, 'secureConnect', cancelTimeout);
+                    });
+                }
+            }
+            if (hasSend) {
+                const timeRequest = () => addTimeout(delays.send, timeoutHandler, 'send');
+                /* istanbul ignore next: hard to test */
+                if (socket.connecting) {
+                    once(socket, 'connect', () => {
+                        once(request, 'upload-complete', timeRequest());
+                    });
+                }
+                else {
+                    once(request, 'upload-complete', timeRequest());
+                }
+            }
+        });
+    }
+    if (typeof delays.response !== 'undefined') {
+        once(request, 'upload-complete', () => {
+            const cancelTimeout = addTimeout(delays.response, timeoutHandler, 'response');
+            once(request, 'response', cancelTimeout);
+        });
+    }
+    if (typeof delays.read !== 'undefined') {
+        once(request, 'response', (response) => {
+            const cancelTimeout = addTimeout(delays.read, timeoutHandler, 'read');
+            once(response, 'end', cancelTimeout);
+        });
+    }
+    return cancelTimeouts;
+}
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/get-body-size.d.ts b/includes/external/addressbook/node_modules/got/dist/source/core/utils/get-body-size.d.ts
new file mode 100644
index 0000000..3030691
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/get-body-size.d.ts
@@ -0,0 +1,3 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { ClientRequestArgs } from 'node:http';
+export default function getBodySize(body: unknown, headers: ClientRequestArgs['headers']): Promise<number | undefined>;
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/get-body-size.js b/includes/external/addressbook/node_modules/got/dist/source/core/utils/get-body-size.js
new file mode 100644
index 0000000..9a85c64
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/get-body-size.js
@@ -0,0 +1,22 @@
+import { Buffer } from 'node:buffer';
+import { promisify } from 'node:util';
+import is from '@sindresorhus/is';
+import isFormData from './is-form-data.js';
+export default async function getBodySize(body, headers) {
+    if (headers && 'content-length' in headers) {
+        return Number(headers['content-length']);
+    }
+    if (!body) {
+        return 0;
+    }
+    if (is.string(body)) {
+        return Buffer.byteLength(body);
+    }
+    if (is.buffer(body)) {
+        return body.length;
+    }
+    if (isFormData(body)) {
+        return promisify(body.getLength.bind(body))();
+    }
+    return undefined;
+}
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-client-request.d.ts b/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-client-request.d.ts
new file mode 100644
index 0000000..5e67ff0
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-client-request.d.ts
@@ -0,0 +1,5 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Writable, Readable } from 'node:stream';
+import type { ClientRequest } from 'node:http';
+declare function isClientRequest(clientRequest: Writable | Readable): clientRequest is ClientRequest;
+export default isClientRequest;
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-client-request.js b/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-client-request.js
new file mode 100644
index 0000000..da80b68
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-client-request.js
@@ -0,0 +1,4 @@
+function isClientRequest(clientRequest) {
+    return clientRequest.writable && !clientRequest.writableEnded;
+}
+export default isClientRequest;
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-form-data.d.ts b/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-form-data.d.ts
new file mode 100644
index 0000000..ed0805f
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-form-data.d.ts
@@ -0,0 +1,8 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Readable } from 'node:stream';
+type FormData = {
+    getBoundary: () => string;
+    getLength: (callback: (error: Error | null, length: number) => void) => void;
+} & Readable;
+export default function isFormData(body: unknown): body is FormData;
+export {};
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-form-data.js b/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-form-data.js
new file mode 100644
index 0000000..13a7823
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-form-data.js
@@ -0,0 +1,4 @@
+import is from '@sindresorhus/is';
+export default function isFormData(body) {
+    return is.nodeStream(body) && is.function_(body.getBoundary);
+}
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-unix-socket-url.d.ts b/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-unix-socket-url.d.ts
new file mode 100644
index 0000000..ee3f162
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-unix-socket-url.d.ts
@@ -0,0 +1,3 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { URL } from 'url';
+export default function isUnixSocketURL(url: URL): boolean;
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-unix-socket-url.js b/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-unix-socket-url.js
new file mode 100644
index 0000000..46f7348
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/is-unix-socket-url.js
@@ -0,0 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export default function isUnixSocketURL(url) {
+    return url.protocol === 'unix:' || url.hostname === 'unix';
+}
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/options-to-url.d.ts b/includes/external/addressbook/node_modules/got/dist/source/core/utils/options-to-url.d.ts
new file mode 100644
index 0000000..86b853f
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/options-to-url.d.ts
@@ -0,0 +1,14 @@
+/// <reference types="node" resolution-mode="require"/>
+import { URL } from 'node:url';
+export type URLOptions = {
+    href?: string;
+    protocol?: string;
+    host?: string;
+    hostname?: string;
+    port?: string | number;
+    pathname?: string;
+    search?: string;
+    searchParams?: unknown;
+    path?: string;
+};
+export default function optionsToUrl(origin: string, options: URLOptions): URL;
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/options-to-url.js b/includes/external/addressbook/node_modules/got/dist/source/core/utils/options-to-url.js
new file mode 100644
index 0000000..46346a7
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/options-to-url.js
@@ -0,0 +1,50 @@
+/* istanbul ignore file: deprecated */
+import { URL } from 'node:url';
+const keys = [
+    'protocol',
+    'host',
+    'hostname',
+    'port',
+    'pathname',
+    'search',
+];
+export default function optionsToUrl(origin, options) {
+    if (options.path) {
+        if (options.pathname) {
+            throw new TypeError('Parameters `path` and `pathname` are mutually exclusive.');
+        }
+        if (options.search) {
+            throw new TypeError('Parameters `path` and `search` are mutually exclusive.');
+        }
+        if (options.searchParams) {
+            throw new TypeError('Parameters `path` and `searchParams` are mutually exclusive.');
+        }
+    }
+    if (options.search && options.searchParams) {
+        throw new TypeError('Parameters `search` and `searchParams` are mutually exclusive.');
+    }
+    if (!origin) {
+        if (!options.protocol) {
+            throw new TypeError('No URL protocol specified');
+        }
+        origin = `${options.protocol}//${options.hostname ?? options.host ?? ''}`;
+    }
+    const url = new URL(origin);
+    if (options.path) {
+        const searchIndex = options.path.indexOf('?');
+        if (searchIndex === -1) {
+            options.pathname = options.path;
+        }
+        else {
+            options.pathname = options.path.slice(0, searchIndex);
+            options.search = options.path.slice(searchIndex + 1);
+        }
+        delete options.path;
+    }
+    for (const key of keys) {
+        if (options[key]) {
+            url[key] = options[key].toString();
+        }
+    }
+    return url;
+}
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/proxy-events.d.ts b/includes/external/addressbook/node_modules/got/dist/source/core/utils/proxy-events.d.ts
new file mode 100644
index 0000000..cbc818a
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/proxy-events.d.ts
@@ -0,0 +1,3 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { EventEmitter } from 'node:events';
+export default function proxyEvents(from: EventEmitter, to: EventEmitter, events: Readonly<string[]>): () => void;
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/proxy-events.js b/includes/external/addressbook/node_modules/got/dist/source/core/utils/proxy-events.js
new file mode 100644
index 0000000..d3d2f2d
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/proxy-events.js
@@ -0,0 +1,15 @@
+export default function proxyEvents(from, to, events) {
+    const eventFunctions = {};
+    for (const event of events) {
+        const eventFunction = (...args) => {
+            to.emit(event, ...args);
+        };
+        eventFunctions[event] = eventFunction;
+        from.on(event, eventFunction);
+    }
+    return () => {
+        for (const [event, eventFunction] of Object.entries(eventFunctions)) {
+            from.off(event, eventFunction);
+        }
+    };
+}
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/unhandle.d.ts b/includes/external/addressbook/node_modules/got/dist/source/core/utils/unhandle.d.ts
new file mode 100644
index 0000000..c494576
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/unhandle.d.ts
@@ -0,0 +1,11 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { EventEmitter } from 'node:events';
+type Origin = EventEmitter;
+type Event = string | symbol;
+type Fn = (...args: any[]) => void;
+type Unhandler = {
+    once: (origin: Origin, event: Event, fn: Fn) => void;
+    unhandleAll: () => void;
+};
+export default function unhandle(): Unhandler;
+export {};
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/unhandle.js b/includes/external/addressbook/node_modules/got/dist/source/core/utils/unhandle.js
new file mode 100644
index 0000000..0312706
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/unhandle.js
@@ -0,0 +1,20 @@
+// When attaching listeners, it's very easy to forget about them.
+// Especially if you do error handling and set timeouts.
+// So instead of checking if it's proper to throw an error on every timeout ever,
+// use this simple tool which will remove all listeners you have attached.
+export default function unhandle() {
+    const handlers = [];
+    return {
+        once(origin, event, fn) {
+            origin.once(event, fn);
+            handlers.push({ origin, event, fn });
+        },
+        unhandleAll() {
+            for (const handler of handlers) {
+                const { origin, event, fn } = handler;
+                origin.removeListener(event, fn);
+            }
+            handlers.length = 0;
+        },
+    };
+}
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/url-to-options.d.ts b/includes/external/addressbook/node_modules/got/dist/source/core/utils/url-to-options.d.ts
new file mode 100644
index 0000000..e3ae8be
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/url-to-options.d.ts
@@ -0,0 +1,15 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { URL, UrlWithStringQuery } from 'node:url';
+export type LegacyUrlOptions = {
+    protocol: string;
+    hostname: string;
+    host: string;
+    hash: string | null;
+    search: string | null;
+    pathname: string;
+    href: string;
+    path: string;
+    port?: number;
+    auth?: string;
+};
+export default function urlToOptions(url: URL | UrlWithStringQuery): LegacyUrlOptions;
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/url-to-options.js b/includes/external/addressbook/node_modules/got/dist/source/core/utils/url-to-options.js
new file mode 100644
index 0000000..959dd69
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/url-to-options.js
@@ -0,0 +1,22 @@
+import is from '@sindresorhus/is';
+export default function urlToOptions(url) {
+    // Cast to URL
+    url = url;
+    const options = {
+        protocol: url.protocol,
+        hostname: is.string(url.hostname) && url.hostname.startsWith('[') ? url.hostname.slice(1, -1) : url.hostname,
+        host: url.host,
+        hash: url.hash,
+        search: url.search,
+        pathname: url.pathname,
+        href: url.href,
+        path: `${url.pathname || ''}${url.search || ''}`,
+    };
+    if (is.string(url.port) && url.port.length > 0) {
+        options.port = Number(url.port);
+    }
+    if (url.username || url.password) {
+        options.auth = `${url.username || ''}:${url.password || ''}`;
+    }
+    return options;
+}
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/weakable-map.d.ts b/includes/external/addressbook/node_modules/got/dist/source/core/utils/weakable-map.d.ts
new file mode 100644
index 0000000..9e3466c
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/weakable-map.d.ts
@@ -0,0 +1,8 @@
+export default class WeakableMap<K, V> {
+    weakMap: WeakMap<Record<string, unknown>, V>;
+    map: Map<K, V>;
+    constructor();
+    set(key: K, value: V): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+}
diff --git a/includes/external/addressbook/node_modules/got/dist/source/core/utils/weakable-map.js b/includes/external/addressbook/node_modules/got/dist/source/core/utils/weakable-map.js
new file mode 100644
index 0000000..805ad76
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/core/utils/weakable-map.js
@@ -0,0 +1,38 @@
+export default class WeakableMap {
+    constructor() {
+        Object.defineProperty(this, "weakMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "map", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.weakMap = new WeakMap();
+        this.map = new Map();
+    }
+    set(key, value) {
+        if (typeof key === 'object') {
+            this.weakMap.set(key, value);
+        }
+        else {
+            this.map.set(key, value);
+        }
+    }
+    get(key) {
+        if (typeof key === 'object') {
+            return this.weakMap.get(key);
+        }
+        return this.map.get(key);
+    }
+    has(key) {
+        if (typeof key === 'object') {
+            return this.weakMap.has(key);
+        }
+        return this.map.has(key);
+    }
+}
diff --git a/includes/external/addressbook/node_modules/got/dist/source/create.d.ts b/includes/external/addressbook/node_modules/got/dist/source/create.d.ts
new file mode 100644
index 0000000..ce0f4b6
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/create.d.ts
@@ -0,0 +1,3 @@
+import type { Got, InstanceDefaults } from './types.js';
+declare const create: (defaults: InstanceDefaults) => Got;
+export default create;
diff --git a/includes/external/addressbook/node_modules/got/dist/source/create.js b/includes/external/addressbook/node_modules/got/dist/source/create.js
new file mode 100644
index 0000000..fb14e49
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/create.js
@@ -0,0 +1,187 @@
+import is, { assert } from '@sindresorhus/is';
+import asPromise from './as-promise/index.js';
+import Request from './core/index.js';
+import Options from './core/options.js';
+// The `delay` package weighs 10KB (!)
+const delay = async (ms) => new Promise(resolve => {
+    setTimeout(resolve, ms);
+});
+const isGotInstance = (value) => is.function_(value);
+const aliases = [
+    'get',
+    'post',
+    'put',
+    'patch',
+    'head',
+    'delete',
+];
+const create = (defaults) => {
+    defaults = {
+        options: new Options(undefined, undefined, defaults.options),
+        handlers: [...defaults.handlers],
+        mutableDefaults: defaults.mutableDefaults,
+    };
+    Object.defineProperty(defaults, 'mutableDefaults', {
+        enumerable: true,
+        configurable: false,
+        writable: false,
+    });
+    // Got interface
+    const got = ((url, options, defaultOptions = defaults.options) => {
+        const request = new Request(url, options, defaultOptions);
+        let promise;
+        const lastHandler = (normalized) => {
+            // Note: `options` is `undefined` when `new Options(...)` fails
+            request.options = normalized;
+            request._noPipe = !normalized.isStream;
+            void request.flush();
+            if (normalized.isStream) {
+                return request;
+            }
+            if (!promise) {
+                promise = asPromise(request);
+            }
+            return promise;
+        };
+        let iteration = 0;
+        const iterateHandlers = (newOptions) => {
+            const handler = defaults.handlers[iteration++] ?? lastHandler;
+            const result = handler(newOptions, iterateHandlers);
+            if (is.promise(result) && !request.options.isStream) {
+                if (!promise) {
+                    promise = asPromise(request);
+                }
+                if (result !== promise) {
+                    const descriptors = Object.getOwnPropertyDescriptors(promise);
+                    for (const key in descriptors) {
+                        if (key in result) {
+                            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+                            delete descriptors[key];
+                        }
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                    Object.defineProperties(result, descriptors);
+                    result.cancel = promise.cancel;
+                }
+            }
+            return result;
+        };
+        return iterateHandlers(request.options);
+    });
+    got.extend = (...instancesOrOptions) => {
+        const options = new Options(undefined, undefined, defaults.options);
+        const handlers = [...defaults.handlers];
+        let mutableDefaults;
+        for (const value of instancesOrOptions) {
+            if (isGotInstance(value)) {
+                options.merge(value.defaults.options);
+                handlers.push(...value.defaults.handlers);
+                mutableDefaults = value.defaults.mutableDefaults;
+            }
+            else {
+                options.merge(value);
+                if (value.handlers) {
+                    handlers.push(...value.handlers);
+                }
+                mutableDefaults = value.mutableDefaults;
+            }
+        }
+        return create({
+            options,
+            handlers,
+            mutableDefaults: Boolean(mutableDefaults),
+        });
+    };
+    // Pagination
+    const paginateEach = (async function* (url, options) {
+        let normalizedOptions = new Options(url, options, defaults.options);
+        normalizedOptions.resolveBodyOnly = false;
+        const { pagination } = normalizedOptions;
+        assert.function_(pagination.transform);
+        assert.function_(pagination.shouldContinue);
+        assert.function_(pagination.filter);
+        assert.function_(pagination.paginate);
+        assert.number(pagination.countLimit);
+        assert.number(pagination.requestLimit);
+        assert.number(pagination.backoff);
+        const allItems = [];
+        let { countLimit } = pagination;
+        let numberOfRequests = 0;
+        while (numberOfRequests < pagination.requestLimit) {
+            if (numberOfRequests !== 0) {
+                // eslint-disable-next-line no-await-in-loop
+                await delay(pagination.backoff);
+            }
+            // eslint-disable-next-line no-await-in-loop
+            const response = (await got(undefined, undefined, normalizedOptions));
+            // eslint-disable-next-line no-await-in-loop
+            const parsed = await pagination.transform(response);
+            const currentItems = [];
+            assert.array(parsed);
+            for (const item of parsed) {
+                if (pagination.filter({ item, currentItems, allItems })) {
+                    if (!pagination.shouldContinue({ item, currentItems, allItems })) {
+                        return;
+                    }
+                    yield item;
+                    if (pagination.stackAllItems) {
+                        allItems.push(item);
+                    }
+                    currentItems.push(item);
+                    if (--countLimit <= 0) {
+                        return;
+                    }
+                }
+            }
+            const optionsToMerge = pagination.paginate({
+                response,
+                currentItems,
+                allItems,
+            });
+            if (optionsToMerge === false) {
+                return;
+            }
+            if (optionsToMerge === response.request.options) {
+                normalizedOptions = response.request.options;
+            }
+            else {
+                normalizedOptions.merge(optionsToMerge);
+                assert.any([is.urlInstance, is.undefined], optionsToMerge.url);
+                if (optionsToMerge.url !== undefined) {
+                    normalizedOptions.prefixUrl = '';
+                    normalizedOptions.url = optionsToMerge.url;
+                }
+            }
+            numberOfRequests++;
+        }
+    });
+    got.paginate = paginateEach;
+    got.paginate.all = (async (url, options) => {
+        const results = [];
+        for await (const item of paginateEach(url, options)) {
+            results.push(item);
+        }
+        return results;
+    });
+    // For those who like very descriptive names
+    got.paginate.each = paginateEach;
+    // Stream API
+    got.stream = ((url, options) => got(url, { ...options, isStream: true }));
+    // Shortcuts
+    for (const method of aliases) {
+        got[method] = ((url, options) => got(url, { ...options, method }));
+        got.stream[method] = ((url, options) => got(url, { ...options, method, isStream: true }));
+    }
+    if (!defaults.mutableDefaults) {
+        Object.freeze(defaults.handlers);
+        defaults.options.freeze();
+    }
+    Object.defineProperty(got, 'defaults', {
+        value: defaults,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+    });
+    return got;
+};
+export default create;
diff --git a/includes/external/addressbook/node_modules/got/dist/source/index.d.ts b/includes/external/addressbook/node_modules/got/dist/source/index.d.ts
new file mode 100644
index 0000000..9447c9a
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/index.d.ts
@@ -0,0 +1,15 @@
+declare const got: import("./types.js").Got;
+export default got;
+export { got };
+export { default as Options } from './core/options.js';
+export * from './core/options.js';
+export * from './core/response.js';
+export type { default as Request } from './core/index.js';
+export * from './core/index.js';
+export * from './core/errors.js';
+export type { Delays } from './core/timed-out.js';
+export { default as calculateRetryDelay } from './core/calculate-retry-delay.js';
+export * from './as-promise/types.js';
+export * from './types.js';
+export { default as create } from './create.js';
+export { default as parseLinkHeader } from './core/parse-link-header.js';
diff --git a/includes/external/addressbook/node_modules/got/dist/source/index.js b/includes/external/addressbook/node_modules/got/dist/source/index.js
new file mode 100644
index 0000000..4056297
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/index.js
@@ -0,0 +1,20 @@
+import create from './create.js';
+import Options from './core/options.js';
+const defaults = {
+    options: new Options(),
+    handlers: [],
+    mutableDefaults: false,
+};
+const got = create(defaults);
+export default got;
+export { got };
+export { default as Options } from './core/options.js';
+export * from './core/options.js';
+export * from './core/response.js';
+export * from './core/index.js';
+export * from './core/errors.js';
+export { default as calculateRetryDelay } from './core/calculate-retry-delay.js';
+export * from './as-promise/types.js';
+export * from './types.js';
+export { default as create } from './create.js';
+export { default as parseLinkHeader } from './core/parse-link-header.js';
diff --git a/includes/external/addressbook/node_modules/got/dist/source/types.d.ts b/includes/external/addressbook/node_modules/got/dist/source/types.d.ts
new file mode 100644
index 0000000..3b76442
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/types.d.ts
@@ -0,0 +1,263 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Buffer } from 'node:buffer';
+import type { URL } from 'node:url';
+import type { CancelableRequest } from './as-promise/types.js';
+import type { Response } from './core/response.js';
+import type Options from './core/options.js';
+import type { PaginationOptions, OptionsInit } from './core/options.js';
+import type Request from './core/index.js';
+type Except<ObjectType, KeysType extends keyof ObjectType> = Pick<ObjectType, Exclude<keyof ObjectType, KeysType>>;
+type Merge<FirstType, SecondType> = Except<FirstType, Extract<keyof FirstType, keyof SecondType>> & SecondType;
+/**
+Defaults for each Got instance.
+*/
+export type InstanceDefaults = {
+    /**
+    An object containing the default options of Got.
+    */
+    options: Options;
+    /**
+    An array of functions. You execute them directly by calling `got()`.
+    They are some sort of "global hooks" - these functions are called first.
+    The last handler (*it's hidden*) is either `asPromise` or `asStream`, depending on the `options.isStream` property.
+
+    @default []
+    */
+    handlers: HandlerFunction[];
+    /**
+    A read-only boolean describing whether the defaults are mutable or not.
+    If set to `true`, you can update headers over time, for example, update an access token when it expires.
+
+    @default false
+    */
+    mutableDefaults: boolean;
+};
+/**
+A Request object returned by calling Got, or any of the Got HTTP alias request functions.
+*/
+export type GotReturn = Request | CancelableRequest;
+/**
+A function to handle options and returns a Request object.
+It acts sort of like a "global hook", and will be called before any actual request is made.
+*/
+export type HandlerFunction = <T extends GotReturn>(options: Options, next: (options: Options) => T) => T | Promise<T>;
+/**
+The options available for `got.extend()`.
+*/
+export type ExtendOptions = {
+    /**
+    An array of functions. You execute them directly by calling `got()`.
+    They are some sort of "global hooks" - these functions are called first.
+    The last handler (*it's hidden*) is either `asPromise` or `asStream`, depending on the `options.isStream` property.
+
+    @default []
+    */
+    handlers?: HandlerFunction[];
+    /**
+    A read-only boolean describing whether the defaults are mutable or not.
+    If set to `true`, you can update headers over time, for example, update an access token when it expires.
+
+    @default false
+    */
+    mutableDefaults?: boolean;
+} & OptionsInit;
+export type OptionsOfTextResponseBody = Merge<OptionsInit, {
+    isStream?: false;
+    resolveBodyOnly?: false;
+    responseType?: 'text';
+}>;
+export type OptionsOfJSONResponseBody = Merge<OptionsInit, {
+    isStream?: false;
+    resolveBodyOnly?: false;
+    responseType?: 'json';
+}>;
+export type OptionsOfBufferResponseBody = Merge<OptionsInit, {
+    isStream?: false;
+    resolveBodyOnly?: false;
+    responseType: 'buffer';
+}>;
+export type OptionsOfUnknownResponseBody = Merge<OptionsInit, {
+    isStream?: false;
+    resolveBodyOnly?: false;
+}>;
+export type StrictOptions = Except<OptionsInit, 'isStream' | 'responseType' | 'resolveBodyOnly'>;
+export type StreamOptions = Merge<OptionsInit, {
+    isStream?: true;
+}>;
+type ResponseBodyOnly = {
+    resolveBodyOnly: true;
+};
+export type OptionsWithPagination<T = unknown, R = unknown> = Merge<OptionsInit, {
+    pagination?: PaginationOptions<T, R>;
+}>;
+/**
+An instance of `got.paginate`.
+*/
+export type GotPaginate = {
+    /**
+    Same as `GotPaginate.each`.
+    */
+    <T, R = unknown>(url: string | URL, options?: OptionsWithPagination<T, R>): AsyncIterableIterator<T>;
+    /**
+    Same as `GotPaginate.each`.
+    */
+    <T, R = unknown>(options?: OptionsWithPagination<T, R>): AsyncIterableIterator<T>;
+    /**
+    Returns an async iterator.
+
+    See pagination.options for more pagination options.
+
+    @example
+    ```
+    import got from 'got';
+
+    const countLimit = 10;
+
+    const pagination = got.paginate('https://api.github.com/repos/sindresorhus/got/commits', {
+        pagination: {countLimit}
+    });
+
+    console.log(`Printing latest ${countLimit} Got commits (newest to oldest):`);
+
+    for await (const commitData of pagination) {
+        console.log(commitData.commit.message);
+    }
+    ```
+    */
+    each: (<T, R = unknown>(url: string | URL, options?: OptionsWithPagination<T, R>) => AsyncIterableIterator<T>) & (<T, R = unknown>(options?: OptionsWithPagination<T, R>) => AsyncIterableIterator<T>);
+    /**
+    Returns a Promise for an array of all results.
+
+    See pagination.options for more pagination options.
+
+    @example
+    ```
+    import got from 'got';
+
+    const countLimit = 10;
+
+    const results = await got.paginate.all('https://api.github.com/repos/sindresorhus/got/commits', {
+        pagination: {countLimit}
+    });
+
+    console.log(`Printing latest ${countLimit} Got commits (newest to oldest):`);
+    console.log(results);
+    ```
+    */
+    all: (<T, R = unknown>(url: string | URL, options?: OptionsWithPagination<T, R>) => Promise<T[]>) & (<T, R = unknown>(options?: OptionsWithPagination<T, R>) => Promise<T[]>);
+};
+export type GotRequestFunction = {
+    (url: string | URL, options?: OptionsOfTextResponseBody): CancelableRequest<Response<string>>;
+    <T>(url: string | URL, options?: OptionsOfJSONResponseBody): CancelableRequest<Response<T>>;
+    (url: string | URL, options?: OptionsOfBufferResponseBody): CancelableRequest<Response<Buffer>>;
+    (url: string | URL, options?: OptionsOfUnknownResponseBody): CancelableRequest<Response>;
+    (options: OptionsOfTextResponseBody): CancelableRequest<Response<string>>;
+    <T>(options: OptionsOfJSONResponseBody): CancelableRequest<Response<T>>;
+    (options: OptionsOfBufferResponseBody): CancelableRequest<Response<Buffer>>;
+    (options: OptionsOfUnknownResponseBody): CancelableRequest<Response>;
+    (url: string | URL, options?: (Merge<OptionsOfTextResponseBody, ResponseBodyOnly>)): CancelableRequest<string>;
+    <T>(url: string | URL, options?: (Merge<OptionsOfJSONResponseBody, ResponseBodyOnly>)): CancelableRequest<T>;
+    (url: string | URL, options?: (Merge<OptionsOfBufferResponseBody, ResponseBodyOnly>)): CancelableRequest<Buffer>;
+    (options: (Merge<OptionsOfTextResponseBody, ResponseBodyOnly>)): CancelableRequest<string>;
+    <T>(options: (Merge<OptionsOfJSONResponseBody, ResponseBodyOnly>)): CancelableRequest<T>;
+    (options: (Merge<OptionsOfBufferResponseBody, ResponseBodyOnly>)): CancelableRequest<Buffer>;
+    (url: string | URL, options?: Merge<OptionsInit, {
+        isStream: true;
+    }>): Request;
+    (options: Merge<OptionsInit, {
+        isStream: true;
+    }>): Request;
+    (url: string | URL, options?: OptionsInit): CancelableRequest | Request;
+    (options: OptionsInit): CancelableRequest | Request;
+    (url: undefined, options: undefined, defaults: Options): CancelableRequest | Request;
+};
+/**
+All available HTTP request methods provided by Got.
+*/
+export type HTTPAlias = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete';
+type GotStreamFunction = ((url?: string | URL, options?: Merge<OptionsInit, {
+    isStream?: true;
+}>) => Request) & ((options?: Merge<OptionsInit, {
+    isStream?: true;
+}>) => Request);
+/**
+An instance of `got.stream()`.
+*/
+export type GotStream = GotStreamFunction & Record<HTTPAlias, GotStreamFunction>;
+/**
+An instance of `got`.
+*/
+export type Got = {
+    /**
+    Sets `options.isStream` to `true`.
+
+    Returns a [duplex stream](https://nodejs.org/api/stream.html#stream_class_stream_duplex) with additional events:
+    - request
+    - response
+    - redirect
+    - uploadProgress
+    - downloadProgress
+    - error
+    */
+    stream: GotStream;
+    /**
+    Returns an async iterator.
+
+    See pagination.options for more pagination options.
+
+    @example
+    ```
+    import got from 'got';
+
+    const countLimit = 10;
+
+    const pagination = got.paginate('https://api.github.com/repos/sindresorhus/got/commits', {
+        pagination: {countLimit}
+    });
+
+    console.log(`Printing latest ${countLimit} Got commits (newest to oldest):`);
+
+    for await (const commitData of pagination) {
+        console.log(commitData.commit.message);
+    }
+    ```
+    */
+    paginate: GotPaginate;
+    /**
+    The Got defaults used in that instance.
+    */
+    defaults: InstanceDefaults;
+    /**
+    Configure a new `got` instance with default `options`.
+    The `options` are merged with the parent instance's `defaults.options` using `got.mergeOptions`.
+    You can access the resolved options with the `.defaults` property on the instance.
+
+    Additionally, `got.extend()` accepts two properties from the `defaults` object: `mutableDefaults` and `handlers`.
+
+    It is also possible to merges many instances into a single one:
+    - options are merged using `got.mergeOptions()` (including hooks),
+    - handlers are stored in an array (you can access them through `instance.defaults.handlers`).
+
+    @example
+    ```
+    import got from 'got';
+
+    const client = got.extend({
+        prefixUrl: 'https://example.com',
+        headers: {
+            'x-unicorn': 'rainbow'
+        }
+    });
+
+    client.get('demo');
+
+    // HTTP Request =>
+    // GET /demo HTTP/1.1
+    // Host: example.com
+    // x-unicorn: rainbow
+    ```
+    */
+    extend: (...instancesOrOptions: Array<Got | ExtendOptions>) => Got;
+} & Record<HTTPAlias, GotRequestFunction> & GotRequestFunction;
+export {};
diff --git a/includes/external/addressbook/node_modules/got/dist/source/types.js b/includes/external/addressbook/node_modules/got/dist/source/types.js
new file mode 100644
index 0000000..cb0ff5c
--- /dev/null
+++ b/includes/external/addressbook/node_modules/got/dist/source/types.js
@@ -0,0 +1 @@
+export {};