@discordeno/utils 19.0.0-next.e2d86ea → 19.0.0-next.e30e5a2

package/dist/cjs/images.cjs

@@ -0,0 +1,136 @@
+/* eslint-disable @typescript-eslint/restrict-template-expressions */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    applicationAssetUrl: function() {
+        return applicationAssetUrl;
+    },
+    applicationCoverUrl: function() {
+        return applicationCoverUrl;
+    },
+    applicationIconUrl: function() {
+        return applicationIconUrl;
+    },
+    avatarDecorationUrl: function() {
+        return avatarDecorationUrl;
+    },
+    avatarUrl: function() {
+        return avatarUrl;
+    },
+    bannerUrl: function() {
+        return bannerUrl;
+    },
+    emojiUrl: function() {
+        return emojiUrl;
+    },
+    formatImageUrl: function() {
+        return formatImageUrl;
+    },
+    getWidgetImageUrl: function() {
+        return getWidgetImageUrl;
+    },
+    guildBannerUrl: function() {
+        return guildBannerUrl;
+    },
+    guildDiscoverySplashUrl: function() {
+        return guildDiscoverySplashUrl;
+    },
+    guildIconUrl: function() {
+        return guildIconUrl;
+    },
+    guildScheduledEventCoverUrl: function() {
+        return guildScheduledEventCoverUrl;
+    },
+    guildSplashUrl: function() {
+        return guildSplashUrl;
+    },
+    memberAvatarUrl: function() {
+        return memberAvatarUrl;
+    },
+    roleIconUrl: function() {
+        return roleIconUrl;
+    },
+    stickerPackBannerUrl: function() {
+        return stickerPackBannerUrl;
+    },
+    stickerUrl: function() {
+        return stickerUrl;
+    },
+    teamIconUrl: function() {
+        return teamIconUrl;
+    }
+});
+const _types = require("@discordeno/types");
+const _hash = require("./hash.cjs");
+function formatImageUrl(url, size = 128, format) {
+    return `${url}.${format ?? (url.includes('/a_') ? 'gif' : 'jpg')}?size=${size}`;
+}
+function emojiUrl(emojiId, animated = false) {
+    return `https://cdn.discordapp.com/emojis/${emojiId}.${animated ? 'gif' : 'png'}`;
+}
+function avatarUrl(userId, discriminator, options) {
+    return options?.avatar ? formatImageUrl(`https://cdn.discordapp.com/avatars/${userId}/${typeof options.avatar === 'string' ? options.avatar : (0, _hash.iconBigintToHash)(options.avatar)}`, options?.size ?? 128, options?.format) : `https://cdn.discordapp.com/embed/avatars/${discriminator === '0' ? (BigInt(userId) >> BigInt(22)) % BigInt(6) : Number(discriminator) % 5}.png`;
+}
+function avatarDecorationUrl(avatarDecoration) {
+    return `https://cdn.discordapp.com/avatar-decoration-presets/${typeof avatarDecoration === 'string' ? avatarDecoration : (0, _hash.iconBigintToHash)(avatarDecoration)}.png`;
+}
+function bannerUrl(userId, options) {
+    return options?.banner ? formatImageUrl(`https://cdn.discordapp.com/banners/${userId}/${typeof options.banner === 'string' ? options.banner : (0, _hash.iconBigintToHash)(options.banner)}`, options?.size ?? 128, options?.format) : undefined;
+}
+function guildBannerUrl(guildId, options) {
+    return options.banner ? formatImageUrl(`https://cdn.discordapp.com/banners/${guildId}/${typeof options.banner === 'string' ? options.banner : (0, _hash.iconBigintToHash)(options.banner)}`, options.size ?? 128, options.format) : undefined;
+}
+function guildIconUrl(guildId, imageHash, options) {
+    return imageHash ? formatImageUrl(`https://cdn.discordapp.com/icons/${guildId}/${typeof imageHash === 'string' ? imageHash : (0, _hash.iconBigintToHash)(imageHash)}`, options?.size ?? 128, options?.format) : undefined;
+}
+function guildSplashUrl(guildId, imageHash, options) {
+    return imageHash ? formatImageUrl(`https://cdn.discordapp.com/splashes/${guildId}/${typeof imageHash === 'string' ? imageHash : (0, _hash.iconBigintToHash)(imageHash)}`, options?.size ?? 128, options?.format) : undefined;
+}
+function guildDiscoverySplashUrl(guildId, imageHash, options) {
+    return imageHash ? formatImageUrl(`https://cdn.discordapp.com/discovery-splashes/${guildId}/${typeof imageHash === 'string' ? imageHash : (0, _hash.iconBigintToHash)(imageHash)}`, options?.size ?? 128, options?.format) : undefined;
+}
+function guildScheduledEventCoverUrl(eventId, options) {
+    return options.cover ? formatImageUrl(`https://cdn.discordapp.com/guild-events/${eventId}/${typeof options.cover === 'string' ? options.cover : (0, _hash.iconBigintToHash)(options.cover)}`, options.size ?? 128, options.format) : undefined;
+}
+function getWidgetImageUrl(guildId, options) {
+    let url = `https://discordapp.com/api/guilds/${guildId}/widget.png`;
+    if (options?.style) {
+        url += `?style=${options.style}`;
+    }
+    return url;
+}
+function memberAvatarUrl(guildId, userId, options) {
+    return options?.avatar ? formatImageUrl(`https://cdn.discordapp.com/guilds/${guildId}/users/${userId}/avatars/${typeof options.avatar === 'string' ? options.avatar : (0, _hash.iconBigintToHash)(options.avatar)}`, options?.size ?? 128, options?.format) : undefined;
+}
+function applicationIconUrl(applicationId, iconHash, options) {
+    return iconHash ? formatImageUrl(`https://cdn.discordapp.com/app-icons/${applicationId}/${typeof iconHash === 'string' ? iconHash : (0, _hash.iconBigintToHash)(iconHash)}`, options?.size ?? 128, options?.format) : undefined;
+}
+function applicationCoverUrl(applicationId, coverHash, options) {
+    return coverHash ? formatImageUrl(`https://cdn.discordapp.com/app-icons/${applicationId}/${typeof coverHash === 'string' ? coverHash : (0, _hash.iconBigintToHash)(coverHash)}`, options?.size ?? 128, options?.format) : undefined;
+}
+function applicationAssetUrl(applicationId, assetId, options) {
+    return assetId ? formatImageUrl(`https://cdn.discordapp.com/app-icons/${applicationId}/${typeof assetId === 'string' ? assetId : (0, _hash.iconBigintToHash)(assetId)}`, options?.size ?? 128, options?.format) : undefined;
+}
+function stickerPackBannerUrl(bannerAssetId, options) {
+    return bannerAssetId ? formatImageUrl(`https://cdn.discordapp.com/app-assets/710982414301790216/store/${typeof bannerAssetId === 'string' ? bannerAssetId : (0, _hash.iconBigintToHash)(bannerAssetId)}`, options?.size ?? 128, options?.format) : undefined;
+}
+function stickerUrl(stickerId, options) {
+    if (!stickerId) return;
+    const url = options?.type === _types.StickerFormatTypes.Gif ? `https://media.discordapp.net/stickers/${stickerId}` : `https://cdn.discordapp.com/stickers/${stickerId}`;
+    return formatImageUrl(url, options?.size ?? 128, options?.format);
+}
+function teamIconUrl(teamId, iconHash, options) {
+    return iconHash ? formatImageUrl(`https://cdn.discordapp.com/team-icons/${teamId}/store/${typeof iconHash === 'string' ? iconHash : (0, _hash.iconBigintToHash)(iconHash)}`, options?.size ?? 128, options?.format) : undefined;
+}
+function roleIconUrl(roleId, iconHash, options) {
+    return iconHash ? formatImageUrl(`https://cdn.discordapp.com/role-icons/${roleId}/${typeof iconHash === 'string' ? iconHash : (0, _hash.iconBigintToHash)(iconHash)}`, options?.size ?? 128, options?.format) : undefined;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/images.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/restrict-template-expressions */\nimport { type BigString, type GetGuildWidgetImageQuery, type ImageFormat, type ImageSize, StickerFormatTypes } from '@discordeno/types'\nimport { iconBigintToHash } from './hash.js'\n\n/** Help format an image url. */\nexport function formatImageUrl(url: string, size: ImageSize = 128, format?: ImageFormat): string {\n  return `${url}.${format ?? (url.includes('/a_') ? 'gif' : 'jpg')}?size=${size}`\n}\n\n/**\n * Get the url for an emoji.\n *\n * @param emojiId The id of the emoji\n * @param animated Whether or not the emoji is animated\n * @returns string\n */\nexport function emojiUrl(emojiId: BigString, animated = false): string {\n  return `https://cdn.discordapp.com/emojis/${emojiId}.${animated ? 'gif' : 'png'}`\n}\n\n/**\n * Builds a URL to a user's avatar stored in the Discord CDN.\n *\n * @param userId - The ID of the user to get the avatar of.\n * @param discriminator - The user's discriminator. (4-digit tag after the hashtag.)\n * @param options - The parameters for the building of the URL.\n * @returns The link to the resource.\n */\nexport function avatarUrl(\n  userId: BigString,\n  discriminator: string,\n  options?: {\n    avatar: BigString | undefined\n    size?: ImageSize\n    format?: ImageFormat\n  },\n): string {\n  return options?.avatar\n    ? formatImageUrl(\n        `https://cdn.discordapp.com/avatars/${userId}/${typeof options.avatar === 'string' ? options.avatar : iconBigintToHash(options.avatar)}`,\n        options?.size ?? 128,\n        options?.format,\n      )\n    : `https://cdn.discordapp.com/embed/avatars/${discriminator === '0' ? (BigInt(userId) >> BigInt(22)) % BigInt(6) : Number(discriminator) % 5}.png`\n}\n\nexport function avatarDecorationUrl(avatarDecoration: BigString): string {\n  return `https://cdn.discordapp.com/avatar-decoration-presets/${\n    typeof avatarDecoration === 'string' ? avatarDecoration : iconBigintToHash(avatarDecoration)\n  }.png`\n}\n\n/**\n * Builds a URL to a user's banner stored in the Discord CDN.\n *\n * @param userId - The ID of the user to get the banner of.\n * @param options - The parameters for the building of the URL.\n * @returns The link to the resource or `undefined` if no banner has not been set.\n */\nexport function bannerUrl(\n  userId: BigString,\n  options?: {\n    banner?: BigString\n    size?: ImageSize\n    format?: ImageFormat\n  },\n): string | undefined {\n  return options?.banner\n    ? formatImageUrl(\n        `https://cdn.discordapp.com/banners/${userId}/${typeof options.banner === 'string' ? options.banner : iconBigintToHash(options.banner)}`,\n        options?.size ?? 128,\n        options?.format,\n      )\n    : undefined\n}\n\n/**\n * Builds a URL to the guild banner stored in the Discord CDN.\n *\n * @param guildId - The ID of the guild to get the link to the banner for.\n * @param options - The parameters for the building of the URL.\n * @returns The link to the resource or `undefined` if no banner has been set.\n */\nexport function guildBannerUrl(\n  guildId: BigString,\n  options: {\n    banner?: BigString\n    size?: ImageSize\n    format?: ImageFormat\n  },\n): string | undefined {\n  return options.banner\n    ? formatImageUrl(\n        `https://cdn.discordapp.com/banners/${guildId}/${typeof options.banner === 'string' ? options.banner : iconBigintToHash(options.banner)}`,\n        options.size ?? 128,\n        options.format,\n      )\n    : undefined\n}\n\n/**\n * Builds a URL to the guild icon stored in the Discord CDN.\n *\n * @param guildId - The ID of the guild to get the link to the banner for.\n * @param imageHash - The hash identifying the event cover image.\n * @param options - The parameters for the building of the URL.\n * @returns The link to the resource or `undefined` if no banner has been set.\n */\nexport function guildIconUrl(\n  guildId: BigString,\n  imageHash: BigString | undefined,\n  options?: {\n    size?: ImageSize\n    format?: ImageFormat\n  },\n): string | undefined {\n  return imageHash\n    ? formatImageUrl(\n        `https://cdn.discordapp.com/icons/${guildId}/${typeof imageHash === 'string' ? imageHash : iconBigintToHash(imageHash)}`,\n        options?.size ?? 128,\n        options?.format,\n      )\n    : undefined\n}\n\n/**\n * Builds the URL to a guild splash stored in the Discord CDN.\n *\n * @param guildId - The ID of the guild to get the splash of.\n * @param imageHash - The hash identifying the splash image.\n * @param options - The parameters for the building of the URL.\n * @returns The link to the resource or `undefined` if the guild does not have a splash image set.\n */\nexport function guildSplashUrl(\n  guildId: BigString,\n  imageHash: BigString | undefined,\n  options?: {\n    size?: ImageSize\n    format?: ImageFormat\n  },\n): string | undefined {\n  return imageHash\n    ? formatImageUrl(\n        `https://cdn.discordapp.com/splashes/${guildId}/${typeof imageHash === 'string' ? imageHash : iconBigintToHash(imageHash)}`,\n        options?.size ?? 128,\n        options?.format,\n      )\n    : undefined\n}\n\n/**\n * Builds the URL to a guild discovery splash stored in the Discord CDN.\n *\n * @param guildId - The ID of the guild to get the splash of.\n * @param imageHash - The hash identifying the discovery splash image.\n * @param options - The parameters for the building of the URL.\n * @returns The link to the resource or `undefined` if the guild does not have a splash image set.\n */\nexport function guildDiscoverySplashUrl(\n  guildId: BigString,\n  imageHash: BigString | undefined,\n  options?: {\n    size?: ImageSize\n    format?: ImageFormat\n  },\n): string | undefined {\n  return imageHash\n    ? formatImageUrl(\n        `https://cdn.discordapp.com/discovery-splashes/${guildId}/${typeof imageHash === 'string' ? imageHash : iconBigintToHash(imageHash)}`,\n        options?.size ?? 128,\n        options?.format,\n      )\n    : undefined\n}\n\n/**\n * Builds the URL to a guild scheduled event cover stored in the Discord CDN.\n *\n * @param eventId - The ID of the scheduled event to get the cover of.\n * @param options - The parameters for the building of the URL.\n * @returns The link to the resource or `undefined`.\n */\nexport function guildScheduledEventCoverUrl(\n  eventId: BigString,\n  options: {\n    cover?: BigString\n    size?: ImageSize\n    format?: ImageFormat\n  },\n): string | undefined {\n  return options.cover\n    ? formatImageUrl(\n        `https://cdn.discordapp.com/guild-events/${eventId}/${typeof options.cover === 'string' ? options.cover : iconBigintToHash(options.cover)}`,\n        options.size ?? 128,\n        options.format,\n      )\n    : undefined\n}\n\n/**\n * Builds a URL to the guild widget image stored in the Discord CDN.\n *\n * @param guildId - The ID of the guild to get the link to the widget image for.\n * @param options - The parameters for the building of the URL.\n * @returns The link to the resource.\n */\nexport function getWidgetImageUrl(guildId: BigString, options?: GetGuildWidgetImageQuery): string {\n  let url = `https://discordapp.com/api/guilds/${guildId}/widget.png`\n\n  if (options?.style) {\n    url += `?style=${options.style}`\n  }\n\n  return url\n}\n\n/**\n * Builds a URL to a member's avatar stored in the Discord CDN.\n *\n * @param guildId - The ID of the guild where the member is\n * @param userId - The ID of the user to get the avatar of.\n * @param options - The parameters for the building of the URL.\n * @returns The link to the resource or `undefined` if no banner has been set.\n */\nexport function memberAvatarUrl(\n  guildId: BigString,\n  userId: BigString,\n  options?: {\n    avatar?: BigString\n    size?: ImageSize\n    format?: ImageFormat\n  },\n): string | undefined {\n  return options?.avatar\n    ? formatImageUrl(\n        `https://cdn.discordapp.com/guilds/${guildId}/users/${userId}/avatars/${\n          typeof options.avatar === 'string' ? options.avatar : iconBigintToHash(options.avatar)\n        }`,\n        options?.size ?? 128,\n        options?.format,\n      )\n    : undefined\n}\n\n/**\n * Builds the URL to an application icon stored in the Discord CDN.\n *\n * @param applicationId - The ID of the application to get the icon of.\n * @param iconHash - The hash identifying the application icon.\n * @param options - The parameters for the building of the URL.\n * @returns The link to the resource or `undefined`\n */\nexport function applicationIconUrl(\n  applicationId: BigString,\n  iconHash: BigString | undefined,\n  options?: {\n    size?: ImageSize\n    format?: ImageFormat\n  },\n): string | undefined {\n  return iconHash\n    ? formatImageUrl(\n        `https://cdn.discordapp.com/app-icons/${applicationId}/${typeof iconHash === 'string' ? iconHash : iconBigintToHash(iconHash)}`,\n        options?.size ?? 128,\n        options?.format,\n      )\n    : undefined\n}\n\n/**\n * Builds the URL to an application cover stored in the Discord CDN.\n *\n * @param applicationId - The ID of the application to get the cover of.\n * @param coverHash - The hash identifying the application cover.\n * @param options - The parameters for the building of the URL.\n * @returns The link to the resource or `undefined`.\n */\nexport function applicationCoverUrl(\n  applicationId: BigString,\n  coverHash: BigString | undefined,\n  options?: {\n    size?: ImageSize\n    format?: ImageFormat\n  },\n): string | undefined {\n  return coverHash\n    ? formatImageUrl(\n        `https://cdn.discordapp.com/app-icons/${applicationId}/${typeof coverHash === 'string' ? coverHash : iconBigintToHash(coverHash)}`,\n        options?.size ?? 128,\n        options?.format,\n      )\n    : undefined\n}\n\n/**\n * Builds the URL to an application asset stored in the Discord CDN.\n *\n * @param applicationId - The ID of the application to get the asset of.\n * @param assetId - The id identifying the application asset.\n * @param options - The parameters for the building of the URL.\n * @returns The link to the resource or `undefined`.\n */\nexport function applicationAssetUrl(\n  applicationId: BigString,\n  assetId: BigString | undefined,\n  options?: {\n    size?: ImageSize\n    format?: ImageFormat\n  },\n): string | undefined {\n  return assetId\n    ? formatImageUrl(\n        `https://cdn.discordapp.com/app-icons/${applicationId}/${typeof assetId === 'string' ? assetId : iconBigintToHash(assetId)}`,\n        options?.size ?? 128,\n        options?.format,\n      )\n    : undefined\n}\n\n/**\n * Builds the URL to a sticker pack banner stored in the Discord CDN.\n *\n * @param bannerAssetId - The ID of the banner asset for the sticker pack.\n * @param options - The parameters for the building of the URL.\n * @returns The link to the resource or `undefined`.\n */\nexport function stickerPackBannerUrl(\n  bannerAssetId: BigString | undefined,\n  options?: {\n    size?: ImageSize\n    format?: ImageFormat\n  },\n): string | undefined {\n  return bannerAssetId\n    ? formatImageUrl(\n        `https://cdn.discordapp.com/app-assets/710982414301790216/store/${\n          typeof bannerAssetId === 'string' ? bannerAssetId : iconBigintToHash(bannerAssetId)\n        }`,\n        options?.size ?? 128,\n        options?.format,\n      )\n    : undefined\n}\n\n/**\n * Builds the URL to a sticker stored in the Discord CDN.\n *\n * @param stickerId - The ID of the sticker to get the icon of\n * @param options - The parameters for the building of the URL.\n * @returns The link to the resource or `undefined`.\n */\nexport function stickerUrl(\n  stickerId: BigString | number,\n  options?: {\n    size?: ImageSize\n    format?: ImageFormat\n    type?: StickerFormatTypes\n  },\n): string | undefined {\n  if (!stickerId) return\n\n  const url =\n    options?.type === StickerFormatTypes.Gif\n      ? `https://media.discordapp.net/stickers/${stickerId}`\n      : `https://cdn.discordapp.com/stickers/${stickerId}`\n\n  return formatImageUrl(url, options?.size ?? 128, options?.format)\n}\n\n/**\n * Builds the URL to a team icon stored in the Discord CDN.\n *\n * @param teamId - The ID of the team to get the icon of\n * @param iconHash - The hash of the team icon.\n * @param options - The parameters for the building of the URL.\n * @returns The link to the resource or `undefined`.\n */\nexport function teamIconUrl(\n  teamId: BigString,\n  iconHash: BigString | undefined,\n  options?: {\n    size?: ImageSize\n    format?: ImageFormat\n  },\n): string | undefined {\n  return iconHash\n    ? formatImageUrl(\n        `https://cdn.discordapp.com/team-icons/${teamId}/store/${typeof iconHash === 'string' ? iconHash : iconBigintToHash(iconHash)}`,\n        options?.size ?? 128,\n        options?.format,\n      )\n    : undefined\n}\n\n/**\n * Builds the URL to a role icon stored in the Discord CDN.\n *\n * @param roleId - The ID of the role to get the icon of\n * @param iconHash - The hash of the role icon.\n * @param options - The parameters for the building of the URL.\n * @returns The link to the resource or `undefined`.\n */\nexport function roleIconUrl(\n  roleId: BigString,\n  iconHash: BigString | undefined,\n  options?: {\n    size?: ImageSize\n    format?: ImageFormat\n  },\n): string | undefined {\n  return iconHash\n    ? formatImageUrl(\n        `https://cdn.discordapp.com/role-icons/${roleId}/${typeof iconHash === 'string' ? iconHash : iconBigintToHash(iconHash)}`,\n        options?.size ?? 128,\n        options?.format,\n      )\n    : undefined\n}\n"],"names":["applicationAssetUrl","applicationCoverUrl","applicationIconUrl","avatarDecorationUrl","avatarUrl","bannerUrl","emojiUrl","formatImageUrl","getWidgetImageUrl","guildBannerUrl","guildDiscoverySplashUrl","guildIconUrl","guildScheduledEventCoverUrl","guildSplashUrl","memberAvatarUrl","roleIconUrl","stickerPackBannerUrl","stickerUrl","teamIconUrl","url","size","format","includes","emojiId","animated","userId","discriminator","options","avatar","iconBigintToHash","BigInt","Number","avatarDecoration","banner","undefined","guildId","imageHash","eventId","cover","style","applicationId","iconHash","coverHash","assetId","bannerAssetId","stickerId","type","StickerFormatTypes","Gif","teamId","roleId"],"mappings":"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"}

package/dist/cjs/index.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./Collection.cjs"), exports);
+_export_star(require("./base64.cjs"), exports);
+_export_star(require("./bucket.cjs"), exports);
+_export_star(require("./builders.cjs"), exports);
+_export_star(require("./casing.cjs"), exports);
+_export_star(require("./colors.cjs"), exports);
+_export_star(require("./hash.cjs"), exports);
+_export_star(require("./images.cjs"), exports);
+_export_star(require("./logger.cjs"), exports);
+_export_star(require("./oauth2.cjs"), exports);
+_export_star(require("./permissions.cjs"), exports);
+_export_star(require("./reactions.cjs"), exports);
+_export_star(require("./token.cjs"), exports);
+_export_star(require("./typeguards.cjs"), exports);
+_export_star(require("./urlToBase64.cjs"), exports);
+_export_star(require("./urls.cjs"), exports);
+_export_star(require("./utils.cjs"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL0NvbGxlY3Rpb24uanMnXG5leHBvcnQgKiBmcm9tICcuL2Jhc2U2NC5qcydcbmV4cG9ydCAqIGZyb20gJy4vYnVja2V0LmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9idWlsZGVycy5qcydcbmV4cG9ydCAqIGZyb20gJy4vY2FzaW5nLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9jb2xvcnMuanMnXG5leHBvcnQgKiBmcm9tICcuL2hhc2guanMnXG5leHBvcnQgKiBmcm9tICcuL2ltYWdlcy5qcydcbmV4cG9ydCAqIGZyb20gJy4vbG9nZ2VyLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9vYXV0aDIuanMnXG5leHBvcnQgKiBmcm9tICcuL3Blcm1pc3Npb25zLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9yZWFjdGlvbnMuanMnXG5leHBvcnQgKiBmcm9tICcuL3Rva2VuLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi90eXBlZ3VhcmRzLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi91cmxUb0Jhc2U2NC5qcydcbmV4cG9ydCAqIGZyb20gJy4vdXJscy5qcydcbmV4cG9ydCAqIGZyb20gJy4vdXRpbHMuanMnXG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztxQkFBYztxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQSJ9

package/dist/cjs/logger.cjs

@@ -0,0 +1,157 @@
+/* eslint-disable @typescript-eslint/no-confusing-void-expression */ /* eslint-disable @typescript-eslint/explicit-function-return-type */ /* eslint-disable @typescript-eslint/no-unsafe-argument */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    LogDepth: function() {
+        return LogDepth;
+    },
+    LogLevels: function() {
+        return LogLevels;
+    },
+    createLogger: function() {
+        return createLogger;
+    },
+    default: function() {
+        return _default;
+    },
+    logger: function() {
+        return logger;
+    }
+});
+const _colors = require("./colors.cjs");
+var LogLevels;
+(function(LogLevels) {
+    LogLevels[LogLevels["Debug"] = 0] = "Debug";
+    LogLevels[LogLevels["Info"] = 1] = "Info";
+    LogLevels[LogLevels["Warn"] = 2] = "Warn";
+    LogLevels[LogLevels["Error"] = 3] = "Error";
+    LogLevels[LogLevels["Fatal"] = 4] = "Fatal";
+})(LogLevels || (LogLevels = {}));
+var LogDepth;
+(function(LogDepth) {
+    LogDepth[LogDepth["Minimal"] = 0] = "Minimal";
+    LogDepth[LogDepth["Full"] = 1] = "Full";
+})(LogDepth || (LogDepth = {}));
+const prefixes = new Map([
+    [
+        0,
+        'DEBUG'
+    ],
+    [
+        1,
+        'INFO'
+    ],
+    [
+        2,
+        'WARN'
+    ],
+    [
+        3,
+        'ERROR'
+    ],
+    [
+        4,
+        'FATAL'
+    ]
+]);
+const noColor = (msg)=>msg;
+const colorFunctions = new Map([
+    [
+        0,
+        _colors.gray
+    ],
+    [
+        1,
+        _colors.cyan
+    ],
+    [
+        2,
+        _colors.yellow
+    ],
+    [
+        3,
+        (str)=>(0, _colors.red)(str)
+    ],
+    [
+        4,
+        (str)=>(0, _colors.red)((0, _colors.bold)((0, _colors.italic)(str)))
+    ]
+]);
+function createLogger({ logLevel = 1, name } = {}) {
+    let depth = 0;
+    function log(level, ...args) {
+        if (level < logLevel) return;
+        let color = colorFunctions.get(level);
+        if (!color) color = noColor;
+        const date = new Date();
+        const log1 = [
+            (0, _colors.bgBrightMagenta)((0, _colors.black)(`[${date.toLocaleDateString()} ${date.toLocaleTimeString()}]`)),
+            color(prefixes.get(level) ?? 'DEBUG'),
+            name ? `${name} >` : '>',
+            ...args
+        ];
+        switch(level){
+            case 0:
+                return console.debug(...log1);
+            case 1:
+                return console.info(...log1);
+            case 2:
+                return console.warn(...log1);
+            case 3:
+                return console.error(...log1);
+            case 4:
+                return console.error(...log1);
+            default:
+                return console.log(...log1);
+        }
+    }
+    function setLevel(level) {
+        logLevel = level;
+    }
+    function setDepth(level) {
+        depth = level;
+    }
+    function debug(...args) {
+        if (0 === depth) log(0, args[0]);
+        else log(0, ...args);
+    }
+    function info(...args) {
+        if (0 === depth) log(1, args[0]);
+        else log(1, ...args);
+    }
+    function warn(...args) {
+        if (0 === depth) log(2, args[0]);
+        else log(2, ...args);
+    }
+    function error(...args) {
+        if (0 === depth) log(3, args[0]);
+        else log(3, ...args);
+    }
+    function fatal(...args) {
+        if (0 === depth) log(4, args[0]);
+        else log(4, ...args);
+    }
+    return {
+        log,
+        setDepth,
+        setLevel,
+        debug,
+        info,
+        warn,
+        error,
+        fatal
+    };
+}
+const logger = createLogger({
+    name: 'Discordeno'
+});
+const _default = logger;
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/oauth2.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createOAuth2Link", {
+    enumerable: true,
+    get: function() {
+        return createOAuth2Link;
+    }
+});
+const _permissions = require("./permissions.cjs");
+function createOAuth2Link(options) {
+    const joinedScopeString = options.scope.join('%20');
+    let url = `https://discord.com/oauth2/authorize?client_id=${options.clientId}&scope=${joinedScopeString}`;
+    if (options.responseType) url += `&response_type=${options.responseType}`;
+    if (options.state) url += `&state=${encodeURIComponent(options.state)}`;
+    if (options.redirectUri) url += `&redirect_uri=${encodeURIComponent(options.redirectUri)}`;
+    if (options.prompt) url += `&prompt=${options.prompt}`;
+    if (options.permissions) url += `&permissions=${Array.isArray(options.permissions) ? (0, _permissions.calculateBits)(options.permissions) : options.permissions}`;
+    if (options.guildId) url += `&guild_id=${options.guildId}`;
+    if (options.disableGuildSelect !== undefined) url += `&disable_guild_select=${options.disableGuildSelect}`;
+    if (options.integrationType) url += `&integration_type=${options.integrationType}`;
+    return url;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/permissions.cjs

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    calculateBits: function() {
+        return calculateBits;
+    },
+    calculatePermissions: function() {
+        return calculatePermissions;
+    }
+});
+const _types = require("@discordeno/types");
+function calculatePermissions(permissionBits) {
+    return Object.keys(_types.BitwisePermissionFlags).filter((permission)=>{
+        // Since Object.keys() not only returns the permission names but also the bit values we need to return false if it is a Number
+        if (Number(permission)) return false;
+        // Check if permissionBits has this permission
+        return permissionBits & _types.BitwisePermissionFlags[permission];
+    });
+}
+function calculateBits(permissions) {
+    return permissions.reduce((bits, perm)=>{
+        bits |= _types.BitwisePermissionFlags[perm];
+        return bits;
+    }, 0n).toString();
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/reactions.cjs

@@ -0,0 +1,21 @@
+/** Converts an reaction emoji unicode string to the discord required form of name:id */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "processReactionString", {
+    enumerable: true,
+    get: function() {
+        return processReactionString;
+    }
+});
+function processReactionString(reaction) {
+    if (reaction.startsWith('<:')) {
+        return reaction.substring(2, reaction.length - 1);
+    }
+    if (reaction.startsWith('<a:')) {
+        return reaction.substring(3, reaction.length - 1);
+    }
+    return reaction;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9yZWFjdGlvbnMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqIENvbnZlcnRzIGFuIHJlYWN0aW9uIGVtb2ppIHVuaWNvZGUgc3RyaW5nIHRvIHRoZSBkaXNjb3JkIHJlcXVpcmVkIGZvcm0gb2YgbmFtZTppZCAqL1xuZXhwb3J0IGZ1bmN0aW9uIHByb2Nlc3NSZWFjdGlvblN0cmluZyhyZWFjdGlvbjogc3RyaW5nKTogc3RyaW5nIHtcbiAgaWYgKHJlYWN0aW9uLnN0YXJ0c1dpdGgoJzw6JykpIHtcbiAgICByZXR1cm4gcmVhY3Rpb24uc3Vic3RyaW5nKDIsIHJlYWN0aW9uLmxlbmd0aCAtIDEpXG4gIH1cblxuICBpZiAocmVhY3Rpb24uc3RhcnRzV2l0aCgnPGE6JykpIHtcbiAgICByZXR1cm4gcmVhY3Rpb24uc3Vic3RyaW5nKDMsIHJlYWN0aW9uLmxlbmd0aCAtIDEpXG4gIH1cblxuICByZXR1cm4gcmVhY3Rpb25cbn1cbiJdLCJuYW1lcyI6WyJwcm9jZXNzUmVhY3Rpb25TdHJpbmciLCJyZWFjdGlvbiIsInN0YXJ0c1dpdGgiLCJzdWJzdHJpbmciLCJsZW5ndGgiXSwibWFwcGluZ3MiOiJBQUFBLHNGQUFzRjs7OzsrQkFDdEVBOzs7ZUFBQUE7OztBQUFULFNBQVNBLHNCQUFzQkMsUUFBZ0I7SUFDcEQsSUFBSUEsU0FBU0MsVUFBVSxDQUFDLE9BQU87UUFDN0IsT0FBT0QsU0FBU0UsU0FBUyxDQUFDLEdBQUdGLFNBQVNHLE1BQU0sR0FBRztJQUNqRDtJQUVBLElBQUlILFNBQVNDLFVBQVUsQ0FBQyxRQUFRO1FBQzlCLE9BQU9ELFNBQVNFLFNBQVMsQ0FBQyxHQUFHRixTQUFTRyxNQUFNLEdBQUc7SUFDakQ7SUFFQSxPQUFPSDtBQUNUIn0=

package/dist/cjs/token.cjs

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getBotIdFromToken: function() {
+        return getBotIdFromToken;
+    },
+    removeTokenPrefix: function() {
+        return removeTokenPrefix;
+    }
+});
+const _nodebuffer = require("node:buffer");
+const validTokenPrefixes = [
+    'Bot',
+    'Bearer'
+];
+function removeTokenPrefix(token, type = 'REST') {
+    // If no token is provided, throw an error
+    if (token === undefined) {
+        throw new Error(`The ${type} was not given a token. Please provide a token and try again.`);
+    }
+    const splittedToken = token.split(' ');
+    // If the token does not have a prefix just return token
+    if (splittedToken.length < 2 || !validTokenPrefixes.includes(splittedToken[0])) return token;
+    // Remove the prefix and return only the token.
+    return splittedToken.splice(1).join(' ');
+}
+function getBotIdFromToken(token) {
+    return BigInt(_nodebuffer.Buffer.from(token.split('.')[0], 'base64').toString());
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/typeguards.cjs

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isGetMessagesAfter: function() {
+        return isGetMessagesAfter;
+    },
+    isGetMessagesAround: function() {
+        return isGetMessagesAround;
+    },
+    isGetMessagesBefore: function() {
+        return isGetMessagesBefore;
+    },
+    isGetMessagesLimit: function() {
+        return isGetMessagesLimit;
+    },
+    isInviteWithMetadata: function() {
+        return isInviteWithMetadata;
+    }
+});
+const _utils = require("./utils.cjs");
+function isGetMessagesAfter(options) {
+    return (0, _utils.hasProperty)(options, 'after');
+}
+function isGetMessagesBefore(options) {
+    return (0, _utils.hasProperty)(options, 'before');
+}
+function isGetMessagesAround(options) {
+    return (0, _utils.hasProperty)(options, 'around');
+}
+function isGetMessagesLimit(options) {
+    return (0, _utils.hasProperty)(options, 'limit');
+}
+function isInviteWithMetadata(options) {
+    return !(0, _utils.hasProperty)(options, 'channel_id');
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/urlToBase64.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "urlToBase64", {
+    enumerable: true,
+    get: function() {
+        return urlToBase64;
+    }
+});
+const _base64 = require("./base64.cjs");
+async function urlToBase64(url) {
+    const buffer = await fetch(url).then(async (res)=>await res.arrayBuffer());
+    const imageStr = (0, _base64.encode)(buffer);
+    const type = url.substring(url.lastIndexOf('.') + 1);
+    return `data:image/${type};base64,${imageStr}`;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91cmxUb0Jhc2U2NC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBlbmNvZGUgfSBmcm9tICcuL2Jhc2U2NC5qcydcblxuLyoqIENvbnZlcnRzIGEgdXJsIHRvIGJhc2UgNjQuIFVzZWZ1bCBmb3IgZXhhbXBsZSwgdXBsb2FkaW5nL2NyZWF0aW5nIHNlcnZlciBlbW9qaXMuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gdXJsVG9CYXNlNjQodXJsOiBzdHJpbmcpOiBQcm9taXNlPHN0cmluZz4ge1xuICBjb25zdCBidWZmZXIgPSBhd2FpdCBmZXRjaCh1cmwpLnRoZW4oYXN5bmMgKHJlcykgPT4gYXdhaXQgcmVzLmFycmF5QnVmZmVyKCkpXG4gIGNvbnN0IGltYWdlU3RyID0gZW5jb2RlKGJ1ZmZlcilcbiAgY29uc3QgdHlwZSA9IHVybC5zdWJzdHJpbmcodXJsLmxhc3RJbmRleE9mKCcuJykgKyAxKVxuICByZXR1cm4gYGRhdGE6aW1hZ2UvJHt0eXBlfTtiYXNlNjQsJHtpbWFnZVN0cn1gXG59XG4iXSwibmFtZXMiOlsidXJsVG9CYXNlNjQiLCJ1cmwiLCJidWZmZXIiLCJmZXRjaCIsInRoZW4iLCJyZXMiLCJhcnJheUJ1ZmZlciIsImltYWdlU3RyIiwiZW5jb2RlIiwidHlwZSIsInN1YnN0cmluZyIsImxhc3RJbmRleE9mIl0sIm1hcHBpbmdzIjoiOzs7OytCQUdzQkE7OztlQUFBQTs7O3dCQUhDO0FBR2hCLGVBQWVBLFlBQVlDLEdBQVc7SUFDM0MsTUFBTUMsU0FBUyxNQUFNQyxNQUFNRixLQUFLRyxJQUFJLENBQUMsT0FBT0MsTUFBUSxNQUFNQSxJQUFJQyxXQUFXO0lBQ3pFLE1BQU1DLFdBQVdDLElBQUFBLGNBQU0sRUFBQ047SUFDeEIsTUFBTU8sT0FBT1IsSUFBSVMsU0FBUyxDQUFDVCxJQUFJVSxXQUFXLENBQUMsT0FBTztJQUNsRCxPQUFPLENBQUMsV0FBVyxFQUFFRixLQUFLLFFBQVEsRUFBRUYsU0FBUyxDQUFDO0FBQ2hEIn0=

package/dist/cjs/urls.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    skuLink: function() {
+        return skuLink;
+    },
+    storeLink: function() {
+        return storeLink;
+    }
+});
+function skuLink(appId, skuId) {
+    return `https://discord.com/application-directory/${appId}/store/${skuId}`;
+}
+function storeLink(appId) {
+    return `https://discord.com/application-directory/${appId}/store`;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91cmxzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgQmlnU3RyaW5nIH0gZnJvbSAnQGRpc2NvcmRlbm8vdHlwZXMnXG5cbmV4cG9ydCBmdW5jdGlvbiBza3VMaW5rKGFwcElkOiBCaWdTdHJpbmcsIHNrdUlkOiBCaWdTdHJpbmcpOiBzdHJpbmcge1xuICByZXR1cm4gYGh0dHBzOi8vZGlzY29yZC5jb20vYXBwbGljYXRpb24tZGlyZWN0b3J5LyR7YXBwSWR9L3N0b3JlLyR7c2t1SWR9YFxufVxuXG5leHBvcnQgZnVuY3Rpb24gc3RvcmVMaW5rKGFwcElkOiBCaWdTdHJpbmcpOiBzdHJpbmcge1xuICByZXR1cm4gYGh0dHBzOi8vZGlzY29yZC5jb20vYXBwbGljYXRpb24tZGlyZWN0b3J5LyR7YXBwSWR9L3N0b3JlYFxufVxuIl0sIm5hbWVzIjpbInNrdUxpbmsiLCJzdG9yZUxpbmsiLCJhcHBJZCIsInNrdUlkIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OztJQUVnQkEsT0FBTztlQUFQQTs7SUFJQUMsU0FBUztlQUFUQTs7O0FBSlQsU0FBU0QsUUFBUUUsS0FBZ0IsRUFBRUMsS0FBZ0I7SUFDeEQsT0FBTyxDQUFDLDBDQUEwQyxFQUFFRCxNQUFNLE9BQU8sRUFBRUMsTUFBTSxDQUFDO0FBQzVFO0FBRU8sU0FBU0YsVUFBVUMsS0FBZ0I7SUFDeEMsT0FBTyxDQUFDLDBDQUEwQyxFQUFFQSxNQUFNLE1BQU0sQ0FBQztBQUNuRSJ9