discord-message-transcript 1.3.1-dev.1.47 → 1.3.1-dev.1.48

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

@@ -1,8 +1,9 @@
 import { CustomWarn } from 'discord-message-transcript-base';
-import { getBase64Limiter } from './limiter.js';
+import { getBase64Limiter } from '../limiter.js';
 import https from 'https';
 import http from 'http';
 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;
@@ -12,7 +13,7 @@ export async function imageToBase64(safeUrlObject, disableWarnings) {
             const client = url.startsWith('https') ? https : http;
             const lookup = createLookup(safeUrlObject.safeIps);
             const request = client.get(url, {
-                headers: { "User-Agent": "discord-message-transcript" },
+                headers: { "User-Agent": USER_AGENT },
                 lookup: lookup
             }, (response) => {
                 if (response.statusCode !== 200) {

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,5 @@
+export * from "./url/imageUrlResolver.js";
+export * from "./url/urlResolver.js";
+export * from "./url/authorUrlResolver.js";
+export * from "./url/messageUrlResolver.js";
+export * from "./limiter.js";

package/dist/core/assetResolver/index.js

@@ -0,0 +1,5 @@
+export * from "./url/imageUrlResolver.js";
+export * from "./url/urlResolver.js";
+export * from "./url/authorUrlResolver.js";
+export * from "./url/messageUrlResolver.js";
+export * from "./limiter.js";

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/{resolveImageUrl.js → assetResolver/url/imageUrlResolver.js}

@@ -1,6 +1,6 @@
 import { FALLBACK_PIXEL } from "discord-message-transcript-base";
 import { isSafeForHTML } from "@/networkSecurity";
-export async function resolveImageURL(url, options, canReturnNull, attachments) {
+export async function imageUrlResolver(url, options, canReturnNull, attachments) {
     if (!url)
         return null;
     // Resolve attachment:// references to actual attachment URL

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[]>;

package/dist/core/{urlResolver.js → assetResolver/url/messageUrlResolver.js}

@@ -1,38 +1,15 @@
 import { JsonComponentType } from "discord-message-transcript-base";
-import { cdnResolver } from "./cdnResolver.js";
-import { imageToBase64 } from "./imageToBase64.js";
-import { isJsonComponentInContainer } from "./componentToJson.js";
-import { FALLBACK_PIXEL } from "discord-message-transcript-base";
-import { resolveImageURL } from "./resolveImageUrl.js";
+import { imageUrlResolver } from "./imageUrlResolver.js";
 import { isSafeForHTML } from "@/networkSecurity";
-export async function urlResolver(safeUrlObject, options, cdnOptions, urlCache) {
-    if (safeUrlObject.safe == false)
-        return "";
-    if (safeUrlObject.url == FALLBACK_PIXEL)
-        return safeUrlObject.url;
-    if (urlCache.has(safeUrlObject.url)) {
-        const cache = urlCache.get(safeUrlObject.url);
-        if (cache)
-            return await cache;
-    }
-    let returnUrl;
-    if (cdnOptions)
-        returnUrl = cdnResolver(safeUrlObject, options, cdnOptions);
-    else if (options.saveImages)
-        returnUrl = imageToBase64(safeUrlObject, options.disableWarnings);
-    if (returnUrl) {
-        urlCache.set(safeUrlObject.url, returnUrl);
-        return await returnUrl;
-    }
-    return safeUrlObject.url;
-}
+import { urlResolver } from "./urlResolver.js";
+import { isJsonComponentInContainer } from "@/core/componentToJson.js";
 export async function messagesUrlResolver(messages, options, cdnOptions, urlCache) {
     return await Promise.all(messages.map(async (message) => {
         // Needs to wait for resolve correct when used attachment://
         const attachments = await Promise.all(message.attachments.map(async (attachment) => {
             let safeUrlObject;
             if (attachment.contentType?.startsWith("image/")) {
-                safeUrlObject = await resolveImageURL(attachment.url, options, false, message.attachments);
+                safeUrlObject = await imageUrlResolver(attachment.url, options, false, message.attachments);
             }
             else {
                 safeUrlObject = await isSafeForHTML(attachment.url, options);
@@ -43,10 +20,10 @@ export async function messagesUrlResolver(messages, options, cdnOptions, urlCach
             };
         }));
         const embedsPromise = Promise.all(message.embeds.map(async (embed) => {
-            const authorIconUrl = embed.author?.iconURL ? await resolveImageURL(embed.author.iconURL, options, true, attachments) : null;
-            const footerIconUrl = embed.footer?.iconURL ? await resolveImageURL(embed.footer.iconURL, options, true, attachments) : null;
-            const imageUrl = embed.image?.url ? await resolveImageURL(embed.image.url, options, true, attachments) : null;
-            const thumbnailUrl = embed.thumbnail?.url ? await resolveImageURL(embed.thumbnail.url, options, true, attachments) : null;
+            const authorIconUrl = embed.author?.iconURL ? await imageUrlResolver(embed.author.iconURL, options, true, attachments) : null;
+            const footerIconUrl = embed.footer?.iconURL ? await imageUrlResolver(embed.footer.iconURL, options, true, attachments) : null;
+            const imageUrl = embed.image?.url ? await imageUrlResolver(embed.image.url, options, true, attachments) : null;
+            const thumbnailUrl = embed.thumbnail?.url ? await imageUrlResolver(embed.thumbnail.url, options, true, attachments) : null;
             return {
                 ...embed,
                 author: embed.author ? { ...embed.author, iconURL: authorIconUrl ? await urlResolver(authorIconUrl, options, cdnOptions, urlCache) : null } : null,
@@ -64,7 +41,7 @@ export async function messagesUrlResolver(messages, options, cdnOptions, urlCach
                             accessory: {
                                 ...component.accessory,
                                 media: {
-                                    url: await urlResolver((await resolveImageURL(component.accessory.media.url, options, false, attachments)), options, cdnOptions, urlCache),
+                                    url: await urlResolver((await imageUrlResolver(component.accessory.media.url, options, false, attachments)), options, cdnOptions, urlCache),
                                 }
                             }
                         };
@@ -76,7 +53,7 @@ export async function messagesUrlResolver(messages, options, cdnOptions, urlCach
                         items: await Promise.all(component.items.map(async (item) => {
                             return {
                                 ...item,
-                                media: { url: await urlResolver((await resolveImageURL(item.media.url, options, false, attachments)), options, cdnOptions, urlCache) },
+                                media: { url: await urlResolver((await imageUrlResolver(item.media.url, options, false, attachments)), options, cdnOptions, urlCache) },
                             };
                         }))
                     };
@@ -110,11 +87,3 @@ export async function messagesUrlResolver(messages, options, cdnOptions, urlCach
         };
     }));
 }
-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 resolveImageURL(author.avatarURL, options, false)), options, cdnOptions, urlCache),
-        };
-    }));
-}

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

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

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

@@ -0,0 +1,24 @@
+import { FALLBACK_PIXEL } from "discord-message-transcript-base";
+import { cdnResolver } from "../cdn/cdnResolver.js";
+import { imageToBase64 } from "../base64/imageToBase64.js";
+export async function urlResolver(safeUrlObject, options, cdnOptions, urlCache) {
+    if (safeUrlObject.safe == false)
+        return "";
+    if (safeUrlObject.url == FALLBACK_PIXEL)
+        return safeUrlObject.url;
+    if (urlCache.has(safeUrlObject.url)) {
+        const cache = urlCache.get(safeUrlObject.url);
+        if (cache)
+            return await cache;
+    }
+    let returnUrl;
+    if (cdnOptions)
+        returnUrl = cdnResolver(safeUrlObject, options, cdnOptions);
+    else if (options.saveImages)
+        returnUrl = imageToBase64(safeUrlObject, options.disableWarnings);
+    if (returnUrl) {
+        urlCache.set(safeUrlObject.url, returnUrl);
+        return await returnUrl;
+    }
+    return safeUrlObject.url;
+}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { CreateTranscriptOptions, ConvertTranscriptOptions, TranscriptOptions, ReturnType, CDNOptions, MimeType } from "@/types";
 export { ReturnFormat, LocalDate, TimeZone } from "discord-message-transcript-base";
-export { setBase64Concurrency, setCDNConcurrency } from '@/core/limiter.js';
+export { setBase64Concurrency, setCDNConcurrency } from '@/assetResolver';
 import { TextBasedChannel } from "discord.js";
 import { ConvertTranscriptOptions, CreateTranscriptOptions, OutputType, ReturnType } from "@/types";
 /**

package/dist/index.js

@@ -1,6 +1,6 @@
 export { ReturnType } from "@/types";
 export { ReturnFormat } from "discord-message-transcript-base";
-export { setBase64Concurrency, setCDNConcurrency } from '@/core/limiter.js';
+export { setBase64Concurrency, setCDNConcurrency } from '@/assetResolver';
 import { AttachmentBuilder } from "discord.js";
 import { Json } from "@/renderers/json/json.js";
 import { fetchMessages } from "@/core/fetchMessages.js";
@@ -8,7 +8,7 @@ import { ReturnType } from "@/types";
 import { output } from "@/core/output.js";
 import { ReturnTypeBase, ReturnFormat, outputBase, CustomError, CustomWarn } from "discord-message-transcript-base";
 import { returnTypeMapper } from "@/core/mappers.js";
-import { authorUrlResolver, messagesUrlResolver } from "@/core/urlResolver.js";
+import { authorUrlResolver, messagesUrlResolver } from "@/assetResolver";
 /**
  * Creates a transcript of a Discord channel's messages.
  * Depending on the `returnType` option, this function can return an `AttachmentBuilder`,

package/dist/renderers/json/json.js

@@ -1,6 +1,5 @@
 import { BaseGuildTextChannel, DMChannel } from "discord.js";
-import { urlResolver } from "@/core/urlResolver.js";
-import { resolveImageURL } from "@/core/resolveImageUrl.js";
+import { imageUrlResolver, urlResolver } from "@/assetResolver";
 export class Json {
     guild;
     channel;
@@ -44,9 +43,9 @@ export class Json {
     async toJson() {
         const channel = await this.channel.fetch();
         const channelImg = channel instanceof DMChannel ? channel.recipient?.displayAvatarURL() ?? "cdn.discordapp.com/embed/avatars/4.png" : channel.isDMBased() ? channel.iconURL() ?? (await channel.fetchOwner()).displayAvatarURL() : null;
-        const safeChannelImg = await resolveImageURL(channelImg, this.options, true);
+        const safeChannelImg = await imageUrlResolver(channelImg, this.options, true);
         const guild = !channel.isDMBased() ? this.guild : null;
-        const guildIcon = guild ? await resolveImageURL(guild.iconURL(), this.options, true) : null;
+        const guildIcon = guild ? await imageUrlResolver(guild.iconURL(), this.options, true) : null;
         const guildJson = !guild ? null : {
             name: guild.name,
             id: guild.id,

package/dist/utils/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(ms: number): Promise<unknown>;

package/dist/utils/sleep.js

@@ -0,0 +1,3 @@
+export function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discord-message-transcript",
-  "version": "1.3.1-dev.1.47",
+  "version": "1.3.1-dev.1.48",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -45,7 +45,7 @@
   },
   "homepage": "https://github.com/HenriqueMairesse/discord-message-transcript#readme",
   "dependencies": {
-    "discord-message-transcript-base": "1.3.1-dev.1.47"
+    "discord-message-transcript-base": "1.3.1-dev.1.48"
   },
   "peerDependencies": {
     "discord.js": ">=14.19.0 <15"

package/dist/core/cdnResolver.d.ts

@@ -1,5 +0,0 @@
-import { CDNOptions, safeUrlReturn } from "@/types";
-import { TranscriptOptionsBase } from "discord-message-transcript-base";
-export declare function cdnResolver(safeUrlObject: safeUrlReturn, options: TranscriptOptionsBase, cdnOptions: CDNOptions): Promise<string>;
-export declare function uploadCareResolver(url: string, publicKey: string, cdnDomain: string, disableWarnings: boolean): Promise<string>;
-export declare function cloudinaryResolver(url: string, fileName: string, cloudName: string, apiKey: string, apiSecret: string, disableWarnings: boolean): Promise<string>;

package/dist/core/cdnResolver.js

@@ -1,213 +0,0 @@
-import { CustomWarn } from "discord-message-transcript-base";
-import crypto from 'crypto';
-import { getCDNLimiter } from "./limiter.js";
-import https from 'https';
-import http from 'http';
-import { createLookup } from "@/networkSecurity";
-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": "discord-message-transcript" },
-                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 cloudinaryResolver(url, options.fileName, cdnOptions.cloudName, cdnOptions.apiKey, cdnOptions.apiSecret, options.disableWarnings);
-            break;
-        }
-        case "UPLOADCARE": {
-            newUrl = await uploadCareResolver(url, cdnOptions.publicKey, cdnOptions.cdnDomain, options.disableWarnings);
-            break;
-        }
-    }
-    if (validateCdnUrl(newUrl, options.disableWarnings))
-        return newUrl;
-    return url;
-}
-function sleep(ms) {
-    return new Promise(r => setTimeout(r, ms));
-}
-export async function uploadCareResolver(url, publicKey, cdnDomain, disableWarnings) {
-    try {
-        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");
-        const res = await fetch("https://upload.uploadcare.com/from_url/", {
-            method: "POST",
-            body: form,
-            headers: {
-                "User-Agent": "discord-message-transcript"
-            }
-        });
-        if (!res.ok) {
-            switch (res.status) {
-                case 400:
-                    throw new Error(`Uploadcare initial request failed with status code ${res.status} - Request failed input parameters validation.`);
-                case 403:
-                    throw new Error(`Uploadcare initial request failed with status code ${res.status} - Request was not allowed.`);
-                case 429:
-                    throw new Error(`Uploadcare initial request failed with status code ${res.status} - Request was throttled.`);
-                default:
-                    throw new Error(`Uploadcare initial request failed with status code ${res.status}`);
-            }
-        }
-        const json = await res.json();
-        if (json.uuid) {
-            return `https://${cdnDomain}/${json.uuid}/`;
-        }
-        let delay = 200;
-        let maxDelay = 2000;
-        if (json.token) {
-            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": "discord-message-transcript" } });
-                if (!resToken.ok)
-                    throw new Error(`Uploadcare status failed with status code ${resToken.status}`);
-                const jsonToken = await resToken.json();
-                if (jsonToken.status === "success" && jsonToken.file_id) {
-                    return `https://${cdnDomain}/${jsonToken.file_id}/`;
-                }
-                if (jsonToken.status === "error") {
-                    throw new Error(jsonToken.error || "Uploadcare failed");
-                }
-            }
-            throw new Error("Uploadcare polling timeout");
-        }
-        return url;
-    }
-    catch (error) {
-        CustomWarn(`Uploadcare CDN upload failed. Using original URL as fallback.
-Check Uploadcare public key, CDN domain, project settings, rate limits, and network access.
-URL: ${url}
-Error: ${error?.message ?? error}`, disableWarnings);
-        return url;
-    }
-}
-export async function cloudinaryResolver(url, fileName, cloudName, apiKey, apiSecret, disableWarnings) {
-    try {
-        const paramsToSign = {
-            folder: `discord-message-transcript/${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);
-        const res = await fetch(`https://api.cloudinary.com/v1_1/${cloudName}/auto/upload`, {
-            method: "POST",
-            body: form,
-            headers: {
-                "User-Agent": "discord-message-transcript"
-            }
-        });
-        if (!res.ok) {
-            switch (res.status) {
-                case 400:
-                    throw new Error(`Cloudinary upload failed with status code ${res.status} - Bad request / invalid params.`);
-                case 403:
-                    throw new Error(`Cloudinary upload failed with status code ${res.status} - Invalid credentials or unauthorized.`);
-                case 429:
-                    throw new Error(`Cloudinary upload failed with status code ${res.status} - Rate limited.`);
-                default:
-                    throw new Error(`Cloudinary upload failed with status code ${res.status}.`);
-            }
-        }
-        const json = await res.json();
-        if (!json.secure_url) {
-            throw new Error("Cloudinary response missing secure_url");
-        }
-        return json.secure_url;
-    }
-    catch (error) {
-        CustomWarn(`Failed to upload asset to Cloudinary CDN. Using original URL as fallback.
-Check Cloudinary configuration (cloud name, API key, API secret) and network access.
-URL: ${url}
-Error: ${error?.message ?? error}`, disableWarnings);
-        return url;
-    }
-}
-// Note: for debug use ${JSON.stringify(await res.json())} to understand the error
-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/resolveImageUrl.d.ts

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

package/dist/core/urlResolver.d.ts

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