lunibee 0.3.3 → 0.4.0

package/dist/chunks/index-5yx92e36.js

@@ -0,0 +1,1170 @@
+// @bun
+import {
+  ComponentEnum2,
+  ButtonType2
+} from "./index-gyvps8b9.js";
+
+// packages/builders/src/clone.ts
+function cloneData(value, depth = 0) {
+  if (value === null || typeof value !== "object")
+    return value;
+  if (depth > 64)
+    return structuredClone(value);
+  if (Array.isArray(value)) {
+    const out = new Array(value.length);
+    for (let i = 0;i < value.length; i++)
+      out[i] = cloneData(value[i], depth + 1);
+    return out;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null)
+    return structuredClone(value);
+  const from = value;
+  const out = {};
+  for (const key of Object.keys(from))
+    out[key] = cloneData(from[key], depth + 1);
+  return out;
+}
+
+// packages/builders/src/embed.ts
+class CreateEmbed2 {
+  #data = {};
+  setTitle(value) {
+    if (value === null)
+      delete this.#data.title;
+    else
+      this.#data.title = validate(value, 256, "Embed title");
+    return this;
+  }
+  setDescription(value) {
+    if (value === null)
+      delete this.#data.description;
+    else
+      this.#data.description = validate(value, 4096, "Embed description");
+    return this;
+  }
+  setURL(value) {
+    if (value === null)
+      delete this.#data.url;
+    else
+      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) {
+    if (value === null) {
+      delete this.#data.thumbnail;
+      return this;
+    }
+    const valueURL = typeof value === "string" ? value : value.url;
+    this.#data.thumbnail = { url: url(valueURL, "Thumbnail URL") };
+    return this;
+  }
+  setImage(value) {
+    if (value === null) {
+      delete this.#data.image;
+      return this;
+    }
+    const valueURL = typeof value === "string" ? value : value.url;
+    this.#data.image = { url: url(valueURL, "Image URL") };
+    return this;
+  }
+  addFields(...fields) {
+    const resolved = fields.length === 1 && Array.isArray(fields[0]) ? fields[0] : fields;
+    if (!resolved.length)
+      throw new TypeError("At least one embed field is required.");
+    const current = this.#data.fields ?? [];
+    if (current.length + resolved.length > 25)
+      throw new RangeError("An embed cannot contain more than 25 fields.");
+    for (const field of resolved) {
+      validate(field.name, 256, "Embed field name");
+      validate(field.value, 1024, "Embed field value");
+    }
+    this.#data.fields = [
+      ...current,
+      ...resolved.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.");
+    for (const field of fields) {
+      validate(field.name, 256, "Embed field name");
+      validate(field.value, 1024, "Embed field value");
+    }
+    current.splice(index, deleteCount, ...fields.map((f) => ({ ...f })));
+    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() {
+    const data = this.#data;
+    const total = (data.title?.length ?? 0) + (data.description?.length ?? 0) + (data.footer?.text.length ?? 0) + (data.author?.name.length ?? 0) + (data.fields ?? []).reduce((sum, field) => sum + field.name.length + field.value.length, 0);
+    if (total > 6000)
+      throw new RangeError(`An embed cannot contain more than 6000 characters in total (this one has ${total}).`);
+    return cloneData(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) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch (error) {
+    throw new TypeError(`${field} must be a valid URL.`, { cause: error });
+  }
+  if (!["http:", "https:", "attachment:"].includes(parsed.protocol))
+    throw new TypeError(`${field} must use http, https or attachment.`);
+  return parsed.toString();
+}
+// packages/builders/src/components.ts
+var TextInputType2 = { Short: 1, Paragraph: 2 };
+
+class CreateActionRow2 {
+  #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() {
+    const components = this.#components.map((component) => component.toJSON());
+    if (components.length === 0)
+      throw new RangeError("An action row needs at least one component.");
+    const types = components.map((component) => component.type);
+    if (types.some((type) => type !== ComponentEnum2.Button) && components.length > 1)
+      throw new RangeError("A select menu or text input must be alone in its action row.");
+    return { type: ComponentEnum2.ActionRow, components };
+  }
+}
+
+class CreateSelectMenu {
+  #select;
+  constructor(data) {
+    this.#select = data;
+  }
+  setCustomId(value) {
+    validateText(value, 100, "Component custom ID");
+    this.#select.custom_id = value;
+    return this;
+  }
+  setPlaceholder(value) {
+    validateText(value, 150, "Component placeholder");
+    this.#select.placeholder = value;
+    return this;
+  }
+  setMinValues(value) {
+    validateCount(value, "min_values", 0);
+    this.#select.min_values = value;
+    return this;
+  }
+  setMaxValues(value) {
+    validateCount(value, "max_values", 1);
+    this.#select.max_values = value;
+    return this;
+  }
+  setRequired(value = true) {
+    this.#select.required = value;
+    return this;
+  }
+  setDisabled(value = true) {
+    this.#select.disabled = value;
+    return this;
+  }
+}
+
+class CreateStringSelect2 extends CreateSelectMenu {
+  #data;
+  constructor() {
+    const data = {
+      type: ComponentEnum2.StringSelect
+    };
+    super(data);
+    this.#data = data;
+  }
+  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() {
+    assertSelect(this.#data);
+    const count = this.#data.options?.length ?? 0;
+    if (count === 0)
+      throw new RangeError("A string select needs at least one option.");
+    if ((this.#data.max_values ?? 1) > count)
+      throw new RangeError("max_values cannot exceed the number of options.");
+    return cloneData(this.#data);
+  }
+}
+
+class CreateButton2 {
+  #data = {
+    type: ComponentEnum2.Button,
+    style: ButtonType2.Secondary
+  };
+  setStyle(style) {
+    const data = this.#data;
+    data.style = style;
+    if (style === ButtonType2.Link) {
+      delete data.custom_id;
+      delete data.sku_id;
+    } else if (style === ButtonType2.Premium) {
+      delete data.custom_id;
+      delete data.url;
+      delete data.label;
+      delete data.emoji;
+    } else {
+      delete data.url;
+      delete data.sku_id;
+    }
+    return this;
+  }
+  setCustomId(value) {
+    validateText(value, 100, "Button custom ID");
+    if (this.#data.style === ButtonType2.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 url;
+    try {
+      url = new URL(value);
+    } catch (error) {
+      throw new TypeError("Button URL must be a valid URL.", {
+        cause: error
+      });
+    }
+    if (!["http:", "https:", "discord:"].includes(url.protocol))
+      throw new TypeError("Button URL must use http, https or discord.");
+    this.setStyle(ButtonType2.Link);
+    this.#data.url = url.toString();
+    return this;
+  }
+  setSKUId(skuId) {
+    validateText(skuId, 20, "Button SKU ID");
+    this.setStyle(ButtonType2.Premium);
+    this.#data.sku_id = skuId;
+    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() {
+    const data = this.#data;
+    if (data.style === ButtonType2.Link) {
+      if (!data.url)
+        throw new TypeError("Link buttons require a URL.");
+      if (data.custom_id || data.sku_id)
+        throw new TypeError("Link buttons cannot have a custom ID or SKU ID.");
+    } else if (data.style === ButtonType2.Premium) {
+      if (!data.sku_id)
+        throw new TypeError("Premium buttons require a SKU ID.");
+      if (data.custom_id || data.url || data.label || data.emoji)
+        throw new TypeError("Premium buttons cannot have a custom ID, URL, label or emoji.");
+    } else {
+      if (!data.custom_id)
+        throw new TypeError("Non-link buttons require a custom ID.");
+      if (data.url || data.sku_id)
+        throw new TypeError("Only link buttons have a URL and only premium buttons have a SKU ID.");
+    }
+    if (data.style !== ButtonType2.Premium && !data.label && !data.emoji)
+      throw new TypeError("Buttons require a label or an emoji.");
+    return cloneData(data);
+  }
+}
+
+class CreateEntitySelect2 extends CreateSelectMenu {
+  #data;
+  constructor(type) {
+    if (type !== ComponentEnum2.UserSelect && type !== ComponentEnum2.RoleSelect && type !== ComponentEnum2.MentionableSelect && type !== ComponentEnum2.ChannelSelect)
+      throw new TypeError("Invalid select component type.");
+    const data = { type };
+    super(data);
+    this.#data = data;
+  }
+  setDefaultValues(...values) {
+    this.#data.default_values = values.map((value) => ({ ...value }));
+    return this;
+  }
+  toJSON() {
+    assertSelect(this.#data);
+    return cloneData(this.#data);
+  }
+}
+
+class CreateModal2 {
+  #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;
+  }
+  addTextInputs(...inputs) {
+    return this.addComponents(...inputs.map((input) => new CreateActionRow2().addComponents(input)));
+  }
+  toJSON() {
+    if (!this.#custom_id || !this.#title)
+      throw new TypeError("Modals require a custom ID and a title.");
+    if (this.#components.length === 0)
+      throw new RangeError("Modals require at least one component.");
+    return {
+      type: 9,
+      custom_id: this.#custom_id,
+      title: this.#title,
+      components: this.#components.map((component) => component.toJSON())
+    };
+  }
+}
+
+class CreateTextInput2 {
+  #data = {
+    type: ComponentEnum2.TextInput,
+    style: TextInputType2.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() {
+    const data = this.#data;
+    if (!data.custom_id)
+      throw new TypeError("Text inputs require a custom ID.");
+    if (data.min_length !== undefined && data.max_length !== undefined && data.min_length > data.max_length)
+      throw new RangeError("min_length cannot exceed max_length.");
+    return cloneData(data);
+  }
+}
+
+class CreateContainer2 {
+  #components = [];
+  #accentColor;
+  #spoiler;
+  addComponents(...components) {
+    if (!components.length)
+      throw new TypeError("At least one component is required.");
+    this.#components.push(...components);
+    return this;
+  }
+  setAccentColor(color) {
+    if (!Number.isInteger(color) || color < 0 || color > 16777215) {
+      throw new RangeError("Accent color must be an integer between 0 and 16777215 (0xFFFFFF).");
+    }
+    this.#accentColor = color;
+    return this;
+  }
+  setSpoiler(spoiler = true) {
+    this.#spoiler = spoiler;
+    return this;
+  }
+  toJSON() {
+    const data = {
+      type: ComponentEnum2.Container,
+      components: this.#components.map((c) => c.toJSON())
+    };
+    if (this.#accentColor !== undefined)
+      data.accent_color = this.#accentColor;
+    if (this.#spoiler !== undefined)
+      data.spoiler = this.#spoiler;
+    return data;
+  }
+}
+
+class CreateSection2 {
+  #components = [];
+  #accessory;
+  addComponents(...components) {
+    if (!components.length)
+      throw new TypeError("At least one component is required.");
+    this.#components.push(...components);
+    return this;
+  }
+  setAccessory(accessory) {
+    this.#accessory = accessory;
+    return this;
+  }
+  toJSON() {
+    return {
+      type: ComponentEnum2.Section,
+      components: this.#components.length ? this.#components.map((c) => c.toJSON()) : undefined,
+      accessory: this.#accessory?.toJSON()
+    };
+  }
+}
+
+class CreateTextDisplay2 {
+  #content = "";
+  setContent(content) {
+    validateText(content, 4000, "Text display content");
+    this.#content = content;
+    return this;
+  }
+  toJSON() {
+    return {
+      type: ComponentEnum2.TextDisplay,
+      content: this.#content
+    };
+  }
+}
+
+class CreateMediaGallery2 {
+  #items = [];
+  addItems(...items) {
+    if (!items.length) {
+      throw new TypeError("At least one media gallery item is required.");
+    }
+    if (this.#items.length + items.length > 10) {
+      throw new RangeError("MediaGallery can only contain up to 10 items.");
+    }
+    this.#items.push(...items.map(({ url, description, spoiler }) => ({
+      media: { url },
+      ...description !== undefined ? { description } : {},
+      ...spoiler !== undefined ? { spoiler } : {}
+    })));
+    return this;
+  }
+  toJSON() {
+    return {
+      type: ComponentEnum2.MediaGallery,
+      items: cloneData(this.#items)
+    };
+  }
+}
+
+class CreateFileComponent2 {
+  #url = "";
+  #spoiler;
+  setUrl(url) {
+    validateText(url, 2048, "File component URL");
+    this.#url = url;
+    return this;
+  }
+  setSpoiler(spoiler = true) {
+    this.#spoiler = spoiler;
+    return this;
+  }
+  toJSON() {
+    if (!this.#url)
+      throw new Error("File component must have a URL.");
+    const data = {
+      type: ComponentEnum2.File,
+      file: { url: this.#url }
+    };
+    if (this.#spoiler !== undefined)
+      data.spoiler = this.#spoiler;
+    return data;
+  }
+}
+
+class CreateSeparator2 {
+  #spacing;
+  #divider;
+  setSpacing(spacing) {
+    this.#spacing = spacing;
+    return this;
+  }
+  setDivider(divider = true) {
+    this.#divider = divider;
+    return this;
+  }
+  toJSON() {
+    const data = {
+      type: ComponentEnum2.Separator
+    };
+    if (this.#spacing !== undefined)
+      data.spacing = this.#spacing;
+    if (this.#divider !== undefined)
+      data.divider = this.#divider;
+    return data;
+  }
+}
+
+class CreateThumbnail2 {
+  #url = "";
+  #description;
+  #spoiler;
+  setUrl(url) {
+    validateText(url, 2048, "Thumbnail URL");
+    this.#url = url;
+    return this;
+  }
+  setDescription(description) {
+    validateText(description, 1024, "Thumbnail description");
+    this.#description = description;
+    return this;
+  }
+  setSpoiler(spoiler = true) {
+    this.#spoiler = spoiler;
+    return this;
+  }
+  toJSON() {
+    const data = {
+      type: ComponentEnum2.Thumbnail,
+      media: { url: this.#url }
+    };
+    if (this.#description !== undefined)
+      data.description = this.#description;
+    if (this.#spoiler !== undefined)
+      data.spoiler = this.#spoiler;
+    return data;
+  }
+}
+
+class CreateContentInventoryEntry2 {
+  #id = "";
+  setId(id) {
+    validateText(id, 100, "Content inventory entry ID");
+    this.#id = id;
+    return this;
+  }
+  toJSON() {
+    return {
+      type: ComponentEnum2.ContentInventoryEntry,
+      id: this.#id
+    };
+  }
+}
+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}.`);
+}
+
+class CreateUserSelect2 extends CreateEntitySelect2 {
+  constructor() {
+    super(ComponentEnum2.UserSelect);
+  }
+}
+
+class CreateRoleSelect2 extends CreateEntitySelect2 {
+  constructor() {
+    super(ComponentEnum2.RoleSelect);
+  }
+}
+
+class CreateMentionableSelect2 extends CreateEntitySelect2 {
+  constructor() {
+    super(ComponentEnum2.MentionableSelect);
+  }
+}
+
+class CreateChannelSelect2 extends CreateEntitySelect2 {
+  constructor() {
+    super(ComponentEnum2.ChannelSelect);
+  }
+}
+function assertSelect(data) {
+  if (!data.custom_id)
+    throw new TypeError("Select menus require a custom ID.");
+  if ((data.min_values ?? 1) > (data.max_values ?? 1))
+    throw new RangeError("min_values cannot exceed max_values.");
+}
+var IS_COMPONENTS_V2 = 1 << 15;
+function componentsV2Message2(components, options) {
+  const list = Array.isArray(components) ? components : [components];
+  if (!list.length)
+    throw new TypeError("A Components V2 message needs at least one component.");
+  return {
+    ...options ?? {},
+    components: list.map((component) => component.toJSON()),
+    flags: (options?.flags ?? 0) | IS_COMPONENTS_V2
+  };
+}
+// packages/builders/src/commands.ts
+var ApplicationCommandOptionEnum2 = {
+  Subcommand: 1,
+  SubcommandGroup: 2,
+  String: 3,
+  Integer: 4,
+  Boolean: 5,
+  User: 6,
+  Channel: 7,
+  Role: 8,
+  Mentionable: 9,
+  Number: 10,
+  Attachment: 11
+};
+function validateContexts(contexts) {
+  if (contexts.some((context) => context !== 0 && context !== 1 && context !== 2))
+    throw new RangeError("Command contexts must be 0, 1 or 2.");
+}
+
+class CreateSlashCommand2 {
+  #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;
+  }
+  setContexts(...contexts) {
+    validateContexts(contexts);
+    this.#data.contexts = [...contexts];
+    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 CreateStringOption2));
+  }
+  addIntegerOption(configure) {
+    return this.addOption(configure(new CreateIntegerOption2));
+  }
+  addNumberOption(configure) {
+    return this.addOption(configure(new CreateNumberOption2));
+  }
+  addBooleanOption(configure) {
+    return this.addOption(configure(new CreateBooleanOption2));
+  }
+  addUserOption(configure) {
+    return this.addOption(configure(new CreateUserOption2));
+  }
+  addChannelOption(configure) {
+    return this.addOption(configure(new CreateChannelOption2));
+  }
+  addRoleOption(configure) {
+    return this.addOption(configure(new CreateRoleOption2));
+  }
+  addMentionableOption(configure) {
+    return this.addOption(configure(new CreateMentionableOption2));
+  }
+  addAttachmentOption(configure) {
+    return this.addOption(configure(new CreateAttachmentOption2));
+  }
+  addSubcommand(configure) {
+    return this.addOption(configure(new CreateSubcommand2));
+  }
+  addSubcommandGroup(configure) {
+    return this.addOption(configure(new CreateSubcommandGroup2));
+  }
+  toJSON() {
+    return cloneData(this.#data);
+  }
+  addOption(option) {
+    this.#data.options = appendOption(this.#data.options, option.toJSON(), "application command");
+    return this;
+  }
+}
+
+class CreateCommandOption2 {
+  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) {
+    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;
+  }
+  toJSON() {
+    return cloneData(this.data);
+  }
+}
+
+class CreateStringOption2 extends CreateCommandOption2 {
+  constructor() {
+    super(ApplicationCommandOptionEnum2.String);
+  }
+  addChoices(...choices) {
+    for (const choice of choices)
+      validateText2(choice.value, "Choice value", 100);
+    appendChoices(this.data, choices);
+    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 CreateNumericOption extends CreateCommandOption2 {
+  #integer;
+  constructor(type, integer) {
+    super(type);
+    this.#integer = integer;
+  }
+  setMinValue(value) {
+    validateNumberRange(value, -MAX_SAFE, MAX_SAFE, "min_value", this.#integer);
+    const max = this.data.max_value;
+    if (max !== undefined && value > max)
+      throw new RangeError("min_value cannot exceed max_value.");
+    this.data.min_value = value;
+    return this;
+  }
+  setMaxValue(value) {
+    validateNumberRange(value, -MAX_SAFE, MAX_SAFE, "max_value", this.#integer);
+    const min = this.data.min_value;
+    if (min !== undefined && min > 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) {
+    appendChoices(this.data, choices);
+    return this;
+  }
+}
+
+class CreateIntegerOption2 extends CreateNumericOption {
+  constructor() {
+    super(ApplicationCommandOptionEnum2.Integer, true);
+  }
+}
+
+class CreateNumberOption2 extends CreateNumericOption {
+  constructor() {
+    super(ApplicationCommandOptionEnum2.Number, false);
+  }
+}
+
+class CreateBooleanOption2 extends CreateCommandOption2 {
+  constructor() {
+    super(ApplicationCommandOptionEnum2.Boolean);
+  }
+}
+
+class CreateUserOption2 extends CreateCommandOption2 {
+  constructor() {
+    super(ApplicationCommandOptionEnum2.User);
+  }
+}
+
+class CreateRoleOption2 extends CreateCommandOption2 {
+  constructor() {
+    super(ApplicationCommandOptionEnum2.Role);
+  }
+}
+
+class CreateMentionableOption2 extends CreateCommandOption2 {
+  constructor() {
+    super(ApplicationCommandOptionEnum2.Mentionable);
+  }
+}
+
+class CreateAttachmentOption2 extends CreateCommandOption2 {
+  constructor() {
+    super(ApplicationCommandOptionEnum2.Attachment);
+  }
+}
+
+class CreateChannelOption2 extends CreateCommandOption2 {
+  constructor() {
+    super(ApplicationCommandOptionEnum2.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 CreateSubcommand2 extends CreateCommandOption2 {
+  constructor() {
+    super(ApplicationCommandOptionEnum2.Subcommand);
+  }
+  addStringOption(configure) {
+    return this.addChildOption(configure(new CreateStringOption2));
+  }
+  addIntegerOption(configure) {
+    return this.addChildOption(configure(new CreateIntegerOption2));
+  }
+  addNumberOption(configure) {
+    return this.addChildOption(configure(new CreateNumberOption2));
+  }
+  addBooleanOption(configure) {
+    return this.addChildOption(configure(new CreateBooleanOption2));
+  }
+  addUserOption(configure) {
+    return this.addChildOption(configure(new CreateUserOption2));
+  }
+  addChannelOption(configure) {
+    return this.addChildOption(configure(new CreateChannelOption2));
+  }
+  addRoleOption(configure) {
+    return this.addChildOption(configure(new CreateRoleOption2));
+  }
+  addMentionableOption(configure) {
+    return this.addChildOption(configure(new CreateMentionableOption2));
+  }
+  addAttachmentOption(configure) {
+    return this.addChildOption(configure(new CreateAttachmentOption2));
+  }
+  addChildOption(option) {
+    const options = this.data.options ?? [];
+    if (options.some((existing) => existing.type === ApplicationCommandOptionEnum2.Subcommand))
+      throw new RangeError("Subcommands cannot contain nested subcommands.");
+    this.data.options = appendOption(options, option.toJSON(), "subcommand");
+    return this;
+  }
+}
+
+class CreateSubcommandGroup2 extends CreateCommandOption2 {
+  constructor() {
+    super(ApplicationCommandOptionEnum2.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 CreateSubcommand2).toJSON();
+    if (options.some((existing) => existing.name === payload.name))
+      throw new RangeError(`Duplicate subcommand name: ${String(payload.name)}.`);
+    if (payload.type !== ApplicationCommandOptionEnum2.Subcommand)
+      throw new TypeError("Subcommand group children must be subcommands.");
+    options.push(payload);
+    this.data.options = options;
+    return this;
+  }
+}
+var MAX_SAFE = Number.MAX_SAFE_INTEGER;
+function appendOption(options, payload, parent) {
+  const list = options ?? [];
+  if (list.length >= 25)
+    throw new RangeError(`${parent === "subcommand" ? "A subcommand" : "An application command"} cannot contain more than 25 options.`);
+  if (list.some((existing) => existing.name === payload.name))
+    throw new RangeError(`Duplicate option name: ${String(payload.name)}.`);
+  if (payload.required === true && list.some((existing) => existing.required !== true))
+    throw new RangeError(`Required ${parent} options must be placed before optional options.`);
+  return [...list, payload];
+}
+function appendChoices(data, choices) {
+  const current = data.choices ?? [];
+  if (!choices.length)
+    throw new TypeError("At least one choice is required.");
+  if (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);
+    const value = choice.value;
+    if (typeof value === "string" ? value.length === 0 || value.length > 100 : typeof value !== "number" || !Number.isFinite(value))
+      throw new TypeError("Choice value must be a string of 1-100 characters or a finite number.");
+  }
+  data.choices = [...current, ...choices.map((choice) => ({ ...choice }))];
+}
+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}.`);
+}
+
+class CreateContextMenuCommand2 {
+  data;
+  constructor(type = 2) {
+    this.data = { type };
+  }
+  setType(type) {
+    if (type !== 2 && type !== 3)
+      throw new RangeError("Context menu command type must be 2 or 3.");
+    this.data.type = type;
+    return this;
+  }
+  setName(name) {
+    if (typeof name !== "string" || name.trim().length < 1 || name.length > 32)
+      throw new RangeError("Command name must contain 1-32 characters.");
+    this.data.name = name;
+    return this;
+  }
+  setDefaultMemberPermissions(permissions) {
+    this.data.default_member_permissions = permissions === null ? null : BigInt(permissions).toString();
+    return this;
+  }
+  setIntegrationTypes(...types) {
+    this.data.integration_types = [...types];
+    return this;
+  }
+  setContexts(...contexts) {
+    validateContexts(contexts);
+    this.data.contexts = [...contexts];
+    return this;
+  }
+  setNameLocalizations(localizations) {
+    this.data.name_localizations = localizations === null ? null : { ...localizations };
+    return this;
+  }
+  toJSON() {
+    return cloneData(this.data);
+  }
+}
+
+class CreateUserCommand2 extends CreateContextMenuCommand2 {
+  constructor() {
+    super(2);
+  }
+}
+
+class CreateMessageCommand2 extends CreateContextMenuCommand2 {
+  constructor() {
+    super(3);
+  }
+}
+// packages/builders/src/attachment.ts
+import { readFile, realpath } from "fs/promises";
+import { basename, isAbsolute, relative, resolve } from "path";
+
+class CreateAttachment2 {
+  name;
+  description;
+  file;
+  root;
+  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;
+      this.root = data?.root;
+    }
+  }
+  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 path = this.root === undefined ? this.file : await insideRoot(this.root, this.file);
+      const buffer = await readFile(path);
+      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);
+    }
+    throw new TypeError("Attachment file must be a supported binary value or file path.");
+  }
+}
+async function insideRoot(root, file) {
+  const base = await realpath(root).catch(() => {
+    throw new Error("Attachment root folder was not found.");
+  });
+  const target = await realpath(resolve(base, file)).catch(() => {
+    throw new Error("Attachment file was not found inside its root.");
+  });
+  const rel = relative(base, target);
+  if (rel === "" || rel === ".." || rel.startsWith("../") || rel.startsWith("..\\") || isAbsolute(rel))
+    throw new Error("Attachment file is outside its root folder.");
+  return target;
+}
+export { CreateEmbed2, TextInputType2, CreateActionRow2, CreateStringSelect2, CreateButton2, CreateEntitySelect2, CreateModal2, CreateTextInput2, CreateContainer2, CreateSection2, CreateTextDisplay2, CreateMediaGallery2, CreateFileComponent2, CreateSeparator2, CreateThumbnail2, CreateContentInventoryEntry2, CreateUserSelect2, CreateRoleSelect2, CreateMentionableSelect2, CreateChannelSelect2, componentsV2Message2, ApplicationCommandOptionEnum2, CreateSlashCommand2, CreateCommandOption2, CreateStringOption2, CreateIntegerOption2, CreateNumberOption2, CreateBooleanOption2, CreateUserOption2, CreateRoleOption2, CreateMentionableOption2, CreateAttachmentOption2, CreateChannelOption2, CreateSubcommand2, CreateSubcommandGroup2, CreateContextMenuCommand2, CreateUserCommand2, CreateMessageCommand2, CreateAttachment2 };
+
+//# debugId=CF218B228D9DB4A464756E2164756E21