lunibee 0.1.1 → 0.1.3

package/dist/builders/index.js

@@ -0,0 +1,828 @@
+// @bun
+// packages/builders/src/embed.ts
+class EmbedBuilder {
+  #data = {};
+  setTitle(value) {
+    this.#data.title = validate(value, 256, "Embed title");
+    return this;
+  }
+  setDescription(value) {
+    this.#data.description = validate(value, 4096, "Embed description");
+    return this;
+  }
+  setURL(value) {
+    this.#data.url = url(value, "Embed URL");
+    return this;
+  }
+  setColor(value) {
+    if (!Number.isInteger(value) || value < 0 || value > 16777215)
+      throw new RangeError("Embed color must be an integer between 0 and 16777215.");
+    this.#data.color = value;
+    return this;
+  }
+  setTimestamp(value = new Date) {
+    const date = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(date.getTime()))
+      throw new RangeError("Embed timestamp must be a valid date.");
+    this.#data.timestamp = date.toISOString();
+    return this;
+  }
+  setFooter(value) {
+    this.#data.footer = {
+      text: validate(value.text, 2048, "Footer text"),
+      ...value.icon_url ? { icon_url: url(value.icon_url, "Footer icon URL") } : {}
+    };
+    return this;
+  }
+  setAuthor(value) {
+    this.#data.author = {
+      name: validate(value.name, 256, "Author name"),
+      ...value.url ? { url: url(value.url, "Author URL") } : {},
+      ...value.icon_url ? { icon_url: url(value.icon_url, "Author icon URL") } : {}
+    };
+    return this;
+  }
+  setThumbnail(value) {
+    const valueURL = typeof value === "string" ? value : value.url;
+    this.#data.thumbnail = { url: url(valueURL, "Thumbnail URL") };
+    return this;
+  }
+  setImage(value) {
+    const valueURL = typeof value === "string" ? value : value.url;
+    this.#data.image = { url: url(valueURL, "Image URL") };
+    return this;
+  }
+  addFields(...fields) {
+    if (!fields.length)
+      throw new TypeError("At least one embed field is required.");
+    const current = this.#data.fields ?? [];
+    if (current.length + fields.length > 25)
+      throw new RangeError("An embed cannot contain more than 25 fields.");
+    for (const field of fields) {
+      validate(field.name, 256, "Embed field name");
+      validate(field.value, 1024, "Embed field value");
+    }
+    this.#data.fields = [...current, ...fields.map((field) => ({ ...field }))];
+    return this;
+  }
+  setFields(fields) {
+    this.#data.fields = [];
+    return this.addFields(...fields);
+  }
+  spliceFields(index, deleteCount, ...fields) {
+    const current = [...this.#data.fields ?? []];
+    if (!Number.isInteger(index) || !Number.isInteger(deleteCount) || index < 0 || deleteCount < 0)
+      throw new RangeError("Field index and delete count must be non-negative integers.");
+    current.splice(index, deleteCount, ...fields);
+    if (current.length > 25)
+      throw new RangeError("An embed cannot contain more than 25 fields.");
+    this.#data.fields = current;
+    return this;
+  }
+  clearFields() {
+    delete this.#data.fields;
+    return this;
+  }
+  clearTitle() {
+    delete this.#data.title;
+    return this;
+  }
+  clearDescription() {
+    delete this.#data.description;
+    return this;
+  }
+  get data() {
+    return this.toJSON();
+  }
+  toJSON() {
+    return structuredClone(this.#data);
+  }
+}
+function validate(value, max, field) {
+  if (typeof value !== "string" || value.length === 0 || value.length > max)
+    throw new RangeError(`${field} must contain 1-${max} characters.`);
+  return value;
+}
+function url(value, field) {
+  try {
+    return new URL(value).toString();
+  } catch (error) {
+    throw new TypeError(`${field} must be a valid URL.`, { cause: error });
+  }
+}
+// packages/builders/src/components.ts
+var ComponentType = {
+  ActionRow: 1,
+  Button: 2,
+  StringSelect: 3,
+  TextInput: 4,
+  UserSelect: 5,
+  RoleSelect: 6,
+  MentionableSelect: 7,
+  ChannelSelect: 8
+};
+var ButtonStyle = {
+  Primary: 1,
+  Secondary: 2,
+  Success: 3,
+  Danger: 4,
+  Link: 5
+};
+var TextInputStyle = { Short: 1, Paragraph: 2 };
+
+class ActionRowBuilder {
+  #components = [];
+  addComponents(...components) {
+    if (!components.length)
+      throw new TypeError("At least one component is required.");
+    if (this.#components.length + components.length > 5)
+      throw new RangeError("An action row cannot contain more than 5 components.");
+    this.#components.push(...components);
+    return this;
+  }
+  clearComponents() {
+    this.#components.length = 0;
+    return this;
+  }
+  toJSON() {
+    return {
+      type: ComponentType.ActionRow,
+      components: this.#components.map((component) => component.toJSON())
+    };
+  }
+}
+
+class StringSelectBuilder {
+  #data = {
+    type: ComponentType.StringSelect
+  };
+  setCustomId(value) {
+    validateText(value, 100, "Component custom ID");
+    this.#data.custom_id = value;
+    return this;
+  }
+  setPlaceholder(value) {
+    validateText(value, 150, "Component placeholder");
+    this.#data.placeholder = value;
+    return this;
+  }
+  setMinValues(value) {
+    validateCount(value, "min_values", 0);
+    this.#data.min_values = value;
+    return this;
+  }
+  setMaxValues(value) {
+    validateCount(value, "max_values", 1);
+    this.#data.max_values = value;
+    return this;
+  }
+  setRequired(value = true) {
+    this.#data.required = value;
+    return this;
+  }
+  setDisabled(value = true) {
+    this.#data.disabled = value;
+    return this;
+  }
+  addOptions(...options) {
+    if (!options.length)
+      throw new TypeError("At least one select option is required.");
+    const current = this.#data.options ?? [];
+    if (current.length + options.length > 25)
+      throw new RangeError("A string select cannot contain more than 25 options.");
+    for (const option of options) {
+      validateText(option.label, 100, "Select option label");
+      validateText(option.value, 100, "Select option value");
+      if (option.description)
+        validateText(option.description, 100, "Select option description");
+    }
+    this.#data.options = [
+      ...current,
+      ...options.map((option) => ({ ...option }))
+    ];
+    return this;
+  }
+  toJSON() {
+    return structuredClone(this.#data);
+  }
+}
+
+class ButtonBuilder {
+  #data = {
+    type: ComponentType.Button,
+    style: ButtonStyle.Secondary
+  };
+  setStyle(style) {
+    this.#data.style = style;
+    if (style === ButtonStyle.Link)
+      delete this.#data.custom_id;
+    return this;
+  }
+  setCustomId(value) {
+    validateText(value, 100, "Button custom ID");
+    if (this.#data.style === ButtonStyle.Link)
+      throw new TypeError("Link buttons cannot use custom IDs.");
+    this.#data.custom_id = value;
+    return this;
+  }
+  setLabel(value) {
+    validateText(value, 80, "Button label");
+    this.#data.label = value;
+    return this;
+  }
+  setURL(value) {
+    validateText(value, 512, "Button URL");
+    let url2;
+    try {
+      url2 = new URL(value);
+    } catch (error) {
+      throw new TypeError("Button URL must be a valid URL.", { cause: error });
+    }
+    this.#data.style = ButtonStyle.Link;
+    delete this.#data.custom_id;
+    this.#data.url = url2.toString();
+    return this;
+  }
+  setEmoji(emoji) {
+    this.#data.emoji = typeof emoji === "string" ? { name: emoji } : { ...emoji };
+    return this;
+  }
+  setDisabled(value = true) {
+    this.#data.disabled = value;
+    return this;
+  }
+  toJSON() {
+    return structuredClone(this.#data);
+  }
+}
+
+class EntitySelectBuilder {
+  #data;
+  constructor(type) {
+    if (type !== ComponentType.UserSelect && type !== ComponentType.RoleSelect && type !== ComponentType.MentionableSelect && type !== ComponentType.ChannelSelect)
+      throw new TypeError("Invalid select component type.");
+    this.#data = { type };
+  }
+  setCustomId(value) {
+    validateText(value, 100, "Component custom ID");
+    this.#data.custom_id = value;
+    return this;
+  }
+  setPlaceholder(value) {
+    validateText(value, 150, "Component placeholder");
+    this.#data.placeholder = value;
+    return this;
+  }
+  setMinValues(value) {
+    validateCount(value, "min_values", 0);
+    this.#data.min_values = value;
+    return this;
+  }
+  setMaxValues(value) {
+    validateCount(value, "max_values", 1);
+    this.#data.max_values = value;
+    return this;
+  }
+  setRequired(value = true) {
+    this.#data.required = value;
+    return this;
+  }
+  setDisabled(value = true) {
+    this.#data.disabled = value;
+    return this;
+  }
+  setDefaultValues(...values) {
+    this.#data.default_values = values;
+    return this;
+  }
+  toJSON() {
+    return structuredClone(this.#data);
+  }
+}
+
+class ModalBuilder {
+  #components = [];
+  #custom_id;
+  #title;
+  setCustomId(value) {
+    validateText(value, 100, "Modal custom ID");
+    this.#custom_id = value;
+    return this;
+  }
+  setTitle(value) {
+    validateText(value, 45, "Modal title");
+    this.#title = value;
+    return this;
+  }
+  addComponents(...components) {
+    if (!components.length)
+      throw new TypeError("At least one modal component is required.");
+    if (this.#components.length + components.length > 5)
+      throw new RangeError("A modal cannot contain more than 5 action rows.");
+    this.#components.push(...components);
+    return this;
+  }
+  toJSON() {
+    return {
+      type: 9,
+      ...this.#custom_id ? { custom_id: this.#custom_id } : {},
+      ...this.#title ? { title: this.#title } : {},
+      components: this.#components.map((component) => component.toJSON())
+    };
+  }
+}
+
+class TextInputBuilder {
+  #data = {
+    type: ComponentType.TextInput,
+    style: TextInputStyle.Short
+  };
+  setStyle(style) {
+    this.#data.style = style;
+    return this;
+  }
+  setCustomId(value) {
+    validateText(value, 100, "Text input custom ID");
+    this.#data.custom_id = value;
+    return this;
+  }
+  setLabel(value) {
+    validateText(value, 45, "Text input label");
+    this.#data.label = value;
+    return this;
+  }
+  setPlaceholder(value) {
+    validateText(value, 100, "Text input placeholder");
+    this.#data.placeholder = value;
+    return this;
+  }
+  setMinLength(value) {
+    validateLength(value, "min_length", 4000);
+    this.#data.min_length = value;
+    return this;
+  }
+  setMaxLength(value) {
+    validateLength(value, "max_length", 4000);
+    this.#data.max_length = value;
+    return this;
+  }
+  setRequired(value = true) {
+    this.#data.required = value;
+    return this;
+  }
+  setValue(value) {
+    validateText(value, 4000, "Text input value");
+    this.#data.value = value;
+    return this;
+  }
+  toJSON() {
+    return structuredClone(this.#data);
+  }
+}
+function validateText(value, max, field) {
+  if (typeof value !== "string")
+    throw new TypeError(`${field} must be a string.`);
+  if (!value.trim())
+    throw new RangeError(`${field} must be a non-empty string.`);
+  if (value.length > max)
+    throw new RangeError(`${field} cannot exceed ${max} characters.`);
+}
+function validateCount(value, field, min, max = 25) {
+  if (!Number.isInteger(value) || value < min || value > max)
+    throw new RangeError(`${field} must be an integer between ${min} and ${max}.`);
+}
+function validateLength(value, field, max = 4000) {
+  if (!Number.isInteger(value) || value < 0 || value > max)
+    throw new RangeError(`${field} must be an integer between 0 and ${max}.`);
+}
+// packages/builders/src/commands.ts
+var ApplicationCommandOptionType = {
+  Subcommand: 1,
+  SubcommandGroup: 2,
+  String: 3,
+  Integer: 4,
+  Boolean: 5,
+  User: 6,
+  Channel: 7,
+  Role: 8,
+  Mentionable: 9,
+  Number: 10,
+  Attachment: 11
+};
+
+class SlashCommandBuilder {
+  #data = { type: 1 };
+  setName(name) {
+    validateName(name, "Command name");
+    this.#data.name = name;
+    return this;
+  }
+  setDescription(description) {
+    validateText2(description, "Command description", 100);
+    this.#data.description = description;
+    return this;
+  }
+  setDMPermission(enabled) {
+    this.#data.dm_permission = enabled;
+    return this;
+  }
+  setNSFW(nsfw = true) {
+    this.#data.nsfw = nsfw;
+    return this;
+  }
+  setNsfw(nsfw = true) {
+    return this.setNSFW(nsfw);
+  }
+  setDefaultMemberPermissions(permissions) {
+    this.#data.default_member_permissions = permissions === null ? null : BigInt(permissions).toString();
+    return this;
+  }
+  setIntegrationTypes(...types) {
+    this.#data.integration_types = [...types];
+    return this;
+  }
+  addStringOption(configure) {
+    return this.addOption(configure(new StringOptionBuilder));
+  }
+  addIntegerOption(configure) {
+    return this.addOption(configure(new IntegerOptionBuilder));
+  }
+  addNumberOption(configure) {
+    return this.addOption(configure(new NumberOptionBuilder));
+  }
+  addBooleanOption(configure) {
+    return this.addOption(configure(new BooleanOptionBuilder));
+  }
+  addUserOption(configure) {
+    return this.addOption(configure(new UserOptionBuilder));
+  }
+  addChannelOption(configure) {
+    return this.addOption(configure(new ChannelOptionBuilder));
+  }
+  addRoleOption(configure) {
+    return this.addOption(configure(new RoleOptionBuilder));
+  }
+  addMentionableOption(configure) {
+    return this.addOption(configure(new MentionableOptionBuilder));
+  }
+  addAttachmentOption(configure) {
+    return this.addOption(configure(new AttachmentOptionBuilder));
+  }
+  addSubcommand(configure) {
+    return this.addOption(configure(new SubcommandBuilder));
+  }
+  addSubcommandGroup(configure) {
+    return this.addOption(configure(new SubcommandGroupBuilder));
+  }
+  toJSON() {
+    return structuredClone(this.#data);
+  }
+  addOption(option) {
+    const options = this.#data.options ?? [];
+    if (options.length >= 25)
+      throw new RangeError("An application command cannot contain more than 25 options.");
+    const payload = option.toJSON();
+    if (options.some((existing) => existing.name === payload.name))
+      throw new RangeError(`Duplicate option name: ${String(payload.name)}.`);
+    if (payload.required === true && options.some((existing) => existing.required !== true))
+      throw new RangeError("Required application command options must be placed before optional options.");
+    options.push(payload);
+    this.#data.options = options;
+    return this;
+  }
+}
+
+class CommandOptionBuilder {
+  data;
+  constructor(type) {
+    this.data = { type };
+  }
+  setName(name) {
+    validateName(name, "Option name");
+    this.data.name = name;
+    return this;
+  }
+  setDescription(description) {
+    validateText2(description, "Option description", 100);
+    this.data.description = description;
+    return this;
+  }
+  setRequired(required = true) {
+    this.data.required = required;
+    return this;
+  }
+  setAutocomplete(enabled = true) {
+    this.data.autocomplete = enabled;
+    return this;
+  }
+  toJSON() {
+    return structuredClone(this.data);
+  }
+}
+
+class StringOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType.String);
+  }
+  addChoices(...choices) {
+    const current = this.data.choices ?? [];
+    if (!choices.length)
+      throw new TypeError("At least one choice is required.");
+    if (this.data.autocomplete === true)
+      throw new RangeError("Autocomplete options cannot define choices.");
+    if (current.length + choices.length > 25)
+      throw new RangeError("An option cannot contain more than 25 choices.");
+    for (const choice of choices) {
+      validateText2(choice.name, "Choice name", 100);
+      validateText2(choice.value, "Choice value", 100);
+    }
+    this.data.choices = [
+      ...current,
+      ...choices.map((choice) => ({ ...choice }))
+    ];
+    return this;
+  }
+  setMinLength(value) {
+    validateIntegerRange(value, 0, 6000, "min_length");
+    this.data.min_length = value;
+    return this;
+  }
+  setMaxLength(value) {
+    validateIntegerRange(value, 1, 6000, "max_length");
+    if (this.data.min_length !== undefined && this.data.min_length > value)
+      throw new RangeError("min_length cannot exceed max_length.");
+    this.data.max_length = value;
+    return this;
+  }
+}
+
+class IntegerOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType.Integer);
+  }
+  setMinValue(value) {
+    validateNumberRange(value, -9007199254740991, 9007199254740991, "min_value", true);
+    this.data.min_value = value;
+    return this;
+  }
+  setMaxValue(value) {
+    validateNumberRange(value, -9007199254740991, 9007199254740991, "max_value", true);
+    if (this.data.min_value !== undefined && this.data.min_value > value)
+      throw new RangeError("min_value cannot exceed max_value.");
+    this.data.max_value = value;
+    return this;
+  }
+  setAutocomplete(enabled = true) {
+    if (enabled && Array.isArray(this.data.choices) && this.data.choices.length)
+      throw new RangeError("Autocomplete options cannot define choices.");
+    this.data.autocomplete = enabled;
+    return this;
+  }
+  addChoices(...choices) {
+    const current = this.data.choices ?? [];
+    if (!choices.length)
+      throw new TypeError("At least one choice is required.");
+    if (this.data.autocomplete === true)
+      throw new RangeError("Autocomplete options cannot define choices.");
+    if (current.length + choices.length > 25)
+      throw new RangeError("An option cannot contain more than 25 choices.");
+    this.data.choices = [...current, ...choices];
+    return this;
+  }
+}
+
+class NumberOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType.Number);
+  }
+  setMinValue(value) {
+    validateNumberRange(value, -9007199254740991, 9007199254740991, "min_value", false);
+    this.data.min_value = value;
+    return this;
+  }
+  setMaxValue(value) {
+    validateNumberRange(value, -9007199254740991, 9007199254740991, "max_value", false);
+    if (this.data.min_value !== undefined && this.data.min_value > value)
+      throw new RangeError("min_value cannot exceed max_value.");
+    this.data.max_value = value;
+    return this;
+  }
+  setAutocomplete(enabled = true) {
+    if (enabled && Array.isArray(this.data.choices) && this.data.choices.length)
+      throw new RangeError("Autocomplete options cannot define choices.");
+    this.data.autocomplete = enabled;
+    return this;
+  }
+  addChoices(...choices) {
+    const current = this.data.choices ?? [];
+    if (!choices.length)
+      throw new TypeError("At least one choice is required.");
+    if (this.data.autocomplete === true)
+      throw new RangeError("Autocomplete options cannot define choices.");
+    if (current.length + choices.length > 25)
+      throw new RangeError("An option cannot contain more than 25 choices.");
+    this.data.choices = [...current, ...choices];
+    return this;
+  }
+}
+
+class BooleanOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType.Boolean);
+  }
+}
+
+class UserOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType.User);
+  }
+}
+
+class RoleOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType.Role);
+  }
+}
+
+class MentionableOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType.Mentionable);
+  }
+}
+
+class AttachmentOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType.Attachment);
+  }
+}
+
+class ChannelOptionBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType.Channel);
+  }
+  addChannelTypes(...types) {
+    if (types.some((type) => !Number.isInteger(type) || type < 0))
+      throw new RangeError("Channel types must be non-negative integers.");
+    this.data.channel_types = [...new Set(types)];
+    return this;
+  }
+}
+
+class SubcommandBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType.Subcommand);
+  }
+  addStringOption(configure) {
+    return this.addChildOption(configure(new StringOptionBuilder));
+  }
+  addIntegerOption(configure) {
+    return this.addChildOption(configure(new IntegerOptionBuilder));
+  }
+  addNumberOption(configure) {
+    return this.addChildOption(configure(new NumberOptionBuilder));
+  }
+  addBooleanOption(configure) {
+    return this.addChildOption(configure(new BooleanOptionBuilder));
+  }
+  addUserOption(configure) {
+    return this.addChildOption(configure(new UserOptionBuilder));
+  }
+  addChannelOption(configure) {
+    return this.addChildOption(configure(new ChannelOptionBuilder));
+  }
+  addRoleOption(configure) {
+    return this.addChildOption(configure(new RoleOptionBuilder));
+  }
+  addMentionableOption(configure) {
+    return this.addChildOption(configure(new MentionableOptionBuilder));
+  }
+  addAttachmentOption(configure) {
+    return this.addChildOption(configure(new AttachmentOptionBuilder));
+  }
+  addChildOption(option) {
+    const options = this.data.options ?? [];
+    if (options.length >= 25)
+      throw new RangeError("A subcommand cannot contain more than 25 options.");
+    const payload = option.toJSON();
+    if (options.some((existing) => existing.name === payload.name))
+      throw new RangeError(`Duplicate option name: ${String(payload.name)}.`);
+    if (payload.required === true && options.some((existing) => existing.required !== true))
+      throw new RangeError("Required subcommand options must be placed before optional options.");
+    if (options.some((existing) => existing.type === ApplicationCommandOptionType.Subcommand))
+      throw new RangeError("Subcommands cannot contain nested subcommands.");
+    options.push(payload);
+    this.data.options = options;
+    return this;
+  }
+}
+
+class SubcommandGroupBuilder extends CommandOptionBuilder {
+  constructor() {
+    super(ApplicationCommandOptionType.SubcommandGroup);
+  }
+  addSubcommand(configure) {
+    const options = this.data.options ?? [];
+    if (options.length >= 25)
+      throw new RangeError("A subcommand group cannot contain more than 25 subcommands.");
+    const payload = configure(new SubcommandBuilder).toJSON();
+    if (options.some((existing) => existing.name === payload.name))
+      throw new RangeError(`Duplicate subcommand name: ${String(payload.name)}.`);
+    if (payload.type !== ApplicationCommandOptionType.Subcommand)
+      throw new TypeError("Subcommand group children must be subcommands.");
+    options.push(payload);
+    this.data.options = options;
+    return this;
+  }
+}
+function validateName(value, field) {
+  if (!/^[\p{L}\p{N}_-]{1,32}$/u.test(value) || value !== value.toLowerCase())
+    throw new RangeError(`${field} must contain 1-32 lowercase letters, numbers, underscores, or hyphens.`);
+}
+function validateText2(value, field, max) {
+  if (typeof value !== "string" || !value.trim() || value.length > max)
+    throw new RangeError(`${field} must contain 1-${max} characters.`);
+}
+function validateIntegerRange(value, minimum, maximum, field) {
+  if (!Number.isInteger(value) || value < minimum || value > maximum)
+    throw new RangeError(`${field} must be an integer between ${minimum} and ${maximum}.`);
+}
+function validateNumberRange(value, minimum, maximum, field, integerOnly = true) {
+  if (!Number.isFinite(value) || integerOnly && !Number.isInteger(value) || value < minimum || value > maximum)
+    throw new RangeError(`${field} must be ${integerOnly ? "an integer" : "a number"} between ${minimum} and ${maximum}.`);
+}
+// packages/builders/src/attachment.ts
+import { readFile } from "fs/promises";
+import { basename } from "path";
+
+class AttachmentBuilder {
+  name;
+  description;
+  file;
+  constructor(file, data) {
+    this.file = file;
+    if (typeof data === "string") {
+      this.name = data;
+    } else {
+      this.name = data?.name ?? (typeof file === "string" ? basename(file) : "file.bin");
+      this.description = data?.description;
+    }
+  }
+  setName(name) {
+    this.name = name;
+    return this;
+  }
+  setDescription(description) {
+    this.description = description;
+    return this;
+  }
+  setFile(file) {
+    this.file = file;
+    return this;
+  }
+  async toBuffer() {
+    if (typeof this.file === "string") {
+      const buffer = await readFile(this.file);
+      return new Uint8Array(buffer);
+    }
+    if (this.file instanceof Uint8Array)
+      return this.file;
+    if (this.file instanceof ArrayBuffer)
+      return new Uint8Array(this.file);
+    if (this.file instanceof Blob) {
+      const buf = await this.file.arrayBuffer();
+      return new Uint8Array(buf);
+    }
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(this.file)) {
+      return new Uint8Array(this.file);
+    }
+    return new Uint8Array;
+  }
+}
+export {
+  ActionRowBuilder,
+  ApplicationCommandOptionType,
+  AttachmentBuilder,
+  AttachmentOptionBuilder,
+  BooleanOptionBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  ChannelOptionBuilder,
+  ComponentType,
+  EmbedBuilder,
+  EntitySelectBuilder,
+  IntegerOptionBuilder,
+  MentionableOptionBuilder,
+  ModalBuilder,
+  NumberOptionBuilder,
+  RoleOptionBuilder,
+  SlashCommandBuilder,
+  StringOptionBuilder,
+  StringSelectBuilder,
+  SubcommandBuilder,
+  SubcommandGroupBuilder,
+  TextInputBuilder,
+  TextInputStyle,
+  UserOptionBuilder
+};
+
+//# debugId=2D9849BFEE96124664756E2164756E21