@codebam/cf-workers-telegram-bot 11.13.0 → 12.0.0

package/dist/telegram_execution_context.js

@@ -1,10 +1,10 @@
 import TelegramApi from './telegram_api.js';
-import TelegramInlineQueryResultArticle from './types/TelegramInlineQueryResultArticle.js';
-import TelegramInlineQueryResultPhoto from './types/TelegramInlineQueryResultPhoto.js';
-import TelegramInlineQueryResultVideo from './types/TelegramInlineQueryResultVideo.js';
-import TelegramInlineQueryResultVoice from './types/TelegramInlineQueryResultVoice.js';
 /** Class representing the context of execution */
 export default class TelegramExecutionContext {
+    /** Cache for business connection owners */
+    static businessOwners = new Map();
+    /** Cache for dead business connections */
+    static poisonedConnections = new Set();
     /** an instance of the telegram bot */
     bot;
     /** an instance of the telegram update */
@@ -45,7 +45,7 @@ export default class TelegramExecutionContext {
      * @returns The user ID or undefined if not available
      */
     get userId() {
-        return this.update.message?.from.id ?? this.update.business_message?.from.id ?? this.update.guest_message?.from.id;
+        return this.update.message?.from?.id ?? this.update.business_message?.from?.id ?? this.update.guest_message?.from?.id;
     }
     /**
      * Parse arguments from the update
@@ -67,6 +67,54 @@ export default class TelegramExecutionContext {
      * Determine the type of update received
      * @returns The update type as a string
      */
+    /**
+     * Determine if the current update should be processed.
+     * For business messages, this checks if the connection is valid and has reply permissions.
+     */
+    async shouldProcess() {
+        if (this.update_type !== 'business_message') {
+            return true;
+        }
+        const connectionId = this.update.business_message?.business_connection_id?.toString();
+        if (!connectionId) {
+            return true;
+        }
+        if (TelegramExecutionContext.poisonedConnections.has(connectionId)) {
+            return false;
+        }
+        let ownerId = TelegramExecutionContext.businessOwners.get(connectionId);
+        if (ownerId === undefined) {
+            try {
+                const response = await this.api.getBusinessConnection(this.bot.api.toString(), connectionId);
+                if (response.status === 200) {
+                    const json = await response.json();
+                    if (json.ok && json.result) {
+                        ownerId = json.result.user?.id || json.result.user_chat_id;
+                        if (ownerId) {
+                            TelegramExecutionContext.businessOwners.set(connectionId, ownerId);
+                        }
+                        if (json.result.can_reply === false) {
+                            console.warn('Business connection ' + connectionId + ' lacks reply permissions, poisoning connection');
+                            TelegramExecutionContext.poisonedConnections.add(connectionId);
+                            return false;
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                if (e instanceof Error && e.message === 'BUSINESS_CONNECTION_INVALID') {
+                    console.warn('Business connection ' + connectionId + ' is invalid, poisoning connection');
+                    TelegramExecutionContext.poisonedConnections.add(connectionId);
+                    return false;
+                }
+                console.warn('Failed to fetch business connection info:', e);
+            }
+        }
+        if (ownerId !== undefined && this.getChatId() === ownerId.toString()) {
+            return false;
+        }
+        return true;
+    }
     determineUpdateType() {
         if (this.update.message?.photo) {
             return 'photo';
@@ -127,6 +175,9 @@ export default class TelegramExecutionContext {
         if (this.update.message?.message_id) {
             return this.update.message.message_id.toString();
         }
+        else if (this.update.business_message?.message_id) {
+            return this.update.business_message.message_id.toString();
+        }
         else if (this.update.guest_message?.message_id) {
             return this.update.guest_message.message_id.toString();
         }
@@ -137,7 +188,7 @@ export default class TelegramExecutionContext {
      * @returns The message thread ID as a number or undefined
      */
     getThreadId() {
-        return this.update.message?.message_thread_id;
+        return this.update.message?.message_thread_id ?? this.update.business_message?.message_thread_id;
     }
     /**
      * Reply to the last message with a video
@@ -145,36 +196,85 @@ export default class TelegramExecutionContext {
      * @param options - any additional options to pass to sendVideo
      * @returns Promise with the API response
      */
-    async replyVideo(video, options = {}) {
-        switch (this.update_type) {
-            case 'voice':
-            case 'message':
-                return await this.api.sendVideo(this.bot.api.toString(), {
-                    ...options,
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    reply_to_message_id: this.getMessageId(),
-                    video,
-                });
-            case 'business_message':
-                return await this.api.sendVideo(this.bot.api.toString(), {
-                    ...options,
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    business_connection_id: this.update.business_message?.business_connection_id.toString() ?? '',
-                    video,
-                });
-            case 'guest_message':
-                return await this.answerGuestQueryVideo(video);
-            case 'inline':
-                return await this.api.answerInline(this.bot.api.toString(), {
-                    ...options,
-                    inline_query_id: this.update.inline_query?.id.toString() ?? '',
-                    results: [new TelegramInlineQueryResultVideo({ video })],
-                });
-            default:
+    /**
+     * Helper to handle business connection fallbacks
+     */
+    async withBusinessFallback(params, apiMethod) {
+        const connectionId = params.business_connection_id?.toString();
+        if (connectionId) {
+            if (TelegramExecutionContext.poisonedConnections.has(connectionId)) {
+                return null;
+            }
+            let ownerId = TelegramExecutionContext.businessOwners.get(connectionId);
+            if (ownerId === undefined) {
+                try {
+                    const response = await this.api.getBusinessConnection(this.bot.api.toString(), connectionId);
+                    if (response.status === 200) {
+                        const json = await response.json();
+                        if (json.ok && json.result) {
+                            ownerId = json.result.user?.id || json.result.user_chat_id;
+                            if (ownerId) {
+                                TelegramExecutionContext.businessOwners.set(connectionId, ownerId);
+                            }
+                            if (json.result.can_reply === false) {
+                                TelegramExecutionContext.poisonedConnections.add(connectionId);
+                                return null;
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    if (e instanceof Error && e.message === 'BUSINESS_CONNECTION_INVALID') {
+                        TelegramExecutionContext.poisonedConnections.add(connectionId);
+                        return null;
+                    }
+                }
+            }
+            if (ownerId !== undefined && params.chat_id?.toString() === ownerId.toString()) {
                 return null;
+            }
+        }
+        try {
+            return await apiMethod(this.bot.api.toString(), params);
         }
+        catch (e) {
+            if (e instanceof Error) {
+                if (e.message === 'BUSINESS_CONNECTION_INVALID') {
+                    if (connectionId) {
+                        TelegramExecutionContext.poisonedConnections.add(connectionId);
+                    }
+                    return null;
+                }
+                if (e.message === 'PEER_ID_INVALID') {
+                    return null;
+                }
+            }
+            throw e;
+        }
+    }
+    async replyVideo(video, options = {}) {
+        const params = {
+            ...options,
+            chat_id: this.getChatId(),
+            message_thread_id: this.getThreadId(),
+            reply_to_message_id: this.getMessageId(),
+            video,
+        };
+        if (this.update_type === 'business_message') {
+            params['business_connection_id'] = this.update.business_message?.business_connection_id;
+            return await this.withBusinessFallback(params, (api, data) => this.api.sendVideo(api, data));
+        }
+        if (this.update_type === 'guest_message') {
+            return await this.answerGuestQueryVideo(video);
+        }
+        if (this.update_type === 'inline') {
+            return await this.api.answerInline(this.bot.api.toString(), {
+                ...options,
+                inline_query_id: this.update.inline_query?.id.toString() ?? '',
+                results: [{ type: 'video', id: crypto.randomUUID(), video_url: video, mime_type: 'video/mp4', thumbnail_url: video, title: 'Video' }],
+            });
+        }
+        return await this.api.sendVideo(this.bot.api.toString(), params);
     }
     /**
      * Get File from telegram file_id
@@ -192,37 +292,28 @@ export default class TelegramExecutionContext {
      * @returns Promise with the API response
      */
     async replyPhoto(photo, caption = '', options = {}) {
-        switch (this.update_type) {
-            case 'voice':
-            case 'photo':
-            case 'message':
-                return await this.api.sendPhoto(this.bot.api.toString(), {
-                    ...options,
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    reply_to_message_id: this.getMessageId(),
-                    photo,
-                    caption,
-                });
-            case 'business_message':
-                return await this.api.sendPhoto(this.bot.api.toString(), {
-                    ...options,
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    business_connection_id: this.update.business_message?.business_connection_id.toString() ?? '',
-                    photo,
-                    caption,
-                });
-            case 'guest_message':
-                return await this.answerGuestQueryPhoto(photo, caption);
-            case 'inline':
-                return await this.api.answerInline(this.bot.api.toString(), {
-                    inline_query_id: this.update.inline_query?.id.toString() ?? '',
-                    results: [new TelegramInlineQueryResultPhoto({ photo })],
-                });
-            default:
-                return null;
+        const params = {
+            ...options,
+            chat_id: this.getChatId(),
+            message_thread_id: this.getThreadId(),
+            reply_to_message_id: this.getMessageId(),
+            photo,
+            caption,
+        };
+        if (this.update_type === 'business_message') {
+            params['business_connection_id'] = this.update.business_message?.business_connection_id;
+            return await this.withBusinessFallback(params, (api, data) => this.api.sendPhoto(api, data));
+        }
+        if (this.update_type === 'guest_message') {
+            return await this.answerGuestQueryPhoto(photo, caption);
         }
+        if (this.update_type === 'inline') {
+            return await this.api.answerInline(this.bot.api.toString(), {
+                inline_query_id: this.update.inline_query?.id.toString() ?? '',
+                results: [{ type: 'photo', id: crypto.randomUUID(), photo_url: photo, thumbnail_url: photo }],
+            });
+        }
+        return await this.api.sendPhoto(this.bot.api.toString(), params);
     }
     /**
      * Reply to the last message with a voice message
@@ -232,57 +323,38 @@ export default class TelegramExecutionContext {
      * @returns Promise with the API response
      */
     async replyVoice(voice, caption = '', options = {}) {
-        switch (this.update_type) {
-            case 'voice':
-            case 'message':
-                return await this.api.sendVoice(this.bot.api.toString(), {
-                    ...options,
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    reply_to_message_id: this.getMessageId(),
-                    voice,
-                    caption,
-                });
-            case 'business_message':
-                return await this.api.sendVoice(this.bot.api.toString(), {
-                    ...options,
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    business_connection_id: this.update.business_message?.business_connection_id.toString() ?? '',
-                    voice,
-                    caption,
-                });
-            case 'guest_message':
-                return await this.answerGuestQueryVoice(voice, caption);
-            default:
-                return null;
+        const params = {
+            ...options,
+            chat_id: this.getChatId(),
+            message_thread_id: this.getThreadId(),
+            reply_to_message_id: this.getMessageId(),
+            voice,
+            caption,
+        };
+        if (this.update_type === 'business_message') {
+            params['business_connection_id'] = this.update.business_message?.business_connection_id;
+            return await this.withBusinessFallback(params, (api, data) => this.api.sendVoice(api, data));
+        }
+        if (this.update_type === 'guest_message') {
+            return await this.answerGuestQueryVoice(voice, caption);
         }
+        return await this.api.sendVoice(this.bot.api.toString(), params);
     }
     /**
      * Send typing in a chat
      * @returns Promise with the API response
      */
     async sendTyping() {
-        switch (this.update_type) {
-            case 'voice':
-            case 'message':
-            case 'photo':
-            case 'document':
-                return await this.api.sendChatAction(this.bot.api.toString(), {
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    action: 'typing',
-                });
-            case 'business_message':
-                return await this.api.sendChatAction(this.bot.api.toString(), {
-                    business_connection_id: this.update.business_message?.business_connection_id.toString() ?? '',
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    action: 'typing',
-                });
-            default:
-                return null;
+        const params = {
+            chat_id: this.getChatId(),
+            message_thread_id: this.getThreadId(),
+            action: 'typing',
+        };
+        if (this.update_type === 'business_message') {
+            params['business_connection_id'] = this.update.business_message?.business_connection_id;
+            return await this.withBusinessFallback(params, (api, data) => this.api.sendChatAction(api, data));
         }
+        return await this.api.sendChatAction(this.bot.api.toString(), params);
     }
     /**
      * Reply to an inline message with a title and content
@@ -295,7 +367,7 @@ export default class TelegramExecutionContext {
         if (this.update_type === 'inline') {
             return await this.api.answerInline(this.bot.api.toString(), {
                 inline_query_id: this.update.inline_query?.id.toString() ?? '',
-                results: [new TelegramInlineQueryResultArticle({ content: message, title, parse_mode })],
+                results: [{ type: 'article', id: crypto.randomUUID(), title: title ?? '', input_message_content: { message_text: message, parse_mode: parse_mode } }],
             });
         }
         return null;
@@ -318,7 +390,7 @@ export default class TelegramExecutionContext {
      * @returns Promise with the API response
      */
     async answerGuestQueryText(message, parse_mode = '') {
-        return await this.answerGuestQuery(new TelegramInlineQueryResultArticle({ content: message, title: 'Response', parse_mode }));
+        return await this.answerGuestQuery({ type: 'article', id: crypto.randomUUID(), title: 'Response', input_message_content: { message_text: message, parse_mode: parse_mode } });
     }
     /**
      * Answer a guest query with a photo
@@ -328,7 +400,7 @@ export default class TelegramExecutionContext {
      * @returns Promise with the API response
      */
     async answerGuestQueryPhoto(photo, caption = '', parse_mode = '') {
-        return await this.answerGuestQuery(new TelegramInlineQueryResultPhoto({ photo, caption, parse_mode }));
+        return await this.answerGuestQuery({ type: 'photo', id: crypto.randomUUID(), photo_url: photo, thumbnail_url: photo, caption, parse_mode: parse_mode });
     }
     /**
      * Answer a guest query with a video
@@ -338,7 +410,7 @@ export default class TelegramExecutionContext {
      * @returns Promise with the API response
      */
     async answerGuestQueryVideo(video, caption = '', parse_mode = '') {
-        return await this.answerGuestQuery(new TelegramInlineQueryResultVideo({ video, caption, parse_mode }));
+        return await this.answerGuestQuery({ type: 'video', id: crypto.randomUUID(), video_url: video, mime_type: 'video/mp4', thumbnail_url: video, title: 'Video', caption, parse_mode: parse_mode });
     }
     /**
      * Answer a guest query with a voice message
@@ -348,7 +420,7 @@ export default class TelegramExecutionContext {
      * @returns Promise with the API response
      */
     async answerGuestQueryVoice(voice, caption = '', parse_mode = '') {
-        return await this.answerGuestQuery(new TelegramInlineQueryResultVoice({ voice, caption, parse_mode }));
+        return await this.answerGuestQuery({ type: 'voice', id: crypto.randomUUID(), voice_url: voice, title: 'Voice', caption, parse_mode: parse_mode });
     }
     /** Map of draft IDs to message IDs for streaming */
     drafts = new Map();
@@ -360,104 +432,56 @@ export default class TelegramExecutionContext {
      * @param options - any additional options to pass to sendMessage/editMessageText
      * @returns Promise with the API response
      */
-    async streamReply(message, draft_id, parse_mode = '', options = {}) {
-        const message_id = this.drafts.get(draft_id);
-        const business_connection_id = this.update.business_message?.business_connection_id.toString();
-        if (message_id) {
-            return await this.api.editMessageText(this.bot.api.toString(), {
-                chat_id: this.getChatId(),
-                message_id,
-                text: message,
-                parse_mode,
-                business_connection_id,
-                ...options,
-            });
-        }
+    async streamReply(message, draft_id, parse_mode = '', options = {}, finish = false) {
         if (this.update_type === 'guest_message') {
-            if (this.drafts.has(draft_id)) {
-                return new Response('Query already answered', { status: 200 });
+            if (finish) {
+                return await this.answerGuestQueryText(message, parse_mode);
             }
-            this.drafts.set(draft_id, -1);
-            return await this.answerGuestQueryText(message, parse_mode);
+            return null;
+        }
+        if (finish) {
+            return await this.reply(message, parse_mode, true, options);
         }
-        const response = await this.api.sendMessage(this.bot.api.toString(), {
+        const params = {
             ...options,
             chat_id: this.getChatId(),
             message_thread_id: this.getThreadId(),
             text: message,
             parse_mode,
-            business_connection_id,
-        });
-        if (response.status === 200) {
-            const cloned = response.clone();
-            try {
-                const json = (await cloned.json());
-                if (json.ok && json.result?.message_id) {
-                    this.drafts.set(draft_id, json.result.message_id);
-                }
-            }
-            catch {
-                // ignore
-            }
+            draft_id,
+        };
+        if (this.update_type === 'business_message') {
+            params.business_connection_id = this.update.business_message?.business_connection_id;
         }
-        return response;
+        return await this.withBusinessFallback(params, (api, data) => this.api.sendMessageDraft(api, data));
     }
-    /**
-     * Reply to the last message with text
-     * @param message - text to reply with
-     * @param parse_mode - one of HTML, MarkdownV2, Markdown, or an empty string for ascii
-     * @param options - any additional options to pass to sendMessage
-     * @returns Promise with the API response
-     */
     async reply(message, parse_mode = '', reply = true, options = {}) {
-        switch (this.update_type) {
-            case 'voice':
-            case 'message':
-            case 'photo':
-            case 'document':
-                if (reply) {
-                    return await this.api.sendMessage(this.bot.api.toString(), {
-                        ...options,
-                        chat_id: this.getChatId(),
-                        message_thread_id: this.getThreadId(),
-                        reply_to_message_id: this.getMessageId(),
-                        text: message,
-                        parse_mode,
-                    });
-                }
-                return await this.api.sendMessage(this.bot.api.toString(), {
-                    ...options,
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    text: message,
-                    parse_mode,
-                });
-            case 'guest_message':
-                return await this.answerGuestQueryText(message, parse_mode);
-            case 'business_message':
-                return await this.api.sendMessage(this.bot.api.toString(), {
-                    chat_id: this.getChatId(),
-                    message_thread_id: this.getThreadId(),
-                    text: message,
-                    business_connection_id: this.update.business_message?.business_connection_id.toString() ?? '',
-                    parse_mode,
-                });
-            case 'callback':
-                if (this.update.callback_query?.message.chat.id) {
-                    return await this.api.sendMessage(this.bot.api.toString(), {
-                        ...options,
-                        chat_id: this.update.callback_query.message.chat.id.toString(),
-                        message_thread_id: this.getThreadId(),
-                        text: message,
-                        parse_mode,
-                    });
-                }
-                return null;
-            case 'inline':
-                return await this.replyInline('Response', message, parse_mode);
-            default:
-                return null;
+        if (this.update_type === 'guest_message') {
+            return await this.answerGuestQueryText(message, parse_mode);
+        }
+        if (this.update_type === 'inline') {
+            return await this.replyInline('Response', message, parse_mode);
         }
+        const params = {
+            ...options,
+            chat_id: this.getChatId(),
+            message_thread_id: this.getThreadId(),
+            text: message,
+            parse_mode,
+        };
+        if (reply) {
+            params.reply_to_message_id = this.getMessageId();
+        }
+        if (this.update_type === 'business_message') {
+            params['business_connection_id'] = this.update.business_message?.business_connection_id;
+            return await this.withBusinessFallback(params, (api, data) => this.api.sendMessage(api, data));
+        }
+        if (this.update_type === 'callback') {
+            if (this.update.callback_query?.message?.chat.id) {
+                params['chat_id'] = this.update.callback_query.message.chat.id.toString();
+            }
+        }
+        return await this.api.sendMessage(this.bot.api.toString(), params);
     }
     /**
      * Send an invoice for Telegram Stars
@@ -468,17 +492,21 @@ export default class TelegramExecutionContext {
      * @returns Promise with the API response
      */
     async sendStarsInvoice(title, description, payload, amount) {
-        return await this.api.sendInvoice(this.bot.api.toString(), {
+        const params = {
             chat_id: this.getChatId(),
             message_thread_id: this.getThreadId(),
-            business_connection_id: this.update.business_message?.business_connection_id.toString(),
             title,
             description,
             payload,
             provider_token: '',
             currency: 'XTR',
             prices: [{ label: title, amount }],
-        });
+        };
+        if (this.update_type === 'business_message') {
+            params['business_connection_id'] = this.update.business_message?.business_connection_id;
+            return await this.withBusinessFallback(params, (api, data) => this.api.sendInvoice(api, data));
+        }
+        return await this.api.sendInvoice(this.bot.api.toString(), params);
     }
     /**
      * Answer a pre-checkout query

package/dist/types/PartialTelegramUpdate.d.ts

@@ -1,10 +1,10 @@
-import TelegramBusinessMessage from './TelegramBusinessMessage.js';
-import TelegramInlineQuery from './TelegramInlineQuery.js';
-import TelegramMessage from './TelegramMessage.js';
+import { Message as TelegramBusinessMessage } from '@grammyjs/types';
+import { InlineQuery as TelegramInlineQuery } from '@grammyjs/types';
+import { Message as TelegramMessage } from '@grammyjs/types';
 import TelegramGuestMessage from './TelegramGuestMessage.js';
-import TelegramPreCheckoutQuery from './TelegramPreCheckoutQuery.js';
-import TelegramCallbackQuery from './TelegramCallbackQuery.js';
-import TelegramBusinessConnection from './TelegramBusinessConnection.js';
+import { PreCheckoutQuery as TelegramPreCheckoutQuery } from '@grammyjs/types';
+import { CallbackQuery as TelegramCallbackQuery } from '@grammyjs/types';
+import { BusinessConnection as TelegramBusinessConnection } from '@grammyjs/types';
 interface PartialTelegramUpdate {
     update_id?: number;
     message?: TelegramMessage;

package/dist/types/TelegramCommand.d.ts

@@ -1,4 +1,4 @@
 import TelegramBot from '../telegram_bot.js';
-import TelegramUpdate from './TelegramUpdate.js';
+import { Update as TelegramUpdate } from '@grammyjs/types';
 type TelegramCommand = (bot: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
 export default TelegramCommand;

package/dist/types/TelegramGuestMessage.d.ts

@@ -1,4 +1,4 @@
-import TelegramMessage from "./TelegramMessage.js";
+import { Message as TelegramMessage } from '@grammyjs/types';
 export default interface TelegramGuestMessage extends TelegramMessage {
     guest_query_id: string;
 }

package/dist/types.d.ts

@@ -1,22 +1,10 @@
+import { Chat as TelegramChat, User as TelegramUser, User as TelegramFrom, MessageEntity as TelegramMessageEntity, PhotoSize as TelegramPhotoSize, Message as TelegramMessage, InputMessageContent as TelegramInputMessageContent, InlineQuery as TelegramInlineQuery, Update as TelegramUpdate, InlineQueryResult as TelegramInlineQueryResult, InlineQueryResultPhoto as TelegramInlineQueryResultPhoto, InlineQueryResultArticle as TelegramInlineQueryResultArticle, ChatPermissions as ChatPermissions } from '@grammyjs/types';
 import TelegramBot from './telegram_bot.js';
 import TelegramExecutionContext from './telegram_execution_context.js';
 import Webhook from './webhook.js';
 import TelegramApi from './telegram_api.js';
 import TelegramCommand from './types/TelegramCommand.js';
-import TelegramFrom from './types/TelegramFrom.js';
-import TelegramChat from './types/TelegramChat.js';
-import TelegramUser from './types/TelegramUser.js';
-import TelegramMessageEntity from './types/TelegramMessageEntity.js';
-import TelegramPhotoSize from './types/TelegramPhotoSize.js';
-import TelegramMessage from './types/TelegramMessage.js';
-import TelegramInputMessageContent from './types/TelegramInputMessageContent.js';
-import TelegramInlineQuery from './types/TelegramInlineQuery.js';
-import TelegramUpdate from './types/TelegramUpdate.js';
 import PartialTelegramUpdate from './types/PartialTelegramUpdate.js';
 import TelegramInlineQueryType from './types/TelegramInlineQueryType.js';
-import TelegramInlineQueryResult from './types/TelegramInlineQueryResult.js';
-import TelegramInlineQueryResultPhoto from './types/TelegramInlineQueryResultPhoto.js';
-import TelegramInlineQueryResultArticle from './types/TelegramInlineQueryResultArticle.js';
-import ChatPermissions from './types/ChatPermissions.js';
 export default TelegramBot;
 export { TelegramBot, TelegramExecutionContext, Webhook, TelegramApi, TelegramCommand, TelegramFrom, TelegramChat, TelegramUser, TelegramMessageEntity, TelegramPhotoSize, TelegramMessage, TelegramInputMessageContent, TelegramInlineQuery, TelegramUpdate, PartialTelegramUpdate, TelegramInlineQueryType, TelegramInlineQueryResult, TelegramInlineQueryResultPhoto, TelegramInlineQueryResultArticle, ChatPermissions, };

package/dist/types.js

@@ -2,9 +2,5 @@ import TelegramBot from './telegram_bot.js';
 import TelegramExecutionContext from './telegram_execution_context.js';
 import Webhook from './webhook.js';
 import TelegramApi from './telegram_api.js';
-import TelegramUpdate from './types/TelegramUpdate.js';
-import TelegramInlineQueryResult from './types/TelegramInlineQueryResult.js';
-import TelegramInlineQueryResultPhoto from './types/TelegramInlineQueryResultPhoto.js';
-import TelegramInlineQueryResultArticle from './types/TelegramInlineQueryResultArticle.js';
 export default TelegramBot;
-export { TelegramBot, TelegramExecutionContext, Webhook, TelegramApi, TelegramUpdate, TelegramInlineQueryResult, TelegramInlineQueryResultPhoto, TelegramInlineQueryResultArticle, };
+export { TelegramBot, TelegramExecutionContext, Webhook, TelegramApi, };

package/dist/utils.js

@@ -27,16 +27,17 @@ export async function markdownToHtml(s) {
         return result;
     };
     renderer.listitem = (item) => {
-        return renderer.parser.parseInline(item.tokens);
+        return renderer.parser.parse(item.tokens).trim();
     };
     renderer.strong = ({ tokens }) => `<b>${renderer.parser.parseInline(tokens)}</b>`;
     renderer.em = ({ tokens }) => `<i>${renderer.parser.parseInline(tokens)}</i>`;
     renderer.codespan = ({ text }) => `<code>${text}</code>`;
     renderer.code = ({ text, lang }) => {
+        const escapedText = text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
         if (lang) {
-            return `<pre><code class="language-${lang}">${text}</code></pre>\n`;
+            return `<pre><code class="language-${lang}">${escapedText}</code></pre>\n`;
         }
-        return `<pre><code>${text}</code></pre>\n`;
+        return `<pre><code>${escapedText}</code></pre>\n`;
     };
     renderer.del = ({ tokens }) => `<s>${renderer.parser.parseInline(tokens)}</s>`;
     renderer.link = ({ href, tokens }) => `<a href="${href}">${renderer.parser.parseInline(tokens)}</a>`;