discord-message-transcript 1.1.7 → 1.2.0-dev-next.0.16

package/dist/core/cdnResolver.d.ts

@@ -0,0 +1,4 @@
+import { CDNOptions } from "../types/types.js";
+export declare function cdnResolver(url: string, cdnOptions: CDNOptions): Promise<string>;
+export declare function uploadCareResolver(url: string, publicKey: string): Promise<string>;
+export declare function cloudinaryResolver(url: string, cloudName: string, apiKey: string, apiSecret: string): Promise<string>;

package/dist/core/cdnResolver.js

@@ -0,0 +1,178 @@
+import https from 'https';
+import http from 'http';
+import { CustomWarn } from "discord-message-transcript-base";
+import crypto from 'crypto';
+export async function cdnResolver(url, cdnOptions) {
+    return new Promise((resolve, reject) => {
+        const client = url.startsWith('https') ? https : http;
+        const request = client.get(url, { headers: { "User-Agent": "discord-message-transcript" } }, 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 ${url}.`);
+                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}.`);
+                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, 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}`);
+            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}.`);
+            resolve(url);
+        });
+        request.end();
+    });
+}
+async function cdnRedirectType(url, contentType, cdnOptions) {
+    switch (cdnOptions.provider) {
+        case "CUSTOM": {
+            try {
+                return await cdnOptions.resolver(url, contentType, cdnOptions.customData);
+            }
+            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}`);
+                return url;
+            }
+        }
+        case "CLOUDINARY": {
+            return '';
+        }
+        case "UPLOADCARE": {
+            return await uploadCareResolver(url, cdnOptions.publicKey);
+        }
+    }
+}
+function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}
+export async function uploadCareResolver(url, publicKey) {
+    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://ucarecdn.com/${json.uuid}/`;
+        }
+        if (json.token) {
+            for (let i = 0; i < 10; i++) {
+                await sleep(500);
+                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://ucarecdn.com/${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, project settings, rate limits, and network access.
+URL: ${url}
+Error: ${error?.message ?? error}`);
+        return url;
+    }
+}
+export async function cloudinaryResolver(url, cloudName, apiKey, apiSecret) {
+    try {
+        const timestamp = Math.floor(Date.now() / 1000);
+        // signature SHA1
+        const signature = crypto
+            .createHash("sha1")
+            .update(`timestamp=${timestamp}${apiSecret}`)
+            .digest("hex");
+        const form = new FormData();
+        form.append("file", url);
+        form.append("api_key", apiKey);
+        form.append("timestamp", timestamp.toString());
+        form.append("signature", signature);
+        form.append("use_filename", "true");
+        form.append("unique_filename", "false");
+        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}`);
+        return url;
+    }
+}

package/dist/core/componentToJson.d.ts

@@ -1,3 +1,4 @@
 import { TopLevelComponent } from "discord.js";
 import { JsonTopLevelComponent, TranscriptOptionsBase } from "discord-message-transcript-base";
-export declare function componentsToJson(components: TopLevelComponent[], options: TranscriptOptionsBase): Promise<JsonTopLevelComponent[]>;
+import { CDNOptions } from "../types/types.js";
+export declare function componentsToJson(components: TopLevelComponent[], options: TranscriptOptionsBase, cdnOptions: CDNOptions | null): Promise<JsonTopLevelComponent[]>;

package/dist/core/componentToJson.js

@@ -1,9 +1,8 @@
 import { ComponentType } from "discord.js";
 import { mapButtonStyle, mapSelectorType, mapSeparatorSpacing } from "./mappers.js";
 import { JsonComponentType } from "discord-message-transcript-base";
-import { CustomError } from "discord-message-transcript-base";
-import { urlToBase64 } from "./imageToBase64.js";
-export async function componentsToJson(components, options) {
+import { urlResolver } from "./urlResolver.js";
+export async function componentsToJson(components, options, cdnOptions) {
     const processedComponents = await Promise.all(components.filter(component => !(!options.includeV2Components && component.type != ComponentType.ActionRow))
         .map(async (component) => {
         switch (component.type) {
@@ -55,7 +54,7 @@ export async function componentsToJson(components, options) {
             }
             case ComponentType.Container: {
                 const newOptions = { ...options, includeComponents: true, includeButtons: true };
-                const componentsJson = await componentsToJson(component.components, newOptions);
+                const componentsJson = await componentsToJson(component.components, newOptions, cdnOptions);
                 return {
                     type: JsonComponentType.Container,
                     components: componentsJson.filter(isJsonComponentInContainer), // Input components that are container-safe must always produce container-safe output.
@@ -64,38 +63,18 @@ export async function componentsToJson(components, options) {
                 };
             }
             case ComponentType.File: {
-                let fileUrl = component.file.url;
-                if (options.saveImages) {
-                    try {
-                        fileUrl = await urlToBase64(fileUrl);
-                    }
-                    catch (err) {
-                        if (err instanceof CustomError)
-                            console.error(err);
-                    }
-                }
                 return {
                     type: JsonComponentType.File,
                     fileName: component.data.name ?? null,
                     size: component.data.size ?? 0,
-                    url: fileUrl,
+                    url: await urlResolver(component.file.url, options, cdnOptions),
                     spoiler: component.spoiler,
                 };
             }
             case ComponentType.MediaGallery: {
                 const mediaItems = await Promise.all(component.items.map(async (item) => {
-                    let mediaUrl = item.media.url;
-                    if (options.saveImages) {
-                        try {
-                            mediaUrl = await urlToBase64(mediaUrl);
-                        }
-                        catch (err) {
-                            if (err instanceof CustomError)
-                                console.error(err);
-                        }
-                    }
                     return {
-                        media: { url: mediaUrl },
+                        media: { url: await urlResolver(item.media.url, options, cdnOptions) },
                         spoiler: item.spoiler,
                     };
                 }));
@@ -116,25 +95,17 @@ export async function componentsToJson(components, options) {
                         disabled: component.accessory.disabled,
                     };
                 }
-                else {
-                    let thumbnailUrl = component.accessory.media.url;
-                    if (options.saveImages) {
-                        try {
-                            thumbnailUrl = await urlToBase64(thumbnailUrl);
-                        }
-                        catch (err) {
-                            if (err instanceof CustomError)
-                                console.error(err);
-                        }
-                    }
+                else if (component.accessory.type === ComponentType.Thumbnail) {
                     accessoryJson = {
                         type: JsonComponentType.Thumbnail,
                         media: {
-                            url: thumbnailUrl,
+                            url: await urlResolver(component.accessory.media.url, options, cdnOptions),
                         },
                         spoiler: component.accessory.spoiler,
                     };
                 }
+                else
+                    return null;
                 const sectionComponents = component.components.map(c => ({
                     type: JsonComponentType.TextDisplay,
                     content: c.content,

package/dist/core/fetchMessages.d.ts

@@ -1,8 +1,7 @@
 import { TextBasedChannel } from "discord.js";
 import { JsonAuthor, JsonMessage, TranscriptOptionsBase } from "discord-message-transcript-base";
-import { MapMentions } from "../types/types.js";
-export declare function fetchMessages(channel: TextBasedChannel, options: TranscriptOptionsBase, authors: Map<string, JsonAuthor>, mentions: MapMentions, before?: string): Promise<{
+import { CDNOptions, MapMentions } from "../types/types.js";
+export declare function fetchMessages(channel: TextBasedChannel, options: TranscriptOptionsBase, cdnOptions: CDNOptions | null, authors: Map<string, JsonAuthor>, mentions: MapMentions, after?: string): Promise<{
     messages: JsonMessage[];
     end: boolean;
-    lastMessageId?: string;
 }>;

package/dist/core/fetchMessages.js

@@ -1,85 +1,28 @@
 import { EmbedType } from "discord.js";
 import { componentsToJson } from "./componentToJson.js";
-import { urlToBase64 } from "./imageToBase64.js";
-import { CustomError } from "discord-message-transcript-base";
+import { urlResolver } from "./urlResolver.js";
 import { getMentions } from "./getMentions.js";
-export async function fetchMessages(channel, options, authors, mentions, before) {
-    const originalMessages = await channel.messages.fetch({ limit: 100, cache: false, before: before });
+export async function fetchMessages(channel, options, cdnOptions, authors, mentions, after) {
+    const originalMessages = await channel.messages.fetch({ limit: 100, cache: false, after: after });
     const rawMessages = await Promise.all(originalMessages.map(async (message) => {
-        let authorAvatar = message.author.displayAvatarURL();
-        if (options.saveImages) {
-            try {
-                authorAvatar = await urlToBase64(authorAvatar);
-            }
-            catch (err) {
-                if (err instanceof CustomError)
-                    console.error(err);
-            }
-        }
         const attachments = await Promise.all(message.attachments.map(async (attachment) => {
-            let attachmentUrl = attachment.url;
-            if (options.saveImages && attachment.contentType?.startsWith('image/')) {
-                try {
-                    attachmentUrl = await urlToBase64(attachment.url);
-                }
-                catch (err) {
-                    if (err instanceof CustomError)
-                        console.error(err);
-                }
-            }
             return {
                 contentType: attachment.contentType,
                 name: attachment.name,
                 size: attachment.size,
                 spoiler: attachment.spoiler,
-                url: attachmentUrl,
+                url: await urlResolver(attachment.url, options, cdnOptions),
             };
         }));
         // This only works because embeds with the type poll_result that are send when a poll end are marked as a message send by the system  
         const embeds = message.system && message.embeds.length == 1 && message.embeds[0].data.type == EmbedType.PollResult && !options.includePolls ? []
             : await Promise.all(message.embeds.map(async (embed) => {
-                let authorIcon = embed.author?.iconURL ?? null;
-                let thumbnailUrl = embed.thumbnail?.url ?? null;
-                let imageUrl = embed.image?.url ?? null;
-                let footerIcon = embed.footer?.iconURL ?? null;
-                if (options.saveImages) {
-                    if (authorIcon) {
-                        try {
-                            authorIcon = await urlToBase64(authorIcon);
-                        }
-                        catch (err) {
-                            if (err instanceof CustomError)
-                                console.error(err);
-                        }
-                    }
-                    if (thumbnailUrl) {
-                        try {
-                            thumbnailUrl = await urlToBase64(thumbnailUrl);
-                        }
-                        catch (err) {
-                            if (err instanceof CustomError)
-                                console.error(err);
-                        }
-                    }
-                    if (imageUrl) {
-                        try {
-                            imageUrl = await urlToBase64(imageUrl);
-                        }
-                        catch (err) {
-                            if (err instanceof CustomError)
-                                console.error(err);
-                        }
-                    }
-                    if (footerIcon) {
-                        try {
-                            footerIcon = await urlToBase64(footerIcon);
-                        }
-                        catch (err) {
-                            if (err instanceof CustomError)
-                                console.error(err);
-                        }
-                    }
-                }
+                const [authorIcon, thumbnailUrl, imageUrl, footerIcon] = await Promise.all([
+                    embed.author?.iconURL ? urlResolver(embed.author.iconURL, options, cdnOptions) : Promise.resolve(null),
+                    embed.thumbnail?.url ? urlResolver(embed.thumbnail.url, options, cdnOptions) : Promise.resolve(null),
+                    embed.image?.url ? urlResolver(embed.image.url, options, cdnOptions) : Promise.resolve(null),
+                    embed.footer?.iconURL ? urlResolver(embed.footer.iconURL, options, cdnOptions) : Promise.resolve(null),
+                ]);
                 return {
                     author: embed.author ? { name: embed.author.name, url: embed.author.url ?? null, iconURL: authorIcon } : null,
                     description: embed.description ?? null,
@@ -96,7 +39,7 @@ export async function fetchMessages(channel, options, authors, mentions, before)
             }));
         if (!authors.has(message.author.id)) {
             authors.set(message.author.id, {
-                avatarURL: authorAvatar,
+                avatarURL: await urlResolver(message.author.displayAvatarURL(), options, cdnOptions),
                 bot: message.author.bot,
                 displayName: message.author.displayName,
                 guildTag: message.author.primaryGuild?.tag ?? null,
@@ -108,7 +51,7 @@ export async function fetchMessages(channel, options, authors, mentions, before)
                 system: message.author.system,
             });
         }
-        const components = await componentsToJson(message.components, options);
+        const components = await componentsToJson(message.components, options, cdnOptions);
         await getMentions(message, mentions);
         return {
             attachments: options.includeAttachments ? attachments : [],
@@ -146,10 +89,9 @@ export async function fetchMessages(channel, options, authors, mentions, before)
             system: message.system,
         };
     }));
-    const lastMessageId = originalMessages.last()?.id;
     const messages = rawMessages.filter(m => !(!options.includeEmpty && m.attachments.length == 0 && m.components.length == 0 && m.content == "" && m.embeds.length == 0 && !m.poll));
     const end = originalMessages.size !== 100;
-    return { messages, end, lastMessageId };
+    return { messages, end };
 }
 function formatTimeLeftPoll(timestamp) {
     const now = new Date();

package/dist/core/imageToBase64.d.ts

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

package/dist/core/imageToBase64.js

@@ -1,16 +1,20 @@
 import https from 'https';
-import { CustomError } from 'discord-message-transcript-base';
-export async function urlToBase64(url) {
+import http from 'http';
+import { CustomWarn } from 'discord-message-transcript-base';
+export async function imageToBase64(url) {
     return new Promise((resolve, reject) => {
-        const request = https.get(url, (response) => {
+        const client = url.startsWith('https') ? https : http;
+        const request = client.get(url, { headers: { "User-Agent": "discord-message-transcript" } }, (response) => {
             if (response.statusCode !== 200) {
-                reject(new CustomError(`Failed to fetch image with status code: ${response.statusCode} from ${url}`));
-                return;
+                response.destroy();
+                CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of converting to base64.
+Failed to fetch image with status code: ${response.statusCode} from ${url}.`);
+                return resolve(url);
             }
             const contentType = response.headers['content-type'];
-            if (!contentType || !contentType.startsWith('image/')) {
-                reject(new CustomError(`URL did not point to an image. Content-Type: ${contentType} from ${url}`));
-                return;
+            if (!contentType || !contentType.startsWith('image/') || contentType === 'image/gif') {
+                response.destroy();
+                return resolve(url);
             }
             const chunks = [];
             response.on('data', (chunk) => {
@@ -21,9 +25,24 @@ export async function urlToBase64(url) {
                 const base64 = buffer.toString('base64');
                 resolve(`data:${contentType};base64,${base64}`);
             });
+            response.on('error', (err) => {
+                CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of converting to base64.
+Stream error while fetching from ${url}.
+Error: ${err.message}`);
+                resolve(url);
+            });
         });
         request.on('error', (err) => {
-            reject(new CustomError(`Error fetching image from ${url}: ${err.message}`));
+            CustomWarn(`This is not an issue with the package. Using the original URL as fallback instead of converting to base64.
+Error fetching image from ${url}
+Error: ${err.message}`);
+            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 converting to base64.
+Request timeout for ${url}.`);
+            resolve(url);
         });
         request.end();
     });

package/dist/core/output.js

@@ -1,5 +1,5 @@
 import { Readable } from 'stream';
-import { outputBase } from "discord-message-transcript-base";
+import { outputBase, CustomError } from "discord-message-transcript-base";
 export async function output(json) {
     const stringJSON = JSON.stringify(json);
     if (json.options.returnFormat == "JSON") {
@@ -24,5 +24,5 @@ export async function output(json) {
     if (json.options.returnFormat == "HTML") {
         return await outputBase(json);
     }
-    throw new Error("Return format or return type invalid!");
+    throw new CustomError("Return format or return type invalid!");
 }

package/dist/core/urlResolver.d.ts

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

package/dist/core/urlResolver.js

@@ -0,0 +1,9 @@
+import { cdnResolver } from "./cdnResolver.js";
+import { imageToBase64 } from "./imageToBase64.js";
+export async function urlResolver(url, options, cdnOptions) {
+    if (cdnOptions)
+        return await cdnResolver(url, cdnOptions);
+    if (options.saveImages)
+        return await imageToBase64(url);
+    return url;
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { CreateTranscriptOptions, ConvertTranscriptOptions, TranscriptOptions, ReturnType } from "./types/types.js";
+export { CreateTranscriptOptions, ConvertTranscriptOptions, TranscriptOptions, ReturnType, CDNOptions, MimeType } from "./types/types.js";
 export { ReturnFormat, LocalDate, TimeZone } from "discord-message-transcript-base";
 import { TextBasedChannel } from "discord.js";
 import { ConvertTranscriptOptions, CreateTranscriptOptions, OutputType, ReturnType } from "./types/types.js";

package/dist/index.js

@@ -55,9 +55,9 @@ export async function createTranscript(channel, options = {}) {
             users: new Map(),
         };
         while (true) {
-            const { messages, end, lastMessageId } = await fetchMessages(channel, internalOptions, authors, mentions, lastMessageID);
+            const { messages, end } = await fetchMessages(channel, internalOptions, options.cdnOptions ?? null, authors, mentions, lastMessageID);
             jsonTranscript.addMessages(messages);
-            lastMessageID = lastMessageId;
+            lastMessageID = messages[messages.length - 1]?.id;
             if (end || (jsonTranscript.messages.length >= quantity && quantity != 0)) {
                 break;
             }

package/dist/types/types.d.ts

@@ -33,7 +33,11 @@ export type ConvertTranscriptOptions<T extends ReturnType> = Partial<{
      */
     watermark: boolean;
 }>;
-export interface TranscriptOptions<T extends ReturnType> {
+export interface TranscriptOptions<T extends ReturnType, Other = unknown> {
+    /**
+     * CDN Options
+     */
+    cdnOptions: CDNOptions;
     /**
      * The name of the file to be created.
      * Default depends if is DM or Guild
@@ -135,3 +139,26 @@ export interface MapMentions {
     roles: Map<string, JsonMessageMentionsRoles>;
     users: Map<string, JsonMessageMentionsUsers>;
 }
+export type MimeType = `${string}/${string}`;
+export type CDNBase = Partial<{
+    includeAudio: boolean;
+    includeImage: boolean;
+    includeVideo: boolean;
+    includeOthers: boolean;
+}>;
+export type CDNOptions = (CDNBase & CDNOptionsCustom<any>) | (CDNBase & CDNOptionsCloudinary) | (CDNBase & CDNOptionsUploadcare);
+export type CDNOptionsCustom<T = unknown> = {
+    provider: "CUSTOM";
+    resolver: (url: string, contentType: MimeType | null, customData: T) => Promise<string> | string;
+    customData: T;
+};
+export type CDNOptionsCloudinary = {
+    provider: "CLOUDINARY";
+    cloudName: string;
+    apiKey: string;
+    apiSecret: string;
+};
+export type CDNOptionsUploadcare = {
+    provider: "UPLOADCARE";
+    publicKey: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discord-message-transcript",
-  "version": "1.1.7",
+  "version": "1.2.0-dev-next.0.16",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,11 +48,14 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "discord-message-transcript-base": "^1.1.7"
+    "discord-message-transcript-base": "1.2.0-dev-next.0.16"
   },
   "peerDependencies": {
     "discord.js": ">=14.19.0 <15"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "tsc"