@discordjs/rest 1.6.0-dev.1677499520-ffdb197.0 → 1.6.0

package/dist/index.js

@@ -19,6 +19,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
@@ -54,7 +58,7 @@ var import_node_url = require("url");
 var import_node_process = __toESM(require("process"));
 var import_v10 = require("discord-api-types/v10");
 var import_undici = require("undici");
-var DefaultUserAgent = `DiscordBot (https://discord.js.org, 1.6.0-dev.1677499520-ffdb197.0)`;
+var DefaultUserAgent = `DiscordBot (https://discord.js.org, [VI]{{inject}}[/VI])`;
 var DefaultRestOptions = {
   get agent() {
     return new import_undici.Agent({
@@ -79,19 +83,40 @@ var DefaultRestOptions = {
   hashLifetime: 864e5,
   handlerSweepInterval: 36e5
 };
-var RESTEvents = /* @__PURE__ */ ((RESTEvents2) => {
+var RESTEvents;
+(function(RESTEvents2) {
   RESTEvents2["Debug"] = "restDebug";
   RESTEvents2["HandlerSweep"] = "handlerSweep";
   RESTEvents2["HashSweep"] = "hashSweep";
   RESTEvents2["InvalidRequestWarning"] = "invalidRequestWarning";
   RESTEvents2["RateLimited"] = "rateLimited";
   RESTEvents2["Response"] = "response";
-  return RESTEvents2;
-})(RESTEvents || {});
-var ALLOWED_EXTENSIONS = ["webp", "png", "jpg", "jpeg", "gif"];
-var ALLOWED_STICKER_EXTENSIONS = ["png", "json", "gif"];
-var ALLOWED_SIZES = [16, 32, 64, 128, 256, 512, 1024, 2048, 4096];
+})(RESTEvents || (RESTEvents = {}));
+var ALLOWED_EXTENSIONS = [
+  "webp",
+  "png",
+  "jpg",
+  "jpeg",
+  "gif"
+];
+var ALLOWED_STICKER_EXTENSIONS = [
+  "png",
+  "json",
+  "gif"
+];
+var ALLOWED_SIZES = [
+  16,
+  32,
+  64,
+  128,
+  256,
+  512,
+  1024,
+  2048,
+  4096
+];
 var OverwrittenMimeTypes = {
+  // https://github.com/discordjs/discord.js/issues/8557
   "image/apng": "image/png"
 };
 
@@ -100,60 +125,201 @@ var CDN = class {
   constructor(base = DefaultRestOptions.cdn) {
     this.base = base;
   }
+  /**
+  * Generates an app asset URL for a client's asset.
+  *
+  * @param clientId - The client id that has the asset
+  * @param assetHash - The hash provided by Discord for this asset
+  * @param options - Optional options for the asset
+  */
   appAsset(clientId, assetHash, options) {
     return this.makeURL(`/app-assets/${clientId}/${assetHash}`, options);
   }
+  /**
+  * Generates an app icon URL for a client's icon.
+  *
+  * @param clientId - The client id that has the icon
+  * @param iconHash - The hash provided by Discord for this icon
+  * @param options - Optional options for the icon
+  */
   appIcon(clientId, iconHash, options) {
     return this.makeURL(`/app-icons/${clientId}/${iconHash}`, options);
   }
+  /**
+  * Generates an avatar URL, e.g. for a user or a webhook.
+  *
+  * @param id - The id that has the icon
+  * @param avatarHash - The hash provided by Discord for this avatar
+  * @param options - Optional options for the avatar
+  */
   avatar(id, avatarHash, options) {
     return this.dynamicMakeURL(`/avatars/${id}/${avatarHash}`, avatarHash, options);
   }
+  /**
+  * Generates a banner URL, e.g. for a user or a guild.
+  *
+  * @param id - The id that has the banner splash
+  * @param bannerHash - The hash provided by Discord for this banner
+  * @param options - Optional options for the banner
+  */
   banner(id, bannerHash, options) {
     return this.dynamicMakeURL(`/banners/${id}/${bannerHash}`, bannerHash, options);
   }
+  /**
+  * Generates an icon URL for a channel, e.g. a group DM.
+  *
+  * @param channelId - The channel id that has the icon
+  * @param iconHash - The hash provided by Discord for this channel
+  * @param options - Optional options for the icon
+  */
   channelIcon(channelId, iconHash, options) {
     return this.makeURL(`/channel-icons/${channelId}/${iconHash}`, options);
   }
+  /**
+  * Generates the default avatar URL for a discriminator.
+  *
+  * @param discriminator - The discriminator modulo 5
+  */
   defaultAvatar(discriminator) {
-    return this.makeURL(`/embed/avatars/${discriminator}`, { extension: "png" });
+    return this.makeURL(`/embed/avatars/${discriminator}`, {
+      extension: "png"
+    });
   }
+  /**
+  * Generates a discovery splash URL for a guild's discovery splash.
+  *
+  * @param guildId - The guild id that has the discovery splash
+  * @param splashHash - The hash provided by Discord for this splash
+  * @param options - Optional options for the splash
+  */
   discoverySplash(guildId, splashHash, options) {
     return this.makeURL(`/discovery-splashes/${guildId}/${splashHash}`, options);
   }
+  /**
+  * Generates an emoji's URL for an emoji.
+  *
+  * @param emojiId - The emoji id
+  * @param extension - The extension of the emoji
+  */
   emoji(emojiId, extension) {
-    return this.makeURL(`/emojis/${emojiId}`, { extension });
+    return this.makeURL(`/emojis/${emojiId}`, {
+      extension
+    });
   }
+  /**
+  * Generates a guild member avatar URL.
+  *
+  * @param guildId - The id of the guild
+  * @param userId - The id of the user
+  * @param avatarHash - The hash provided by Discord for this avatar
+  * @param options - Optional options for the avatar
+  */
   guildMemberAvatar(guildId, userId, avatarHash, options) {
     return this.dynamicMakeURL(`/guilds/${guildId}/users/${userId}/avatars/${avatarHash}`, avatarHash, options);
   }
+  /**
+  * Generates a guild member banner URL.
+  *
+  * @param guildId - The id of the guild
+  * @param userId - The id of the user
+  * @param bannerHash - The hash provided by Discord for this banner
+  * @param options - Optional options for the banner
+  */
   guildMemberBanner(guildId, userId, bannerHash, options) {
     return this.dynamicMakeURL(`/guilds/${guildId}/users/${userId}/banner`, bannerHash, options);
   }
+  /**
+  * Generates an icon URL, e.g. for a guild.
+  *
+  * @param id - The id that has the icon splash
+  * @param iconHash - The hash provided by Discord for this icon
+  * @param options - Optional options for the icon
+  */
   icon(id, iconHash, options) {
     return this.dynamicMakeURL(`/icons/${id}/${iconHash}`, iconHash, options);
   }
+  /**
+  * Generates a URL for the icon of a role
+  *
+  * @param roleId - The id of the role that has the icon
+  * @param roleIconHash - The hash provided by Discord for this role icon
+  * @param options - Optional options for the role icon
+  */
   roleIcon(roleId, roleIconHash, options) {
     return this.makeURL(`/role-icons/${roleId}/${roleIconHash}`, options);
   }
+  /**
+  * Generates a guild invite splash URL for a guild's invite splash.
+  *
+  * @param guildId - The guild id that has the invite splash
+  * @param splashHash - The hash provided by Discord for this splash
+  * @param options - Optional options for the splash
+  */
   splash(guildId, splashHash, options) {
     return this.makeURL(`/splashes/${guildId}/${splashHash}`, options);
   }
+  /**
+  * Generates a sticker URL.
+  *
+  * @param stickerId - The sticker id
+  * @param extension - The extension of the sticker
+  * @privateRemarks
+  * Stickers cannot have a `.webp` extension, so we default to a `.png`
+  */
   sticker(stickerId, extension = "png") {
-    return this.makeURL(`/stickers/${stickerId}`, { allowedExtensions: ALLOWED_STICKER_EXTENSIONS, extension });
+    return this.makeURL(`/stickers/${stickerId}`, {
+      allowedExtensions: ALLOWED_STICKER_EXTENSIONS,
+      extension
+    });
   }
+  /**
+  * Generates a sticker pack banner URL.
+  *
+  * @param bannerId - The banner id
+  * @param options - Optional options for the banner
+  */
   stickerPackBanner(bannerId, options) {
     return this.makeURL(`/app-assets/710982414301790216/store/${bannerId}`, options);
   }
+  /**
+  * Generates a team icon URL for a team's icon.
+  *
+  * @param teamId - The team id that has the icon
+  * @param iconHash - The hash provided by Discord for this icon
+  * @param options - Optional options for the icon
+  */
   teamIcon(teamId, iconHash, options) {
     return this.makeURL(`/team-icons/${teamId}/${iconHash}`, options);
   }
+  /**
+  * Generates a cover image for a guild scheduled event.
+  *
+  * @param scheduledEventId - The scheduled event id
+  * @param coverHash - The hash provided by discord for this cover image
+  * @param options - Optional options for the cover image
+  */
   guildScheduledEventCover(scheduledEventId, coverHash, options) {
     return this.makeURL(`/guild-events/${scheduledEventId}/${coverHash}`, options);
   }
+  /**
+  * Constructs the URL for the resource, checking whether or not `hash` starts with `a_` if `dynamic` is set to `true`.
+  *
+  * @param route - The base cdn route
+  * @param hash - The hash provided by Discord for this icon
+  * @param options - Optional options for the link
+  */
   dynamicMakeURL(route, hash, { forceStatic = false, ...options } = {}) {
-    return this.makeURL(route, !forceStatic && hash.startsWith("a_") ? { ...options, extension: "gif" } : options);
-  }
+    return this.makeURL(route, !forceStatic && hash.startsWith("a_") ? {
+      ...options,
+      extension: "gif"
+    } : options);
+  }
+  /**
+  * Constructs the URL for the resource
+  *
+  * @param route - The base cdn route
+  * @param options - The extension/size options for the link
+  */
   makeURL(route, { allowedExtensions = ALLOWED_EXTENSIONS, extension = "webp", size } = {}) {
     extension = String(extension).toLowerCase();
     if (!allowedExtensions.includes(extension)) {
@@ -183,6 +349,14 @@ function isErrorResponse(error) {
 }
 __name(isErrorResponse, "isErrorResponse");
 var DiscordAPIError = class extends Error {
+  /**
+  * @param rawError - The error reported by Discord
+  * @param code - The error code reported by Discord
+  * @param status - The status code of the response
+  * @param method - The method of the request that erred
+  * @param url - The url of the request that erred
+  * @param bodyData - The unparsed data for the request that errored
+  */
   constructor(rawError, code, status, method, url, bodyData) {
     super(DiscordAPIError.getMessage(rawError));
     this.rawError = rawError;
@@ -190,9 +364,14 @@ var DiscordAPIError = class extends Error {
     this.status = status;
     this.method = method;
     this.url = url;
-    this.requestBody = { files: bodyData.files, json: bodyData.body };
+    this.requestBody = {
+      files: bodyData.files,
+      json: bodyData.body
+    };
   }
-  requestBody;
+  /**
+  * The name of the error
+  */
   get name() {
     return `${DiscordAPIError.name}[${this.code}]`;
   }
@@ -200,7 +379,9 @@ var DiscordAPIError = class extends Error {
     let flattened = "";
     if ("code" in error) {
       if (error.errors) {
-        flattened = [...this.flattenDiscordError(error.errors)].join("\n");
+        flattened = [
+          ...this.flattenDiscordError(error.errors)
+        ].join("\n");
       }
       return error.message && flattened ? `${error.message}
 ${flattened}` : error.message || flattened || "Unknown Error";
@@ -230,28 +411,28 @@ __name(DiscordAPIError, "DiscordAPIError");
 // src/lib/errors/HTTPError.ts
 var import_node_http = require("http");
 var HTTPError = class extends Error {
+  /**
+  * @param status - The status code of the response
+  * @param method - The method of the request that erred
+  * @param url - The url of the request that erred
+  * @param bodyData - The unparsed data for the request that errored
+  */
   constructor(status, method, url, bodyData) {
     super(import_node_http.STATUS_CODES[status]);
     this.status = status;
     this.method = method;
     this.url = url;
-    this.requestBody = { files: bodyData.files, json: bodyData.body };
+    this.name = HTTPError.name;
+    this.requestBody = {
+      files: bodyData.files,
+      json: bodyData.body
+    };
   }
-  requestBody;
-  name = HTTPError.name;
 };
 __name(HTTPError, "HTTPError");
 
 // src/lib/errors/RateLimitError.ts
 var RateLimitError = class extends Error {
-  timeToReset;
-  limit;
-  method;
-  hash;
-  url;
-  route;
-  majorParameter;
-  global;
   constructor({ timeToReset, limit, method, hash, url, route, majorParameter, global }) {
     super();
     this.timeToReset = timeToReset;
@@ -263,6 +444,9 @@ var RateLimitError = class extends Error {
     this.majorParameter = majorParameter;
     this.global = global;
   }
+  /**
+  * The name of the error
+  */
   get name() {
     return `${RateLimitError.name}[${this.route}]`;
   }
@@ -342,10 +526,13 @@ function hasSublimit(bucketRoute, body, method) {
   if (bucketRoute === "/channels/:id") {
     if (typeof body !== "object" || body === null)
       return false;
-    if (method !== "PATCH" /* Patch */)
+    if (method !== RequestMethod.Patch)
       return false;
     const castedBody = body;
-    return ["name", "topic"].some((key) => Reflect.has(castedBody, key));
+    return [
+      "name",
+      "topic"
+    ].some((key) => Reflect.has(castedBody, key));
   }
   return true;
 }
@@ -368,7 +555,9 @@ async function resolveBody(body) {
   } else if (body instanceof import_undici2.FormData) {
     return body;
   } else if (body[Symbol.iterator]) {
-    const chunks = [...body];
+    const chunks = [
+      ...body
+    ];
     const length = chunks.reduce((a, b) => a + b.length, 0);
     const uint8 = new Uint8Array(length);
     let lengthUsed = 0;
@@ -397,43 +586,96 @@ __name(shouldRetry, "shouldRetry");
 // src/lib/handlers/SequentialHandler.ts
 var invalidCount = 0;
 var invalidCountResetTime = null;
+var QueueType;
+(function(QueueType2) {
+  QueueType2[QueueType2["Standard"] = 0] = "Standard";
+  QueueType2[QueueType2["Sublimit"] = 1] = "Sublimit";
+})(QueueType || (QueueType = {}));
 var SequentialHandler = class {
+  /**
+  * The interface used to sequence async requests sequentially
+  */
+  #asyncQueue;
+  /**
+  * The interface used to sequence sublimited async requests sequentially
+  */
+  #sublimitedQueue;
+  /**
+  * A promise wrapper for when the sublimited queue is finished being processed or null when not being processed
+  */
+  #sublimitPromise;
+  /**
+  * Whether the sublimit queue needs to be shifted in the finally block
+  */
+  #shiftSublimit;
+  /**
+  * @param manager - The request manager
+  * @param hash - The hash that this RequestHandler handles
+  * @param majorParameter - The major parameter for this handler
+  */
   constructor(manager, hash, majorParameter) {
     this.manager = manager;
     this.hash = hash;
     this.majorParameter = majorParameter;
+    this.reset = -1;
+    this.remaining = 1;
+    this.limit = Number.POSITIVE_INFINITY;
+    this.#asyncQueue = new import_async_queue.AsyncQueue();
+    this.#sublimitedQueue = null;
+    this.#sublimitPromise = null;
+    this.#shiftSublimit = false;
     this.id = `${hash}:${majorParameter}`;
   }
-  id;
-  reset = -1;
-  remaining = 1;
-  limit = Number.POSITIVE_INFINITY;
-  #asyncQueue = new import_async_queue.AsyncQueue();
-  #sublimitedQueue = null;
-  #sublimitPromise = null;
-  #shiftSublimit = false;
+  /**
+  * {@inheritDoc IHandler.inactive}
+  */
   get inactive() {
     return this.#asyncQueue.remaining === 0 && (this.#sublimitedQueue === null || this.#sublimitedQueue.remaining === 0) && !this.limited;
   }
+  /**
+  * If the rate limit bucket is currently limited by the global limit
+  */
   get globalLimited() {
     return this.manager.globalRemaining <= 0 && Date.now() < this.manager.globalReset;
   }
+  /**
+  * If the rate limit bucket is currently limited by its limit
+  */
   get localLimited() {
     return this.remaining <= 0 && Date.now() < this.reset;
   }
+  /**
+  * If the rate limit bucket is currently limited
+  */
   get limited() {
     return this.globalLimited || this.localLimited;
   }
+  /**
+  * The time until queued requests can continue
+  */
   get timeToReset() {
     return this.reset + this.manager.options.offset - Date.now();
   }
+  /**
+  * Emits a debug message
+  *
+  * @param message - The message to debug
+  */
   debug(message) {
-    this.manager.emit("restDebug" /* Debug */, `[REST ${this.id}] ${message}`);
+    this.manager.emit(RESTEvents.Debug, `[REST ${this.id}] ${message}`);
   }
+  /**
+  * Delay all requests for the specified amount of time, handling global rate limits
+  *
+  * @param time - The amount of time to delay all requests for
+  */
   async globalDelayFor(time) {
     await (0, import_promises.setTimeout)(time);
     this.manager.globalDelay = null;
   }
+  /*
+  * Determines whether the request should be queued or whether a RateLimitError should be thrown
+  */
   async onRateLimit(rateLimitData) {
     const { options } = this.manager;
     if (!options.rejectOnRateLimit)
@@ -443,15 +685,20 @@ var SequentialHandler = class {
       throw new RateLimitError(rateLimitData);
     }
   }
+  /**
+  * {@inheritDoc IHandler.queueRequest}
+  */
   async queueRequest(routeId, url, options, requestData) {
     let queue = this.#asyncQueue;
-    let queueType = 0 /* Standard */;
+    let queueType = 0;
     if (this.#sublimitedQueue && hasSublimit(routeId.bucketRoute, requestData.body, options.method)) {
       queue = this.#sublimitedQueue;
-      queueType = 1 /* Sublimit */;
+      queueType = 1;
     }
-    await queue.wait({ signal: requestData.signal });
-    if (queueType === 0 /* Standard */) {
+    await queue.wait({
+      signal: requestData.signal
+    });
+    if (queueType === 0) {
       if (this.#sublimitedQueue && hasSublimit(routeId.bucketRoute, requestData.body, options.method)) {
         queue = this.#sublimitedQueue;
         const wait = queue.wait();
@@ -475,6 +722,15 @@ var SequentialHandler = class {
       }
     }
   }
+  /**
+  * The method that actually makes the request to the api, and updates info about the bucket accordingly
+  *
+  * @param routeId - The generalized api route with literal ids for major parameters
+  * @param url - The fully resolved url to make the request to
+  * @param options - The fetch options needed to make the request
+  * @param requestData - Extra data from the user's request needed for errors and additional processing
+  * @param retries - The number of retries this request has already attempted (recursion)
+  */
   async runRequest(routeId, url, options, requestData, retries = 0) {
     while (this.limited) {
       const isGlobal = this.globalLimited;
@@ -503,7 +759,7 @@ var SequentialHandler = class {
         majorParameter: this.majorParameter,
         global: isGlobal
       };
-      this.manager.emit("rateLimited" /* RateLimited */, rateLimitData);
+      this.manager.emit(RESTEvents.RateLimited, rateLimitData);
       await this.onRateLimit(rateLimitData);
       if (isGlobal) {
         this.debug(`Global rate limit hit, blocking all requests for ${timeout2}ms`);
@@ -529,7 +785,10 @@ var SequentialHandler = class {
     }
     let res;
     try {
-      res = await (0, import_undici3.request)(url, { ...options, signal: controller.signal });
+      res = await (0, import_undici3.request)(url, {
+        ...options,
+        signal: controller.signal
+      });
     } catch (error) {
       if (!(error instanceof Error))
         throw error;
@@ -540,19 +799,17 @@ var SequentialHandler = class {
     } finally {
       (0, import_node_timers.clearTimeout)(timeout);
     }
-    if (this.manager.listenerCount("response" /* Response */)) {
-      this.manager.emit(
-        "response" /* Response */,
-        {
-          method,
-          path: routeId.original,
-          route: routeId.bucketRoute,
-          options,
-          data: requestData,
-          retries
-        },
-        { ...res }
-      );
+    if (this.manager.listenerCount(RESTEvents.Response)) {
+      this.manager.emit(RESTEvents.Response, {
+        method,
+        path: routeId.original,
+        route: routeId.bucketRoute,
+        options,
+        data: requestData,
+        retries
+      }, {
+        ...res
+      });
     }
     const status = res.statusCode;
     let retryAfter = 0;
@@ -567,8 +824,15 @@ var SequentialHandler = class {
     if (retry)
       retryAfter = Number(retry) * 1e3 + this.manager.options.offset;
     if (hash && hash !== this.hash) {
-      this.debug(["Received bucket hash update", `  Old Hash  : ${this.hash}`, `  New Hash  : ${hash}`].join("\n"));
-      this.manager.hashes.set(`${method}:${routeId.bucketRoute}`, { value: hash, lastAccess: Date.now() });
+      this.debug([
+        "Received bucket hash update",
+        `  Old Hash  : ${this.hash}`,
+        `  New Hash  : ${hash}`
+      ].join("\n"));
+      this.manager.hashes.set(`${method}:${routeId.bucketRoute}`, {
+        value: hash,
+        lastAccess: Date.now()
+      });
     } else if (hash) {
       const hashData = this.manager.hashes.get(`${method}:${routeId.bucketRoute}`);
       if (hashData) {
@@ -592,7 +856,7 @@ var SequentialHandler = class {
       invalidCount++;
       const emitInvalid = this.manager.options.invalidRequestWarningInterval > 0 && invalidCount % this.manager.options.invalidRequestWarningInterval === 0;
       if (emitInvalid) {
-        this.manager.emit("invalidRequestWarning" /* InvalidRequestWarning */, {
+        this.manager.emit(RESTEvents.InvalidRequestWarning, {
           count: invalidCount,
           remainingTime: invalidCountResetTime - Date.now()
         });
@@ -621,20 +885,18 @@ var SequentialHandler = class {
         majorParameter: this.majorParameter,
         global: isGlobal
       });
-      this.debug(
-        [
-          "Encountered unexpected 429 rate limit",
-          `  Global         : ${isGlobal.toString()}`,
-          `  Method         : ${method}`,
-          `  URL            : ${url}`,
-          `  Bucket         : ${routeId.bucketRoute}`,
-          `  Major parameter: ${routeId.majorParameter}`,
-          `  Hash           : ${this.hash}`,
-          `  Limit          : ${limit2}`,
-          `  Retry After    : ${retryAfter}ms`,
-          `  Sublimit       : ${sublimitTimeout ? `${sublimitTimeout}ms` : "None"}`
-        ].join("\n")
-      );
+      this.debug([
+        "Encountered unexpected 429 rate limit",
+        `  Global         : ${isGlobal.toString()}`,
+        `  Method         : ${method}`,
+        `  URL            : ${url}`,
+        `  Bucket         : ${routeId.bucketRoute}`,
+        `  Major parameter: ${routeId.majorParameter}`,
+        `  Hash           : ${this.hash}`,
+        `  Limit          : ${limit2}`,
+        `  Retry After    : ${retryAfter}ms`,
+        `  Sublimit       : ${sublimitTimeout ? `${sublimitTimeout}ms` : "None"}`
+      ].join("\n"));
       if (sublimitTimeout) {
         const firstSublimit = !this.#sublimitedQueue;
         if (firstSublimit) {
@@ -647,7 +909,10 @@ var SequentialHandler = class {
         await (0, import_promises.setTimeout)(sublimitTimeout);
         let resolve;
         const promise = new Promise((res2) => resolve = res2);
-        this.#sublimitPromise = { promise, resolve };
+        this.#sublimitPromise = {
+          promise,
+          resolve
+        };
         if (firstSublimit) {
           await this.#asyncQueue.wait();
           this.#shiftSublimit = true;
@@ -675,28 +940,43 @@ __name(SequentialHandler, "SequentialHandler");
 
 // src/lib/RequestManager.ts
 var getFileType = (0, import_util.lazy)(async () => import("file-type"));
-var RequestMethod = /* @__PURE__ */ ((RequestMethod2) => {
+var RequestMethod;
+(function(RequestMethod2) {
   RequestMethod2["Delete"] = "DELETE";
   RequestMethod2["Get"] = "GET";
   RequestMethod2["Patch"] = "PATCH";
   RequestMethod2["Post"] = "POST";
   RequestMethod2["Put"] = "PUT";
-  return RequestMethod2;
-})(RequestMethod || {});
+})(RequestMethod || (RequestMethod = {}));
 var RequestManager = class extends import_node_events.EventEmitter {
+  /**
+  * The {@link https://undici.nodejs.org/#/docs/api/Agent | Agent} for all requests
+  * performed by this manager.
+  */
   agent = null;
-  globalRemaining;
+  /**
+  * The promise used to wait out the global rate limit
+  */
   globalDelay = null;
+  /**
+  * The timestamp at which the global bucket resets
+  */
   globalReset = -1;
+  /**
+  * API bucket hashes that are cached from provided routes
+  */
   hashes = new import_collection.Collection();
+  /**
+  * Request handlers created from the bucket hash and the major parameters
+  */
   handlers = new import_collection.Collection();
   #token = null;
-  hashTimer;
-  handlerTimer;
-  options;
   constructor(options) {
     super();
-    this.options = { ...DefaultRestOptions, ...options };
+    this.options = {
+      ...DefaultRestOptions,
+      ...options
+    };
     this.options.offset = Math.max(0, this.options.offset);
     this.globalRemaining = this.options.globalRequestsPerSecond;
     this.agent = options.agent ?? null;
@@ -720,10 +1000,10 @@ var RequestManager = class extends import_node_events.EventEmitter {
           if (shouldSweep) {
             sweptHashes.set(key, val);
           }
-          this.emit("restDebug" /* Debug */, `Hash ${val.value} for ${key} swept due to lifetime being exceeded`);
+          this.emit(RESTEvents.Debug, `Hash ${val.value} for ${key} swept due to lifetime being exceeded`);
           return shouldSweep;
         });
-        this.emit("hashSweep" /* HashSweep */, sweptHashes);
+        this.emit(RESTEvents.HashSweep, sweptHashes);
       }, this.options.hashSweepInterval).unref();
     }
     if (this.options.handlerSweepInterval !== 0 && this.options.handlerSweepInterval !== Number.POSITIVE_INFINITY) {
@@ -735,21 +1015,37 @@ var RequestManager = class extends import_node_events.EventEmitter {
           if (inactive) {
             sweptHandlers.set(key, val);
           }
-          this.emit("restDebug" /* Debug */, `Handler ${val.id} for ${key} swept due to being inactive`);
+          this.emit(RESTEvents.Debug, `Handler ${val.id} for ${key} swept due to being inactive`);
           return inactive;
         });
-        this.emit("handlerSweep" /* HandlerSweep */, sweptHandlers);
+        this.emit(RESTEvents.HandlerSweep, sweptHandlers);
       }, this.options.handlerSweepInterval).unref();
     }
   }
+  /**
+  * Sets the default agent to use for requests performed by this manager
+  *
+  * @param agent - The agent to use
+  */
   setAgent(agent) {
     this.agent = agent;
     return this;
   }
+  /**
+  * Sets the authorization token that should be used for requests
+  *
+  * @param token - The authorization token to use
+  */
   setToken(token) {
     this.#token = token;
     return this;
   }
+  /**
+  * Queues a request to be sent
+  *
+  * @param request - All the information needed to make a request
+  * @returns The response from the api request
+  */
   async queueRequest(request2) {
     const routeId = RequestManager.generateRouteData(request2.fullRoute, request2.method);
     const hash = this.hashes.get(`${request2.method}:${routeId.bucketRoute}`) ?? {
@@ -765,11 +1061,23 @@ var RequestManager = class extends import_node_events.EventEmitter {
       signal: request2.signal
     });
   }
+  /**
+  * Creates a new rate limit handler from a hash, based on the hash and the major parameter
+  *
+  * @param hash - The hash for the route
+  * @param majorParameter - The major parameter for this handler
+  * @internal
+  */
   createHandler(hash, majorParameter) {
     const queue = new SequentialHandler(this, hash, majorParameter);
     this.handlers.set(queue.id, queue);
     return queue;
   }
+  /**
+  * Formats the request data to a usable format for fetch
+  *
+  * @param request - The request data
+  */
   async resolveRequest(request2) {
     const { options } = this;
     let query = "";
@@ -808,9 +1116,17 @@ var RequestManager = class extends import_node_events.EventEmitter {
               contentType = OverwrittenMimeTypes[parsedType] ?? parsedType;
             }
           }
-          formData.append(fileKey, new import_node_buffer2.Blob([file.data], { type: contentType }), file.name);
+          formData.append(fileKey, new import_node_buffer2.Blob([
+            file.data
+          ], {
+            type: contentType
+          }), file.name);
         } else {
-          formData.append(fileKey, new import_node_buffer2.Blob([`${file.data}`], { type: file.contentType }), file.name);
+          formData.append(fileKey, new import_node_buffer2.Blob([
+            `${file.data}`
+          ], {
+            type: file.contentType
+          }), file.name);
         }
       }
       if (request2.body != null) {
@@ -828,33 +1144,55 @@ var RequestManager = class extends import_node_events.EventEmitter {
         finalBody = request2.body;
       } else {
         finalBody = JSON.stringify(request2.body);
-        additionalHeaders = { "Content-Type": "application/json" };
+        additionalHeaders = {
+          "Content-Type": "application/json"
+        };
       }
     }
     finalBody = await resolveBody(finalBody);
     const fetchOptions = {
-      headers: { ...request2.headers, ...additionalHeaders, ...headers },
+      headers: {
+        ...request2.headers,
+        ...additionalHeaders,
+        ...headers
+      },
       method: request2.method.toUpperCase()
     };
     if (finalBody !== void 0) {
       fetchOptions.body = finalBody;
     }
     fetchOptions.dispatcher = request2.dispatcher ?? this.agent ?? void 0;
-    return { url, fetchOptions };
+    return {
+      url,
+      fetchOptions
+    };
   }
+  /**
+  * Stops the hash sweeping interval
+  */
   clearHashSweeper() {
     (0, import_node_timers2.clearInterval)(this.hashTimer);
   }
+  /**
+  * Stops the request handler sweeping interval
+  */
   clearHandlerSweeper() {
     (0, import_node_timers2.clearInterval)(this.handlerTimer);
   }
+  /**
+  * Generates route data for an endpoint:method
+  *
+  * @param endpoint - The raw endpoint to generalize
+  * @param method - The HTTP method this endpoint is called without
+  * @internal
+  */
   static generateRouteData(endpoint, method) {
-    const majorIdMatch = /^\/(?:channels|guilds|webhooks)\/(\d{16,19})/.exec(endpoint);
+    const majorIdMatch = /^\/(?:channels|guilds|webhooks)\/(\d{17,19})/.exec(endpoint);
     const majorId = majorIdMatch?.[1] ?? "global";
-    const baseRoute = endpoint.replaceAll(/\d{16,19}/g, ":id").replace(/\/reactions\/(.*)/, "/reactions/:reaction");
+    const baseRoute = endpoint.replaceAll(/\d{17,19}/g, ":id").replace(/\/reactions\/(.*)/, "/reactions/:reaction");
     let exceptions = "";
-    if (method === "DELETE" /* Delete */ && baseRoute === "/channels/:id/messages/:id") {
-      const id = /\d{16,19}$/.exec(endpoint)[0];
+    if (method === "DELETE" && baseRoute === "/channels/:id/messages/:id") {
+      const id = /\d{17,19}$/.exec(endpoint)[0];
       const timestamp = import_snowflake.DiscordSnowflake.timestampFrom(id);
       if (Date.now() - timestamp > 1e3 * 60 * 60 * 24 * 14) {
         exceptions += "/Delete Old Message";
@@ -872,51 +1210,122 @@ __name(RequestManager, "RequestManager");
 // src/lib/REST.ts
 var import_node_events2 = require("events");
 var REST = class extends import_node_events2.EventEmitter {
-  cdn;
-  requestManager;
   constructor(options = {}) {
     super();
     this.cdn = new CDN(options.cdn ?? DefaultRestOptions.cdn);
-    this.requestManager = new RequestManager(options).on("restDebug" /* Debug */, this.emit.bind(this, "restDebug" /* Debug */)).on("rateLimited" /* RateLimited */, this.emit.bind(this, "rateLimited" /* RateLimited */)).on("invalidRequestWarning" /* InvalidRequestWarning */, this.emit.bind(this, "invalidRequestWarning" /* InvalidRequestWarning */)).on("hashSweep" /* HashSweep */, this.emit.bind(this, "hashSweep" /* HashSweep */));
+    this.requestManager = new RequestManager(options).on(RESTEvents.Debug, this.emit.bind(this, RESTEvents.Debug)).on(RESTEvents.RateLimited, this.emit.bind(this, RESTEvents.RateLimited)).on(RESTEvents.InvalidRequestWarning, this.emit.bind(this, RESTEvents.InvalidRequestWarning)).on(RESTEvents.HashSweep, this.emit.bind(this, RESTEvents.HashSweep));
     this.on("newListener", (name, listener) => {
-      if (name === "response" /* Response */)
+      if (name === RESTEvents.Response)
         this.requestManager.on(name, listener);
     });
     this.on("removeListener", (name, listener) => {
-      if (name === "response" /* Response */)
+      if (name === RESTEvents.Response)
         this.requestManager.off(name, listener);
     });
   }
+  /**
+  * Gets the agent set for this instance
+  */
   getAgent() {
     return this.requestManager.agent;
   }
+  /**
+  * Sets the default agent to use for requests performed by this instance
+  *
+  * @param agent - Sets the agent to use
+  */
   setAgent(agent) {
     this.requestManager.setAgent(agent);
     return this;
   }
+  /**
+  * Sets the authorization token that should be used for requests
+  *
+  * @param token - The authorization token to use
+  */
   setToken(token) {
     this.requestManager.setToken(token);
     return this;
   }
+  /**
+  * Runs a get request from the api
+  *
+  * @param fullRoute - The full route to query
+  * @param options - Optional request options
+  */
   async get(fullRoute, options = {}) {
-    return this.request({ ...options, fullRoute, method: "GET" /* Get */ });
+    return this.request({
+      ...options,
+      fullRoute,
+      method: RequestMethod.Get
+    });
   }
+  /**
+  * Runs a delete request from the api
+  *
+  * @param fullRoute - The full route to query
+  * @param options - Optional request options
+  */
   async delete(fullRoute, options = {}) {
-    return this.request({ ...options, fullRoute, method: "DELETE" /* Delete */ });
+    return this.request({
+      ...options,
+      fullRoute,
+      method: RequestMethod.Delete
+    });
   }
+  /**
+  * Runs a post request from the api
+  *
+  * @param fullRoute - The full route to query
+  * @param options - Optional request options
+  */
   async post(fullRoute, options = {}) {
-    return this.request({ ...options, fullRoute, method: "POST" /* Post */ });
+    return this.request({
+      ...options,
+      fullRoute,
+      method: RequestMethod.Post
+    });
   }
+  /**
+  * Runs a put request from the api
+  *
+  * @param fullRoute - The full route to query
+  * @param options - Optional request options
+  */
   async put(fullRoute, options = {}) {
-    return this.request({ ...options, fullRoute, method: "PUT" /* Put */ });
+    return this.request({
+      ...options,
+      fullRoute,
+      method: RequestMethod.Put
+    });
   }
+  /**
+  * Runs a patch request from the api
+  *
+  * @param fullRoute - The full route to query
+  * @param options - Optional request options
+  */
   async patch(fullRoute, options = {}) {
-    return this.request({ ...options, fullRoute, method: "PATCH" /* Patch */ });
+    return this.request({
+      ...options,
+      fullRoute,
+      method: RequestMethod.Patch
+    });
   }
+  /**
+  * Runs a request from the api
+  *
+  * @param options - Request options
+  */
   async request(options) {
     const response = await this.raw(options);
     return parseResponse(response);
   }
+  /**
+  * Runs a request from the API, yielding the raw Response object
+  *
+  * @param options - Request options
+  */
   async raw(options) {
     return this.requestManager.queueRequest(options);
   }
@@ -924,7 +1333,7 @@ var REST = class extends import_node_events2.EventEmitter {
 __name(REST, "REST");
 
 // src/index.ts
-var version = "1.6.0-dev.1677499520-ffdb197.0";
+var version = "[VI]{{inject}}[/VI]";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALLOWED_EXTENSIONS,