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

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/core/{componentToJson.d.ts → discordParser/componentToJson.d.ts}

@@ -1,4 +1,4 @@
 import { TopLevelComponent } from "discord.js";
-import { JsonTopLevelComponent, JsonComponentInContainer, TranscriptOptionsBase } from "discord-message-transcript-base";
+import { JsonTopLevelComponent, TranscriptOptionsBase, JsonComponentInContainer } from "discord-message-transcript-base";
 export declare function componentsToJson(components: TopLevelComponent[], options: TranscriptOptionsBase): Promise<JsonTopLevelComponent[]>;
 export declare function isJsonComponentInContainer(component: JsonTopLevelComponent): component is JsonComponentInContainer;

package/dist/core/discordParser/componentToJson.js

@@ -0,0 +1,159 @@
+import { ComponentType } from "discord.js";
+import { mapButtonStyle, mapSelectorType, mapSeparatorSpacing } from "../mappers.js";
+import { JsonComponentType } from "discord-message-transcript-base";
+import { isValidHexColor } from "discord-message-transcript-base";
+export async function componentsToJson(components, options) {
+    const filtered = components.filter(c => options.includeV2Components || c.type === ComponentType.ActionRow);
+    const processed = await Promise.all(filtered.map(c => convertComponent(c, options)));
+    return processed.filter(c => c != null);
+}
+async function convertComponent(component, options) {
+    switch (component.type) {
+        case ComponentType.ActionRow:
+            return convertActionRow(component, options);
+        case ComponentType.Container:
+            return convertContainer(component, options);
+        case ComponentType.File:
+            return convertFile(component);
+        case ComponentType.MediaGallery:
+            return convertMediaGallery(component);
+        case ComponentType.Section:
+            return convertSection(component);
+        case ComponentType.Separator:
+            return convertSeparator(component);
+        case ComponentType.TextDisplay:
+            return convertTextDisplay(component);
+        default:
+            return null;
+    }
+}
+async function convertActionRow(component, options) {
+    const rowComponents = await Promise.all(component.components
+        .filter(c => (c.type === ComponentType.Button ? options.includeButtons : options.includeComponents))
+        .map(c => convertActionRowChild(c)));
+    if (rowComponents.length === 0)
+        return null;
+    return { type: JsonComponentType.ActionRow, components: rowComponents };
+}
+async function convertActionRowChild(component) {
+    switch (component.type) {
+        case ComponentType.Button: {
+            return {
+                type: JsonComponentType.Button,
+                style: mapButtonStyle(component.style),
+                label: component.label,
+                emoji: component.emoji?.name ?? null,
+                url: component.url,
+                disabled: component.disabled,
+            };
+        }
+        case ComponentType.StringSelect: {
+            return {
+                type: JsonComponentType.StringSelect,
+                placeholder: component.placeholder,
+                disabled: component.disabled,
+                options: component.options.map(option => ({
+                    label: option.label,
+                    description: option.description ?? null,
+                    emoji: option.emoji ? { id: option.emoji.id ?? null, name: option.emoji.name ?? null, animated: option.emoji.animated ?? false } : null,
+                })),
+            };
+        }
+        default: {
+            return {
+                type: mapSelectorType(component.type),
+                placeholder: component.placeholder,
+                disabled: component.disabled,
+            };
+        }
+    }
+}
+async function convertContainer(component, options) {
+    const newOptions = { ...options, includeComponents: true, includeButtons: true };
+    const componentsJson = await componentsToJson(component.components, newOptions);
+    return {
+        type: JsonComponentType.Container,
+        components: componentsJson.filter(isJsonComponentInContainer), // Input components that are container-safe must always produce container-safe output.
+        hexAccentColor: isValidHexColor(component.hexAccentColor, false),
+        spoiler: component.spoiler,
+    };
+}
+function convertFile(component) {
+    return {
+        type: JsonComponentType.File,
+        fileName: component.data.name ?? null,
+        size: component.data.size ?? 0,
+        url: component.file.url,
+        spoiler: component.spoiler,
+    };
+}
+async function convertMediaGallery(component) {
+    const mediaItems = await Promise.all(component.items.map(item => {
+        return {
+            media: { url: item.media.url },
+            spoiler: item.spoiler,
+        };
+    }));
+    return {
+        type: JsonComponentType.MediaGallery,
+        items: mediaItems,
+    };
+}
+function convertSection(component) {
+    let accessoryJson = null;
+    switch (component.accessory.type) {
+        case ComponentType.Button: {
+            accessoryJson = {
+                type: JsonComponentType.Button,
+                style: mapButtonStyle(component.accessory.style),
+                label: component.accessory.label,
+                emoji: component.accessory.emoji?.name ? component.accessory.emoji.name : null,
+                url: component.accessory.url,
+                disabled: component.accessory.disabled,
+            };
+            break;
+        }
+        case ComponentType.Thumbnail: {
+            accessoryJson = {
+                type: JsonComponentType.Thumbnail,
+                media: {
+                    url: component.accessory.media.url,
+                },
+                spoiler: component.accessory.spoiler,
+            };
+            break;
+        }
+        default:
+            break;
+    }
+    const sectionComponents = component.components.map(c => ({
+        type: JsonComponentType.TextDisplay,
+        content: c.content,
+    }));
+    return {
+        type: JsonComponentType.Section,
+        accessory: accessoryJson,
+        components: sectionComponents,
+    };
+}
+function convertSeparator(component) {
+    return {
+        type: JsonComponentType.Separator,
+        spacing: mapSeparatorSpacing(component.spacing),
+        divider: component.divider,
+    };
+}
+function convertTextDisplay(component) {
+    return {
+        type: JsonComponentType.TextDisplay,
+        content: component.content,
+    };
+}
+export function isJsonComponentInContainer(component) {
+    return (component.type == JsonComponentType.ActionRow ||
+        component.type == JsonComponentType.File ||
+        component.type == JsonComponentType.MediaGallery ||
+        component.type == JsonComponentType.Section ||
+        component.type == JsonComponentType.Separator ||
+        component.type == JsonComponentType.TextDisplay);
+}

package/dist/core/discordParser/fetchMessages.d.ts

@@ -0,0 +1,7 @@
+import { JsonMessage } from "discord-message-transcript-base";
+import { FetchMessagesContext } from "@/types";
+export declare function fetchMessages(ctx: FetchMessagesContext): Promise<{
+    messages: JsonMessage[];
+    end: boolean;
+    newLastMessageId: string | undefined;
+}>;

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

@@ -0,0 +1,4 @@
+import { CDNOptions, ReturnDiscordParser } from "@/types/types.js";
+import { TranscriptOptionsBase } from "discord-message-transcript-base";
+import { TextBasedChannel } from "discord.js";
+export declare function discordParser(channel: TextBasedChannel, options: TranscriptOptionsBase, cdnOptions: CDNOptions | null): Promise<ReturnDiscordParser>;

package/dist/core/discordParser/index.js

@@ -0,0 +1,33 @@
+import { fetchMessages } from "./fetchMessages.js";
+import { Json } from "@/renderers/json/json.js";
+export async function discordParser(channel, options, cdnOptions) {
+    const urlCache = new Map();
+    const authors = new Map();
+    const mentions = {
+        channels: new Map(),
+        roles: new Map(),
+        users: new Map(),
+    };
+    const fetchMessageParameter = {
+        channel: channel,
+        options: options,
+        transcriptState: {
+            authors: authors,
+            mentions: mentions,
+        },
+        lastMessageId: undefined
+    };
+    const jsonTranscript = channel.isDMBased() ? new Json(null, channel, options, cdnOptions, urlCache) : new Json(channel.guild, channel, options, cdnOptions, urlCache);
+    while (true) {
+        const { messages, end, newLastMessageId } = await fetchMessages(fetchMessageParameter);
+        jsonTranscript.addMessages(messages);
+        fetchMessageParameter.lastMessageId = newLastMessageId;
+        if (end || (jsonTranscript.getMessages().length >= options.quantity && options.quantity != 0)) {
+            break;
+        }
+    }
+    if (options.quantity > 0 && jsonTranscript.getMessages().length > options.quantity) {
+        jsonTranscript.sliceMessages(options.quantity);
+    }
+    return [jsonTranscript, { ...fetchMessageParameter.transcriptState, urlCache }];
+}

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,14 +1,13 @@
 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";
 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 { jsonAssetResolver } from "@/assetResolver";
+import { discordParser } from "./core/discordParser/index.js";
 /**
  * Creates a transcript of a Discord channel's messages.
  * Depending on the `returnType` option, this function can return an `AttachmentBuilder`,
@@ -55,60 +54,18 @@ export async function createTranscript(channel, options = {}) {
             timeZone,
             watermark
         };
-        const urlCache = new Map();
-        const authors = new Map();
-        const mentions = {
-            channels: new Map(),
-            roles: new Map(),
-            users: new Map(),
-        };
-        const fetchMessageParameter = {
-            channel: channel,
-            options: internalOptions,
-            transcriptState: {
-                authors: authors,
-                mentions: mentions,
-            },
-            lastMessageId: undefined
-        };
-        const jsonTranscript = channel.isDMBased() ? new Json(null, channel, internalOptions, options.cdnOptions ?? null, urlCache) : new Json(channel.guild, channel, internalOptions, options.cdnOptions ?? null, urlCache);
-        while (true) {
-            const { messages, end, newLastMessageId } = await fetchMessages(fetchMessageParameter);
-            jsonTranscript.addMessages(messages);
-            fetchMessageParameter.lastMessageId = newLastMessageId;
-            if (end || (jsonTranscript.getMessages().length >= quantity && quantity != 0)) {
-                break;
-            }
-        }
-        if (quantity > 0 && jsonTranscript.getMessages().length > quantity) {
-            jsonTranscript.sliceMessages(quantity);
-        }
-        if (options.cdnOptions) {
-            options.cdnOptions = {
+        const cdnOptions = options.cdnOptions ?
+            {
                 includeAudio: true,
                 includeImage: true,
                 includeVideo: true,
                 includeOthers: true,
                 ...options.cdnOptions
-            };
-        }
-        await Promise.all([
-            (async () => {
-                jsonTranscript.setAuthors(await authorUrlResolver(authors, internalOptions, options.cdnOptions ?? null, urlCache));
-                authors.clear();
-            })(),
-            (() => {
-                jsonTranscript.setMentions({ channels: Array.from(mentions.channels.values()), roles: Array.from(mentions.roles.values()), users: Array.from(mentions.users.values()) });
-                mentions.channels.clear();
-                mentions.roles.clear();
-                mentions.users.clear();
-            })(),
-            (async () => {
-                jsonTranscript.setMessages(await messagesUrlResolver(jsonTranscript.getMessages(), internalOptions, options.cdnOptions ?? null, urlCache));
-            })()
-        ]);
+            } : null;
+        const [jsonTranscript, maps] = await discordParser(channel, internalOptions, cdnOptions);
+        await jsonAssetResolver(jsonTranscript, maps, internalOptions, cdnOptions);
         const outputJson = await jsonTranscript.toJson();
-        urlCache.clear();
+        maps.urlCache.clear();
         const result = await output(outputJson);
         if (!options.returnType || options.returnType == "attachment") {
             if (!(result instanceof Buffer)) {

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/types/types.d.ts

@@ -1,5 +1,6 @@
-import { JsonMessageMentionsChannels, JsonMessageMentionsRoles, JsonMessageMentionsUsers, LocalDate, TimeZone, Uploadable, ReturnFormat } from "discord-message-transcript-base";
-import { AttachmentBuilder } from "discord.js";
+import { Json } from "@/renderers/json/json.js";
+import { JsonMessageMentionsChannels, JsonMessageMentionsRoles, JsonMessageMentionsUsers, LocalDate, TimeZone, Uploadable, ReturnFormat, TranscriptOptionsBase, JsonAuthor } from "discord-message-transcript-base";
+import { AttachmentBuilder, TextBasedChannel } from "discord.js";
 import Stream from 'stream';
 /**
  * An enum-like object providing the possible return types for the transcript functions.
@@ -298,3 +299,24 @@ export interface safeUrlReturn {
     safeIps: string[];
     url: string;
 }
+export type FetchMessagesContext = {
+    channel: TextBasedChannel;
+    options: TranscriptOptionsBase;
+    transcriptState: TranscriptState;
+    lastMessageId: string | undefined;
+};
+export type TranscriptState = {
+    authors: Map<string, JsonAuthor>;
+    mentions: MapMentions;
+};
+export type ReturnDiscordParser = [
+    json: Json,
+    maps: Maps
+];
+export type MapAuthors = Map<string, JsonAuthor>;
+export type MapCache = Map<string, Promise<string>>;
+export type Maps = {
+    authors: MapAuthors;
+    mentions: MapMentions;
+    urlCache: MapCache;
+};

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",
+  "version": "1.3.2-dev.0.49",
   "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"
+    "discord-message-transcript-base": "1.3.2-dev.0.49"
   },
   "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;
-}