discord-message-transcript 1.3.1-dev.3.35 → 1.3.2-dev.0.49

package/dist/core/assetResolver/base64/imageToBase64.d.ts

@@ -0,0 +1,2 @@
+import { safeUrlReturn } from '@/types';
+export declare function imageToBase64(safeUrlObject: safeUrlReturn, disableWarnings: boolean): Promise<string>;

package/dist/core/{imageToBase64.js → assetResolver/base64/imageToBase64.js}

@@ -1,13 +1,21 @@
+import { CustomWarn } from 'discord-message-transcript-base';
+import { getBase64Limiter } from '../limiter.js';
 import https from 'https';
 import http from 'http';
-import { CustomWarn } from 'discord-message-transcript-base';
-import { getBase64Limiter } from './limiter.js';
-export async function imageToBase64(url, disableWarnings) {
+import { createLookup } from '@/networkSecurity';
+import { USER_AGENT } from '../contants.js';
+const MAX_BYTES = 25 * 1024 * 1024; // 25MB
+export async function imageToBase64(safeUrlObject, disableWarnings) {
+    const url = safeUrlObject.url;
     const limit = getBase64Limiter();
     return limit(async () => {
         return new Promise((resolve, reject) => {
             const client = url.startsWith('https') ? https : http;
-            const request = client.get(url, { headers: { "User-Agent": "discord-message-transcript" } }, (response) => {
+            const lookup = createLookup(safeUrlObject.safeIps);
+            const request = client.get(url, {
+                headers: { "User-Agent": USER_AGENT },
+                lookup: lookup
+            }, (response) => {
                 if (response.statusCode !== 200) {
                     response.destroy();
                     CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of converting to base64.
@@ -19,8 +27,14 @@ Failed to fetch image with status code: ${response.statusCode} from ${url}.`, di
                     response.destroy();
                     return resolve(url);
                 }
+                let total = 0;
                 const chunks = [];
                 response.on('data', (chunk) => {
+                    total += chunk.length;
+                    if (total > MAX_BYTES) {
+                        response.destroy();
+                        return resolve(url);
+                    }
                     chunks.push(chunk);
                 });
                 response.on('end', () => {

package/dist/core/assetResolver/cdn/cdnCustomError.d.ts

@@ -0,0 +1,16 @@
+export declare class CDNProviderError extends Error {
+    provider: "CLOUDINARY" | "UPLOADCARE" | "CUSTOM";
+    code: string;
+    status?: number;
+    hint?: string;
+    errorMessage?: string;
+    constructor(opts: {
+        provider: "CLOUDINARY" | "UPLOADCARE" | "CUSTOM";
+        message: string;
+        code: string;
+        status?: number;
+        hint?: string;
+        errorMessage?: string;
+    });
+}
+export declare function warnCdnError(provider: string, url: string, err: any, disableWarnings: boolean): void;

package/dist/core/assetResolver/cdn/cdnCustomError.js

@@ -0,0 +1,28 @@
+import { CustomWarn } from "discord-message-transcript-base";
+export class CDNProviderError extends Error {
+    provider;
+    code;
+    status;
+    hint;
+    errorMessage;
+    constructor(opts) {
+        super(opts.message);
+        this.provider = opts.provider;
+        this.code = opts.code;
+        this.status = opts.status;
+        this.hint = opts.hint;
+        this.errorMessage = opts.errorMessage;
+    }
+}
+export function warnCdnError(provider, url, err, disableWarnings) {
+    if (err instanceof CDNProviderError) {
+        CustomWarn(`[CDN:${err.provider}] Upload failed → fallback to original URL
+URL: ${url}
+Reason: ${err.message}
+Code: ${err.code}${err.status ? ` (HTTP ${err.status})` : ""}${err.hint ? `\nHint: ${err.hint}` : ""} ${err.errorMessage ? `\nError Message: ${err.errorMessage}` : ""}`, disableWarnings);
+        return;
+    }
+    CustomWarn(`[CDN:${provider}] Unknown error → fallback to original URL
+URL: ${url}
+Error: ${err?.message ?? err}`, disableWarnings);
+}

package/dist/core/assetResolver/cdn/cdnResolver.d.ts

@@ -0,0 +1,3 @@
+import { CDNOptions, safeUrlReturn } from "@/types/types.js";
+import { TranscriptOptionsBase } from "discord-message-transcript-base";
+export declare function cdnResolver(safeUrlObject: safeUrlReturn, options: TranscriptOptionsBase, cdnOptions: CDNOptions): Promise<string>;

package/dist/core/assetResolver/cdn/cdnResolver.js

@@ -0,0 +1,90 @@
+import { CustomWarn } from "discord-message-transcript-base";
+import { getCDNLimiter } from "../limiter.js";
+import { createLookup } from "@/networkSecurity";
+import https from 'https';
+import http from 'http';
+import { uploadCareCdnResolver } from "./uploadCareCdnResolver.js";
+import { cloudinaryCdnResolver } from "./cloudinaryCdnResolver.js";
+import { validateCdnUrl } from "./validateCdnUrl.js";
+import { USER_AGENT } from "../contants.js";
+export async function cdnResolver(safeUrlObject, options, cdnOptions) {
+    const url = safeUrlObject.url;
+    const limit = getCDNLimiter();
+    return limit(async () => {
+        return new Promise((resolve, reject) => {
+            const client = safeUrlObject.url.startsWith('https') ? https : http;
+            const lookup = createLookup(safeUrlObject.safeIps);
+            const request = client.get(url, {
+                headers: { "User-Agent": USER_AGENT },
+                lookup: lookup
+            }, async (response) => {
+                if (response.statusCode !== 200) {
+                    response.destroy();
+                    CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of uploading to CDN.
+Failed to fetch attachment with status code: ${response.statusCode} from ${safeUrlObject.url}.`, options.disableWarnings);
+                    return resolve(url);
+                }
+                const contentType = response.headers["content-type"];
+                const splitContentType = contentType ? contentType?.split('/') : [];
+                if (!contentType || splitContentType.length != 2 || splitContentType[0].length == 0 || splitContentType[1].length == 0) {
+                    response.destroy();
+                    CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of uploading to CDN.
+Failed to receive a valid content-type from ${url}.`, options.disableWarnings);
+                    return resolve(url);
+                }
+                response.destroy();
+                const isImage = contentType.startsWith('image/') && contentType !== 'image/gif';
+                const isAudio = contentType.startsWith('audio/');
+                const isVideo = contentType.startsWith('video/') || contentType === 'image/gif';
+                if ((cdnOptions.includeImage && isImage) ||
+                    (cdnOptions.includeAudio && isAudio) ||
+                    (cdnOptions.includeVideo && isVideo) ||
+                    (cdnOptions.includeOthers && !isAudio && !isImage && !isVideo)) {
+                    return resolve(await cdnRedirectType(url, options, contentType, cdnOptions));
+                }
+                return resolve(url);
+            });
+            request.on('error', (err) => {
+                CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of uploading to CDN.
+Error: ${err.message}`, options.disableWarnings);
+                return resolve(url);
+            });
+            request.setTimeout(15000, () => {
+                request.destroy();
+                CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of uploading to CDN.
+Request timeout for ${url}.`, options.disableWarnings);
+                return resolve(url);
+            });
+            request.end();
+        });
+    });
+}
+async function cdnRedirectType(url, options, contentType, cdnOptions) {
+    let newUrl;
+    switch (cdnOptions.provider) {
+        case "CUSTOM": {
+            try {
+                newUrl = await cdnOptions.resolver(url, contentType, cdnOptions.customData);
+                break;
+            }
+            catch (error) {
+                CustomWarn(`Custom CDN resolver threw an error. Falling back to original URL.
+This is most likely an issue in the custom CDN implementation provided by the user.
+URL: ${url}
+Error: ${error?.message ?? error}`, options.disableWarnings);
+                return url;
+            }
+        }
+        case "CLOUDINARY": {
+            newUrl = await cloudinaryCdnResolver(url, options.fileName, cdnOptions.cloudName, cdnOptions.apiKey, cdnOptions.apiSecret, options.disableWarnings);
+            break;
+        }
+        case "UPLOADCARE": {
+            newUrl = await uploadCareCdnResolver(url, cdnOptions.publicKey, cdnOptions.cdnDomain, options.disableWarnings);
+            break;
+        }
+    }
+    if (validateCdnUrl(newUrl, options.disableWarnings))
+        return newUrl;
+    return url;
+}

package/dist/core/assetResolver/cdn/cloudinaryCdnResolver.d.ts

@@ -0,0 +1 @@
+export declare function cloudinaryCdnResolver(url: string, fileName: string, cloudName: string, apiKey: string, apiSecret: string, disableWarnings: boolean): Promise<string>;

package/dist/core/assetResolver/cdn/cloudinaryCdnResolver.js

@@ -0,0 +1,120 @@
+import crypto from 'crypto';
+import { CDNProviderError, warnCdnError } from './cdnCustomError.js';
+import { sanitizeFileName } from './sanitizeFileName.js';
+import { USER_AGENT } from '../contants.js';
+// https://cloudinary.com/documentation/upload_images
+export async function cloudinaryCdnResolver(url, fileName, cloudName, apiKey, apiSecret, disableWarnings) {
+    try {
+        if (!cloudName || !apiKey || !apiSecret) {
+            throw new CDNProviderError({
+                provider: "CLOUDINARY",
+                code: "CONFIG_MISSING",
+                message: "Cloudinary configuration is missing required fields.",
+                hint: "Verify cloudName, apiKey and apiSecret."
+            });
+        }
+        const paramsToSign = {
+            folder: `discord-message-transcript/${sanitizeFileName(fileName)}`,
+            timestamp: Math.floor(Date.now() / 1000).toString(),
+            unique_filename: "true",
+            use_filename: "true",
+        };
+        const stringToSign = Object.keys(paramsToSign).sort().map(k => `${k}=${paramsToSign[k]}`).join("&");
+        // signature SHA256
+        const signature = crypto
+            .createHash("sha256")
+            .update(stringToSign + apiSecret)
+            .digest("hex");
+        const form = new FormData();
+        form.append("folder", paramsToSign.folder);
+        form.append("file", url);
+        form.append("api_key", apiKey);
+        form.append("timestamp", paramsToSign.timestamp);
+        form.append("signature", signature);
+        form.append("use_filename", paramsToSign.use_filename);
+        form.append("unique_filename", paramsToSign.unique_filename);
+        let res;
+        try {
+            res = await fetch(`https://api.cloudinary.com/v1_1/${cloudName}/auto/upload`, {
+                method: "POST",
+                body: form,
+                headers: { "User-Agent": USER_AGENT }
+            });
+        }
+        catch (networkErr) {
+            throw new CDNProviderError({
+                provider: "CLOUDINARY",
+                code: "NETWORK_ERROR",
+                message: "Network error while contacting Cloudinary.",
+                hint: "Check internet connection, DNS, firewall or proxy.",
+            });
+        }
+        if (!res.ok) {
+            let body = {};
+            try {
+                body = await res.json();
+            }
+            catch { } // It isn't a problem body be empty
+            switch (res.status) {
+                case 400:
+                    throw new CDNProviderError({
+                        provider: "CLOUDINARY",
+                        code: "BAD_REQUEST",
+                        status: res.status,
+                        message: body?.error?.message ?? "Invalid upload parameters.",
+                        hint: "Check folder name, file URL accessibility, and signature.",
+                        errorMessage: body.error.message ? body.error.message : undefined
+                    });
+                case 401:
+                case 403:
+                    throw new CDNProviderError({
+                        provider: "CLOUDINARY",
+                        code: "INVALID_CREDENTIALS",
+                        status: res.status,
+                        message: "Cloudinary rejected credentials.",
+                        hint: "Check apiKey/apiSecret and cloudName.",
+                        errorMessage: body.error.message ? body.error.message : undefined
+                    });
+                case 420:
+                    throw new CDNProviderError({
+                        provider: "CLOUDINARY",
+                        code: "RATE_LIMIT",
+                        status: res.status,
+                        message: "Cloudinary rate limit exceeded.",
+                        hint: "Reduce concurrency.",
+                        errorMessage: body.error.message ? body.error.message : undefined
+                    });
+                case 500:
+                    throw new CDNProviderError({
+                        provider: "CLOUDINARY",
+                        code: "CLOUDINARY_INTERNAL_ERROR",
+                        status: res.status,
+                        message: "Cloudinary has a internal error.",
+                        hint: "Contact support or check https://status.cloudinary.com.",
+                        errorMessage: body.error.message ? body.error.message : undefined
+                    });
+                default:
+                    throw new CDNProviderError({
+                        provider: "CLOUDINARY",
+                        code: "HTTP_ERROR",
+                        status: res.status,
+                        message: `Unexpected Cloudinary response.`,
+                        errorMessage: body.error.message ? body.error.message : undefined
+                    });
+            }
+        }
+        const json = await res.json();
+        if (!json.secure_url) {
+            throw new CDNProviderError({
+                provider: "CLOUDINARY",
+                code: "INVALID_RESPONSE",
+                message: "Cloudinary response missing secure_url."
+            });
+        }
+        return json.secure_url;
+    }
+    catch (error) {
+        warnCdnError("CLOUDINARY", url, error, disableWarnings);
+        return url;
+    }
+}

package/dist/core/assetResolver/cdn/sanitizeFileName.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeFileName(fileName: string): string;

package/dist/core/assetResolver/cdn/sanitizeFileName.js

@@ -0,0 +1,17 @@
+import { randomUUID } from "crypto";
+const INVALID_REGEX = /[<>:"/\\|?*\x00-\x1F]|[^\p{L}\p{N}._ -]/gu;
+const MAX_LENGTH = 100;
+export function sanitizeFileName(fileName) {
+    fileName = fileName
+        .trim()
+        .replace(INVALID_REGEX, "")
+        .replace(/\s+/g, " ");
+    fileName = fileName.replace(/[. ]+$/, "");
+    if (fileName.length > MAX_LENGTH) {
+        fileName = fileName.slice(0, MAX_LENGTH);
+    }
+    if (!fileName.length) {
+        fileName = `fallbackFile-${randomUUID()}`;
+    }
+    return fileName;
+}

package/dist/core/assetResolver/cdn/uploadCareCdnResolver.d.ts

@@ -0,0 +1 @@
+export declare function uploadCareCdnResolver(url: string, publicKey: string, cdnDomain: string, disableWarnings: boolean): Promise<string>;

package/dist/core/assetResolver/cdn/uploadCareCdnResolver.js

@@ -0,0 +1,137 @@
+import { sleep } from "@/utils/sleep.js";
+import { CDNProviderError, warnCdnError } from "./cdnCustomError.js";
+import { USER_AGENT } from "../contants.js";
+// https://uploadcare.com/api-refs/upload-api/#tag/Upload/operation/fromURLUpload
+export async function uploadCareCdnResolver(url, publicKey, cdnDomain, disableWarnings) {
+    try {
+        if (!publicKey || !cdnDomain) {
+            throw new CDNProviderError({
+                provider: "UPLOADCARE",
+                code: "CONFIG_MISSING",
+                message: "Uploadcare configuration is missing required fields.",
+                hint: "Verify cdnDomain and publickey."
+            });
+        }
+        const form = new FormData();
+        form.append("pub_key", publicKey);
+        form.append("source_url", url);
+        form.append("store", "1");
+        form.append("check_URL_duplicates", "1");
+        form.append("save_URL_duplicates", "1");
+        let res;
+        try {
+            res = await fetch("https://upload.uploadcare.com/from_url/", {
+                method: "POST",
+                body: form,
+                headers: { "User-Agent": USER_AGENT }
+            });
+        }
+        catch {
+            throw new CDNProviderError({
+                provider: "UPLOADCARE",
+                code: "NETWORK_ERROR",
+                message: "Network error while contacting Uploadcare.",
+                hint: "Check DNS, firewall or internet connection."
+            });
+        }
+        if (!res.ok) {
+            let body = {};
+            try {
+                body = await res.text(); // Uploadcare use text/plain for error messages
+            }
+            catch { } // It isn't a problem body be empty
+            switch (res.status) {
+                case 400:
+                    throw new CDNProviderError({
+                        provider: "UPLOADCARE",
+                        code: "BAD_REQUEST",
+                        status: 400,
+                        message: "Uploadcare rejected parameters.",
+                        hint: "Check publickKey, file URL accessibility, and signature.",
+                        errorMessage: body ?? undefined
+                    });
+                case 403:
+                    throw new CDNProviderError({
+                        provider: "UPLOADCARE",
+                        code: "INVALID_KEY",
+                        status: 403,
+                        message: "Uploadcare rejected public key.",
+                        hint: "Verify public key and project settings.",
+                        errorMessage: body ?? undefined
+                    });
+                case 429:
+                    throw new CDNProviderError({
+                        provider: "UPLOADCARE",
+                        code: "RATE_LIMIT",
+                        status: 429,
+                        message: "Uploadcare rate limit exceeded.",
+                        hint: "Reduce concurrency.",
+                        errorMessage: body ?? undefined
+                    });
+                case 500:
+                    throw new CDNProviderError({
+                        provider: "UPLOADCARE",
+                        code: "UPLOADCARE_INTERNAL",
+                        status: res.status,
+                        message: "Uploadcare internal error.",
+                        hint: "Check https://status.uploadcare.com",
+                        errorMessage: body ?? undefined
+                    });
+                default:
+                    throw new CDNProviderError({
+                        provider: "UPLOADCARE",
+                        code: "HTTP_ERROR",
+                        status: res.status,
+                        message: "Unexpected Uploadcare response.",
+                        errorMessage: body ?? undefined
+                    });
+            }
+        }
+        const json = await res.json();
+        if (json.uuid) {
+            return `https://${cdnDomain}/${json.uuid}/`;
+        }
+        if (!json.token) {
+            throw new CDNProviderError({
+                provider: "UPLOADCARE",
+                code: "INVALID_RESPONSE",
+                message: "Uploadcare response missing uuid/token."
+            });
+        }
+        let delay = 200;
+        let maxDelay = 2000;
+        for (let i = 0; i < 10; i++) {
+            await sleep(delay);
+            delay = Math.min(delay * 2, maxDelay);
+            const resToken = await fetch(`https://upload.uploadcare.com/from_url/status/?token=${json.token}&pub_key=${publicKey}`, { headers: { "User-Agent": USER_AGENT } });
+            if (!resToken.ok) {
+                throw new CDNProviderError({
+                    provider: "UPLOADCARE",
+                    code: "STATUS_ERROR",
+                    status: resToken.status,
+                    message: "Uploadcare status endpoint failed."
+                });
+            }
+            const jsonToken = await resToken.json();
+            if (jsonToken.status === "success" && jsonToken.file_id) {
+                return `https://${cdnDomain}/${jsonToken.file_id}/`;
+            }
+            if (jsonToken.status === "error") {
+                throw new CDNProviderError({
+                    provider: "UPLOADCARE",
+                    code: "UPLOAD_FAILED",
+                    message: jsonToken.error || "Uploadcare processing failed."
+                });
+            }
+        }
+        throw new CDNProviderError({
+            provider: "UPLOADCARE",
+            code: "TIMEOUT",
+            message: "Uploadcare polling timeout."
+        });
+    }
+    catch (error) {
+        warnCdnError("UPLOADCARE", url, error, disableWarnings);
+        return url;
+    }
+}

package/dist/core/assetResolver/cdn/validateCdnUrl.d.ts

@@ -0,0 +1 @@
+export declare function validateCdnUrl(url: string, disableWarnings: boolean): boolean;

package/dist/core/assetResolver/cdn/validateCdnUrl.js

@@ -0,0 +1,8 @@
+import { CustomWarn } from "discord-message-transcript-base";
+export function validateCdnUrl(url, disableWarnings) {
+    if (url.includes('"') || url.includes('<') || url.includes('>')) {
+        CustomWarn(`Unsafe URL received from CDN, using fallback.\nURL: ${url}`, disableWarnings);
+        return false;
+    }
+    return true;
+}

package/dist/core/assetResolver/contants.d.ts

@@ -0,0 +1 @@
+export declare const USER_AGENT = "discord-message-transcript";

package/dist/core/assetResolver/contants.js

@@ -0,0 +1 @@
+export const USER_AGENT = "discord-message-transcript";

package/dist/core/assetResolver/index.d.ts

@@ -0,0 +1,7 @@
+import { Json } from "@/renderers/json/json.js";
+import { CDNOptions, Maps } from "@/types/types.js";
+import { TranscriptOptionsBase } from "discord-message-transcript-base";
+export * from "./limiter.js";
+export * from "./url/imageUrlResolver.js";
+export * from "./url/urlResolver.js";
+export declare function jsonAssetResolver(jsonTranscript: Json, maps: Maps, options: TranscriptOptionsBase, cdnOptions: CDNOptions | null): Promise<void>;

package/dist/core/assetResolver/index.js

@@ -0,0 +1,22 @@
+import { authorUrlResolver } from "./url/authorUrlResolver.js";
+import { messagesUrlResolver } from "./url/messageUrlResolver.js";
+export * from "./limiter.js";
+export * from "./url/imageUrlResolver.js";
+export * from "./url/urlResolver.js";
+export async function jsonAssetResolver(jsonTranscript, maps, options, cdnOptions) {
+    await Promise.all([
+        (async () => {
+            jsonTranscript.setAuthors(await authorUrlResolver(maps.authors, options, cdnOptions, maps.urlCache));
+            maps.authors.clear();
+        })(),
+        (() => {
+            jsonTranscript.setMentions({ channels: Array.from(maps.mentions.channels.values()), roles: Array.from(maps.mentions.roles.values()), users: Array.from(maps.mentions.users.values()) });
+            maps.mentions.channels.clear();
+            maps.mentions.roles.clear();
+            maps.mentions.users.clear();
+        })(),
+        (async () => {
+            jsonTranscript.setMessages(await messagesUrlResolver(jsonTranscript.getMessages(), options, cdnOptions, maps.urlCache));
+        })()
+    ]);
+}

package/dist/core/assetResolver/url/authorUrlResolver.d.ts

@@ -0,0 +1,3 @@
+import { JsonAuthor, TranscriptOptionsBase } from "discord-message-transcript-base";
+import { CDNOptions } from "@/types/types.js";
+export declare function authorUrlResolver(authors: Map<string, JsonAuthor>, options: TranscriptOptionsBase, cdnOptions: CDNOptions | null, urlCache: Map<string, Promise<string>>): Promise<JsonAuthor[]>;

package/dist/core/assetResolver/url/authorUrlResolver.js

@@ -0,0 +1,10 @@
+import { imageUrlResolver } from "./imageUrlResolver.js";
+import { urlResolver } from "./urlResolver.js";
+export async function authorUrlResolver(authors, options, cdnOptions, urlCache) {
+    return await Promise.all(Array.from(authors.values()).map(async (author) => {
+        return {
+            ...author,
+            avatarURL: await urlResolver((await imageUrlResolver(author.avatarURL, options, false)), options, cdnOptions, urlCache),
+        };
+    }));
+}

package/dist/core/assetResolver/url/imageUrlResolver.d.ts

@@ -0,0 +1,4 @@
+import { JsonAttachment, TranscriptOptionsBase } from "discord-message-transcript-base";
+import { safeUrlReturn } from "@/types";
+export declare function imageUrlResolver(url: string, options: TranscriptOptionsBase, canReturnNull: false, attachments?: JsonAttachment[]): Promise<safeUrlReturn>;
+export declare function imageUrlResolver(url: string | null, options: TranscriptOptionsBase, canReturnNull: true, attachments?: JsonAttachment[]): Promise<safeUrlReturn | null>;

package/dist/core/assetResolver/url/imageUrlResolver.js

@@ -0,0 +1,20 @@
+import { FALLBACK_PIXEL } from "discord-message-transcript-base";
+import { isSafeForHTML } from "@/networkSecurity";
+export async function imageUrlResolver(url, options, canReturnNull, attachments) {
+    if (!url)
+        return null;
+    // Resolve attachment:// references to actual attachment URL
+    if (url.startsWith("attachment://")) {
+        const name = url.slice("attachment://".length).trim();
+        const found = attachments?.find(a => a.name === name);
+        if (!found)
+            return { safe: true, safeIps: [], url: FALLBACK_PIXEL };
+        url = found.url;
+    }
+    const safeUrlReturn = await isSafeForHTML(url, options);
+    if (safeUrlReturn.safe)
+        return safeUrlReturn;
+    if (canReturnNull)
+        return null;
+    return { safe: true, safeIps: [], url: FALLBACK_PIXEL };
+}

package/dist/core/assetResolver/url/messageUrlResolver.d.ts

@@ -0,0 +1,3 @@
+import { CDNOptions } from "@/types/types.js";
+import { JsonMessage, TranscriptOptionsBase } from "discord-message-transcript-base";
+export declare function messagesUrlResolver(messages: JsonMessage[], options: TranscriptOptionsBase, cdnOptions: CDNOptions | null, urlCache: Map<string, Promise<string>>): Promise<JsonMessage[]>;