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

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

@@ -0,0 +1,4 @@
+import { TranscriptOptionsBase } from "discord-message-transcript-base/internal";
+import { safeUrlReturn } from "../../../types/private/network.js";
+import { CDNOptions } from "../../../types/private/cdn.js";
+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/internal";
+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/internal";
 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,158 @@
+import { ComponentType } from "discord.js";
+import { mapButtonStyle, mapSelectorType, mapSeparatorSpacing } from "../mappers.js";
+import { JsonComponentType, isValidHexColor } from "discord-message-transcript-base/internal";
+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/internal";
+import { FetchMessagesContext } from "../../types/private/discordParser.js";
+export declare function fetchMessages(ctx: FetchMessagesContext): Promise<{
+    messages: JsonMessage[];
+    end: boolean;
+    newLastMessageId: string | undefined;
+}>;

package/dist/core/{fetchMessages.js → discordParser/fetchMessages.js}

@@ -1,6 +1,6 @@
 import { EmbedType } from "discord.js";
 import { componentsToJson } from "./componentToJson.js";
-import { isValidHexColor, sanitize } from "discord-message-transcript-base";
+import { isValidHexColor, sanitize } from "discord-message-transcript-base/internal";
 import { getMentions } from "./getMentions.js";
 export async function fetchMessages(ctx) {
     const { channel, options, transcriptState, lastMessageId } = ctx;

package/dist/core/{getMentions.d.ts → discordParser/getMentions.d.ts}

@@ -1,3 +1,3 @@
 import { Message } from "discord.js";
-import { MapMentions } from "@/types";
+import { MapMentions } from "../../types/private/maps.js";
 export declare function getMentions(message: Message, mentions: MapMentions): Promise<void>;

package/dist/core/{getMentions.js → discordParser/getMentions.js}

@@ -1,5 +1,5 @@
 import { ChannelType } from "discord.js";
-import { isValidHexColor, sanitize } from "discord-message-transcript-base";
+import { isValidHexColor, sanitize } from "discord-message-transcript-base/internal";
 export async function getMentions(message, mentions) {
     message.mentions.channels.forEach(channel => {
         if (!mentions.channels.has(channel.id)) {

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

@@ -0,0 +1,5 @@
+import { TranscriptOptionsBase } from "discord-message-transcript-base/internal";
+import { TextBasedChannel } from "discord.js";
+import { ReturnDiscordParser } from "../../types/private/discordParser.js";
+import { CDNOptions } from "../../types/private/cdn.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/core/mappers.d.ts

@@ -1,6 +1,7 @@
 import { ButtonStyle, ComponentType, SeparatorSpacingSize } from "discord.js";
-import { JsonButtonStyle, JsonComponentType, JsonSeparatorSpacingSize, ReturnTypeBase } from "discord-message-transcript-base";
-import { ReturnType } from "@/types";
+import { JsonButtonStyle, JsonComponentType, JsonSeparatorSpacingSize } from "discord-message-transcript-base/internal";
+import { ReturnType } from "../types/public/return.js";
+import { ReturnType as ReturnTypeBase } from "discord-message-transcript-base";
 export declare function mapButtonStyle(style: ButtonStyle): JsonButtonStyle;
 export declare function mapSeparatorSpacing(spacing: SeparatorSpacingSize): JsonSeparatorSpacingSize;
 export declare function mapComponentType(componentType: ComponentType): JsonComponentType;

package/dist/core/mappers.js

@@ -1,6 +1,7 @@
 import { ButtonStyle, ComponentType, SeparatorSpacingSize } from "discord.js";
-import { CustomError, JsonButtonStyle, JsonComponentType, JsonSeparatorSpacingSize, ReturnTypeBase } from "discord-message-transcript-base";
-import { ReturnType } from "@/types";
+import { CustomError, JsonButtonStyle, JsonComponentType, JsonSeparatorSpacingSize } from "discord-message-transcript-base/internal";
+import { ReturnType } from "../types/public/return.js";
+import { ReturnType as ReturnTypeBase } from "discord-message-transcript-base";
 export function mapButtonStyle(style) {
     switch (style) {
         case ButtonStyle.Primary:

package/dist/core/networkSecurity/dns.d.ts

@@ -1,2 +1,2 @@
-import { LookupResult } from "@/types";
+import { LookupResult } from "../../types/private/network.js";
 export declare function resolveAllIps(host: string): Promise<LookupResult[]>;

package/dist/core/networkSecurity/urlSafety.d.ts

@@ -1,3 +1,3 @@
-import { TranscriptOptionsBase } from "discord-message-transcript-base";
-import { safeUrlReturn } from "@/types";
+import { TranscriptOptionsBase } from "discord-message-transcript-base/internal";
+import { safeUrlReturn } from "../../types/private/network.js";
 export declare function isSafeForHTML(url: string, options: TranscriptOptionsBase): Promise<safeUrlReturn>;

package/dist/core/networkSecurity/urlSafety.js

@@ -1,4 +1,4 @@
-import { CustomWarn } from "discord-message-transcript-base";
+import { CustomWarn } from "discord-message-transcript-base/internal";
 import { TRUSTED_DISCORD_HOSTS } from "./constants.js";
 import { isPrivateIp } from "./ip.js";
 import { resolveAllIps } from "./dns.js";

package/dist/core/output.d.ts

@@ -1,4 +1,4 @@
 import { AttachmentBuilder } from "discord.js";
 import Stream from 'stream';
-import { JsonData, Uploadable } from "discord-message-transcript-base";
+import { JsonData, Uploadable } from "discord-message-transcript-base/internal";
 export declare function output(json: JsonData): Promise<string | Stream | AttachmentBuilder | Buffer | Uploadable>;

package/dist/core/output.js

@@ -1,5 +1,5 @@
 import { Readable } from 'stream';
-import { outputBase, CustomError } from "discord-message-transcript-base";
+import { outputBase, CustomError } from "discord-message-transcript-base/internal";
 export async function output(json) {
     const stringJSON = JSON.stringify(json);
     if (json.options.returnFormat == "JSON") {

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-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 * from "./types/index.js";
+export { setBase64Concurrency, setCDNConcurrency } from './core/assetResolver/index.js';
 import { TextBasedChannel } from "discord.js";
-import { ConvertTranscriptOptions, CreateTranscriptOptions, OutputType, ReturnType } from "@/types";
+import { OutputType, ReturnType } from "./types/public/return.js";
+import { ConvertTranscriptOptions, CreateTranscriptOptions } from "./types/public/createAndConvertTranscript.js";
 /**
  * Creates a transcript of a Discord channel's messages.
  * Depending on the `returnType` option, this function can return an `AttachmentBuilder`,

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 * from "./types/index.js";
+export { setBase64Concurrency, setCDNConcurrency } from './core/assetResolver/index.js';
 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 { output } from "./core/output.js";
+import { ReturnFormat, outputBase, CustomError, CustomWarn } from "discord-message-transcript-base/internal";
+import { ReturnType as ReturnTypeBase } from "discord-message-transcript-base";
+import { returnTypeMapper } from "./core/mappers.js";
+import { jsonAssetResolver } from "./core/assetResolver/index.js";
+import { discordParser } from "./core/discordParser/index.js";
+import { ReturnType } from "./types/public/return.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.d.ts

@@ -1,6 +1,6 @@
 import { Guild, TextBasedChannel } from "discord.js";
-import { ArrayMentions, JsonAuthor, JsonMessage, TranscriptOptionsBase, JsonData } from "discord-message-transcript-base";
-import { CDNOptions } from "@/types";
+import { ArrayMentions, JsonAuthor, JsonMessage, TranscriptOptionsBase, JsonData } from "discord-message-transcript-base/internal";
+import { CDNOptions } from "../../types/private/cdn.js";
 export declare class Json {
     private guild;
     private channel;

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 "../../core/assetResolver/index.js";
 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/index.d.ts

@@ -0,0 +1,3 @@
+export { ReturnFormat } from "discord-message-transcript-base/internal";
+export * from "./public/return.js";
+export * from "./public/createAndConvertTranscript.js";

package/dist/types/index.js

@@ -0,0 +1,3 @@
+export { ReturnFormat } from "discord-message-transcript-base/internal";
+export * from "./public/return.js";
+export * from "./public/createAndConvertTranscript.js";

package/dist/types/private/cdn.d.ts

@@ -0,0 +1,89 @@
+import { MimeType } from "./others.js";
+/**
+ * Base options applicable to all CDN providers.
+ */
+export type CDNBase = Partial<{
+    /**
+     * Whether to upload audio files to the CDN.
+     * @default true
+     */
+    includeAudio: boolean;
+    /**
+     * Whether to upload image files (excluding GIFs) to the CDN.
+     * @default true
+     */
+    includeImage: boolean;
+    /**
+     * Whether to upload video files (and GIFs) to the CDN.
+     * @default true
+     */
+    includeVideo: boolean;
+    /**
+     * Whether to upload any other file types to the CDN.
+     * @default true
+     */
+    includeOthers: boolean;
+}>;
+/**
+ * A discriminated union of all possible CDN configurations.
+ */
+export type CDNOptions = (CDNBase & CDNOptionsCustom<any>) | (CDNBase & CDNOptionsCloudinary) | (CDNBase & CDNOptionsUploadcare);
+/**
+ * Configuration for using a custom, user-provided CDN resolver function.
+ */
+export type CDNOptionsCustom<T = unknown> = {
+    /** Specifies the use of a custom CDN resolver. */
+    provider: "CUSTOM";
+    /**
+     * An async function that takes a URL and returns a new URL.
+     * @param url The original Discord asset URL.
+     * @param contentType The MIME type of the asset.
+     * @param customData Any additional data you want to pass to your resolver.
+     * @returns The new URL of the asset on your CDN.
+     */
+    resolver: (url: string, contentType: MimeType | null, customData: T) => Promise<string> | string;
+    /**
+     * Any custom data you wish to make available within your resolver function.
+     */
+    customData: T;
+};
+/**
+ * Configuration for using Cloudinary as the CDN.
+ */
+export type CDNOptionsCloudinary = {
+    /**
+     * Specifies the use of the built-in Cloudinary provider.
+     */
+    provider: "CLOUDINARY";
+    /**
+     * Your Cloudinary cloud name.
+     */
+    cloudName: string;
+    /**
+     * Your Cloudinary API key.
+     * */
+    apiKey: string;
+    /**
+     * Your Cloudinary API secret.
+    */
+    apiSecret: string;
+};
+/**
+ * Configuration for using Uploadcare as the CDN.
+ */
+export type CDNOptionsUploadcare = {
+    /**
+     * Specifies the use of the built-in Uploadcare provider.
+     */
+    provider: "UPLOADCARE";
+    /**
+     * Your Uploadcare public key.
+     */
+    publicKey: string;
+    /**
+     * Your Uploadcare CDN domain.
+     * Example: "aaa111aaa1.ucarecd.net".
+     * DO NOT INCLUDE https://
+     */
+    cdnDomain: string;
+};

package/dist/types/private/cdn.js

@@ -0,0 +1 @@
+export {};

package/dist/types/private/discordParser.d.ts

@@ -0,0 +1,18 @@
+import { Json } from "../../renderers/json/json.js";
+import { MapMentions, Maps } from "./maps.js";
+import { TextBasedChannel } from "discord.js";
+import { JsonAuthor, TranscriptOptionsBase } from "discord-message-transcript-base/internal";
+export type ReturnDiscordParser = [
+    json: Json,
+    maps: Maps
+];
+export type FetchMessagesContext = {
+    channel: TextBasedChannel;
+    options: TranscriptOptionsBase;
+    transcriptState: TranscriptState;
+    lastMessageId: string | undefined;
+};
+export type TranscriptState = {
+    authors: Map<string, JsonAuthor>;
+    mentions: MapMentions;
+};

package/dist/types/private/discordParser.js

@@ -0,0 +1 @@
+export {};

package/dist/types/private/maps.d.ts

@@ -0,0 +1,17 @@
+import { JsonAuthor, JsonMessageMentionsChannels, JsonMessageMentionsRoles, JsonMessageMentionsUsers } from "discord-message-transcript-base/internal";
+export type MapAuthors = Map<string, JsonAuthor>;
+export type MapCache = Map<string, Promise<string>>;
+/**
+ * Defines the structure for storing discovered mentions (users, roles, channels) during transcript creation.
+ * Uses Maps for efficient lookups.
+ */
+export interface MapMentions {
+    channels: Map<string, JsonMessageMentionsChannels>;
+    roles: Map<string, JsonMessageMentionsRoles>;
+    users: Map<string, JsonMessageMentionsUsers>;
+}
+export type Maps = {
+    authors: MapAuthors;
+    mentions: MapMentions;
+    urlCache: MapCache;
+};

package/dist/types/private/maps.js

@@ -0,0 +1 @@
+export {};

package/dist/types/private/network.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Result from dns.lookup
+ */
+export type LookupResult = {
+    address: string;
+    family: 4 | 6;
+};
+export interface safeUrlReturn {
+    safe: boolean;
+    safeIps: string[];
+    url: string;
+}

package/dist/types/private/network.js

@@ -0,0 +1 @@
+export {};

package/dist/types/private/others.d.ts

@@ -0,0 +1,4 @@
+/**
+ * A string template type for representing a MIME type (e.g., 'image/png', 'application/json').
+ */
+export type MimeType = `${string}/${string}`;

package/dist/types/private/others.js

@@ -0,0 +1 @@
+export {};