baff.js 0.0.0-stage → 0.1.1

package/dist/cjs/util/Collection.d.ts

@@ -0,0 +1,32 @@
+export declare class Collection<K, V> extends Map<K, V> {
+    ensure(key: K, make: (key: K, collection: this) => V): V;
+    hasAll(...keys: K[]): boolean;
+    hasAny(...keys: K[]): boolean;
+    first(): V | undefined;
+    first(amount: number): V[];
+    firstKey(): K | undefined;
+    last(): V | undefined;
+    last(amount: number): V[];
+    lastKey(): K | undefined;
+    at(index: number): V | undefined;
+    random(): V | undefined;
+    find(fn: (value: V, key: K, collection: this) => boolean): V | undefined;
+    findKey(fn: (value: V, key: K, collection: this) => boolean): K | undefined;
+    filter(fn: (value: V, key: K, collection: this) => boolean): Collection<K, V>;
+    partition(fn: (value: V, key: K, collection: this) => boolean): [Collection<K, V>, Collection<K, V>];
+    map<T>(fn: (value: V, key: K, collection: this) => T): T[];
+    mapValues<T>(fn: (value: V, key: K, collection: this) => T): Collection<K, T>;
+    flatMap<T>(fn: (value: V, key: K, collection: this) => T[]): T[];
+    some(fn: (value: V, key: K, collection: this) => boolean): boolean;
+    every(fn: (value: V, key: K, collection: this) => boolean): boolean;
+    reduce<T>(fn: (acc: T, value: V, key: K, collection: this) => T, initial: T): T;
+    each(fn: (value: V, key: K, collection: this) => void): this;
+    tap(fn: (collection: this) => void): this;
+    sweep(fn: (value: V, key: K, collection: this) => boolean): number;
+    sort(compare?: (a: V, b: V, aKey: K, bKey: K) => number): this;
+    toSorted(compare?: (a: V, b: V, aKey: K, bKey: K) => number): Collection<K, V>;
+    clone(): Collection<K, V>;
+    concat(...others: Collection<K, V>[]): Collection<K, V>;
+    toJSON(): V[];
+    private static defaultCompare;
+}

package/dist/cjs/util/Collection.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collection = void 0;
+class Collection extends Map {
+    ensure(key, make) {
+        if (this.has(key))
+            return this.get(key);
+        const value = make(key, this);
+        this.set(key, value);
+        return value;
+    }
+    hasAll(...keys) {
+        return keys.every((key) => this.has(key));
+    }
+    hasAny(...keys) {
+        return keys.some((key) => this.has(key));
+    }
+    first(amount) {
+        if (amount === undefined)
+            return this.values().next().value;
+        return [...this.values()].slice(0, Math.max(0, amount));
+    }
+    firstKey() {
+        return this.keys().next().value;
+    }
+    last(amount) {
+        const values = [...this.values()];
+        if (amount === undefined)
+            return values[values.length - 1];
+        return amount <= 0 ? [] : values.slice(-amount);
+    }
+    lastKey() {
+        const keys = [...this.keys()];
+        return keys[keys.length - 1];
+    }
+    at(index) {
+        return [...this.values()].at(index);
+    }
+    random() {
+        const values = [...this.values()];
+        return values[Math.floor(Math.random() * values.length)];
+    }
+    find(fn) {
+        for (const [key, value] of this)
+            if (fn(value, key, this))
+                return value;
+        return undefined;
+    }
+    findKey(fn) {
+        for (const [key, value] of this)
+            if (fn(value, key, this))
+                return key;
+        return undefined;
+    }
+    filter(fn) {
+        const out = new Collection();
+        for (const [key, value] of this)
+            if (fn(value, key, this))
+                out.set(key, value);
+        return out;
+    }
+    partition(fn) {
+        const yes = new Collection();
+        const no = new Collection();
+        for (const [key, value] of this)
+            (fn(value, key, this) ? yes : no).set(key, value);
+        return [yes, no];
+    }
+    map(fn) {
+        const out = [];
+        for (const [key, value] of this)
+            out.push(fn(value, key, this));
+        return out;
+    }
+    mapValues(fn) {
+        const out = new Collection();
+        for (const [key, value] of this)
+            out.set(key, fn(value, key, this));
+        return out;
+    }
+    flatMap(fn) {
+        return this.map(fn).flat();
+    }
+    some(fn) {
+        for (const [key, value] of this)
+            if (fn(value, key, this))
+                return true;
+        return false;
+    }
+    every(fn) {
+        for (const [key, value] of this)
+            if (!fn(value, key, this))
+                return false;
+        return true;
+    }
+    reduce(fn, initial) {
+        let acc = initial;
+        for (const [key, value] of this)
+            acc = fn(acc, value, key, this);
+        return acc;
+    }
+    each(fn) {
+        for (const [key, value] of this)
+            fn(value, key, this);
+        return this;
+    }
+    tap(fn) {
+        fn(this);
+        return this;
+    }
+    sweep(fn) {
+        const before = this.size;
+        for (const [key, value] of [...this])
+            if (fn(value, key, this))
+                this.delete(key);
+        return before - this.size;
+    }
+    sort(compare = Collection.defaultCompare) {
+        const sorted = [...this].sort((a, b) => compare(a[1], b[1], a[0], b[0]));
+        this.clear();
+        for (const [key, value] of sorted)
+            this.set(key, value);
+        return this;
+    }
+    toSorted(compare = Collection.defaultCompare) {
+        return this.clone().sort(compare);
+    }
+    clone() {
+        return new Collection(this);
+    }
+    concat(...others) {
+        const out = this.clone();
+        for (const other of others)
+            for (const [key, value] of other)
+                out.set(key, value);
+        return out;
+    }
+    toJSON() {
+        return [...this.values()];
+    }
+    static defaultCompare(a, b) {
+        return a < b ? -1 : a > b ? 1 : 0;
+    }
+}
+exports.Collection = Collection;

package/dist/cjs/util/Permissions.d.ts

@@ -0,0 +1,87 @@
+export declare const PermissionFlagsBits: {
+    readonly Administrator: bigint;
+    readonly ManageServer: bigint;
+    readonly ManageRoles: bigint;
+    readonly ManageChannels: bigint;
+    readonly KickMembers: bigint;
+    readonly BanMembers: bigint;
+    readonly CreateInvite: bigint;
+    readonly SendMessages: bigint;
+    readonly ManageMessages: bigint;
+    readonly AttachFiles: bigint;
+    readonly AddReactions: bigint;
+    readonly ManageExpressions: bigint;
+    readonly MentionEveryone: bigint;
+    readonly ViewChannel: bigint;
+    readonly ManageWebhooks: bigint;
+    readonly Connect: bigint;
+    readonly Speak: bigint;
+    readonly Video: bigint;
+    readonly BaffleUpload: bigint;
+    readonly BaffleWithdraw: bigint;
+    readonly ManageBaffles: bigint;
+    readonly ModerateMembers: bigint;
+    readonly ViewAuditLog: bigint;
+    readonly UseSoundboard: bigint;
+    readonly ManageThreads: bigint;
+    readonly ManageStage: bigint;
+    readonly ChangeNickname: bigint;
+    readonly ManageNicknames: bigint;
+    readonly ManageEvents: bigint;
+    readonly SetVoiceChannelStatus: bigint;
+    readonly RequestToSpeak: bigint;
+};
+export type PermissionString = keyof typeof PermissionFlagsBits;
+export type PermissionResolvable = PermissionString | `${bigint}` | bigint | number | PermissionsBitField | readonly PermissionResolvable[];
+export declare class PermissionsBitField {
+    static readonly Flags: {
+        readonly Administrator: bigint;
+        readonly ManageServer: bigint;
+        readonly ManageRoles: bigint;
+        readonly ManageChannels: bigint;
+        readonly KickMembers: bigint;
+        readonly BanMembers: bigint;
+        readonly CreateInvite: bigint;
+        readonly SendMessages: bigint;
+        readonly ManageMessages: bigint;
+        readonly AttachFiles: bigint;
+        readonly AddReactions: bigint;
+        readonly ManageExpressions: bigint;
+        readonly MentionEveryone: bigint;
+        readonly ViewChannel: bigint;
+        readonly ManageWebhooks: bigint;
+        readonly Connect: bigint;
+        readonly Speak: bigint;
+        readonly Video: bigint;
+        readonly BaffleUpload: bigint;
+        readonly BaffleWithdraw: bigint;
+        readonly ManageBaffles: bigint;
+        readonly ModerateMembers: bigint;
+        readonly ViewAuditLog: bigint;
+        readonly UseSoundboard: bigint;
+        readonly ManageThreads: bigint;
+        readonly ManageStage: bigint;
+        readonly ChangeNickname: bigint;
+        readonly ManageNicknames: bigint;
+        readonly ManageEvents: bigint;
+        readonly SetVoiceChannelStatus: bigint;
+        readonly RequestToSpeak: bigint;
+    };
+    static readonly All: PermissionsBitField;
+    readonly bitfield: bigint;
+    constructor(bits?: PermissionResolvable);
+    static fromBits(bits: string | number | bigint): PermissionsBitField;
+    static resolve(bits: PermissionResolvable): bigint;
+    has(permission: PermissionResolvable, checkAdmin?: boolean): boolean;
+    any(permission: PermissionResolvable, checkAdmin?: boolean): boolean;
+    missing(permission: PermissionResolvable, checkAdmin?: boolean): PermissionString[];
+    add(...permissions: PermissionResolvable[]): PermissionsBitField;
+    remove(...permissions: PermissionResolvable[]): PermissionsBitField;
+    equals(other: PermissionResolvable): boolean;
+    toArray(): PermissionString[];
+    serialize(checkAdmin?: boolean): Record<PermissionString, boolean>;
+    toJSON(): string;
+    toString(): string;
+    valueOf(): bigint;
+    private static names;
+}

package/dist/cjs/util/Permissions.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionsBitField = exports.PermissionFlagsBits = void 0;
+const BaffError_js_1 = require("../errors/BaffError.js");
+exports.PermissionFlagsBits = {
+    Administrator: 1n << 0n,
+    ManageServer: 1n << 1n,
+    ManageRoles: 1n << 2n,
+    ManageChannels: 1n << 3n,
+    KickMembers: 1n << 4n,
+    BanMembers: 1n << 5n,
+    CreateInvite: 1n << 6n,
+    SendMessages: 1n << 7n,
+    ManageMessages: 1n << 8n,
+    AttachFiles: 1n << 9n,
+    AddReactions: 1n << 10n,
+    ManageExpressions: 1n << 11n,
+    MentionEveryone: 1n << 12n,
+    ViewChannel: 1n << 13n,
+    ManageWebhooks: 1n << 14n,
+    Connect: 1n << 15n,
+    Speak: 1n << 16n,
+    Video: 1n << 17n,
+    BaffleUpload: 1n << 18n,
+    BaffleWithdraw: 1n << 19n,
+    ManageBaffles: 1n << 20n,
+    ModerateMembers: 1n << 21n,
+    ViewAuditLog: 1n << 22n,
+    UseSoundboard: 1n << 23n,
+    ManageThreads: 1n << 24n,
+    ManageStage: 1n << 25n,
+    ChangeNickname: 1n << 26n,
+    ManageNicknames: 1n << 27n,
+    ManageEvents: 1n << 28n,
+    SetVoiceChannelStatus: 1n << 29n,
+    RequestToSpeak: 1n << 30n
+};
+const ALL = Object.values(exports.PermissionFlagsBits).reduce((acc, bit) => acc | bit, 0n);
+class PermissionsBitField {
+    static Flags = exports.PermissionFlagsBits;
+    static All = new PermissionsBitField(ALL);
+    bitfield;
+    constructor(bits = 0n) {
+        this.bitfield = PermissionsBitField.resolve(bits);
+    }
+    static fromBits(bits) {
+        return new PermissionsBitField(BigInt(bits));
+    }
+    static resolve(bits) {
+        if (bits instanceof PermissionsBitField)
+            return bits.bitfield;
+        if (typeof bits === 'bigint')
+            return bits;
+        if (typeof bits === 'number')
+            return BigInt(bits);
+        if (Array.isArray(bits))
+            return bits.reduce((acc, bit) => acc | PermissionsBitField.resolve(bit), 0n);
+        if (typeof bits === 'string') {
+            if (/^\d+$/.test(bits))
+                return BigInt(bits);
+            const flag = exports.PermissionFlagsBits[bits];
+            if (flag === undefined)
+                throw new BaffError_js_1.BaffError('INVALID_PERMISSION', `Unknown permission "${bits}".`);
+            return flag;
+        }
+        throw new BaffError_js_1.BaffError('INVALID_PERMISSION', `Cannot read ${String(bits)} as a permission.`);
+    }
+    has(permission, checkAdmin = true) {
+        // Resolve first, so a misspelled name throws for administrators too.
+        const bit = PermissionsBitField.resolve(permission);
+        if (checkAdmin && (this.bitfield & exports.PermissionFlagsBits.Administrator) !== 0n)
+            return true;
+        return (this.bitfield & bit) === bit;
+    }
+    any(permission, checkAdmin = true) {
+        const bit = PermissionsBitField.resolve(permission);
+        if (checkAdmin && (this.bitfield & exports.PermissionFlagsBits.Administrator) !== 0n)
+            return true;
+        return (this.bitfield & bit) !== 0n;
+    }
+    missing(permission, checkAdmin = true) {
+        return PermissionsBitField.names(PermissionsBitField.resolve(permission)).filter((name) => !this.has(name, checkAdmin));
+    }
+    add(...permissions) {
+        return new PermissionsBitField(permissions.reduce((acc, p) => acc | PermissionsBitField.resolve(p), this.bitfield));
+    }
+    remove(...permissions) {
+        return new PermissionsBitField(permissions.reduce((acc, p) => acc & ~PermissionsBitField.resolve(p), this.bitfield));
+    }
+    equals(other) {
+        return this.bitfield === PermissionsBitField.resolve(other);
+    }
+    toArray() {
+        return PermissionsBitField.names(this.bitfield);
+    }
+    serialize(checkAdmin = true) {
+        const out = {};
+        for (const name of Object.keys(exports.PermissionFlagsBits))
+            out[name] = this.has(name, checkAdmin);
+        return out;
+    }
+    toJSON() {
+        return this.bitfield.toString();
+    }
+    toString() {
+        return this.bitfield.toString();
+    }
+    valueOf() {
+        return this.bitfield;
+    }
+    static names(bits) {
+        return Object.keys(exports.PermissionFlagsBits).filter((name) => (bits & exports.PermissionFlagsBits[name]) !== 0n);
+    }
+}
+exports.PermissionsBitField = PermissionsBitField;

package/dist/cjs/util/Snowflake.d.ts

@@ -0,0 +1,20 @@
+export interface DeconstructedSnowflake {
+    timestamp: number;
+    date: Date;
+    workerId: number;
+    sequence: number;
+    binary: string;
+}
+export interface SnowflakeParts {
+    timestamp?: number | Date;
+    workerId?: number;
+    sequence?: number;
+}
+export declare const Snowflake: {
+    EPOCH: number;
+    deconstruct(id: string | bigint): DeconstructedSnowflake;
+    timestampOf(id: string | bigint): number;
+    generate({ timestamp, workerId, sequence }?: SnowflakeParts): string;
+    compare(a: string, b: string): -1 | 0 | 1;
+    isValid(value: unknown): value is string;
+};

package/dist/cjs/util/Snowflake.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Snowflake = void 0;
+const EPOCH = 1767225600000n;
+const WORKER_BITS = 10n;
+const SEQUENCE_BITS = 12n;
+const WORKER_MASK = (1n << WORKER_BITS) - 1n;
+const SEQUENCE_MASK = (1n << SEQUENCE_BITS) - 1n;
+exports.Snowflake = {
+    EPOCH: Number(EPOCH),
+    deconstruct(id) {
+        const value = BigInt(id);
+        const timestamp = Number((value >> (WORKER_BITS + SEQUENCE_BITS)) + EPOCH);
+        return {
+            timestamp,
+            date: new Date(timestamp),
+            workerId: Number((value >> SEQUENCE_BITS) & WORKER_MASK),
+            sequence: Number(value & SEQUENCE_MASK),
+            binary: value.toString(2).padStart(64, '0')
+        };
+    },
+    timestampOf(id) {
+        return exports.Snowflake.deconstruct(id).timestamp;
+    },
+    generate({ timestamp = Date.now(), workerId = 0, sequence = 0 } = {}) {
+        const ms = BigInt(timestamp instanceof Date ? timestamp.getTime() : timestamp);
+        if (ms < EPOCH)
+            throw new RangeError('Timestamp is before the baff.gg epoch (2026-01-01T00:00:00Z).');
+        const id = ((ms - EPOCH) << (WORKER_BITS + SEQUENCE_BITS)) | ((BigInt(workerId) & WORKER_MASK) << SEQUENCE_BITS) | (BigInt(sequence) & SEQUENCE_MASK);
+        return id.toString();
+    },
+    compare(a, b) {
+        const x = BigInt(a);
+        const y = BigInt(b);
+        return x < y ? -1 : x > y ? 1 : 0;
+    },
+    isValid(value) {
+        return typeof value === 'string' && /^\d{1,19}$/.test(value) && BigInt(value) < 1n << 63n;
+    }
+};

package/dist/cjs/util/TypedEmitter.d.ts

@@ -0,0 +1,17 @@
+export type EventMap = {
+    [event: string]: unknown[];
+};
+export interface TypedEmitterShape<E extends EventMap> {
+    on<K extends keyof E & string>(event: K, listener: (...args: E[K]) => void): this;
+    once<K extends keyof E & string>(event: K, listener: (...args: E[K]) => void): this;
+    off<K extends keyof E & string>(event: K, listener: (...args: E[K]) => void): this;
+    addListener<K extends keyof E & string>(event: K, listener: (...args: E[K]) => void): this;
+    removeListener<K extends keyof E & string>(event: K, listener: (...args: E[K]) => void): this;
+    removeAllListeners(event?: keyof E & string): this;
+    emit<K extends keyof E & string>(event: K, ...args: E[K]): boolean;
+    listenerCount(event: keyof E & string): number;
+    setMaxListeners(n: number): this;
+}
+export declare const TypedEmitter: new <E extends EventMap>(options?: {
+    captureRejections?: boolean;
+}) => TypedEmitterShape<E>;

package/dist/cjs/util/TypedEmitter.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedEmitter = void 0;
+const node_events_1 = require("node:events");
+exports.TypedEmitter = node_events_1.EventEmitter;

package/dist/cjs/util/constants.d.ts

@@ -0,0 +1,78 @@
+export declare const Colors: {
+    readonly Default: 0;
+    readonly White: 16777215;
+    readonly Ink: 270365;
+    readonly Baff: 3065014;
+    readonly Green: 3066993;
+    readonly Red: 15158332;
+    readonly Orange: 15105570;
+    readonly Yellow: 15844367;
+    readonly Blue: 3447003;
+    readonly Pink: 15277667;
+    readonly Grey: 9807270;
+    readonly DarkGrey: 5533306;
+};
+export declare const MessageFlags: {
+    readonly Ephemeral: number;
+    readonly IsComponentsV2: number;
+};
+export declare const ComponentType: {
+    readonly ActionRow: 1;
+    readonly Button: 2;
+    readonly StringSelect: 3;
+    readonly TextInput: 4;
+    readonly UserSelect: 5;
+    readonly RoleSelect: 6;
+    readonly MentionableSelect: 7;
+    readonly ChannelSelect: 8;
+    readonly Section: 9;
+    readonly TextDisplay: 10;
+    readonly Thumbnail: 11;
+    readonly MediaGallery: 12;
+    readonly Separator: 14;
+    readonly Container: 17;
+};
+export declare const ButtonStyle: {
+    readonly Primary: 1;
+    readonly Secondary: 2;
+    readonly Success: 3;
+    readonly Danger: 4;
+    readonly Link: 5;
+};
+export declare const TextInputStyle: {
+    readonly Short: 1;
+    readonly Paragraph: 2;
+};
+export declare const SeparatorSpacing: {
+    readonly Small: 1;
+    readonly Large: 2;
+};
+export declare const ChannelType: {
+    readonly Text: "text";
+    readonly Announcement: "announcement";
+    readonly Forum: "forum";
+    readonly Voice: "voice";
+    readonly Stage: "stage";
+    readonly Category: "category";
+    readonly Thread: "thread";
+};
+export declare const ApplicationCommandOptionType: {
+    readonly Subcommand: "subcommand";
+    readonly SubcommandGroup: "subcommand_group";
+    readonly String: "string";
+    readonly Integer: "integer";
+    readonly Number: "number";
+    readonly Boolean: "boolean";
+    readonly User: "user";
+    readonly Channel: "channel";
+    readonly Role: "role";
+};
+export declare const PresenceStatus: {
+    readonly Online: "online";
+    readonly Idle: "idle";
+    readonly DoNotDisturb: "dnd";
+    readonly Invisible: "invisible";
+};
+export declare const DEFAULT_API_URL = "https://baff.gg/api";
+export declare const DEFAULT_GATEWAY_URL = "wss://baff.gg/api/gateway";
+export declare const VERSION = "0.1.1";

package/dist/cjs/util/constants.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = exports.DEFAULT_GATEWAY_URL = exports.DEFAULT_API_URL = exports.PresenceStatus = exports.ApplicationCommandOptionType = exports.ChannelType = exports.SeparatorSpacing = exports.TextInputStyle = exports.ButtonStyle = exports.ComponentType = exports.MessageFlags = exports.Colors = void 0;
+exports.Colors = {
+    Default: 0x000000,
+    White: 0xffffff,
+    Ink: 0x04201d,
+    Baff: 0x2ec4b6,
+    Green: 0x2ecc71,
+    Red: 0xe74c3c,
+    Orange: 0xe67e22,
+    Yellow: 0xf1c40f,
+    Blue: 0x3498db,
+    Pink: 0xe91e63,
+    Grey: 0x95a5a6,
+    DarkGrey: 0x546e7a
+};
+exports.MessageFlags = {
+    Ephemeral: 1 << 6,
+    IsComponentsV2: 1 << 15
+};
+exports.ComponentType = {
+    ActionRow: 1,
+    Button: 2,
+    StringSelect: 3,
+    TextInput: 4,
+    UserSelect: 5,
+    RoleSelect: 6,
+    MentionableSelect: 7,
+    ChannelSelect: 8,
+    Section: 9,
+    TextDisplay: 10,
+    Thumbnail: 11,
+    MediaGallery: 12,
+    Separator: 14,
+    Container: 17
+};
+exports.ButtonStyle = {
+    Primary: 1,
+    Secondary: 2,
+    Success: 3,
+    Danger: 4,
+    Link: 5
+};
+exports.TextInputStyle = {
+    Short: 1,
+    Paragraph: 2
+};
+exports.SeparatorSpacing = {
+    Small: 1,
+    Large: 2
+};
+exports.ChannelType = {
+    Text: 'text',
+    Announcement: 'announcement',
+    Forum: 'forum',
+    Voice: 'voice',
+    Stage: 'stage',
+    Category: 'category',
+    Thread: 'thread'
+};
+exports.ApplicationCommandOptionType = {
+    Subcommand: 'subcommand',
+    SubcommandGroup: 'subcommand_group',
+    String: 'string',
+    Integer: 'integer',
+    Number: 'number',
+    Boolean: 'boolean',
+    User: 'user',
+    Channel: 'channel',
+    Role: 'role'
+};
+exports.PresenceStatus = {
+    Online: 'online',
+    Idle: 'idle',
+    DoNotDisturb: 'dnd',
+    Invisible: 'invisible'
+};
+exports.DEFAULT_API_URL = 'https://baff.gg/api';
+exports.DEFAULT_GATEWAY_URL = 'wss://baff.gg/api/gateway';
+exports.VERSION = '0.1.1';

package/dist/cjs/util/emoji.d.ts

@@ -0,0 +1,8 @@
+export type EmojiResolvable = string | {
+    id: string;
+    name: string;
+    animated?: boolean;
+} | {
+    identifier: string;
+};
+export declare function resolveEmoji(emoji: EmojiResolvable): string;

package/dist/cjs/util/emoji.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEmoji = resolveEmoji;
+const CUSTOM = /^<(a?):(\w{2,32}):(\d+)>$/;
+function resolveEmoji(emoji) {
+    if (typeof emoji === 'object')
+        return 'identifier' in emoji ? emoji.identifier : `${emoji.animated ? 'a:' : ''}${emoji.name}:${emoji.id}`;
+    const match = CUSTOM.exec(emoji.trim());
+    return match ? `${match[1] ? 'a:' : ''}${match[2]}:${match[3]}` : emoji;
+}

package/dist/cjs/util/formatters.d.ts

@@ -0,0 +1,29 @@
+export declare const userMention: (id: string) => `<@${string}>`;
+export declare const roleMention: (id: string) => `<@&${string}>`;
+export declare const channelMention: (id: string) => `<#${string}>`;
+export declare const everyoneMention = "@everyone";
+export declare const hereMention = "@here";
+export declare const formatEmoji: (id: string, name: string, animated?: boolean) => string;
+export declare const bold: (text: string) => string;
+export declare const italic: (text: string) => string;
+export declare const underline: (text: string) => string;
+export declare const strikethrough: (text: string) => string;
+export declare const spoiler: (text: string) => string;
+export declare const inlineCode: (text: string) => string;
+export declare const codeBlock: (content: string, language?: string) => string;
+export declare const quote: (text: string) => string;
+export declare const blockQuote: (text: string) => string;
+export declare const heading: (text: string, level?: 1 | 2 | 3) => string;
+export declare const subtext: (text: string) => string;
+export declare const hyperlink: (text: string, url: string) => string;
+export declare const hideLinkEmbed: (url: string) => string;
+export interface EscapeOptions {
+    codeBlock?: boolean;
+    inlineCode?: boolean;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    spoiler?: boolean;
+}
+export declare function escapeMarkdown(text: string, options?: EscapeOptions): string;