transcriptify 1.0.0

package/dist/src/transcript.js

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGuildTagForUser = resolveGuildTagForUser;
+exports.mapMessageToSerializable = mapMessageToSerializable;
+exports.createTranscript = createTranscript;
+exports.generateFromMessages = generateFromMessages;
+const discord_js_1 = require("discord.js");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const userGuildTagCache = new Map();
+async function resolveGuildTagForUser(user) {
+    const cached = userGuildTagCache.get(user.id);
+    if (cached)
+        return cached;
+    if (!user.bot && user.primaryGuild && user.primaryGuild.identityEnabled) {
+        const pg = user.primaryGuild;
+        const userGuildTag = { name: user.username, iconUrl: `https://cdn.discordapp.com/clan-badges/${pg.identityEnabled}/${pg.badge}.png` };
+        userGuildTagCache.set(user.id, userGuildTag);
+        return userGuildTag;
+    }
+    userGuildTagCache.set(user.id, { name: null, iconUrl: null });
+    return {
+        name: null,
+        iconUrl: null
+    };
+}
+async function mapMessageToSerializable(m) {
+    const mapEmbed = (e) => ({
+        title: e.title ?? null,
+        description: e.description ?? null,
+        url: e.url ?? null,
+        timestamp: e.timestamp ? new Date(e.timestamp).toISOString() : null,
+        color: typeof e.hexColor === "string"
+            ? e.hexColor
+            : typeof e.color === "string"
+                ? e.color
+                : typeof e.color === "number"
+                    ? `#${e.color.toString(16).padStart(6, "0")}`
+                    : null,
+        footer: e.footer ? { text: e.footer.text ?? null, iconUrl: e.footer.iconURL ?? null } : null,
+        image: e.image ? { url: e.image.url ?? null } : null,
+        thumbnail: e.thumbnail ? { url: e.thumbnail.url ?? null } : null,
+        author: e.author ? { name: e.author.name ?? null, url: e.author.url ?? null, iconUrl: e.author.iconURL ?? null } : null,
+        fields: e.fields ? e.fields.map((f) => ({ name: f.name, value: f.value, inline: !!f.inline })) : undefined
+    });
+    const attachments = Array.from(m.attachments.values()).map((a) => ({
+        id: a.id,
+        filename: a.name ?? a.filename ?? "",
+        url: a.url,
+        proxyURL: a.proxyURL ?? null,
+        contentType: a.contentType ?? null,
+        size: a.size ?? undefined,
+        width: a.width ?? null,
+        height: a.height ?? null
+    }));
+    const referencedMessageId = (m.reference && m.reference.messageId) ?? (m.referencedMessage ? m.referencedMessage.id : null) ?? null;
+    let forwarded = null;
+    if (referencedMessageId) {
+        let refMsg = m.referencedMessage ?? null;
+        if (!refMsg) {
+            try {
+                refMsg = await m.fetchReference();
+            }
+            catch (e) {
+                refMsg = null;
+            }
+        }
+        if (refMsg) {
+            const isDifferentOrigin = refMsg.channelId !== m.channelId || (refMsg.guild?.id ?? null) !== (m.guild?.id ?? null);
+            if (isDifferentOrigin) {
+                const refAttachments = Array.from(refMsg.attachments.values()).map((a) => ({
+                    id: a.id,
+                    filename: a.name ?? a.filename ?? "",
+                    url: a.url,
+                    proxyURL: a.proxyURL ?? null,
+                    contentType: a.contentType ?? null,
+                    size: a.size ?? undefined,
+                    width: a.width ?? null,
+                    height: a.height ?? null
+                }));
+                const mapEmbed = (e) => ({
+                    title: e.title ?? null,
+                    description: e.description ?? null,
+                    url: e.url ?? null,
+                    timestamp: e.timestamp ? new Date(e.timestamp).toISOString() : null,
+                    color: typeof e.hexColor === "string"
+                        ? e.hexColor
+                        : typeof e.color === "string"
+                            ? e.color
+                            : typeof e.color === "number"
+                                ? `#${e.color.toString(16).padStart(6, "0")}`
+                                : null,
+                    footer: e.footer ? { text: e.footer.text ?? null, iconUrl: e.footer.iconURL ?? null } : null,
+                    image: e.image ? { url: e.image.url ?? null } : null,
+                    thumbnail: e.thumbnail ? { url: e.thumbnail.url ?? null } : null,
+                    author: e.author ? { name: e.author.name ?? null, url: e.author.url ?? null, iconUrl: e.author.iconURL ?? null } : null,
+                    fields: e.fields ? e.fields.map((f) => ({ name: f.name, value: f.value, inline: !!f.inline })) : undefined
+                });
+                forwarded = {
+                    fromMessageId: refMsg.id,
+                    fromChannelId: refMsg.channelId,
+                    fromGuildId: refMsg.guild?.id ?? null,
+                    original: {
+                        id: refMsg.id,
+                        content: refMsg.content ?? "",
+                        author: refMsg.author ? { id: refMsg.author.id, username: refMsg.author.username, tag: refMsg.author.tag ?? null } : null,
+                        createdAt: refMsg.createdAt ? refMsg.createdAt.toISOString() : null,
+                        embeds: refMsg.embeds ? refMsg.embeds.map(mapEmbed) : undefined,
+                        attachments: refAttachments
+                    }
+                };
+            }
+        }
+    }
+    const authorId = m.author ? m.author.id : `system:${m.id}`;
+    return {
+        id: m.id,
+        content: m.content ?? (typeof m.type !== "undefined" ? `[System message: type ${m.type}]` : ""),
+        author: authorId,
+        createdAt: m.createdAt.toISOString(),
+        messageType: m.type ?? undefined,
+        embeds: m.embeds
+            ? Array.isArray(m.embeds)
+                ? m.embeds.map(mapEmbed)
+                : typeof m.embeds.values === "function"
+                    ? Array.from(m.embeds.values()).map(mapEmbed)
+                    : undefined
+            : undefined,
+        editedAt: m.editedAt ? m.editedAt.toISOString() : null,
+        attachments,
+        pinned: m.pinned ?? false,
+        referencedMessageId: referencedMessageId,
+        forwarded: forwarded
+    };
+}
+async function createTranscript(channel, options = {}) {
+    if (!channel.isTextBased())
+        throw new TypeError("Provided channel must be text-based");
+    let channelMessages = [];
+    let lastMessageID;
+    const { limit } = options;
+    const resolveLimit = typeof limit === "undefined" ? Infinity : limit;
+    while (true) {
+        const fetchLimitOptions = { limit: 100, before: lastMessageID };
+        if (!lastMessageID)
+            delete fetchLimitOptions.before;
+        const messages = await channel.messages.fetch(fetchLimitOptions);
+        channelMessages.push(...messages.values());
+        lastMessageID = messages.lastKey();
+        if (messages.size < 100)
+            break;
+        if (channelMessages.length >= resolveLimit)
+            break;
+    }
+    if (resolveLimit < channelMessages.length)
+        channelMessages = channelMessages.slice(0, limit);
+    return generateFromMessages(channelMessages.reverse(), channel, options);
+}
+async function generateFromMessages(messages, channel, options = {}) {
+    const transformedMessages = messages instanceof discord_js_1.Collection ? Array.from(messages.values()) : messages;
+    const messagesSerialized = await Promise.all(transformedMessages.map((m) => mapMessageToSerializable(m)));
+    const transcript = {
+        meta: {
+            channelId: channel.id ?? "unknown",
+            channelName: channel.name ?? null,
+            guildId: channel.guild?.id ?? null,
+            generatedAt: new Date().toISOString(),
+            messageCount: messagesSerialized.length
+        },
+        messages: messagesSerialized
+    };
+    const fileName = `transcript-${transcript.meta.channelId}-${Date.now()}.json`;
+    const outPath = path_1.default.join(process.cwd(), fileName);
+    await promises_1.default.writeFile(outPath, JSON.stringify(transcript, null, 2), "utf8");
+    return outPath;
+}

package/dist/src/types/entities.d.ts

@@ -0,0 +1,30 @@
+export interface GuildTag {
+    name?: string | null;
+    iconUrl?: string | null;
+}
+export interface AuthorData {
+    id: string;
+    username: string;
+    tag?: string;
+    guildTag?: GuildTag | null;
+    nickname?: string | null;
+    avatar?: string | null;
+    bot: boolean;
+    color?: string | null;
+    verified?: boolean | null;
+}
+export interface ForwardedOriginal {
+    id: string | null;
+    content: string;
+    author: string | null;
+    createdAt: string | null;
+    embeds: any[];
+    attachments: any[];
+    stickers: any[];
+}
+export interface ForwardedData {
+    fromMessageId: string | null;
+    fromChannelId: string | null;
+    fromGuildId: string | null;
+    original: ForwardedOriginal;
+}

package/dist/src/types/entities.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/utils/assetManager.d.ts

@@ -0,0 +1,12 @@
+export declare class AssetManager {
+    private urlMap;
+    private assetsDir;
+    private compression?;
+    constructor(assetsDir?: string, opts?: {
+        compression?: number;
+    });
+    initialize(): Promise<void>;
+    downloadAssets(data: unknown): Promise<void>;
+    replaceUrls(data: unknown): unknown;
+    private extractDiscordUrls;
+}

package/dist/src/utils/assetManager.js

@@ -0,0 +1,295 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetManager = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const promises_2 = require("stream/promises");
+const https_1 = __importDefault(require("https"));
+const os_1 = require("os");
+const crypto_1 = require("crypto");
+const sharp_1 = __importDefault(require("sharp"));
+async function downloadFile(url, outputDir, baseName) {
+    async function _download(u, tempOut, redirects = 0) {
+        return await new Promise((resolve, reject) => {
+            const req = https_1.default.get(u, (response) => {
+                const code = response.statusCode || 0;
+                if (code >= 300 && code < 400 && response.headers.location) {
+                    if (redirects >= 5) {
+                        reject(new Error("Too many redirects"));
+                        return;
+                    }
+                    const loc = response.headers.location;
+                    const next = loc.startsWith("http") ? loc : new URL(loc, u).toString();
+                    resolve(_download(next, tempOut, redirects + 1));
+                    return;
+                }
+                if (code !== 200) {
+                    reject(new Error(`HTTP ${code}`));
+                    return;
+                }
+                const file = (0, fs_1.createWriteStream)(tempOut);
+                (0, promises_2.pipeline)(response, file)
+                    .then(() => resolve({ temp: tempOut, headers: response.headers }))
+                    .catch(reject);
+            });
+            req.on("error", reject);
+        });
+    }
+    try {
+        if (!(0, fs_1.existsSync)(outputDir))
+            await promises_1.default.mkdir(outputDir, { recursive: true });
+        const rand = (0, crypto_1.randomBytes)(6).toString("hex");
+        const tempOut = path_1.default.join((0, os_1.tmpdir)(), `asset-${Date.now()}-${rand}.tmp`);
+        const result = await _download(url, tempOut, 0);
+        if (!result)
+            return null;
+        const headers = result.headers || {};
+        const contentType = (headers["content-type"] || "").toString();
+        const map = {
+            "image/png": ".png",
+            "image/jpeg": ".jpg",
+            "image/jpg": ".jpg",
+            "image/gif": ".gif",
+            "image/webp": ".webp",
+            "image/svg+xml": ".svg",
+            "application/pdf": ".pdf",
+            "text/html": ".html",
+            "audio/mpeg": ".mp3",
+            "audio/mp3": ".mp3",
+            "audio/wav": ".wav",
+            "video/mp4": ".mp4",
+            "video/webm": ".webm"
+        };
+        let parsedExt = path_1.default.extname(baseName) || "";
+        let ext = parsedExt;
+        if (!ext) {
+            try {
+                const u2 = new URL(url);
+                const pExt = path_1.default.extname(u2.pathname || "") || "";
+                if (pExt)
+                    parsedExt = pExt;
+            }
+            catch { }
+        }
+        if (!ext && parsedExt) {
+            ext = parsedExt;
+        }
+        if (!ext && contentType) {
+            const t = contentType.split(";")[0].trim().toLowerCase();
+            if (map[t])
+                ext = map[t];
+        }
+        const baseOnly = parsedExt ? baseName.slice(0, -parsedExt.length) : baseName;
+        const encodedName = encodeURIComponent(baseOnly) + (ext || "");
+        const finalOut = path_1.default.join(outputDir, encodedName);
+        try {
+            await promises_1.default.rename(tempOut, finalOut).catch(async () => {
+                await promises_1.default.copyFile(tempOut, finalOut);
+                await promises_1.default.unlink(tempOut).catch(() => { });
+            });
+            if (finalOut.includes("%25")) {
+                try {
+                    const alt1 = finalOut.replace(/%25/g, "%");
+                    if (!(0, fs_1.existsSync)(alt1)) {
+                        await promises_1.default.copyFile(finalOut, alt1).catch(() => { });
+                    }
+                }
+                catch { }
+            }
+            try {
+                const base = path_1.default.basename(finalOut);
+                const dir = path_1.default.dirname(finalOut);
+                let decodedBase = base;
+                try {
+                    decodedBase = decodeURIComponent(base);
+                }
+                catch { }
+                if (decodedBase !== base) {
+                    const alt2 = path_1.default.join(dir, decodedBase);
+                    if (!(0, fs_1.existsSync)(alt2)) {
+                        await promises_1.default.copyFile(finalOut, alt2).catch(() => { });
+                    }
+                }
+            }
+            catch { }
+        }
+        catch (e) {
+            try {
+                await promises_1.default.unlink(tempOut).catch(() => { });
+            }
+            catch { }
+            return null;
+        }
+        return finalOut;
+    }
+    catch (e) {
+        return null;
+    }
+}
+function getAssetType(url) {
+    const imageExts = /\.(png|jpg|jpeg|gif|webp|svg|bmp|avif)(\?|$)/i;
+    const videoExts = /\.(mp4|mov|webm|avi|mkv|flv|wmv)(\?|$)/i;
+    const audioExts = /\.(mp3|wav|ogg|m4a|flac|aac|weba)(\?|$)/i;
+    const profileExts = /\/avatars\/|\/user-content\/|\/emojis\//i;
+    if (profileExts.test(url))
+        return "profiles";
+    if (imageExts.test(url))
+        return "images";
+    if (videoExts.test(url))
+        return "videos";
+    if (audioExts.test(url))
+        return "audio";
+    return "files";
+}
+function getFilenameFromUrl(url) {
+    try {
+        const u = new URL(url);
+        const pathname = (u.pathname || "") + (u.search || "");
+        const parts = pathname.split("/");
+        const filename = parts[parts.length - 1];
+        if (filename && filename.length > 0) {
+            return filename.split("?")[0] || `file_${Date.now()}`;
+        }
+    }
+    catch { }
+    return `file_${Date.now()}`;
+}
+function decodeHtmlEntities(value) {
+    return value.replace(/&amp;/g, "&").replace(/&#38;/g, "&");
+}
+function normalizeExternalUrl(url) {
+    try {
+        const newUrl = new URL(url);
+        if (/images-ext(?:-[^.]*)?\.discordapp\.net/i.test(newUrl.hostname)) {
+            const decoded = decodeURIComponent((newUrl.pathname || "") + (newUrl.search || ""));
+            let idx = decoded.lastIndexOf("/https/");
+            if (idx === -1)
+                idx = decoded.lastIndexOf("/http/");
+            if (idx !== -1) {
+                let inner = decoded.slice(idx + 1);
+                inner = inner.replace(/^https?\//i, (m) => m.replace("/", "://"));
+                return inner;
+            }
+            const find = decoded.match(/https?:\/\/[^\s"'<>]+/i);
+            if (find && find[0])
+                return find[0];
+        }
+    }
+    catch { }
+    return url;
+}
+class AssetManager {
+    urlMap = new Map();
+    assetsDir;
+    compression;
+    constructor(assetsDir = "assets", opts) {
+        this.assetsDir = assetsDir;
+        this.compression = opts?.compression;
+    }
+    async initialize() {
+        if (!(0, fs_1.existsSync)(this.assetsDir)) {
+            await promises_1.default.mkdir(this.assetsDir, { recursive: true });
+        }
+    }
+    async downloadAssets(data) {
+        const urls = this.extractDiscordUrls(data);
+        for (const url of urls) {
+            if (!this.urlMap.has(url)) {
+                const cleanedUrl = decodeHtmlEntities(url);
+                const type = getAssetType(cleanedUrl);
+                const rawFilename = getFilenameFromUrl(cleanedUrl);
+                const typeDir = path_1.default.join(this.assetsDir, type);
+                if (!(0, fs_1.existsSync)(typeDir)) {
+                    await promises_1.default.mkdir(typeDir, { recursive: true });
+                }
+                const downloadedPath = await downloadFile(normalizeExternalUrl(cleanedUrl), typeDir, rawFilename);
+                if (downloadedPath) {
+                    let finalFilename = path_1.default.basename(downloadedPath);
+                    let finalSavedPath = downloadedPath;
+                    const imageExts = /\.(png|jpg|jpeg|gif|webp|svg|bmp|avif)(\?|$)/i;
+                    if (this.compression && this.compression > 0 && imageExts.test(finalFilename)) {
+                        try {
+                            const q = Math.max(1, Math.min(100, Math.floor(this.compression)));
+                            const dirName = path_1.default.dirname(downloadedPath);
+                            const baseOnlyName = path_1.default.basename(downloadedPath, path_1.default.extname(downloadedPath));
+                            let tmpOut = path_1.default.join(dirName, `${baseOnlyName}.webp`);
+                            let uniqueTmpOut = tmpOut;
+                            let idx = 0;
+                            while ((0, fs_1.existsSync)(uniqueTmpOut)) {
+                                idx += 1;
+                                uniqueTmpOut = path_1.default.join(dirName, `${baseOnlyName}-${idx}.webp`);
+                            }
+                            await (0, sharp_1.default)(downloadedPath).toFormat("webp", { quality: q }).toFile(uniqueTmpOut);
+                            try {
+                                await promises_1.default.unlink(downloadedPath).catch(() => { });
+                            }
+                            catch { }
+                            finalSavedPath = uniqueTmpOut;
+                            finalFilename = path_1.default.basename(finalSavedPath);
+                        }
+                        catch (_) { }
+                    }
+                    const localPath = path_1.default.join("assets", type, finalFilename).replace(/\\/g, "/");
+                    this.urlMap.set(url, localPath);
+                    if (cleanedUrl !== url)
+                        this.urlMap.set(cleanedUrl, localPath);
+                    const baseUrl = cleanedUrl.split("?")[0];
+                    if (!this.urlMap.has(baseUrl))
+                        this.urlMap.set(baseUrl, localPath);
+                }
+            }
+        }
+    }
+    replaceUrls(data) {
+        if (typeof data === "string") {
+            let result = data;
+            for (const [original, local] of this.urlMap.entries()) {
+                const esc = original.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                const re = new RegExp(esc + "(?:\\?[^\"'\\s>]*)?", "g");
+                result = result.replace(re, local);
+            }
+            return result;
+        }
+        if (Array.isArray(data)) {
+            return data.map((item) => this.replaceUrls(item));
+        }
+        if (data !== null && typeof data === "object") {
+            const obj = data;
+            const result = {};
+            for (const [key, value] of Object.entries(obj)) {
+                result[key] = this.replaceUrls(value);
+            }
+            return result;
+        }
+        return data;
+    }
+    extractDiscordUrls(data, urls = new Set()) {
+        if (typeof data === "string") {
+            const discordUrlRegex = /https?:\/\/(?:cdn\.discordapp\.com|media\.discordapp\.net|images-ext(?:-[^.]*)?\.discordapp\.net)\/[^\s"<>){}[\]]+/g;
+            let match;
+            while ((match = discordUrlRegex.exec(data)) !== null) {
+                urls.add(match[0]);
+            }
+            return urls;
+        }
+        if (Array.isArray(data)) {
+            for (const item of data) {
+                this.extractDiscordUrls(item, urls);
+            }
+            return urls;
+        }
+        if (data !== null && typeof data === "object") {
+            const obj = data;
+            for (const value of Object.values(obj)) {
+                this.extractDiscordUrls(value, urls);
+            }
+            return urls;
+        }
+        return urls;
+    }
+}
+exports.AssetManager = AssetManager;

package/dist/src/utils/authors.d.ts

@@ -0,0 +1,4 @@
+import type { AuthorData, ForwardedOriginal, ForwardedData } from "../types/entities";
+export declare function buildSystemAuthor(messageId: string, messageType?: number): AuthorData;
+export declare function buildForwardedOriginal(message: any): ForwardedOriginal;
+export declare function extractForwarded(message: any): Promise<ForwardedData | null>;

package/dist/src/utils/authors.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSystemAuthor = buildSystemAuthor;
+exports.buildForwardedOriginal = buildForwardedOriginal;
+exports.extractForwarded = extractForwarded;
+function buildSystemAuthor(messageId, messageType) {
+    return {
+        id: `system:${messageId}`,
+        username: `System${messageType ? ` (type ${messageType})` : ""}`,
+        bot: false,
+        color: null,
+        verified: null
+    };
+}
+function buildForwardedOriginal(message) {
+    const rawEmbeds = Array.isArray(message.embeds)
+        ? message.embeds
+        : typeof message.embeds?.values === "function"
+            ? Array.from(message.embeds.values())
+            : [];
+    const rawAttachments = Array.isArray(message.attachments)
+        ? message.attachments
+        : typeof message.attachments?.values === "function"
+            ? Array.from(message.attachments.values())
+            : [];
+    const rawStickers = Array.isArray(message.stickers)
+        ? message.stickers
+        : typeof message.stickers?.values === "function"
+            ? Array.from(message.stickers.values())
+            : [];
+    return {
+        id: message.id ?? null,
+        content: message.content ?? "",
+        author: message.author?.id ?? null,
+        createdAt: message.createdAt ? new Date(message.createdAt).toISOString() : null,
+        embeds: rawEmbeds.map((e) => ({
+            title: e.title ?? null,
+            description: e.description ?? null,
+            url: e.url ?? null,
+            timestamp: e.timestamp ? new Date(e.timestamp).toISOString() : null,
+            color: typeof e.hexColor === "string"
+                ? e.hexColor
+                : typeof e.color === "string"
+                    ? e.color
+                    : typeof e.color === "number"
+                        ? `#${e.color.toString(16).padStart(6, "0")}`
+                        : null,
+            footer: e.footer ? { text: e.footer.text ?? null, iconUrl: e.footer.iconURL ?? null } : null,
+            image: e.image
+                ? {
+                    url: e.image.proxyURL ?? e.image.proxy_url ?? e.image.url ?? null,
+                    width: e.image?.width ?? null,
+                    height: e.image?.height ?? null
+                }
+                : null,
+            thumbnail: e.thumbnail
+                ? {
+                    url: e.thumbnail.proxyURL ?? e.thumbnail.proxy_url ?? e.thumbnail.url ?? null,
+                    width: e.thumbnail?.width ?? null,
+                    height: e.thumbnail?.height ?? null
+                }
+                : null,
+            author: e.author
+                ? {
+                    name: e.author.name ?? null,
+                    url: e.author.url ?? null,
+                    iconUrl: e.author.proxyIconURL ?? e.author.proxy_icon_url ?? e.author.iconURL ?? null
+                }
+                : null,
+            fields: Array.isArray(e.fields) ? e.fields.map((f) => ({ name: f.name, value: f.value, inline: !!f.inline })) : undefined
+        })),
+        attachments: rawAttachments.map((a) => ({
+            id: a.id ?? null,
+            filename: a.name ?? a.filename ?? null,
+            url: a.url ?? null,
+            proxyURL: a.proxyURL ?? a.proxy_url ?? null,
+            contentType: a.contentType ?? a.content_type ?? null,
+            size: a.size ?? undefined,
+            width: a.width ?? null,
+            height: a.height ?? null
+        })),
+        stickers: rawStickers.map((s) => ({
+            id: s.id ?? null,
+            name: s.name ?? null,
+            format: s.format ?? s.formatType ?? null,
+            url: s.url ?? s.image?.proxyURL ?? null
+        }))
+    };
+}
+async function extractForwarded(message) {
+    try {
+        let source = message.forwarded ?? message.forwardedMessage ?? null;
+        if (!source) {
+            const snapshots = message.messageSnapshots;
+            if (snapshots && typeof snapshots.values === "function") {
+                const iterator = snapshots.values();
+                const first = iterator.next();
+                if (!first.done)
+                    source = first.value;
+            }
+        }
+        if (source) {
+            return {
+                fromMessageId: source.id ?? null,
+                fromChannelId: source.channelId ?? source.channel?.id ?? null,
+                fromGuildId: source.guildId ?? source.guild?.id ?? null,
+                original: buildForwardedOriginal(source)
+            };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/utils/cache.d.ts

@@ -0,0 +1,16 @@
+import type { GuildTag } from "../types/entities";
+declare class GuildTagCache {
+    private cache;
+    get(userId: string): GuildTag | undefined;
+    set(userId: string, tag: GuildTag): void;
+    has(userId: string): boolean;
+}
+declare class UserColorCache {
+    private cache;
+    get(key: string): string | null | undefined;
+    set(key: string, color: string | null): void;
+    has(key: string): boolean;
+}
+export declare const guildTagCache: GuildTagCache;
+export declare const userColorCache: UserColorCache;
+export {};