@deffa5556/bail 1.0.6 → 1.0.7

package/cjs/lib/Discord/rest/OAuthHelper.cjs

@@ -0,0 +1,226 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function (o, m, k, k2) {
+    if (k2 === undefined)
+        k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function () { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function (o, m, k, k2) {
+    if (k2 === undefined)
+        k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function (o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function (o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function (o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o)
+                if (Object.prototype.hasOwnProperty.call(o, k))
+                    ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule)
+            return mod;
+        var result = {};
+        if (mod != null)
+            for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+                if (k[i] !== "default")
+                    __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const OAuthApplication_1 = __importDefault(require("../structures/OAuthApplication"));
+const Routes = __importStar(require("../util/Routes"));
+const PartialApplication_1 = __importDefault(require("../structures/PartialApplication"));
+const Integration_1 = __importDefault(require("../structures/Integration"));
+const Member_1 = __importDefault(require("../structures/Member"));
+const OAuthGuild_1 = __importDefault(require("../structures/OAuthGuild"));
+const ExtendedUser_1 = __importDefault(require("../structures/ExtendedUser"));
+const Constants_1 = require("../Constants");
+/** A helper to make using authenticated oauth requests without needing a new client instance. */
+class OAuthHelper {
+    constructor(manager, token) {
+        this._token = token;
+        this._manager = manager;
+    }
+    /**
+     * Construct an oauth authorization url.
+     * @param options The options to construct the url with.
+     */
+    static constructURL(options) {
+        const params = [
+            `client_id=${options.clientID}`,
+            `response_type=${options.responseType ?? "code"}`,
+            `scope=${options.scopes.join("%20")}`
+        ];
+        if (options.redirectURI) {
+            params.push(`redirect_uri=${options.redirectURI}`);
+        }
+        if (options.disableGuildSelect !== undefined) {
+            params.push(`disable_guild_select=${String(options.disableGuildSelect)}`);
+        }
+        if (options.prompt) {
+            params.push(`prompt=${options.prompt}`);
+        }
+        if (options.permissions) {
+            params.push(`permissions=${options.permissions}`);
+        }
+        if (options.guildID) {
+            params.push(`guild_id=${options.guildID}`);
+        }
+        if (options.state) {
+            params.push(`state=${options.state}`);
+        }
+        if (options.integrationType) {
+            params.push(`integration_type=${options.integrationType}`);
+        }
+        return `${Constants_1.BASE_URL}${Routes.OAUTH_AUTHORIZE}?${params.join("&")}`;
+    }
+    async addGuildMember(guildID, userID, options) {
+        return this._manager.guilds.addMember(guildID, userID, { accessToken: this._token.split(" ").slice(1).join(" "), ...options });
+    }
+    /**
+     * Get the current OAuth2 application's information.
+     */
+    async getApplication() {
+        return this._manager.request({
+            method: "GET",
+            path: Routes.OAUTH_APPLICATION,
+            auth: this._token
+        }).then(data => new OAuthApplication_1.default(data, this._manager.client));
+    }
+    /**
+     * Get information about the current authorization.
+     */
+    async getCurrentAuthorizationInformation() {
+        return this._manager.request({
+            method: "GET",
+            path: Routes.OAUTH_INFO,
+            auth: this._token
+        }).then(data => ({
+            application: new PartialApplication_1.default(data.application, this._manager.client),
+            expires: new Date(data.expires),
+            scopes: data.scopes,
+            user: this._manager.client.users.update(data.user)
+        }));
+    }
+    /**
+     * Get the connections of the currently authenticated user.
+     *
+     * Note: Requires the `connections` scope.
+     */
+    async getCurrentConnections() {
+        return this._manager.request({
+            method: "GET",
+            path: Routes.OAUTH_CONNECTIONS,
+            auth: this._token
+        }).then(data => data.map(connection => ({
+            friendSync: connection.friend_sync,
+            id: connection.id,
+            integrations: connection.integrations?.map(integration => new Integration_1.default(integration, this._manager.client)),
+            name: connection.name,
+            revoked: connection.revoked,
+            showActivity: connection.show_activity,
+            twoWayLink: connection.two_way_link,
+            type: connection.type,
+            verified: connection.verified,
+            visibility: connection.visibility
+        })));
+    }
+    /**
+     * Get the guild member information about the currently authenticated user.
+     *
+     * Note: Requires the `guilds.members.read` scope.
+     * @param guild the ID of the guild
+     */
+    async getCurrentGuildMember(guild) {
+        return this._manager.request({
+            method: "GET",
+            path: Routes.OAUTH_GUILD_MEMBER(guild),
+            auth: this._token
+        }).then(data => new Member_1.default(data, this._manager.client, guild));
+    }
+    /**
+     * Get the currently authenticated user's guilds. Note these are missing several properties gateway guilds have.
+     */
+    async getCurrentGuilds() {
+        return this._manager.request({
+            method: "GET",
+            path: Routes.OAUTH_GUILDS,
+            auth: this._token
+        }).then(data => data.map(d => new OAuthGuild_1.default(d, this._manager.client)));
+    }
+    /**
+     * Get the currently authenticated user's information.
+     *
+     * Note: This does not touch the client's cache in any way.
+     */
+    async getCurrentUser() {
+        return this._manager.request({
+            method: "GET",
+            path: Routes.OAUTH_CURRENT_USER,
+            auth: this._token
+        }).then(data => new ExtendedUser_1.default(data, this._manager.client));
+    }
+    /**
+     * Revoke the used access token.
+     * @param options The options for revoking the token.
+     */
+    async revokeToken(options) {
+        const form = new FormData();
+        form.append("client_id", options.clientID);
+        form.append("client_secret", options.clientSecret);
+        form.append("token", this._token);
+        await this._manager.authRequest({
+            method: "POST",
+            path: Routes.OAUTH_TOKEN_REVOKE,
+            form
+        });
+    }
+    /**
+     * Update the authenticated user's role connection object for an application. This requires the `role_connections.write` scope.
+     * @param applicationID The ID of the application.
+     * @param data The metadata to update.
+     */
+    async updateRoleConnection(applicationID, data) {
+        return this._manager.request({
+            method: "PUT",
+            path: Routes.OAUTH_ROLE_CONNECTION(applicationID),
+            json: {
+                metadata: data.metadata,
+                platform_name: data.platformName,
+                platform_username: data.platformUsername
+            },
+            auth: this._token
+        }).then(d => ({
+            metadata: Object.entries(d.metadata).map(([key, value]) => ({
+                [key]: {
+                    description: value.description,
+                    descriptionLocalizations: value.description_localizations,
+                    key: value.key,
+                    name: value.name,
+                    nameLocalizations: value.name_localizations,
+                    type: value.type
+                }
+            })).reduce((a, b) => ({ ...a, ...b })),
+            platformName: d.platform_name,
+            platformUsername: d.platform_username
+        }));
+    }
+}
+exports.default = OAuthHelper;

package/cjs/lib/Discord/rest/RESTManager.cjs

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function (o, m, k, k2) {
+    if (k2 === undefined)
+        k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function () { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function (o, m, k, k2) {
+    if (k2 === undefined)
+        k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function (o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function (o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function (o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o)
+                if (Object.prototype.hasOwnProperty.call(o, k))
+                    ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule)
+            return mod;
+        var result = {};
+        if (mod != null)
+            for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+                if (k[i] !== "default")
+                    __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module RESTManager */
+const RequestHandler_1 = __importDefault(require("./RequestHandler"));
+const Channels_1 = __importDefault(require("../routes/Channels"));
+const Guilds_1 = __importDefault(require("../routes/Guilds"));
+const Users_1 = __importDefault(require("../routes/Users"));
+const OAuth_1 = __importDefault(require("../routes/OAuth"));
+const Webhooks_1 = __importDefault(require("../routes/Webhooks"));
+const Applications_1 = __importDefault(require("../routes/Applications"));
+const Interactions_1 = __importDefault(require("../routes/Interactions"));
+const Routes = __importStar(require("../util/Routes"));
+const Miscellaneous_1 = __importDefault(require("../routes/Miscellaneous"));
+const Lobbies_1 = __importDefault(require("../routes/Lobbies"));
+/** A manager for all rest actions. */
+class RESTManager {
+    constructor(client, options) {
+        this.applications = new Applications_1.default(this);
+        this.channels = new Channels_1.default(this);
+        this._client = client;
+        this.guilds = new Guilds_1.default(this);
+        this.handler = new RequestHandler_1.default(this, options);
+        this.interactions = new Interactions_1.default(this);
+        this.lobbies = new Lobbies_1.default(this);
+        this.misc = new Miscellaneous_1.default(this);
+        this.oauth = new OAuth_1.default(this);
+        this.users = new Users_1.default(this);
+        this.webhooks = new Webhooks_1.default(this);
+    }
+    get client() {
+        return this._client;
+    }
+    get options() {
+        return this.handler.options;
+    }
+    /** Alias for {@link RequestHandler#authRequest | RequestHandler#authRequest} */
+    async authRequest(options) {
+        return this.handler.authRequest(options);
+    }
+    /**
+     * Get the gateway information related to your bot client.
+     */
+    async getBotGateway() {
+        return this.authRequest({
+            method: "GET",
+            path: Routes.GATEWAY_BOT
+        }).then(data => ({
+            url: data.url,
+            shards: data.shards,
+            sessionStartLimit: {
+                total: data.session_start_limit.total,
+                remaining: data.session_start_limit.remaining,
+                resetAfter: data.session_start_limit.reset_after,
+                maxConcurrency: data.session_start_limit.max_concurrency
+            }
+        }));
+    }
+    /**
+     * Get the gateway information.
+     */
+    async getGateway() {
+        return this.request({
+            method: "GET",
+            path: Routes.GATEWAY
+        });
+    }
+    /** Alias for {@link RequestHandler#request | RequestHandler#request} */
+    async request(options) {
+        return this.handler.request(options);
+    }
+}
+exports.default = RESTManager;

package/cjs/lib/Discord/rest/RequestHandler.cjs

@@ -0,0 +1,320 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module RequestHandler */
+const SequentialBucket_1 = __importDefault(require("./SequentialBucket"));
+const DiscordRESTError_1 = __importDefault(require("./DiscordRESTError"));
+const DiscordHTTPError_1 = __importDefault(require("./DiscordHTTPError"));
+const Constants_1 = require("../Constants");
+const Base_1 = __importDefault(require("../structures/Base"));
+const Errors_1 = require("../util/Errors");
+/**
+ * Latency & ratelimit related things lovingly borrowed from eris
+ * https://github.com/abalabahaha/eris/blob/dev/lib/rest/RequestHandler.js (eb403730855714eafa36c541dbe2cb84c9979158)
+ */
+/** The primary means of communicating with Discord via rest. */
+class RequestHandler {
+    constructor(manager, options = {}) {
+        this.globalBlock = false;
+        this.ratelimits = {};
+        this.readyQueue = [];
+        if (options && options.baseURL && options.baseURL.endsWith("/")) {
+            options.baseURL = options.baseURL.slice(0, -1);
+        }
+        this._manager = manager;
+        this.options = {
+            agent: options.agent,
+            baseURL: options.baseURL ?? Constants_1.API_URL,
+            disableLatencyCompensation: !!options.disableLatencyCompensation,
+            followRedirects: !!options.followRedirects,
+            host: options.host ?? (options.baseURL ? new URL(options.baseURL).host : new URL(Constants_1.API_URL).host),
+            latencyThreshold: options.latencyThreshold ?? 30000,
+            maxRatelimitRetryWindow: options.maxRatelimitRetryWindow ?? 30000,
+            ratelimiterOffset: options.ratelimiterOffset ?? 0,
+            requestTimeout: options.requestTimeout ?? 15000,
+            superProperties: options.superProperties ?? null,
+            userAgent: options.userAgent ?? Constants_1.USER_AGENT
+        };
+        this.latencyRef = {
+            lastTimeOffsetCheck: 0,
+            latency: options.ratelimiterOffset ?? 0,
+            raw: Array.from({ length: 10 }).fill(options.ratelimiterOffset ?? 0),
+            timeOffsets: Array.from({ length: 10 }).fill(0),
+            timeoffset: 0
+        };
+    }
+    getRoute(path, method) {
+        let route = path.replaceAll(/\/([a-z-]+)\/\d{15,21}/g, function (match, p) {
+            return p === "channels" || p === "guilds" || p === "webhooks" ? match : `/${p}/:id`;
+        }).replaceAll(/\/reactions\/[^/]+/g, "/reactions/:id").replaceAll(/\/reactions\/:id\/[^/]+/g, "/reactions/:id/:userID").replace(/^\/webhooks\/(\d+)\/[\w-]{64,}/, "/webhooks/$1/:token");
+        if (method === "DELETE" && route.endsWith("/messages/:id")) {
+            const messageID = path.slice(path.lastIndexOf("/") + 1);
+            const createdAt = Base_1.default.getCreatedAt(messageID).getTime();
+            if (Date.now() - this.latencyRef.latency - createdAt >= 1000 * 60 * 60 * 24 * 14) {
+                method += "_OLD";
+            }
+            else if (Date.now() - this.latencyRef.latency - createdAt <= 1000 * 10) {
+                method += "_NEW";
+            }
+            route = method + route;
+        }
+        else if (method === "GET" && /\/guilds\/\d+\/channels$/.test(route)) {
+            route = "/guilds/:id/channels";
+        }
+        if (method === "PUT" || method === "DELETE") {
+            const index = route.indexOf("/reactions");
+            if (index !== -1) {
+                route = "MODIFY" + route.slice(0, index + 10);
+            }
+        }
+        return route;
+    }
+    globalUnblock() {
+        this.globalBlock = false;
+        while (this.readyQueue.length !== 0) {
+            this.readyQueue.shift()();
+        }
+    }
+    /** same as `request`, but with `auth` always set to `true`. */
+    async authRequest(options) {
+        return this.request({
+            ...options,
+            auth: true
+        });
+    }
+    /**
+     * Make a request. `null` will be returned if the request results in a `204 NO CONTENT`.
+     * @param options The options for the request.
+     */
+    async request(options) {
+        options.method = options.method.toUpperCase();
+        if (!Constants_1.RESTMethods.includes(options.method)) {
+            throw new TypeError(`Invalid method "${options.method}.`);
+        }
+        const _stackHolder = {};
+        Error.captureStackTrace(_stackHolder);
+        if (!options.path.startsWith("/")) {
+            options.path = `/${options.path}`;
+        }
+        const route = options.route ?? this.getRoute(options.path, options.method);
+        if (!this.ratelimits[route]) {
+            this.ratelimits[route] = new SequentialBucket_1.default(1, this.latencyRef);
+        }
+        let attempts = 0;
+        return new Promise((resolve, reject) => {
+            async function attempt(cb) {
+                const headers = options.headers ?? {};
+                try {
+                    if (typeof options.auth === "string") {
+                        headers.Authorization = options.auth;
+                    }
+                    else if (options.auth && this._manager.client.options.auth) {
+                        headers.Authorization = this._manager.client.options.auth;
+                    }
+                    if (options.reason) {
+                        headers["X-Audit-Log-Reason"] = encodeURIComponent(options.reason);
+                    }
+                    let reqBody;
+                    if (options.method !== "GET") {
+                        let stringBody;
+                        if (options.json) {
+                            stringBody = JSON.stringify(options.json, (k, v) => typeof v === "bigint" ? v.toString() : v);
+                        }
+                        if (options.form || (options.files && options.files.length !== 0)) {
+                            const data = options.form ?? new FormData();
+                            let index = 0;
+                            if (options.files)
+                                for (const file of options.files.values()) {
+                                    index++;
+                                    if (file.index !== undefined) {
+                                        index = file.index;
+                                    }
+                                    if (!file.contents) {
+                                        continue;
+                                    }
+                                    data.set(file.field || `files[${index}]`, new Blob([file.contents]), file.name);
+                                }
+                            if (stringBody) {
+                                data.set("payload_json", stringBody);
+                            }
+                            reqBody = data;
+                        }
+                        else if (options.json) {
+                            reqBody = stringBody;
+                            headers["Content-Type"] = "application/json";
+                        }
+                    }
+                    if (this.options.host) {
+                        headers.Host = this.options.host;
+                    }
+                    if (this.options.superProperties) {
+                        headers["X-Super-Properties"] = typeof this.options.superProperties === "object" ? JSON.stringify(this.options.superProperties) : this.options.superProperties;
+                    }
+                    const url = `${this.options.baseURL}${options.path}${options.query && Array.from(options.query.keys()).length !== 0 ? `?${options.query.toString()}` : ""}`;
+                    let latency = Date.now();
+                    const controller = new AbortController();
+                    let timeout;
+                    if (this.options.requestTimeout > 0 && this.options.requestTimeout !== Infinity) {
+                        timeout = setTimeout(() => controller.abort(), this.options.requestTimeout);
+                    }
+                    const res = await fetch(url, {
+                        method: options.method,
+                        headers,
+                        body: reqBody,
+                        dispatcher: this.options.agent || undefined,
+                        signal: controller.signal,
+                        redirect: this.options.followRedirects ? "follow" : "manual"
+                    });
+                    if (timeout) {
+                        clearTimeout(timeout);
+                    }
+                    latency = Date.now() - latency;
+                    if (!this.options.disableLatencyCompensation) {
+                        this.latencyRef.raw.push(latency);
+                        this.latencyRef.latency = this.latencyRef.latency - Math.trunc((this.latencyRef.raw.shift() ?? 0) / 10) + Math.trunc(latency / 10);
+                    }
+                    let resBody;
+                    if (res.status === 204) {
+                        resBody = null;
+                    }
+                    else {
+                        if (res.headers.get("content-type") === "application/json") {
+                            const b = await res.text();
+                            try {
+                                resBody = JSON.parse(b);
+                            }
+                            catch (err) {
+                                this._manager.client.emit("error", err);
+                                resBody = b;
+                            }
+                        }
+                        else {
+                            resBody = Buffer.from(await res.arrayBuffer());
+                        }
+                    }
+                    this._manager.client.emit("request", {
+                        method: options.method,
+                        path: options.path,
+                        route,
+                        withAuth: !!options.auth,
+                        requestBody: reqBody,
+                        responseBody: resBody
+                    });
+                    const headerNow = Date.parse(res.headers.get("date"));
+                    const now = Date.now();
+                    if (this.latencyRef.lastTimeOffsetCheck < (Date.now() - 5000)) {
+                        const timeOffset = headerNow + 500 - (this.latencyRef.lastTimeOffsetCheck = Date.now());
+                        if (this.latencyRef.timeoffset - this.latencyRef.latency >= this.options.latencyThreshold && timeOffset - this.latencyRef.latency >= this.options.latencyThreshold) {
+                            this._manager.client.emit("warn", `Your clock is ${this.latencyRef.timeoffset}ms behind Discord's server clock. Please check your connection and system time.`);
+                        }
+                        this.latencyRef.timeoffset = this.latencyRef.timeoffset - Math.trunc(this.latencyRef.timeOffsets.shift() / 10) + Math.trunc(timeOffset / 10);
+                        this.latencyRef.timeOffsets.push(timeOffset);
+                    }
+                    if (res.headers.has("x-ratelimit-limit")) {
+                        this.ratelimits[route].limit = Number(res.headers.get("x-ratelimit-limit"));
+                    }
+                    if (options.method !== "GET" && (!res.headers.has("x-ratelimit-remaining") || !res.headers.has("x-ratelimit-limit")) && this.ratelimits[route].limit !== 1) {
+                        this._manager.client.emit("debug", [`Missing ratelimit headers for SequentialBucket(${this.ratelimits[route].remaining}/${this.ratelimits[route].limit}) with non-default limit\n`,
+                            `${res.status} ${res.headers.get("content-type") ?? "null"}: ${options.method} ${route} | ${res.headers.get("cf-ray") ?? "null"}\n`,
+                            `content-type = ${res.headers.get("content-type") ?? "null"}\n`,
+                            `x-ratelimit-remaining = ${res.headers.get("x-ratelimit-remaining") ?? "null"}\n`,
+                            `x-ratelimit-limit = ${res.headers.get("x-ratelimit-limit") ?? "null"}\n`,
+                            `x-ratelimit-reset = ${res.headers.get("x-ratelimit-reset") ?? "null"}\n`,
+                            `x-ratelimit-global = ${res.headers.get("x-ratelimit-global") ?? "null"}`].join("\n"));
+                    }
+                    this.ratelimits[route].remaining = res.headers.has("x-ratelimit-remaining") ? Number(res.headers.get("x-ratelimit-remaining")) ?? 0 : 1;
+                    const retryAfter = Number(res.headers.get("x-ratelimit-reset-after") ?? res.headers.get("retry-after") ?? 0) * 1000;
+                    if (retryAfter >= 0) {
+                        if (res.headers.has("x-ratelimit-global")) {
+                            this.globalBlock = true;
+                            setTimeout(this.globalUnblock.bind(this), retryAfter ?? 1);
+                        }
+                        else {
+                            this.ratelimits[route].reset = (retryAfter ?? 1) + now;
+                        }
+                    }
+                    else if (res.headers.has("x-ratelimit-reset")) {
+                        let resetTime = Number(res.headers.get("x-ratelimit-reset")) * 1000;
+                        if (route.endsWith("/reactions/:id") && (resetTime - headerNow) === 1000) {
+                            resetTime = now + 250;
+                        }
+                        this.ratelimits[route].reset = Math.max(resetTime - this.latencyRef.latency, now);
+                    }
+                    else {
+                        this.ratelimits[route].reset = now;
+                    }
+                    if (res.status !== 429) {
+                        this._manager.client.emit("debug", `${now} ${route} ${res.status}: ${latency}ms (${this.latencyRef.latency}ms avg) | ${this.ratelimits[route].remaining}/${this.ratelimits[route].limit} left | Reset ${this.ratelimits[route].reset} (${this.ratelimits[route].reset - now}ms left)`);
+                    }
+                    if (res.status > 300) {
+                        if (res.status === 429) {
+                            let delay = retryAfter;
+                            if (res.headers.get("x-ratelimit-scope") === "shared") {
+                                try {
+                                    delay = resBody.retry_after * 1000;
+                                }
+                                catch (err) {
+                                    cb();
+                                    reject(err);
+                                }
+                            }
+                            this._manager.client.emit("debug", `${res.headers.has("x-ratelimit-global") ? "Global" : "Unexpected"} RateLimit: ${JSON.stringify(resBody)}\n${now} ${route} ${res.status}: ${latency}ms (${this.latencyRef.latency}ms avg) | ${this.ratelimits[route].remaining}/${this.ratelimits[route].limit} left | Reset ${delay} (${this.ratelimits[route].reset - now}ms left) | Scope ${res.headers.get("x-ratelimit-scope")}`);
+                            if (delay) {
+                                if (delay > this.options.maxRatelimitRetryWindow) {
+                                    cb();
+                                    return reject(new Errors_1.RateLimitedError(`Ratelimit on "${options.method} ${route}" exceeds the maximum retry window (${delay} > ${this.options.maxRatelimitRetryWindow})`, delay));
+                                }
+                                setTimeout(() => {
+                                    cb();
+                                    // eslint-disable-next-line prefer-rest-params, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, prefer-spread
+                                    this.request(options).then(resolve).catch(reject);
+                                }, delay);
+                                return;
+                            }
+                            else {
+                                cb();
+                                this.request(options).then(resolve).catch(reject);
+                                return;
+                            }
+                        }
+                        else if (res.status === 502 && ++attempts < 4) {
+                            this._manager.client.emit("debug", `Unexpected 502 on ${options.method} ${route}`);
+                            setTimeout(() => {
+                                this.request(options).then(resolve).catch(reject);
+                            }, Math.floor(Math.random() * 1900 + 100));
+                            return cb();
+                        }
+                        cb();
+                        let { stack } = _stackHolder;
+                        if (stack.startsWith("Error\n")) {
+                            stack = stack.slice(6);
+                        }
+                        const err = resBody && typeof resBody === "object" && "code" in resBody ? new DiscordRESTError_1.default(res, resBody, options.method, stack) : new DiscordHTTPError_1.default(res, resBody, options.method, stack);
+                        reject(err);
+                        return;
+                    }
+                    cb();
+                    resolve(resBody);
+                }
+                catch (err) {
+                    cb();
+                    if (err instanceof Error && err.constructor.name === "DOMException" && err.name === "AbortError") {
+                        reject(new Error(`Request Timed Out (>${this.options.requestTimeout}ms) on ${options.method} ${options.path}`));
+                    }
+                    this._manager.client.emit("error", err);
+                }
+            }
+            if (this.globalBlock && options.auth) {
+                (options.priority ? this.readyQueue.unshift.bind(this.readyQueue) : this.readyQueue.push.bind(this.readyQueue))(() => {
+                    this.ratelimits[route].queue(attempt.bind(this), options.priority);
+                });
+            }
+            else {
+                this.ratelimits[route].queue(attempt.bind(this), options.priority);
+            }
+        });
+    }
+}
+exports.default = RequestHandler;