@codebam/cf-workers-telegram-bot 3.40.0

package/dist/main/src/telegram_bot.js

@@ -0,0 +1,152 @@
+import { preTagString, prettyJSON, addSearchParams, responseToJSON, } from "./libs";
+import TelegramApi from "./telegram_api";
+import { TelegramInlineQueryResultArticle, TelegramInlineQueryResultPhoto, } from "./types";
+export default class TelegramBot extends TelegramApi {
+    url;
+    kv;
+    get_set;
+    constructor(config) {
+        super(config.commands, config.webhook, config.handler);
+        this.url = config.url;
+        this.kv = config.kv;
+        this.get_set = config.kv?.get_set;
+    }
+    // bot command: /code
+    code = async (update) => ((url) => (update.inline_query &&
+        this.answerInlineQuery(update.inline_query.id, [
+            new TelegramInlineQueryResultArticle(url),
+        ])) ??
+        this.sendMessage(update.message?.chat.id ?? 0, url))("https://github.com/codebam/cf-workers-telegram-bot");
+    // bot command: /duckduckgo
+    duckduckgo = async (update, args) => ((query) => ((duckduckgo_url) => (update.inline_query &&
+        query === "" &&
+        this.answerInlineQuery(update.inline_query.id, [
+            new TelegramInlineQueryResultArticle("https://duckduckgo.com"),
+        ])) ||
+        (update.inline_query &&
+            fetch(addSearchParams(new URL("https://api.duckduckgo.com"), {
+                q: query,
+                format: "json",
+                t: "telegram_bot",
+                no_redirect: "1",
+            }).href).then((response) => response
+                .json()
+                .then((results) => results)
+                .then((ddg_response) => ((instant_answer_url, thumb_url, default_thumb_url = "https://duckduckgo.com/assets/icons/meta/DDG-icon_256x256.png") => this.answerInlineQuery(update.inline_query?.id ?? 0, (instant_answer_url !== "" && [
+                new TelegramInlineQueryResultArticle(`${instant_answer_url}\n\n<a href="${addSearchParams(new URL(duckduckgo_url), {
+                    q: args
+                        .slice(1)
+                        .join(" ")
+                        .replace(/^!\w* /, ""),
+                }).href}">Results From DuckDuckGo</a>`, instant_answer_url, "HTML", thumb_url),
+                new TelegramInlineQueryResultArticle(duckduckgo_url, duckduckgo_url, "", default_thumb_url),
+            ]) || [
+                new TelegramInlineQueryResultArticle(duckduckgo_url, duckduckgo_url, "", default_thumb_url),
+            ], 3600 // 1 hour
+            ))(ddg_response.Redirect || ddg_response.AbstractURL, (ddg_response.Redirect === "" &&
+                `https://duckduckgo.com${(ddg_response.Image !== "" && ddg_response.Image) ||
+                    (ddg_response.RelatedTopics.length !== 0 &&
+                        ddg_response.RelatedTopics[0].Icon.URL !== "" &&
+                        ddg_response.RelatedTopics[0].Icon.URL) ||
+                    "/i/f96d4798.png"}`) ||
+                "")))) ||
+        this.sendMessage(update.message?.chat.id ?? 0, duckduckgo_url))((query === "" && "https://duckduckgo.com") ||
+        addSearchParams(new URL("https://duckduckgo.com"), {
+            q: query,
+        }).href))(args.slice(1).join(" "));
+    // bot command: /kanye
+    kanye = async (update) => fetch("https://api.kanye.rest")
+        .then((response) => responseToJSON(response))
+        .then((json) => ((message) => (update.inline_query !== undefined &&
+        this.answerInlineQuery(update.inline_query.id, [
+            new TelegramInlineQueryResultArticle(message),
+        ])) ||
+        this.sendMessage(update.message?.chat.id ?? 0, message))(`Kanye says... ${json.quote}`))
+        .catch(() => new Response("Failed to parse JSON"));
+    // bot command: /joke
+    joke = async (update) => fetch("https://v2.jokeapi.dev/joke/Any?safe-mode")
+        .then((response) => responseToJSON(response))
+        .then((joke) => joke)
+        .then((joke_response) => ((message) => (update.inline_query &&
+        this.answerInlineQuery(update.inline_query.id, [
+            new TelegramInlineQueryResultArticle(message, joke_response.joke ?? joke_response.setup, "HTML"),
+        ], 0)) ??
+        this.sendMessage(update.message?.chat.id ?? 0, message, "HTML"))(joke_response.joke ??
+        `${joke_response.setup}\n\n<tg-spoiler>${joke_response.delivery}</tg-spoiler>`));
+    // bot command: /dog
+    dog = async (update) => fetch("https://shibe.online/api/shibes")
+        .then((response) => response.json())
+        .then((json) => json)
+        .then((shibe_response) => (update.inline_query &&
+        this.answerInlineQuery(update.inline_query.id, [new TelegramInlineQueryResultPhoto(shibe_response[0])], 0)) ??
+        this.sendPhoto(update.message?.chat.id ?? 0, shibe_response[0]));
+    // bot command: /cat
+    cat = async (update) => fetch("https://meow.senither.com/v1/random")
+        .then((response) => response.json())
+        .then((json) => json)
+        .then((json) => (update.inline_query &&
+        this.answerInlineQuery(update.inline_query.id, [new TelegramInlineQueryResultPhoto(json.data.url)], 0)) ??
+        this.sendPhoto(update.message?.chat.id ?? 0, json.data.url));
+    // bot command: /bored
+    bored = async (update) => fetch("https://boredapi.com/api/activity/")
+        .then((response) => responseToJSON(response))
+        .then((json) => json)
+        .then((bored_response) => (update.inline_query &&
+        this.answerInlineQuery(update.inline_query.id, [new TelegramInlineQueryResultArticle(bored_response.activity)], 0)) ??
+        this.sendMessage(update.message?.chat.id ?? 0, bored_response.activity));
+    // bot command: /epoch
+    epoch = async (update) => ((seconds) => (update.inline_query &&
+        this.answerInlineQuery(update.inline_query.id, [new TelegramInlineQueryResultArticle(seconds)], 0)) ??
+        this.sendMessage(update.message?.chat.id ?? 0, seconds))(Math.floor(Date.now() / 1000).toString());
+    // bot command: /get
+    _get = async (update, args) => ((key) => this.get_set
+        .get(key)
+        .then((value) => (update.inline_query &&
+        this.answerInlineQuery(update.inline_query.id, [new TelegramInlineQueryResultArticle(value ?? "")], 0)) ??
+        this.sendMessage(update.message?.chat.id ?? 0, value ?? "")))(args[1]);
+    // bot command: /set
+    _set = async (update, args) => {
+        const key = args[1];
+        const value = args.slice(2).join(" ");
+        const message = `set ${key} to ${value}`;
+        this.get_set.put(key, value).then(() => {
+            if (update.inline_query) {
+                return this.answerInlineQuery(update.inline_query.id, [new TelegramInlineQueryResultArticle(message)], 0);
+            }
+            return this.sendMessage(update.message?.chat.id ?? 0, message);
+        });
+        return new Response();
+    };
+    _average = (numbers) => parseFloat((numbers.reduce((prev, cur) => prev + cur, 0) / numbers.length || 0).toFixed(2));
+    // bot command: /recursion
+    recursion = async (update) => this.sendMessage(update.message?.chat.id ?? 0, "/recursion");
+    // .then((response) => responseToJSON(response))
+    // .then((result: { ok: boolean; result: { text: string } }) =>
+    //   this.handler.postResponse(
+    //     new Request("", {
+    //       method: "POST",
+    //       body: JSON.stringify({
+    //         message: {
+    //           text: result.result.text,
+    //           chat: { id: update.message.chat.id },
+    //         },
+    //       }),
+    //     }),
+    //     this
+    //   )
+    // );
+    // bot command: /roll
+    roll = async (update, args) => ((outcome, message) => (update.inline_query &&
+        this.answerInlineQuery(update.inline_query.id, [
+            new TelegramInlineQueryResultArticle(message(update.inline_query.from.username, update.inline_query.from.first_name, outcome)),
+        ])) ??
+        this.sendMessage(update.message?.chat.id ?? 0, message(update.message?.from.username ?? "", update.message?.from.first_name ?? "", outcome)))(Math.floor(Math.random() * (parseInt(args[1]) || 6 - 1 + 1) + 1), (username, first_name, outcome) => `${first_name ?? username} rolled a ${parseInt(args[1]) || 6} sided die. it landed on ${outcome}`);
+    // bot command: /commandList
+    commandList = async (update) => this.sendMessage(update.message?.chat.id ?? 0, `<pre>${JSON.stringify(Object.keys(this.commands))}</pre>`, "HTML");
+    // bot command: /toss
+    toss = async (update) => this.sendMessage(update.message?.chat.id ?? 0, Math.floor(Math.random() * 2) == 0 ? "heads" : "tails");
+    // bot command: /ping
+    ping = async (update, args) => this.sendMessage(update.message?.chat.id ?? 0, args.length === 1 ? "pong" : args.slice(1).join(" "));
+    // bot command: /chatInfo
+    getChatInfo = async (update) => this.sendMessage(update.message?.chat.id ?? 0, preTagString(prettyJSON(update.message?.chat ?? 0)), "HTML");
+}

package/dist/main/src/telegram_commands.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="@cloudflare/workers-types" />
+import TelegramBot from "./telegram_bot";
+import { TelegramUpdate } from "./types";
+export default class TelegramCommands {
+    static ping: (bot: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
+    static toss: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+    static epoch: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+    static kanye: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+    static bored: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+    static joke: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+    static dog: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+    static cat: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+    static roll: (bot: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
+    static _get: (bot: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
+    static _set: (bot: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
+    static duckduckgo: (bot: TelegramBot, update: TelegramUpdate, args: string[]) => Promise<Response>;
+    static code: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+    static commandList: (bot: TelegramBot, update: TelegramUpdate) => Promise<Response>;
+}

package/dist/main/src/telegram_commands.js

@@ -0,0 +1,16 @@
+export default class TelegramCommands {
+    static ping = async (bot, update, args) => bot.ping(update, args);
+    static toss = async (bot, update) => bot.toss(update);
+    static epoch = async (bot, update) => bot.epoch(update);
+    static kanye = async (bot, update) => bot.kanye(update);
+    static bored = async (bot, update) => bot.bored(update);
+    static joke = async (bot, update) => bot.joke(update);
+    static dog = async (bot, update) => bot.dog(update);
+    static cat = async (bot, update) => bot.cat(update);
+    static roll = async (bot, update, args) => bot.roll(update, args);
+    static _get = async (bot, update, args) => bot._get(update, args);
+    static _set = async (bot, update, args) => bot._set(update, args);
+    static duckduckgo = async (bot, update, args) => bot.duckduckgo(update, args);
+    static code = async (bot, update) => bot.code(update);
+    static commandList = async (bot, update) => bot.commandList(update);
+}

package/dist/main/src/telegram_webhook.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="@cloudflare/workers-types" />
+import Webhook from "./webhook";
+import { WebhookCommands } from "./types";
+export default class TelegramWebhook extends Webhook {
+    constructor(api: URL, token: string, url: URL);
+    set: (drop_pending_updates?: boolean) => Promise<Response>;
+    get: () => Promise<Response>;
+    delete: () => Promise<Response>;
+    commands: WebhookCommands;
+}

package/dist/main/src/telegram_webhook.js

@@ -0,0 +1,21 @@
+import Webhook from "./webhook";
+import { sha256, addSearchParams, fetch_json } from "./libs";
+export default class TelegramWebhook extends Webhook {
+    constructor(api, token, url) {
+        super(api, token, url);
+    }
+    set = async (drop_pending_updates = true) => sha256(this.token).then((access_key) => fetch_json(addSearchParams(new URL(`${this.api.href}/setWebhook`), {
+        url: new URL(`${this.url.href}/${access_key}`).href,
+        max_connections: "100",
+        allowed_updates: JSON.stringify(["message", "inline_query"]),
+        drop_pending_updates: drop_pending_updates.toString(),
+    })));
+    get = async () => fetch_json(new URL(`${this.api.href}/getWebhookInfo`));
+    delete = async () => fetch_json(new URL(`${this.api.href}/deleteWebhook`));
+    commands = {
+        ...this.commands,
+        set: this.set,
+        get: this.get,
+        delete: this.delete,
+    };
+}

package/dist/main/src/types.d.ts

@@ -0,0 +1,220 @@
+/// <reference types="@cloudflare/workers-types" />
+import BotApi from "./bot_api";
+import Handler from "./handler";
+import TelegramApi from "./telegram_api";
+import Webhook from "./webhook";
+export { Webhook };
+export type Command = (bot: BotApi, update: Update, args?: string[]) => Promise<Response>;
+export type TelegramCommand = (bot: TelegramApi, update: TelegramUpdate, args?: string[]) => Promise<Response>;
+export type Commands = Record<string, Command>;
+export type Kv = Record<string, KVNamespace> | undefined;
+export declare class Config {
+    bot_name: string;
+    api: object;
+    webhook: Webhook;
+    commands: Record<string, Command>;
+    kv: Kv | undefined;
+    url: URL;
+    handler: Handler | undefined;
+    constructor(config?: PartialConfig);
+}
+export type PartialConfig = {
+    bot_name?: string;
+    api?: object;
+    webhook?: Webhook;
+    commands?: Record<string, Command>;
+    kv?: Kv | undefined;
+    url?: URL;
+    handler?: Handler;
+};
+export declare const localhost: URL;
+export declare class WebhookCommands {
+    [key: string]: () => Promise<Response>;
+}
+export type Joke = {
+    error: boolean;
+    category: string;
+    type: string;
+    setup?: string;
+    delivery?: string;
+    joke?: string;
+    flags: {
+        nsfw: boolean;
+        religious: boolean;
+        political: boolean;
+        racist: boolean;
+        sexist: boolean;
+        explicit: boolean;
+    };
+    id: number;
+    safe: boolean;
+    lang: string;
+};
+export type Bored = {
+    activity: string;
+    type: string;
+    participants: number;
+    price: number;
+    link: string;
+    key: string;
+    accessibility: 0;
+};
+export type Balance = Record<string, {
+    final_balance: number;
+    n_tx: number;
+    total_received: number;
+}>;
+export type TelegramFrom = {
+    first_name: string;
+    id: number;
+    is_bot: boolean;
+    language_code: string;
+    username: string;
+};
+export type TelegramChat = {
+    id: number;
+    type: string;
+    title?: string;
+    username?: string;
+    first_name?: string;
+    last_name?: string;
+    bio?: string;
+    has_private_forwards: boolean;
+    description?: string;
+    invite_link?: string;
+    pinned_message?: TelegramMessage;
+    slow_mode_delay?: number;
+    message_auto_delete_time?: number;
+    has_protected_content?: boolean;
+    sticker_set_name?: string;
+    can_set_sticker_set?: boolean;
+    linked_chat_id?: number;
+};
+export type TelegramUser = {
+    id: number;
+    is_bot: boolean;
+    first_name: string;
+    last_name?: string;
+    username?: string;
+    language_code?: string;
+    can_join_groups?: boolean;
+    can_read_all_group_messages?: boolean;
+    supports_inline_queries: boolean;
+};
+export type TelegramMessageEntity = {
+    type: string;
+    offset: number;
+    length: number;
+    url?: string;
+    user?: TelegramUser;
+    language?: string;
+};
+export type TelegramPhotoSize = {
+    file_id: string;
+    file_unique_id: string;
+    width: number;
+    height: number;
+    file_size?: number;
+};
+export type TelegramMessage = {
+    message_id: number;
+    from: TelegramFrom;
+    sender_chat?: TelegramChat;
+    date: number;
+    chat: TelegramChat;
+    forward_from?: TelegramUser;
+    forward_from_chat?: TelegramChat;
+    forward_from_message_id?: number;
+    forward_signature?: string;
+    forward_sender_name?: string;
+    forward_date?: number;
+    is_automatic_forward?: boolean;
+    reply_to_message?: TelegramMessage;
+    via_bot?: TelegramUser;
+    edit_date?: number;
+    has_protected_content?: boolean;
+    media_group_id?: string;
+    author_signature?: string;
+    text?: string;
+    entities?: TelegramMessageEntity[];
+    photo?: TelegramPhotoSize[];
+    caption?: string;
+    caption_entities?: TelegramMessageEntity[];
+    new_chat_members?: TelegramUser[];
+    left_chat_member?: TelegramUser;
+    new_chat_title?: string;
+    delete_chat_photo?: boolean;
+    group_chat_created?: boolean;
+    supergroup_chat_created?: boolean;
+    channel_chat_created?: boolean;
+    migrate_to_chat_id?: number;
+    migrate_from_chat_id?: number;
+    pinned_message?: TelegramMessage;
+    connected_website?: string;
+};
+export type TelegramInputMessageContent = {
+    message_text: string;
+    parse_mode: string;
+};
+export type TelegramInlineQuery = {
+    chat_type: "sender" | "private" | "group" | "supergroup" | "channel";
+    from: TelegramFrom;
+    id: number;
+    offset: string;
+    query: string;
+};
+export declare class Update {
+    [key: string]: unknown;
+}
+export declare class TelegramUpdate extends Update {
+    update_id: number;
+    message?: TelegramMessage;
+    edited_message?: TelegramMessage;
+    channel_post?: TelegramMessage;
+    edited_channel_post?: TelegramMessage;
+    inline_query?: TelegramInlineQuery;
+    constructor(update: PartialTelegramUpdate);
+}
+export type PartialTelegramUpdate = {
+    update_id?: number;
+    message?: TelegramMessage;
+    edited_message?: TelegramMessage;
+    channel_post?: TelegramMessage;
+    edited_channel_post?: TelegramMessage;
+    inline_query?: TelegramInlineQuery;
+};
+export type TelegramInlineQueryType = "article" | "photo" | "gif" | "mpeg4_gif" | "video" | "audio" | "voice" | "document" | "location" | "venue" | "contact" | "game" | "sticker";
+export declare class TelegramInlineQueryResult {
+    type: TelegramInlineQueryType;
+    id: string;
+    constructor(type: TelegramInlineQueryType);
+}
+export declare class TelegramInlineQueryResultPhoto extends TelegramInlineQueryResult {
+    photo_url: string;
+    thumb_url: string;
+    photo_width?: number;
+    photo_height?: number;
+    title?: string;
+    description?: string;
+    caption?: string;
+    parse_mode?: string;
+    caption_entities?: string;
+    constructor(photo: string);
+}
+export declare class TelegramInlineQueryResultArticle extends TelegramInlineQueryResult {
+    title: string;
+    input_message_content: TelegramInputMessageContent;
+    thumb_url: string;
+    constructor(content: string, title?: string, parse_mode?: string, thumb_url?: string);
+}
+export type DDGQueryResponse = {
+    AbstractSource: string;
+    AbstractURL: string;
+    Redirect: string;
+    Image: string;
+    RelatedTopics: {
+        Icon: {
+            URL: string;
+        };
+    }[];
+};

package/dist/main/src/types.js

@@ -0,0 +1,100 @@
+import Webhook from "./webhook";
+export { Webhook };
+export class Config {
+    bot_name;
+    api;
+    webhook;
+    commands;
+    kv;
+    url;
+    handler;
+    constructor(config = {}) {
+        this.bot_name = config.bot_name || "";
+        this.api = config.api || {};
+        this.webhook = config.webhook || new Webhook(localhost, "", localhost);
+        this.commands = config.commands || {};
+        this.kv = config.kv;
+        this.url = config.url || new URL(localhost);
+        this.handler = config.handler;
+    }
+}
+export const localhost = new URL("http://localhost");
+export class WebhookCommands {
+}
+export class Update {
+}
+export class TelegramUpdate extends Update {
+    update_id;
+    message;
+    edited_message;
+    channel_post;
+    edited_channel_post;
+    inline_query;
+    // chosen_inline_result?: TelegramChosenInlineResult;
+    // callback_query?: TelegramCallbackQuery;
+    // shipping_query?: TelegramShippingQuery;
+    // pre_checkout_query?: TelegramPreCheckoutQuery;
+    // poll?: TelegramPoll;
+    // poll_answer?: TelegramPollAnswer;
+    // my_chat_member?: TelegramChatMemberUpdated;
+    // chat_member?: TelegramChatMemberUpdated;
+    // chat_join_request: TelegramChatJoinRequest;
+    constructor(update) {
+        super();
+        this.update_id = update.update_id || 0;
+        this.message = update.message;
+        this.edited_message = update.edited_message;
+        this.channel_post = update.channel_post;
+        this.edited_channel_post = update.edited_channel_post;
+        this.inline_query = update.inline_query;
+        // chosen_inline_result = update.chosen_inline_result;
+        // callback_query = update.callback_query;
+        // shipping_query = update.shipping_query;
+        // pre_checkout_query = update.pre_checkout_query;
+        // poll = update.poll;
+        // poll_answer = update.poll_answer;
+        // my_chat_member = update.my_chat_member;
+        // chat_member = update.chat_member;
+        // chat_join_request = update.chat_join_request;
+    }
+}
+export class TelegramInlineQueryResult {
+    type;
+    id;
+    constructor(type) {
+        this.type = type;
+        this.id = crypto.randomUUID();
+    }
+}
+export class TelegramInlineQueryResultPhoto extends TelegramInlineQueryResult {
+    photo_url; // must be a jpg
+    thumb_url;
+    photo_width;
+    photo_height;
+    title;
+    description;
+    caption;
+    parse_mode;
+    caption_entities;
+    // reply_markup?: TelegramInlineKeyboardMarkup;
+    // input_message_content?: TelegramInputMessageContent;
+    constructor(photo) {
+        super("photo");
+        this.photo_url = photo;
+        this.thumb_url = photo;
+    }
+}
+export class TelegramInlineQueryResultArticle extends TelegramInlineQueryResult {
+    title;
+    input_message_content;
+    thumb_url;
+    constructor(content, title = content, parse_mode = "", thumb_url = "") {
+        super("article");
+        this.title = title;
+        this.input_message_content = {
+            message_text: content.toString(),
+            parse_mode,
+        };
+        this.thumb_url = thumb_url;
+    }
+}

package/dist/main/src/webhook.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="@cloudflare/workers-types" />
+import { WebhookCommands } from "./types";
+export default class Webhook {
+    api: URL;
+    token: string;
+    url: URL;
+    commands: WebhookCommands;
+    constructor(api: URL, token: string, url: URL);
+    process: (url: URL) => Promise<Response>;
+}

package/dist/main/src/webhook.js

@@ -0,0 +1,17 @@
+import { JSONResponse } from "./libs";
+export default class Webhook {
+    api;
+    token;
+    url;
+    commands;
+    constructor(api, token, url) {
+        this.api = api;
+        this.token = token;
+        this.url = url;
+        this.commands = {
+            default: () => new Promise(() => JSONResponse({ error: "Invalid command" }, 400)),
+        };
+    }
+    process = async (url) => this.commands[url.searchParams.get("command") ?? ""]?.() ??
+        this.commands.default;
+}

package/dist/worker/src/worker.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="@cloudflare/workers-types" />
+interface Environment {
+    SECRET_TELEGRAM_API_TOKEN: string;
+    KV_GET_SET: KVNamespace;
+    KV_UID_DATA: KVNamespace;
+    SECRET_TELEGRAM_API_TOKEN2: string;
+    SECRET_TELEGRAM_API_TOKEN3: string;
+}
+declare const _default: {
+    fetch: (request: Request, env: Environment) => Promise<Response>;
+};
+export default _default;

package/dist/worker/src/worker.js

@@ -0,0 +1,64 @@
+////////////////////////////////////////////////////////////////////
+////           Telegram Bot using Cloudflare Worker             ////
+////////////////////////////////////////////////////////////////////
+////  Author: Nikhil John                                       ////
+////  Repo: https://github.com/nikhiljohn10/telegram-bot-worker ////
+////  License: MIT                                              ////
+////                                                            ////
+////  Author: Sean Behan                                        ////
+////  Repo: https://github.com/codebam/cf-workers-telegram-bot  ////
+////  License: Apache-2.0                                       ////
+////////////////////////////////////////////////////////////////////
+import { TelegramCommands, Handler, TelegramWebhook, TelegramBot, } from "../../main/src/main";
+export default {
+    fetch: async (request, env) => new Handler([
+        {
+            bot_name: "cf-workers-telegram-bot",
+            api: TelegramBot,
+            webhook: new TelegramWebhook(new URL(`https://api.telegram.org/bot${env.SECRET_TELEGRAM_API_TOKEN}`), env.SECRET_TELEGRAM_API_TOKEN, new URL(new URL(request.url).origin)),
+            commands: {
+                "/ping": TelegramCommands.ping,
+                "/toss": TelegramCommands.toss,
+                "/epoch": TelegramCommands.epoch,
+                "/kanye": TelegramCommands.kanye,
+                "/bored": TelegramCommands.bored,
+                "/joke": TelegramCommands.joke,
+                "/dog": TelegramCommands.dog,
+                "/cat": TelegramCommands.cat,
+                "/roll": TelegramCommands.roll,
+                "/get": TelegramCommands._get,
+                "/set": TelegramCommands._set,
+                "/duckduckgo": TelegramCommands.duckduckgo,
+                "/code": TelegramCommands.code,
+                "/commands": TelegramCommands.commandList,
+                "/help": TelegramCommands.commandList,
+                "/start": TelegramCommands.commandList,
+            },
+            kv: { get_set: env.KV_GET_SET, uid_data: env.KV_UID_DATA },
+        },
+        {
+            bot_name: "@duckduckbot",
+            api: TelegramBot,
+            webhook: new TelegramWebhook(new URL(`https://api.telegram.org/bot${env.SECRET_TELEGRAM_API_TOKEN2}`), env.SECRET_TELEGRAM_API_TOKEN2, new URL(new URL(request.url).origin)),
+            commands: {
+                inline: TelegramCommands.duckduckgo,
+                "/duckduckgo": TelegramCommands.duckduckgo,
+                "/code": TelegramCommands.code,
+                "/commands": TelegramCommands.commandList,
+                "/start": TelegramCommands.commandList,
+            },
+        },
+        {
+            bot_name: "@ddggbot",
+            api: TelegramBot,
+            webhook: new TelegramWebhook(new URL(`https://api.telegram.org/bot${env.SECRET_TELEGRAM_API_TOKEN3}`), env.SECRET_TELEGRAM_API_TOKEN3, new URL(new URL(request.url).origin)),
+            commands: {
+                inline: TelegramCommands.duckduckgo,
+                "/duckduckgo": TelegramCommands.duckduckgo,
+                "/code": TelegramCommands.code,
+                "/commands": TelegramCommands.commandList,
+                "/start": TelegramCommands.commandList,
+            },
+        },
+    ]).handle(request),
+};