discord-message-transcript 1.0.0

package/dist/core/fetchMessages.js

@@ -0,0 +1,169 @@
+import { EmbedType } from "discord.js";
+import { componentsToJson } from "./componentToJson.js";
+import { urlToBase64 } from "./imageToBase64.js";
+import { CustomError } from "discord-message-transcript-base";
+import { getMentions } from "./getMentions.js";
+export async function fetchMessages(channel, options, authors, mentions, after) {
+    const originalMessages = await channel.messages.fetch({ limit: 100, cache: false, after: after });
+    const rawMessages = await Promise.all(originalMessages.map(async (message) => {
+        let authorAvatar = message.author.displayAvatarURL();
+        if (options.saveImages) {
+            try {
+                authorAvatar = await urlToBase64(authorAvatar);
+            }
+            catch (err) {
+                if (err instanceof CustomError)
+                    console.error(err);
+            }
+        }
+        const attachments = await Promise.all(message.attachments.map(async (attachment) => {
+            let attachmentUrl = attachment.url;
+            if (options.saveImages && attachment.contentType?.startsWith('image/')) {
+                try {
+                    attachmentUrl = await urlToBase64(attachment.url);
+                }
+                catch (err) {
+                    if (err instanceof CustomError)
+                        console.error(err);
+                }
+            }
+            return {
+                contentType: attachment.contentType,
+                name: attachment.name,
+                size: attachment.size,
+                spoiler: attachment.spoiler,
+                url: attachmentUrl,
+            };
+        }));
+        // This only works because embeds with the type poll_result that are send when a poll end are marked as a message send by the system  
+        const embeds = message.system && message.embeds.length == 1 && message.embeds[0].data.type == EmbedType.PollResult && !options.includePolls ? []
+            : await Promise.all(message.embeds.map(async (embed) => {
+                let authorIcon = embed.author?.iconURL ?? null;
+                let thumbnailUrl = embed.thumbnail?.url ?? null;
+                let imageUrl = embed.image?.url ?? null;
+                let footerIcon = embed.footer?.iconURL ?? null;
+                if (options.saveImages) {
+                    if (authorIcon) {
+                        try {
+                            authorIcon = await urlToBase64(authorIcon);
+                        }
+                        catch (err) {
+                            if (err instanceof CustomError)
+                                console.error(err);
+                        }
+                    }
+                    if (thumbnailUrl) {
+                        try {
+                            thumbnailUrl = await urlToBase64(thumbnailUrl);
+                        }
+                        catch (err) {
+                            if (err instanceof CustomError)
+                                console.error(err);
+                        }
+                    }
+                    if (imageUrl) {
+                        try {
+                            imageUrl = await urlToBase64(imageUrl);
+                        }
+                        catch (err) {
+                            if (err instanceof CustomError)
+                                console.error(err);
+                        }
+                    }
+                    if (footerIcon) {
+                        try {
+                            footerIcon = await urlToBase64(footerIcon);
+                        }
+                        catch (err) {
+                            if (err instanceof CustomError)
+                                console.error(err);
+                        }
+                    }
+                }
+                return {
+                    author: embed.author ? { name: embed.author.name, url: embed.author.url ?? null, iconURL: authorIcon } : null,
+                    description: embed.description ?? null,
+                    fields: embed.fields.map(field => ({ inline: field.inline ?? false, name: field.name, value: field.value })),
+                    footer: embed.footer ? { iconURL: footerIcon, text: embed.footer.text } : null,
+                    hexColor: embed.hexColor ?? null,
+                    image: imageUrl ? { url: imageUrl } : null,
+                    thumbnail: thumbnailUrl ? { url: thumbnailUrl } : null,
+                    timestamp: embed.timestamp,
+                    title: embed.title,
+                    type: embed.data.type ?? "rich",
+                    url: embed.url,
+                };
+            }));
+        if (!authors.has(message.author.id)) {
+            authors.set(message.author.id, {
+                avatarURL: authorAvatar,
+                bot: message.author.bot,
+                displayName: message.author.displayName,
+                guildTag: message.author.primaryGuild?.tag ?? null,
+                id: message.author.id,
+                member: message.member ? {
+                    displayHexColor: message.member.displayHexColor,
+                    displayName: message.member.displayName,
+                } : null,
+                system: message.author.system,
+            });
+        }
+        const components = await componentsToJson(message.components, options);
+        getMentions(message, mentions);
+        return {
+            attachments: options.includeAttachments ? attachments : [],
+            authorId: message.author.id,
+            components: components,
+            content: message.content,
+            createdTimestamp: message.createdTimestamp,
+            embeds: options.includeEmbeds || options.includePolls ? embeds : [],
+            id: message.id,
+            mentions: message.mentions.everyone,
+            poll: options.includePolls && message.poll ? {
+                answers: Array.from(message.poll.answers.values()).map(answer => ({
+                    count: answer.voteCount,
+                    emoji: answer.emoji ? {
+                        animated: answer.emoji.animated ?? false,
+                        id: answer.emoji.id,
+                        name: answer.emoji.name,
+                    } : null,
+                    id: answer.id,
+                    text: answer.text ?? "",
+                })),
+                expiry: message.poll.expiresTimestamp ? formatTimeLeftPoll(message.poll.expiresTimestamp) : null,
+                isFinalized: message.poll.resultsFinalized,
+                question: message.poll.question.text ?? "",
+            } : null,
+            reactions: options.includeReactions ? message.reactions.cache.map(reaction => {
+                if (reaction.emoji.name == null)
+                    return null;
+                return {
+                    count: reaction.count,
+                    emoji: reaction.emoji.name,
+                };
+            }).filter(r => r != null) : [],
+            references: message.reference ? { messageId: message.reference.messageId ?? null } : null,
+            system: message.system,
+        };
+    }));
+    const messages = rawMessages.filter(m => !(!options.includeEmpty && m.attachments.length == 0 && m.components.length == 0 && m.content == "" && m.embeds.length == 0 && !m.poll));
+    const end = originalMessages.size !== 100;
+    return { messages, end };
+}
+function formatTimeLeftPoll(timestamp) {
+    const now = new Date();
+    const leftDate = new Date(timestamp);
+    const diffSeconds = Math.floor((leftDate.getTime() - now.getTime()) / 1000);
+    const day = Math.floor(diffSeconds / 86400);
+    if (day > 0)
+        return `${day}d left`;
+    const hour = Math.floor(diffSeconds / 3600);
+    if (hour > 0)
+        return `${hour}h left`;
+    const min = Math.floor(diffSeconds / 60);
+    if (min > 0)
+        return `${min}m left`;
+    if (diffSeconds > 0)
+        return `${diffSeconds}s left`;
+    return "now"; // fallback
+}

package/dist/core/getMentions.d.ts

@@ -0,0 +1,3 @@
+import { Message } from "discord.js";
+import { MapMentions } from "../types/types.js";
+export declare function getMentions(message: Message, mentions: MapMentions): void;

package/dist/core/getMentions.js

@@ -0,0 +1,99 @@
+import { ChannelType } from "discord.js";
+export function getMentions(message, mentions) {
+    message.mentions.channels.forEach(channel => {
+        if (!mentions.channels.has(channel.id)) {
+            mentions.channels.set(channel.id, {
+                id: channel.id,
+                name: channel.type !== ChannelType.DM ? channel.name : channel.recipient?.displayName ?? null
+            });
+        }
+    });
+    message.mentions.roles.forEach(role => {
+        if (!mentions.roles.has(role.id)) {
+            mentions.roles.set(role.id, {
+                id: role.id,
+                color: role.hexColor,
+                name: role.name
+            });
+        }
+    });
+    if (message.guild) {
+    }
+    if (message.mentions.members) {
+        message.mentions.members.forEach(member => {
+            if (!mentions.users.has(member.id)) {
+                mentions.users.set(member.id, {
+                    id: member.id,
+                    color: member.displayHexColor,
+                    name: member.displayName
+                });
+            }
+        });
+    }
+    else {
+        message.mentions.users.forEach(user => {
+            if (!mentions.users.has(user.id)) {
+                mentions.users.set(user.id, {
+                    id: user.id,
+                    color: user.hexAccentColor ?? null,
+                    name: user.displayName
+                });
+            }
+        });
+    }
+    fetchRoleMention(message, mentions);
+    fetchChannelMention(message, mentions);
+    fetchUserMention(message, mentions);
+}
+// Needs to fix that sometimes discord laks to provide all roles mentions in a message
+function fetchRoleMention(message, mentions) {
+    const roleIds = [];
+    for (const match of message.content.matchAll(/<@&(\d+)>/g)) {
+        const roleId = match[1];
+        if (roleId && !roleIds.includes(roleId) && !mentions.roles.has(roleId)) {
+            roleIds.push(roleId);
+        }
+    }
+    roleIds.forEach(async (id) => {
+        const role = await message.guild?.roles.fetch(id);
+        if (!role)
+            return;
+        mentions.roles.set(role.id, { id: role.id, color: role.hexColor, name: role.name });
+    });
+}
+function fetchUserMention(message, mentions) {
+    const usersId = [];
+    for (const match of message.content.matchAll(/<@(\d+)>/g)) {
+        const userId = match[1];
+        if (userId && !usersId.includes(userId) && !mentions.roles.has(userId)) {
+            usersId.push(userId);
+        }
+    }
+    usersId.forEach(async (id) => {
+        if (message.guild) {
+            const user = await message.guild.members.fetch(id);
+            if (!user)
+                return;
+            mentions.users.set(user.id, { id: user.id, color: user.displayHexColor, name: user.displayName });
+        }
+        const user = await message.client.users.fetch(id);
+        if (!user)
+            return;
+        mentions.users.set(user.id, { id: user.id, color: user.hexAccentColor ?? null, name: user.displayName });
+    });
+}
+function fetchChannelMention(message, mentions) {
+    const channelIds = [];
+    for (const match of message.content.matchAll(/<#(\d+)>/g)) {
+        const channelId = match[1];
+        if (channelId && !channelIds.includes(channelId) && !mentions.channels.has(channelId)) {
+            channelIds.push(channelId);
+        }
+    }
+    channelIds.forEach(async (id) => {
+        const channel = await message.guild?.channels.fetch(id);
+        if (!channel)
+            return;
+        mentions.channels.set(channel.id, { id: channel.id, name: channel.name });
+    });
+}

package/dist/core/imageToBase64.d.ts

@@ -0,0 +1 @@
+export declare function urlToBase64(url: string): Promise<string>;

package/dist/core/imageToBase64.js

@@ -0,0 +1,30 @@
+import https from 'https';
+import { CustomError } from 'discord-message-transcript-base';
+export async function urlToBase64(url) {
+    return new Promise((resolve, reject) => {
+        const request = https.get(url, (response) => {
+            if (response.statusCode !== 200) {
+                reject(new CustomError(`Failed to fetch image with status code: ${response.statusCode} from ${url}`));
+                return;
+            }
+            const contentType = response.headers['content-type'];
+            if (!contentType || !contentType.startsWith('image/')) {
+                reject(new CustomError(`URL did not point to an image. Content-Type: ${contentType} from ${url}`));
+                return;
+            }
+            const chunks = [];
+            response.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+            response.on('end', () => {
+                const buffer = Buffer.concat(chunks);
+                const base64 = buffer.toString('base64');
+                resolve(`data:${contentType};base64,${base64}`);
+            });
+        });
+        request.on('error', (err) => {
+            reject(new CustomError(`Error fetching image from ${url}: ${err.message}`));
+        });
+        request.end();
+    });
+}

package/dist/core/mappers.d.ts

@@ -0,0 +1,8 @@
+import { ButtonStyle, ComponentType, SeparatorSpacingSize } from "discord.js";
+import { JsonButtonStyle, JsonComponentType, JsonSeparatorSpacingSize, ReturnTypeBase } from "discord-message-transcript-base";
+import { ReturnType } from "../types/types.js";
+export declare function mapButtonStyle(style: ButtonStyle): JsonButtonStyle;
+export declare function mapSeparatorSpacing(spacing: SeparatorSpacingSize): JsonSeparatorSpacingSize;
+export declare function mapComponentType(componentType: ComponentType): JsonComponentType;
+export declare function mapSelectorType(selectorType: ComponentType.UserSelect | ComponentType.RoleSelect | ComponentType.MentionableSelect | ComponentType.ChannelSelect): JsonComponentType.UserSelect | JsonComponentType.RoleSelect | JsonComponentType.MentionableSelect | JsonComponentType.ChannelSelect;
+export declare function returnTypeMapper(type: ReturnType): ReturnTypeBase;

package/dist/core/mappers.js

@@ -0,0 +1,101 @@
+import { ButtonStyle, ComponentType, SeparatorSpacingSize } from "discord.js";
+import { CustomError, JsonButtonStyle, JsonComponentType, JsonSeparatorSpacingSize, ReturnTypeBase } from "discord-message-transcript-base";
+import { ReturnType } from "../types/types.js";
+export function mapButtonStyle(style) {
+    switch (style) {
+        case ButtonStyle.Primary:
+            return JsonButtonStyle.Primary;
+        case ButtonStyle.Secondary:
+            return JsonButtonStyle.Secondary;
+        case ButtonStyle.Success:
+            return JsonButtonStyle.Success;
+        case ButtonStyle.Danger:
+            return JsonButtonStyle.Danger;
+        case ButtonStyle.Link:
+            return JsonButtonStyle.Link;
+        case ButtonStyle.Premium:
+            return JsonButtonStyle.Premium;
+        default:
+            throw new CustomError(`Unknow ButtonStyle: ${style}`);
+    }
+}
+export function mapSeparatorSpacing(spacing) {
+    switch (spacing) {
+        case SeparatorSpacingSize.Small:
+            return JsonSeparatorSpacingSize.Small;
+        case SeparatorSpacingSize.Large:
+            return JsonSeparatorSpacingSize.Large;
+        default:
+            throw new CustomError(`Unknow SeparatorSpacingSize: ${spacing}`);
+    }
+}
+export function mapComponentType(componentType) {
+    switch (componentType) {
+        case ComponentType.ActionRow:
+            return JsonComponentType.ActionRow;
+        case ComponentType.Button:
+            return JsonComponentType.Button;
+        case ComponentType.StringSelect:
+            return JsonComponentType.StringSelect;
+        case ComponentType.TextInput:
+            return JsonComponentType.TextInput;
+        case ComponentType.UserSelect:
+            return JsonComponentType.UserSelect;
+        case ComponentType.RoleSelect:
+            return JsonComponentType.RoleSelect;
+        case ComponentType.MentionableSelect:
+            return JsonComponentType.MentionableSelect;
+        case ComponentType.ChannelSelect:
+            return JsonComponentType.ChannelSelect;
+        case ComponentType.Section:
+            return JsonComponentType.Section;
+        case ComponentType.TextDisplay:
+            return JsonComponentType.TextDisplay;
+        case ComponentType.Thumbnail:
+            return JsonComponentType.Thumbnail;
+        case ComponentType.MediaGallery:
+            return JsonComponentType.MediaGallery;
+        case ComponentType.File:
+            return JsonComponentType.File;
+        case ComponentType.Separator:
+            return JsonComponentType.Separator;
+        case ComponentType.ContentInventoryEntry:
+            return JsonComponentType.ContentInventoryEntry;
+        case ComponentType.Container:
+            return JsonComponentType.Container;
+        case ComponentType.Label:
+            return JsonComponentType.Label;
+        case ComponentType.FileUpload:
+            return JsonComponentType.FileUpload;
+        default:
+            throw new CustomError(`Unknow ComponentType: ${componentType}`);
+    }
+}
+export function mapSelectorType(selectorType) {
+    switch (selectorType) {
+        case ComponentType.UserSelect:
+            return JsonComponentType.UserSelect;
+        case ComponentType.RoleSelect:
+            return JsonComponentType.RoleSelect;
+        case ComponentType.MentionableSelect:
+            return JsonComponentType.MentionableSelect;
+        case ComponentType.ChannelSelect:
+            return JsonComponentType.ChannelSelect;
+        default:
+            throw new CustomError(`Unknow SelectorComponentType: ${selectorType}`);
+    }
+}
+export function returnTypeMapper(type) {
+    switch (type) {
+        case ReturnType.Buffer:
+            return ReturnTypeBase.Buffer;
+        case ReturnType.Stream:
+            return ReturnTypeBase.Stream;
+        case ReturnType.String:
+            return ReturnTypeBase.String;
+        case ReturnType.Uploadable:
+            return ReturnTypeBase.Uploadable;
+        default:
+            throw new CustomError(`Can't convert ReturnType.Attachment to ReturnTypeBase!`);
+    }
+}

package/dist/core/markdown.d.ts

@@ -0,0 +1,2 @@
+import { JsonMessageMentions } from "../types/types";
+export declare function markdownToHTML(text: string, mentions: JsonMessageMentions, dateFormat: Intl.DateTimeFormat): string;

package/dist/core/markdown.js

@@ -0,0 +1,175 @@
+export function markdownToHTML(text, mentions, dateFormat) {
+    const codeBlock = [];
+    const codeLine = [];
+    // Code Block (```)
+    text = text.replace(/```(?:(\S+)\n)?([\s\S]+?)```/g, (_m, lang, code) => {
+        const rawLang = lang?.toLowerCase();
+        const normalizedLang = rawLang ? (LANGUAGE_ALIAS[rawLang] ?? rawLang) : null;
+        const language = normalizedLang && SUPPORTED_LANGUAGES.has(rawLang) ? normalizedLang : 'plaintext';
+        codeBlock.push(`<pre><code class="language-${language}">${code.trimEnd()}</code></pre>`);
+        return `%$%CODE!BLOCK!${codeBlock.length - 1}%$%`;
+    });
+    // Code line (`)
+    text = text.replace(/`([^`]+)`/g, (_m, code) => {
+        codeLine.push(`<code>${code}</code>`);
+        return `%$%CODE!LINE!${codeLine.length - 1}%$%`;
+    });
+    // Citation (> | >>>)
+    text = text.replace(/(^> ?.*(?:(?:\n^> ?.*)+)?)/gm, (match) => {
+        const cleanContent = match.split('\n').map(line => {
+            return line.replace(/^>+ ?/, '');
+        }).join('\n');
+        return `<blockquote class="quote-multi">${cleanContent}</blockquote>`;
+    });
+    // Headers (#)
+    text = text.replace(/^### (.*)(?=\n|$)/gm, `<h3>$1</h3>`);
+    text = text.replace(/^## (.*)(?=\n|$)/gm, `<h2>$1</h2>`);
+    text = text.replace(/^# (.*)(?=\n|$)/gm, `<h1>$1</h1>`);
+    // Subtext(-#)
+    text = text.replace(/^-# (.*)(?=\n|$)/gm, `<p class="subtext">$1</p>`);
+    // List (- | *)
+    text = text.replace(/^(\s*)[-*] (.*)(?=\n|$)/gm, (_m, indentation, text) => {
+        const isSubItem = indentation.length > 0;
+        const bullet = isSubItem ? '◦' : '•';
+        return `<p class="pList">${indentation}${bullet} ${text}</p>`;
+    });
+    // Spoiler (||)
+    text = text.replace(/\|\|(.*?)\|\|/gs, `<span class="spoilerMsg">$1</span>`);
+    // Bold & Italic (***)
+    text = text.replace(/\*\*\*(.*?)\*\*\*/gs, `<strong><em>$1</em></strong>`);
+    // Bold (**)
+    text = text.replace(/\*\*(.*?)\*\*/gs, `<strong>$1</strong>`);
+    // Underline(__)
+    text = text.replace(/__(.*?)__/gs, `<u>$1</u>`);
+    // Italic (*)
+    text = text.replace(/\*(.*?)\*/gs, `<em>$1</em>`);
+    text = text.replace(/\_(.*?)\_/gs, `<em>$1</em>`);
+    // Strikethrough (~~)
+    text = text.replace(/~~(.*?)~~/gs, `<s>$1</s>`);
+    // Links ([]() && https)
+    text = text.replace(/\[([^\]]+)\]\((https?:\/\/[^\s]+)\)/g, (_m, text, link) => `<a href="${link}" target="_blank">${text}</a>`);
+    text = text.replace(/(?<!href=")(https?:\/\/[^\s]+)/g, (_m, link) => `<a href="${link}" target="_blank">${link}</a>`);
+    // Mentions (@)
+    if (mentions.users.length != 0) {
+        const users = new Map(mentions.users.map(user => [user.id, user]));
+        text = text.replace(/<@!?(\d+)>/g, (_m, id) => {
+            let user = users.get(id);
+            return user ? `<span class="mention" style="color: ${user.color ?? "#dbdee1"}">@${user.name}</span> ` : `<span class="mention"><@${id}></span> `;
+        });
+    }
+    if (mentions.roles.length != 0) {
+        const roles = new Map(mentions.roles.map(role => [role.id, role]));
+        text = text.replace(/<@&(\d+)>/g, (_m, id) => {
+            const role = roles.get(id);
+            return role ? `<span class="mention" style="color: ${role.color}">@${role.name}</span> ` : `<span class="mention"><@&${id}></span> `;
+        });
+    }
+    if (mentions.channels.length != 0) {
+        const channels = new Map(mentions.channels.map(channel => [channel.id, channel]));
+        text = text.replace(/<#(\d+)>/g, (_m, id) => {
+            const channel = channels.get(id);
+            return channel && channel.name ? `<span class="mention">#${channel.name}</span> ` : `<span class="mention"><#${id}></span> `;
+        });
+    }
+    if (mentions.everyone) {
+        text = text.replace("@everyone", `<span class="mention">@everyone</span> `);
+        text = text.replace("@here", `<span class="mention">@here</span> `);
+    }
+    // Timestamp  
+    const { locale, timeZone } = dateFormat.resolvedOptions();
+    text = text.replace(/<t:(\d+)(?::([tTdDfFR]))?>/g, (_m, timestamp, format) => {
+        const date = new Date(parseInt(timestamp, 10) * 1000);
+        const style = format || 'f';
+        const isoString = date.toISOString();
+        const titleFormatter = new Intl.DateTimeFormat(locale, {
+            dateStyle: 'full',
+            timeStyle: 'full',
+            timeZone: timeZone,
+        });
+        const fullDateForTitle = titleFormatter.format(date);
+        if (style === 'R') {
+            const rtf = new Intl.RelativeTimeFormat(locale, { numeric: 'auto' });
+            const seconds = Math.floor((date.getTime() - Date.now()) / 1000);
+            const minutes = Math.floor(seconds / 60);
+            const hours = Math.floor(minutes / 60);
+            const days = Math.floor(hours / 24);
+            let relativeString;
+            if (Math.abs(days) > 30)
+                relativeString = rtf.format(Math.floor(days / 30.44), 'month');
+            else if (Math.abs(days) > 0)
+                relativeString = rtf.format(days, 'day');
+            else if (Math.abs(hours) > 0)
+                relativeString = rtf.format(hours, 'hour');
+            else if (Math.abs(minutes) > 0)
+                relativeString = rtf.format(minutes, 'minute');
+            else
+                relativeString = rtf.format(seconds, 'second');
+            return `<time datetime="${isoString}" title="${fullDateForTitle}">${relativeString}</time>`;
+        }
+        else if (isStyleKey(style)) {
+            const formatter = new Intl.DateTimeFormat(locale, {
+                ...styleOptions[style],
+                timeZone: timeZone,
+            });
+            const formattedDate = formatter.format(date);
+            return `<time datetime="${isoString}" title="${fullDateForTitle}">${formattedDate}</time>`;
+        }
+        return _m;
+    });
+    // Break Line
+    text = text.replace(/\n/g, '<br>');
+    // Clear Unecessary Break Line
+    text = text.replace(/(<\/(?:p|h[1-3]|blockquote)>)\s*<br>/g, '$1');
+    // Remove Placeholders
+    text = text.replace(/%\$%CODE!BLOCK!(\d+)%\$%/g, (_m, number) => {
+        return codeBlock[number];
+    });
+    text = text.replace(/%\$%CODE!LINE!(\d+)%\$%/g, (_m, number) => {
+        return codeLine[number];
+    });
+    return text;
+}
+// Check if styleKey is valid
+const styleOptions = {
+    't': { timeStyle: 'short' },
+    'T': { timeStyle: 'medium' },
+    'd': { dateStyle: 'short' },
+    'D': { dateStyle: 'long' },
+    'f': { dateStyle: 'long', timeStyle: 'short' },
+    'F': { dateStyle: 'full', timeStyle: 'short' },
+};
+function isStyleKey(key) {
+    return key in styleOptions;
+}
+// At least I hope
+const SUPPORTED_LANGUAGES = new Set([
+    'bash', 'sh', 'shell',
+    'c',
+    'cpp',
+    'css',
+    'javascript', 'js',
+    'typescript', 'ts',
+    'json',
+    'xml',
+    'yaml', 'yml',
+    'java',
+    'kotlin',
+    'php',
+    'python', 'py',
+    'ruby', 'rb',
+    'sql',
+    'lua',
+    'markdown', 'md',
+    'plaintext', 'txt'
+]);
+const LANGUAGE_ALIAS = {
+    sh: 'bash',
+    shell: 'bash',
+    js: 'javascript',
+    ts: 'typescript',
+    py: 'python',
+    rb: 'ruby',
+    md: 'markdown',
+    yml: 'yaml',
+    txt: 'plaintext'
+};

package/dist/core/output.d.ts

@@ -0,0 +1,4 @@
+import { AttachmentBuilder } from "discord.js";
+import Stream from 'stream';
+import { JsonData, Uploadable } from "discord-message-transcript-base";
+export declare function output(json: JsonData): Promise<string | Stream | AttachmentBuilder | Buffer | Uploadable>;

package/dist/core/output.js

@@ -0,0 +1,28 @@
+import { Readable } from 'stream';
+import { outputBase } from "discord-message-transcript-base";
+export async function output(json) {
+    const stringJSON = JSON.stringify(json);
+    if (json.options.returnFormat == "JSON") {
+        if (json.options.returnType == "string") {
+            return stringJSON;
+        }
+        const buffer = Buffer.from(stringJSON, 'utf-8');
+        if (json.options.returnType == "buffer") {
+            return buffer;
+        }
+        if (json.options.returnType == "stream") {
+            return Readable.from([stringJSON]);
+        }
+        if (json.options.returnType == "uploadable") {
+            return {
+                content: stringJSON,
+                contentType: 'application/json',
+                fileName: json.options.fileName
+            };
+        }
+    }
+    if (json.options.returnFormat == "HTML") {
+        return await outputBase(json);
+    }
+    throw new Error("Return format or return type invalid!");
+}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+export { CreateTranscriptOptions, ConvertTranscriptOptions, TranscriptOptions, ReturnType } from "./types/types.js";
+export { ReturnFormat, LocalDate, TimeZone } from "discord-message-transcript-base";
+import { TextBasedChannel } from "discord.js";
+import { ConvertTranscriptOptions, CreateTranscriptOptions, OutputType, ReturnType } from "./types/types.js";
+/**
+ * Creates a transcript of a Discord channel's messages.
+ * Depending on the `returnType` option, this function can return an `AttachmentBuilder`,
+ * a `string` (for HTML or JSON), a `Buffer`, a `Stream`, or an `Uploadable` object.
+ *
+ * @param channel The Discord text-based channel (e.g., `TextChannel`, `DMChannel`) to create a transcript from.
+ * @param options Configuration options for creating the transcript. See {@link CreateTranscriptOptions} for details.
+ * @returns A promise that resolves to the transcript in the specified format.
+ */
+export declare function createTranscript<T extends ReturnType = typeof ReturnType.Attachment>(channel: TextBasedChannel, options?: CreateTranscriptOptions<T>): Promise<OutputType<T>>;
+/**
+ * Converts a JSON transcript string into an HTML transcript.
+ * Depending on the `returnType` option, this function can return an `AttachmentBuilder`,
+ * a `string`, a `Buffer`, a `Stream`, or an `Uploadable`  object.
+ *
+ * @param jsonString The JSON string representing the transcript data.
+ * @param options Configuration options for converting the transcript. See {@link ConvertTranscriptOptions} for details.
+ * @returns A promise that resolves to the HTML transcript in the specified format.
+ */
+export declare function renderHTMLFromJSON<T extends ReturnType = typeof ReturnType.Attachment>(jsonString: string, options?: ConvertTranscriptOptions<T>): Promise<OutputType<T>>;