@jubbio/core 1.0.0

package/dist/utils/DataResolver.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Data resolver utilities for handling various data types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataResolver = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+/**
+ * Resolves various data types to usable formats
+ */
+class DataResolver {
+    /**
+     * Resolves a BufferResolvable to a Buffer
+     * @param resource The resource to resolve
+     */
+    static async resolveBuffer(resource) {
+        if (Buffer.isBuffer(resource))
+            return resource;
+        if (typeof resource === 'string') {
+            // Check if it's a file path
+            if (resource.startsWith('/') || resource.startsWith('./') || resource.startsWith('../') || /^[a-zA-Z]:/.test(resource)) {
+                return (0, promises_1.readFile)(resource);
+            }
+            // Check if it's a URL
+            if (resource.startsWith('http://') || resource.startsWith('https://')) {
+                const response = await fetch(resource);
+                const arrayBuffer = await response.arrayBuffer();
+                return Buffer.from(arrayBuffer);
+            }
+            // Check if it's base64
+            if (resource.startsWith('data:')) {
+                const base64Data = resource.split(',')[1];
+                return Buffer.from(base64Data, 'base64');
+            }
+            // Assume it's a file path
+            return (0, promises_1.readFile)(resource);
+        }
+        throw new TypeError('Invalid resource type');
+    }
+    /**
+     * Resolves a Base64Resolvable to a base64 string
+     * @param resource The resource to resolve
+     * @param mimeType The MIME type for the data URI
+     */
+    static async resolveBase64(resource, mimeType = 'image/png') {
+        const buffer = await this.resolveBuffer(resource);
+        return `data:${mimeType};base64,${buffer.toString('base64')}`;
+    }
+    /**
+     * Resolves a file to a name and buffer
+     * @param resource The file resource
+     */
+    static async resolveFile(resource) {
+        if (typeof resource === 'object' && 'attachment' in resource) {
+            const buffer = await this.resolveBuffer(resource.attachment);
+            const name = resource.name ?? 'file';
+            return { name, data: buffer };
+        }
+        const buffer = await this.resolveBuffer(resource);
+        const name = typeof resource === 'string' ? (0, path_1.basename)(resource) : 'file';
+        return { name, data: buffer };
+    }
+    /**
+     * Resolves multiple files
+     * @param resources The file resources
+     */
+    static async resolveFiles(resources) {
+        return Promise.all(resources.map(r => this.resolveFile(r)));
+    }
+    /**
+     * Resolves a color to a number
+     * @param color The color to resolve
+     */
+    static resolveColor(color) {
+        if (color === null)
+            return null;
+        if (typeof color === 'number') {
+            if (color < 0 || color > 0xFFFFFF)
+                throw new RangeError('Color must be between 0 and 16777215');
+            return color;
+        }
+        if (typeof color === 'string') {
+            if (color.startsWith('#')) {
+                return parseInt(color.slice(1), 16);
+            }
+            // Named colors
+            const namedColors = {
+                default: 0x000000,
+                white: 0xFFFFFF,
+                aqua: 0x1ABC9C,
+                green: 0x57F287,
+                blue: 0x3498DB,
+                yellow: 0xFEE75C,
+                purple: 0x9B59B6,
+                fuchsia: 0xEB459E,
+                gold: 0xF1C40F,
+                orange: 0xE67E22,
+                red: 0xED4245,
+                grey: 0x95A5A6,
+                navy: 0x34495E,
+                blurple: 0x5865F2,
+            };
+            const lower = color.toLowerCase();
+            if (lower in namedColors)
+                return namedColors[lower];
+            return parseInt(color, 16);
+        }
+        if (Array.isArray(color)) {
+            return (color[0] << 16) + (color[1] << 8) + color[2];
+        }
+        throw new TypeError('Invalid color type');
+    }
+    /**
+     * Resolves a string to a snowflake ID
+     * @param value The value to resolve
+     */
+    static resolveSnowflake(value) {
+        if (typeof value === 'object' && 'id' in value) {
+            return String(value.id);
+        }
+        return String(value);
+    }
+    /**
+     * Resolves an image to a base64 data URI
+     * @param image The image to resolve
+     */
+    static async resolveImage(image) {
+        const buffer = await this.resolveBuffer(image);
+        // Detect MIME type from magic bytes
+        let mimeType = 'image/png';
+        if (buffer[0] === 0xFF && buffer[1] === 0xD8) {
+            mimeType = 'image/jpeg';
+        }
+        else if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46) {
+            mimeType = 'image/gif';
+        }
+        else if (buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46) {
+            mimeType = 'image/webp';
+        }
+        return `data:${mimeType};base64,${buffer.toString('base64')}`;
+    }
+}
+exports.DataResolver = DataResolver;
+exports.default = DataResolver;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DataResolver.js","sourceRoot":"","sources":["../../src/utils/DataResolver.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Data resolver utilities for handling various data types\r\n */\r\n\r\nimport { readFile } from 'fs/promises';\r\nimport { basename } from 'path';\r\n\r\nexport type BufferResolvable = Buffer | string;\r\nexport type Base64Resolvable = Buffer | string;\r\n\r\n/**\r\n * Resolves various data types to usable formats\r\n */\r\nexport class DataResolver {\r\n  /**\r\n   * Resolves a BufferResolvable to a Buffer\r\n   * @param resource The resource to resolve\r\n   */\r\n  static async resolveBuffer(resource: BufferResolvable): Promise<Buffer> {\r\n    if (Buffer.isBuffer(resource)) return resource;\r\n    \r\n    if (typeof resource === 'string') {\r\n      // Check if it's a file path\r\n      if (resource.startsWith('/') || resource.startsWith('./') || resource.startsWith('../') || /^[a-zA-Z]:/.test(resource)) {\r\n        return readFile(resource);\r\n      }\r\n      \r\n      // Check if it's a URL\r\n      if (resource.startsWith('http://') || resource.startsWith('https://')) {\r\n        const response = await fetch(resource);\r\n        const arrayBuffer = await response.arrayBuffer();\r\n        return Buffer.from(arrayBuffer);\r\n      }\r\n      \r\n      // Check if it's base64\r\n      if (resource.startsWith('data:')) {\r\n        const base64Data = resource.split(',')[1];\r\n        return Buffer.from(base64Data, 'base64');\r\n      }\r\n      \r\n      // Assume it's a file path\r\n      return readFile(resource);\r\n    }\r\n    \r\n    throw new TypeError('Invalid resource type');\r\n  }\r\n\r\n  /**\r\n   * Resolves a Base64Resolvable to a base64 string\r\n   * @param resource The resource to resolve\r\n   * @param mimeType The MIME type for the data URI\r\n   */\r\n  static async resolveBase64(resource: Base64Resolvable, mimeType = 'image/png'): Promise<string> {\r\n    const buffer = await this.resolveBuffer(resource);\r\n    return `data:${mimeType};base64,${buffer.toString('base64')}`;\r\n  }\r\n\r\n  /**\r\n   * Resolves a file to a name and buffer\r\n   * @param resource The file resource\r\n   */\r\n  static async resolveFile(resource: BufferResolvable | { name?: string; attachment: BufferResolvable }): Promise<{ name: string; data: Buffer }> {\r\n    if (typeof resource === 'object' && 'attachment' in resource) {\r\n      const buffer = await this.resolveBuffer(resource.attachment);\r\n      const name = resource.name ?? 'file';\r\n      return { name, data: buffer };\r\n    }\r\n    \r\n    const buffer = await this.resolveBuffer(resource);\r\n    const name = typeof resource === 'string' ? basename(resource) : 'file';\r\n    return { name, data: buffer };\r\n  }\r\n\r\n  /**\r\n   * Resolves multiple files\r\n   * @param resources The file resources\r\n   */\r\n  static async resolveFiles(resources: (BufferResolvable | { name?: string; attachment: BufferResolvable })[]): Promise<{ name: string; data: Buffer }[]> {\r\n    return Promise.all(resources.map(r => this.resolveFile(r)));\r\n  }\r\n\r\n  /**\r\n   * Resolves a color to a number\r\n   * @param color The color to resolve\r\n   */\r\n  static resolveColor(color: number | string | [number, number, number] | null): number | null {\r\n    if (color === null) return null;\r\n    \r\n    if (typeof color === 'number') {\r\n      if (color < 0 || color > 0xFFFFFF) throw new RangeError('Color must be between 0 and 16777215');\r\n      return color;\r\n    }\r\n    \r\n    if (typeof color === 'string') {\r\n      if (color.startsWith('#')) {\r\n        return parseInt(color.slice(1), 16);\r\n      }\r\n      // Named colors\r\n      const namedColors: Record<string, number> = {\r\n        default: 0x000000,\r\n        white: 0xFFFFFF,\r\n        aqua: 0x1ABC9C,\r\n        green: 0x57F287,\r\n        blue: 0x3498DB,\r\n        yellow: 0xFEE75C,\r\n        purple: 0x9B59B6,\r\n        fuchsia: 0xEB459E,\r\n        gold: 0xF1C40F,\r\n        orange: 0xE67E22,\r\n        red: 0xED4245,\r\n        grey: 0x95A5A6,\r\n        navy: 0x34495E,\r\n        blurple: 0x5865F2,\r\n      };\r\n      const lower = color.toLowerCase();\r\n      if (lower in namedColors) return namedColors[lower];\r\n      return parseInt(color, 16);\r\n    }\r\n    \r\n    if (Array.isArray(color)) {\r\n      return (color[0] << 16) + (color[1] << 8) + color[2];\r\n    }\r\n    \r\n    throw new TypeError('Invalid color type');\r\n  }\r\n\r\n  /**\r\n   * Resolves a string to a snowflake ID\r\n   * @param value The value to resolve\r\n   */\r\n  static resolveSnowflake(value: string | number | { id: string | number }): string {\r\n    if (typeof value === 'object' && 'id' in value) {\r\n      return String(value.id);\r\n    }\r\n    return String(value);\r\n  }\r\n\r\n  /**\r\n   * Resolves an image to a base64 data URI\r\n   * @param image The image to resolve\r\n   */\r\n  static async resolveImage(image: BufferResolvable): Promise<string> {\r\n    const buffer = await this.resolveBuffer(image);\r\n    \r\n    // Detect MIME type from magic bytes\r\n    let mimeType = 'image/png';\r\n    if (buffer[0] === 0xFF && buffer[1] === 0xD8) {\r\n      mimeType = 'image/jpeg';\r\n    } else if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46) {\r\n      mimeType = 'image/gif';\r\n    } else if (buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46) {\r\n      mimeType = 'image/webp';\r\n    }\r\n    \r\n    return `data:${mimeType};base64,${buffer.toString('base64')}`;\r\n  }\r\n}\r\n\r\nexport default DataResolver;\r\n"]}

package/dist/utils/Formatters.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Formatters for markdown and mentions
+ */
+/**
+ * Formats a user mention
+ * @param userId The user ID to mention
+ */
+export declare function userMention(userId: string | number): string;
+/**
+ * Formats a channel mention
+ * @param channelId The channel ID to mention
+ */
+export declare function channelMention(channelId: string | number): string;
+/**
+ * Formats a role mention
+ * @param roleId The role ID to mention
+ */
+export declare function roleMention(roleId: string | number): string;
+/**
+ * Formats a custom emoji
+ * @param emojiId The emoji ID
+ * @param name The emoji name
+ * @param animated Whether the emoji is animated
+ */
+export declare function formatEmoji(emojiId: string | number, name: string, animated?: boolean): string;
+/**
+ * Formats text as bold
+ * @param text The text to format
+ */
+export declare function bold(text: string): string;
+/**
+ * Formats text as italic
+ * @param text The text to format
+ */
+export declare function italic(text: string): string;
+/**
+ * Formats text as underline
+ * @param text The text to format
+ */
+export declare function underline(text: string): string;
+/**
+ * Formats text as strikethrough
+ * @param text The text to format
+ */
+export declare function strikethrough(text: string): string;
+/**
+ * Formats text as spoiler
+ * @param text The text to format
+ */
+export declare function spoiler(text: string): string;
+/**
+ * Formats text as inline code
+ * @param text The text to format
+ */
+export declare function inlineCode(text: string): string;
+/**
+ * Formats text as a code block
+ * @param text The text to format
+ * @param language The language for syntax highlighting
+ */
+export declare function codeBlock(text: string, language?: string): string;
+/**
+ * Formats text as a block quote
+ * @param text The text to format
+ */
+export declare function blockQuote(text: string): string;
+/**
+ * Formats text as a single-line quote
+ * @param text The text to format
+ */
+export declare function quote(text: string): string;
+/**
+ * Formats a URL as a hyperlink
+ * @param text The text to display
+ * @param url The URL to link to
+ * @param title Optional title for the link
+ */
+export declare function hyperlink(text: string, url: string, title?: string): string;
+/**
+ * Formats a URL to hide the embed
+ * @param url The URL to format
+ */
+export declare function hideLinkEmbed(url: string): string;
+/**
+ * Time format styles
+ */
+export declare enum TimestampStyles {
+    /** Short time format (e.g., 16:20) */
+    ShortTime = "t",
+    /** Long time format (e.g., 16:20:30) */
+    LongTime = "T",
+    /** Short date format (e.g., 20/04/2021) */
+    ShortDate = "d",
+    /** Long date format (e.g., 20 April 2021) */
+    LongDate = "D",
+    /** Short date/time format (e.g., 20 April 2021 16:20) */
+    ShortDateTime = "f",
+    /** Long date/time format (e.g., Tuesday, 20 April 2021 16:20) */
+    LongDateTime = "F",
+    /** Relative time format (e.g., 2 months ago) */
+    RelativeTime = "R"
+}
+/**
+ * Formats a timestamp
+ * @param timestamp The timestamp (Date, number in ms, or seconds)
+ * @param style The style to use
+ */
+export declare function time(timestamp: Date | number, style?: TimestampStyles): string;
+/**
+ * Formats a heading (H1)
+ * @param text The text to format
+ */
+export declare function heading(text: string, level?: 1 | 2 | 3): string;
+/**
+ * Formats an unordered list
+ * @param items The items to list
+ */
+export declare function unorderedList(items: string[]): string;
+/**
+ * Formats an ordered list
+ * @param items The items to list
+ */
+export declare function orderedList(items: string[]): string;
+export declare const Formatters: {
+    userMention: typeof userMention;
+    channelMention: typeof channelMention;
+    roleMention: typeof roleMention;
+    formatEmoji: typeof formatEmoji;
+    bold: typeof bold;
+    italic: typeof italic;
+    underline: typeof underline;
+    strikethrough: typeof strikethrough;
+    spoiler: typeof spoiler;
+    inlineCode: typeof inlineCode;
+    codeBlock: typeof codeBlock;
+    blockQuote: typeof blockQuote;
+    quote: typeof quote;
+    hyperlink: typeof hyperlink;
+    hideLinkEmbed: typeof hideLinkEmbed;
+    time: typeof time;
+    heading: typeof heading;
+    unorderedList: typeof unorderedList;
+    orderedList: typeof orderedList;
+    TimestampStyles: typeof TimestampStyles;
+};

package/dist/utils/Formatters.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * Formatters for markdown and mentions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Formatters = exports.TimestampStyles = void 0;
+exports.userMention = userMention;
+exports.channelMention = channelMention;
+exports.roleMention = roleMention;
+exports.formatEmoji = formatEmoji;
+exports.bold = bold;
+exports.italic = italic;
+exports.underline = underline;
+exports.strikethrough = strikethrough;
+exports.spoiler = spoiler;
+exports.inlineCode = inlineCode;
+exports.codeBlock = codeBlock;
+exports.blockQuote = blockQuote;
+exports.quote = quote;
+exports.hyperlink = hyperlink;
+exports.hideLinkEmbed = hideLinkEmbed;
+exports.time = time;
+exports.heading = heading;
+exports.unorderedList = unorderedList;
+exports.orderedList = orderedList;
+/**
+ * Formats a user mention
+ * @param userId The user ID to mention
+ */
+function userMention(userId) {
+    return `<@${userId}>`;
+}
+/**
+ * Formats a channel mention
+ * @param channelId The channel ID to mention
+ */
+function channelMention(channelId) {
+    return `<#${channelId}>`;
+}
+/**
+ * Formats a role mention
+ * @param roleId The role ID to mention
+ */
+function roleMention(roleId) {
+    return `<@&${roleId}>`;
+}
+/**
+ * Formats a custom emoji
+ * @param emojiId The emoji ID
+ * @param name The emoji name
+ * @param animated Whether the emoji is animated
+ */
+function formatEmoji(emojiId, name, animated = false) {
+    return `<${animated ? 'a' : ''}:${name}:${emojiId}>`;
+}
+/**
+ * Formats text as bold
+ * @param text The text to format
+ */
+function bold(text) {
+    return `**${text}**`;
+}
+/**
+ * Formats text as italic
+ * @param text The text to format
+ */
+function italic(text) {
+    return `*${text}*`;
+}
+/**
+ * Formats text as underline
+ * @param text The text to format
+ */
+function underline(text) {
+    return `__${text}__`;
+}
+/**
+ * Formats text as strikethrough
+ * @param text The text to format
+ */
+function strikethrough(text) {
+    return `~~${text}~~`;
+}
+/**
+ * Formats text as spoiler
+ * @param text The text to format
+ */
+function spoiler(text) {
+    return `||${text}||`;
+}
+/**
+ * Formats text as inline code
+ * @param text The text to format
+ */
+function inlineCode(text) {
+    return `\`${text}\``;
+}
+/**
+ * Formats text as a code block
+ * @param text The text to format
+ * @param language The language for syntax highlighting
+ */
+function codeBlock(text, language) {
+    return `\`\`\`${language ?? ''}\n${text}\n\`\`\``;
+}
+/**
+ * Formats text as a block quote
+ * @param text The text to format
+ */
+function blockQuote(text) {
+    return `>>> ${text}`;
+}
+/**
+ * Formats text as a single-line quote
+ * @param text The text to format
+ */
+function quote(text) {
+    return `> ${text}`;
+}
+/**
+ * Formats a URL as a hyperlink
+ * @param text The text to display
+ * @param url The URL to link to
+ * @param title Optional title for the link
+ */
+function hyperlink(text, url, title) {
+    return title ? `[${text}](${url} "${title}")` : `[${text}](${url})`;
+}
+/**
+ * Formats a URL to hide the embed
+ * @param url The URL to format
+ */
+function hideLinkEmbed(url) {
+    return `<${url}>`;
+}
+/**
+ * Time format styles
+ */
+var TimestampStyles;
+(function (TimestampStyles) {
+    /** Short time format (e.g., 16:20) */
+    TimestampStyles["ShortTime"] = "t";
+    /** Long time format (e.g., 16:20:30) */
+    TimestampStyles["LongTime"] = "T";
+    /** Short date format (e.g., 20/04/2021) */
+    TimestampStyles["ShortDate"] = "d";
+    /** Long date format (e.g., 20 April 2021) */
+    TimestampStyles["LongDate"] = "D";
+    /** Short date/time format (e.g., 20 April 2021 16:20) */
+    TimestampStyles["ShortDateTime"] = "f";
+    /** Long date/time format (e.g., Tuesday, 20 April 2021 16:20) */
+    TimestampStyles["LongDateTime"] = "F";
+    /** Relative time format (e.g., 2 months ago) */
+    TimestampStyles["RelativeTime"] = "R";
+})(TimestampStyles || (exports.TimestampStyles = TimestampStyles = {}));
+/**
+ * Formats a timestamp
+ * @param timestamp The timestamp (Date, number in ms, or seconds)
+ * @param style The style to use
+ */
+function time(timestamp, style) {
+    const seconds = timestamp instanceof Date
+        ? Math.floor(timestamp.getTime() / 1000)
+        : typeof timestamp === 'number' && timestamp > 1e12
+            ? Math.floor(timestamp / 1000)
+            : timestamp;
+    return style ? `<t:${seconds}:${style}>` : `<t:${seconds}>`;
+}
+/**
+ * Formats a heading (H1)
+ * @param text The text to format
+ */
+function heading(text, level = 1) {
+    return `${'#'.repeat(level)} ${text}`;
+}
+/**
+ * Formats an unordered list
+ * @param items The items to list
+ */
+function unorderedList(items) {
+    return items.map(item => `- ${item}`).join('\n');
+}
+/**
+ * Formats an ordered list
+ * @param items The items to list
+ */
+function orderedList(items) {
+    return items.map((item, i) => `${i + 1}. ${item}`).join('\n');
+}
+// Export all formatters as a namespace too (DJS compatibility)
+exports.Formatters = {
+    userMention,
+    channelMention,
+    roleMention,
+    formatEmoji,
+    bold,
+    italic,
+    underline,
+    strikethrough,
+    spoiler,
+    inlineCode,
+    codeBlock,
+    blockQuote,
+    quote,
+    hyperlink,
+    hideLinkEmbed,
+    time,
+    heading,
+    unorderedList,
+    orderedList,
+    TimestampStyles,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Formatters.js","sourceRoot":"","sources":["../../src/utils/Formatters.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Formatters for markdown and mentions\r\n */\r\n\r\n/**\r\n * Formats a user mention\r\n * @param userId The user ID to mention\r\n */\r\nexport function userMention(userId: string | number): string {\r\n  return `<@${userId}>`;\r\n}\r\n\r\n/**\r\n * Formats a channel mention\r\n * @param channelId The channel ID to mention\r\n */\r\nexport function channelMention(channelId: string | number): string {\r\n  return `<#${channelId}>`;\r\n}\r\n\r\n/**\r\n * Formats a role mention\r\n * @param roleId The role ID to mention\r\n */\r\nexport function roleMention(roleId: string | number): string {\r\n  return `<@&${roleId}>`;\r\n}\r\n\r\n/**\r\n * Formats a custom emoji\r\n * @param emojiId The emoji ID\r\n * @param name The emoji name\r\n * @param animated Whether the emoji is animated\r\n */\r\nexport function formatEmoji(emojiId: string | number, name: string, animated = false): string {\r\n  return `<${animated ? 'a' : ''}:${name}:${emojiId}>`;\r\n}\r\n\r\n/**\r\n * Formats text as bold\r\n * @param text The text to format\r\n */\r\nexport function bold(text: string): string {\r\n  return `**${text}**`;\r\n}\r\n\r\n/**\r\n * Formats text as italic\r\n * @param text The text to format\r\n */\r\nexport function italic(text: string): string {\r\n  return `*${text}*`;\r\n}\r\n\r\n/**\r\n * Formats text as underline\r\n * @param text The text to format\r\n */\r\nexport function underline(text: string): string {\r\n  return `__${text}__`;\r\n}\r\n\r\n/**\r\n * Formats text as strikethrough\r\n * @param text The text to format\r\n */\r\nexport function strikethrough(text: string): string {\r\n  return `~~${text}~~`;\r\n}\r\n\r\n/**\r\n * Formats text as spoiler\r\n * @param text The text to format\r\n */\r\nexport function spoiler(text: string): string {\r\n  return `||${text}||`;\r\n}\r\n\r\n/**\r\n * Formats text as inline code\r\n * @param text The text to format\r\n */\r\nexport function inlineCode(text: string): string {\r\n  return `\\`${text}\\``;\r\n}\r\n\r\n/**\r\n * Formats text as a code block\r\n * @param text The text to format\r\n * @param language The language for syntax highlighting\r\n */\r\nexport function codeBlock(text: string, language?: string): string {\r\n  return `\\`\\`\\`${language ?? ''}\\n${text}\\n\\`\\`\\``;\r\n}\r\n\r\n/**\r\n * Formats text as a block quote\r\n * @param text The text to format\r\n */\r\nexport function blockQuote(text: string): string {\r\n  return `>>> ${text}`;\r\n}\r\n\r\n/**\r\n * Formats text as a single-line quote\r\n * @param text The text to format\r\n */\r\nexport function quote(text: string): string {\r\n  return `> ${text}`;\r\n}\r\n\r\n/**\r\n * Formats a URL as a hyperlink\r\n * @param text The text to display\r\n * @param url The URL to link to\r\n * @param title Optional title for the link\r\n */\r\nexport function hyperlink(text: string, url: string, title?: string): string {\r\n  return title ? `[${text}](${url} \"${title}\")` : `[${text}](${url})`;\r\n}\r\n\r\n/**\r\n * Formats a URL to hide the embed\r\n * @param url The URL to format\r\n */\r\nexport function hideLinkEmbed(url: string): string {\r\n  return `<${url}>`;\r\n}\r\n\r\n/**\r\n * Time format styles\r\n */\r\nexport enum TimestampStyles {\r\n  /** Short time format (e.g., 16:20) */\r\n  ShortTime = 't',\r\n  /** Long time format (e.g., 16:20:30) */\r\n  LongTime = 'T',\r\n  /** Short date format (e.g., 20/04/2021) */\r\n  ShortDate = 'd',\r\n  /** Long date format (e.g., 20 April 2021) */\r\n  LongDate = 'D',\r\n  /** Short date/time format (e.g., 20 April 2021 16:20) */\r\n  ShortDateTime = 'f',\r\n  /** Long date/time format (e.g., Tuesday, 20 April 2021 16:20) */\r\n  LongDateTime = 'F',\r\n  /** Relative time format (e.g., 2 months ago) */\r\n  RelativeTime = 'R',\r\n}\r\n\r\n/**\r\n * Formats a timestamp\r\n * @param timestamp The timestamp (Date, number in ms, or seconds)\r\n * @param style The style to use\r\n */\r\nexport function time(timestamp: Date | number, style?: TimestampStyles): string {\r\n  const seconds = timestamp instanceof Date \r\n    ? Math.floor(timestamp.getTime() / 1000) \r\n    : typeof timestamp === 'number' && timestamp > 1e12 \r\n      ? Math.floor(timestamp / 1000) \r\n      : timestamp;\r\n  \r\n  return style ? `<t:${seconds}:${style}>` : `<t:${seconds}>`;\r\n}\r\n\r\n/**\r\n * Formats a heading (H1)\r\n * @param text The text to format\r\n */\r\nexport function heading(text: string, level: 1 | 2 | 3 = 1): string {\r\n  return `${'#'.repeat(level)} ${text}`;\r\n}\r\n\r\n/**\r\n * Formats an unordered list\r\n * @param items The items to list\r\n */\r\nexport function unorderedList(items: string[]): string {\r\n  return items.map(item => `- ${item}`).join('\\n');\r\n}\r\n\r\n/**\r\n * Formats an ordered list\r\n * @param items The items to list\r\n */\r\nexport function orderedList(items: string[]): string {\r\n  return items.map((item, i) => `${i + 1}. ${item}`).join('\\n');\r\n}\r\n\r\n// Export all formatters as a namespace too (DJS compatibility)\r\nexport const Formatters = {\r\n  userMention,\r\n  channelMention,\r\n  roleMention,\r\n  formatEmoji,\r\n  bold,\r\n  italic,\r\n  underline,\r\n  strikethrough,\r\n  spoiler,\r\n  inlineCode,\r\n  codeBlock,\r\n  blockQuote,\r\n  quote,\r\n  hyperlink,\r\n  hideLinkEmbed,\r\n  time,\r\n  heading,\r\n  unorderedList,\r\n  orderedList,\r\n  TimestampStyles,\r\n};\r\n"]}

package/dist/utils/IntentsBitField.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Intents BitField for calculating gateway intents
+ */
+import { BitField, BitFieldResolvable } from './BitField';
+/**
+ * Intent flag names
+ */
+export type IntentFlagsString = keyof typeof IntentsBitField.Flags;
+/**
+ * Gateway Intent Bits
+ */
+export declare const GatewayIntentBits: {
+    readonly Guilds: number;
+    readonly GuildMembers: number;
+    readonly GuildModeration: number;
+    readonly GuildEmojisAndStickers: number;
+    readonly GuildIntegrations: number;
+    readonly GuildWebhooks: number;
+    readonly GuildInvites: number;
+    readonly GuildVoiceStates: number;
+    readonly GuildPresences: number;
+    readonly GuildMessages: number;
+    readonly GuildMessageReactions: number;
+    readonly GuildMessageTyping: number;
+    readonly DirectMessages: number;
+    readonly DirectMessageReactions: number;
+    readonly DirectMessageTyping: number;
+    readonly MessageContent: number;
+    readonly GuildScheduledEvents: number;
+    readonly AutoModerationConfiguration: number;
+    readonly AutoModerationExecution: number;
+};
+/**
+ * All non-privileged intents
+ */
+export declare const IntentsAll: number;
+/**
+ * Privileged intents that require approval
+ */
+export declare const PrivilegedIntents: number;
+/**
+ * Data structure for gateway intents
+ */
+export declare class IntentsBitField extends BitField<IntentFlagsString, number> {
+    static Flags: {
+        readonly Guilds: number;
+        readonly GuildMembers: number;
+        readonly GuildModeration: number;
+        readonly GuildEmojisAndStickers: number;
+        readonly GuildIntegrations: number;
+        readonly GuildWebhooks: number;
+        readonly GuildInvites: number;
+        readonly GuildVoiceStates: number;
+        readonly GuildPresences: number;
+        readonly GuildMessages: number;
+        readonly GuildMessageReactions: number;
+        readonly GuildMessageTyping: number;
+        readonly DirectMessages: number;
+        readonly DirectMessageReactions: number;
+        readonly DirectMessageTyping: number;
+        readonly MessageContent: number;
+        readonly GuildScheduledEvents: number;
+        readonly AutoModerationConfiguration: number;
+        readonly AutoModerationExecution: number;
+    };
+    static DefaultBit: number;
+    constructor(bits?: BitFieldResolvable<IntentFlagsString, number>);
+    /**
+     * Check if any privileged intents are enabled
+     */
+    hasPrivileged(): boolean;
+    /**
+     * Get all privileged intents that are enabled
+     */
+    getPrivileged(): IntentFlagsString[];
+}
+/**
+ * Calculate intents from an array of intent names or values
+ */
+export declare function calculateIntents(intents: (IntentFlagsString | number)[]): number;
+/**
+ * Get all intent names from a bitfield value
+ */
+export declare function resolveIntents(bits: number): IntentFlagsString[];
+export default IntentsBitField;