elynn-baileys 1.0.1

package/lib/Telegram/core/network/multipart-stream.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream = __importStar(require("stream"));
+const check_1 = require("../helpers/check");
+const sandwich_stream_1 = __importDefault(require("sandwich-stream"));
+const CRNL = '\r\n';
+class MultipartStream extends sandwich_stream_1.default {
+    constructor(boundary) {
+        super({
+            head: `--${boundary}${CRNL}`,
+            tail: `${CRNL}--${boundary}--`,
+            separator: `${CRNL}--${boundary}${CRNL}`,
+        });
+    }
+    addPart(part) {
+        const partStream = new stream.PassThrough();
+        for (const [key, header] of Object.entries(part.headers)) {
+            partStream.write(`${key}:${header}${CRNL}`);
+        }
+        partStream.write(CRNL);
+        if (MultipartStream.isStream(part.body)) {
+            part.body.pipe(partStream);
+        }
+        else {
+            partStream.end(part.body);
+        }
+        this.add(partStream);
+    }
+    static isStream(stream) {
+        return (typeof stream === 'object' &&
+            stream !== null &&
+            (0, check_1.hasPropType)(stream, 'pipe', 'function'));
+    }
+}
+exports.default = MultipartStream;

package/lib/Telegram/core/network/polling.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Polling = void 0;
+const abort_controller_1 = __importDefault(require("abort-controller"));
+const debug_1 = __importDefault(require("debug"));
+const util_1 = require("util");
+const error_1 = require("./error");
+const debug = (0, debug_1.default)('telegraf:polling');
+const wait = (0, util_1.promisify)(setTimeout);
+function always(x) {
+    return () => x;
+}
+const noop = always(Promise.resolve());
+class Polling {
+    constructor(telegram, allowedUpdates) {
+        this.telegram = telegram;
+        this.allowedUpdates = allowedUpdates;
+        this.abortController = new abort_controller_1.default();
+        this.skipOffsetSync = false;
+        this.offset = 0;
+    }
+    async *[Symbol.asyncIterator]() {
+        var _a, _b;
+        debug('Starting long polling');
+        do {
+            try {
+                const updates = await this.telegram.callApi('getUpdates', {
+                    timeout: 50,
+                    offset: this.offset,
+                    allowed_updates: this.allowedUpdates,
+                }, this.abortController);
+                const last = updates[updates.length - 1];
+                if (last !== undefined) {
+                    this.offset = last.update_id + 1;
+                }
+                yield updates;
+            }
+            catch (error) {
+                const err = error;
+                if (err.name === 'AbortError')
+                    return;
+                if (err.name === 'FetchError' ||
+                    (err instanceof error_1.TelegramError && err.code === 429) ||
+                    (err instanceof error_1.TelegramError && err.code >= 500)) {
+                    const retryAfter = (_b = (_a = err.parameters) === null || _a === void 0 ? void 0 : _a.retry_after) !== null && _b !== void 0 ? _b : 5;
+                    debug('Failed to fetch updates, retrying after %ds.', retryAfter, err);
+                    await wait(retryAfter * 1000);
+                    continue;
+                }
+                if (err instanceof error_1.TelegramError &&
+                    // Unauthorized      Conflict
+                    (err.code === 401 || err.code === 409)) {
+                    this.skipOffsetSync = true;
+                    throw err;
+                }
+                throw err;
+            }
+        } while (!this.abortController.signal.aborted);
+    }
+    async syncUpdateOffset() {
+        if (this.skipOffsetSync)
+            return;
+        debug('Syncing update offset...');
+        await this.telegram.callApi('getUpdates', { offset: this.offset, limit: 1 });
+    }
+    async loop(handleUpdate) {
+        if (this.abortController.signal.aborted)
+            throw new Error('Polling instances must not be reused!');
+        try {
+            for await (const updates of this)
+                await Promise.all(updates.map(handleUpdate));
+        }
+        finally {
+            debug('Long polling stopped');
+            // prevent instance reuse
+            this.stop();
+            await this.syncUpdateOffset().catch(noop);
+        }
+    }
+    stop() {
+        this.abortController.abort();
+    }
+}
+exports.Polling = Polling;

package/lib/Telegram/core/network/webhook.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = generateWebhook;
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('telegraf:webhook');
+function generateWebhook(filter, updateHandler) {
+    return async (req, res, next = () => {
+        res.statusCode = 403;
+        debug('Replying with status code', res.statusCode);
+        res.end();
+    }) => {
+        debug('Incoming request', req.method, req.url);
+        if (!filter(req)) {
+            debug('Webhook filter failed', req.method, req.url);
+            return next();
+        }
+        let update;
+        try {
+            if (req.body != null) {
+                /* If req.body is already set, we expect it to be the parsed
+                 request body (update object) received from Telegram
+                 However, some libraries such as `serverless-http` set req.body to the
+                 raw buffer, so we'll handle that additionally */
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                let body = req.body;
+                // if body is Buffer, parse it into string
+                if (body instanceof Buffer)
+                    body = String(req.body);
+                // if body is string, parse it into object
+                if (typeof body === 'string')
+                    body = JSON.parse(body);
+                update = body;
+            }
+            else {
+                let body = '';
+                // parse each buffer to string and append to body
+                for await (const chunk of req)
+                    body += String(chunk);
+                // parse body to object
+                update = JSON.parse(body);
+            }
+        }
+        catch (error) {
+            // if any of the parsing steps fails, give up and respond with error
+            res.writeHead(415).end();
+            debug('Failed to parse request body:', error);
+            return;
+        }
+        return await updateHandler(update, res);
+    };
+}

package/lib/Telegram/core/types/typegram.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// internal type provisions
+__exportStar(require("@telegraf/types/api"), exports);
+__exportStar(require("@telegraf/types/inline"), exports);
+__exportStar(require("@telegraf/types/manage"), exports);
+__exportStar(require("@telegraf/types/markup"), exports);
+__exportStar(require("@telegraf/types/message"), exports);
+__exportStar(require("@telegraf/types/methods"), exports);
+__exportStar(require("@telegraf/types/passport"), exports);
+__exportStar(require("@telegraf/types/payment"), exports);
+__exportStar(require("@telegraf/types/settings"), exports);
+__exportStar(require("@telegraf/types/update"), exports);

package/lib/Telegram/elynn-telegraf.js

@@ -0,0 +1,256 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElynnTelegraf = void 0;
+const crypto = __importStar(require("crypto"));
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const composer_1 = require("./composer");
+const compact_1 = require("./core/helpers/compact");
+const context_1 = __importDefault(require("./context"));
+const debug_1 = __importDefault(require("debug"));
+const webhook_1 = __importDefault(require("./core/network/webhook"));
+const polling_1 = require("./core/network/polling");
+const p_timeout_1 = __importDefault(require("p-timeout"));
+const telegram_1 = __importDefault(require("./telegram"));
+const url_1 = require("url");
+const safeCompare = require("safe-compare");
+const debug = (0, debug_1.default)('telegraf:main');
+const DEFAULT_OPTIONS = {
+    telegram: {},
+    handlerTimeout: 90000, // 90s in ms
+    contextType: context_1.default,
+};
+function always(x) {
+    return () => x;
+}
+const anoop = always(Promise.resolve());
+const TOKEN_HEADER = 'x-telegram-bot-api-secret-token';
+class ElynnTelegraf extends composer_1.Composer {
+    constructor(token, options) {
+        super();
+        this.context = {};
+        /** Assign to this to customise the webhook filter middleware.
+         * `{ path, secretToken }` will be bound to this rather than the Telegraf instance.
+         * Remember to assign a regular function and not an arrow function so it's bindable.
+         */
+        this.webhookFilter = function (req) {
+            const debug = (0, debug_1.default)('telegraf:webhook');
+            if (req.method === 'POST') {
+                if (safeCompare(this.path, req.url)) {
+                    // no need to check if secret_token was not set
+                    if (!this.secretToken)
+                        return true;
+                    else {
+                        const token = req.headers[TOKEN_HEADER];
+                        if (safeCompare(this.secretToken, token))
+                            return true;
+                        else
+                            debug('Secret token does not match:', token, this.secretToken);
+                    }
+                }
+                else
+                    debug('Path does not match:', req.url, this.path);
+            }
+            else
+                debug('Unexpected request method, not POST. Received:', req.method);
+            return false;
+        };
+        this.handleError = (err, ctx) => {
+            // set exit code to emulate `warn-with-error-code` behavior of
+            // https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode
+            // to prevent a clean exit despite an error being thrown
+            process.exitCode = 1;
+            console.error('Unhandled error while processing', ctx.update);
+            throw err;
+        };
+        // @ts-expect-error Trust me, TS
+        this.options = {
+            ...DEFAULT_OPTIONS,
+            ...(0, compact_1.compactOptions)(options),
+        };
+        this.telegram = new telegram_1.default(token, this.options.telegram);
+        debug('Created a `Telegraf` instance');
+    }
+    get token() {
+        return this.telegram.token;
+    }
+    /** @deprecated use `ctx.telegram.webhookReply` */
+    set webhookReply(webhookReply) {
+        this.telegram.webhookReply = webhookReply;
+    }
+    /** @deprecated use `ctx.telegram.webhookReply` */
+    get webhookReply() {
+        return this.telegram.webhookReply;
+    }
+    /**
+     * _Override_ error handling
+     */
+    catch(handler) {
+        this.handleError = handler;
+        return this;
+    }
+    /**
+     * You must call `bot.telegram.setWebhook` for this to work.
+     * You should probably use {@link Telegraf.createWebhook} instead.
+     */
+    webhookCallback(path = '/', opts = {}) {
+        const { secretToken } = opts;
+        return (0, webhook_1.default)(this.webhookFilter.bind({ hookPath: path, path, secretToken }), (update, res) => this.handleUpdate(update, res));
+    }
+    getDomainOpts(opts) {
+        var _a;
+        const protocol = opts.domain.startsWith('https://') || opts.domain.startsWith('http://');
+        if (protocol)
+            debug('Unexpected protocol in domain, telegraf will use https:', opts.domain);
+        const domain = protocol ? new url_1.URL(opts.domain).host : opts.domain;
+        const path = (_a = opts.path) !== null && _a !== void 0 ? _a : `/telegraf/${this.secretPathComponent()}`;
+        const url = `https://${domain}${path}`;
+        return { domain, path, url };
+    }
+    /**
+     * Specify a url to receive incoming updates via webhook.
+     * Returns an Express-style middleware you can pass to app.use()
+     */
+    async createWebhook(opts) {
+        const { domain, path, ...extra } = opts;
+        const domainOpts = this.getDomainOpts({ domain, path });
+        await this.telegram.setWebhook(domainOpts.url, extra);
+        debug(`Webhook set to ${domainOpts.url}`);
+        return this.webhookCallback(domainOpts.path, {
+            secretToken: extra.secret_token,
+        });
+    }
+    startPolling(allowedUpdates = []) {
+        this.polling = new polling_1.Polling(this.telegram, allowedUpdates);
+        return this.polling.loop(async (update) => {
+            await this.handleUpdate(update);
+        });
+    }
+    startWebhook(path, tlsOptions, port, host, cb, secretToken) {
+        const webhookCb = this.webhookCallback(path, { secretToken });
+        const callback = typeof cb === 'function'
+            ? (req, res) => webhookCb(req, res, () => cb(req, res))
+            : webhookCb;
+        this.webhookServer =
+            tlsOptions != null
+                ? https.createServer(tlsOptions, callback)
+                : http.createServer(callback);
+        this.webhookServer.listen(port, host, () => {
+            debug('Webhook listening on port: %s', port);
+        });
+        return this;
+    }
+    secretPathComponent() {
+        return crypto
+            .createHash('sha3-256')
+            .update(this.token)
+            .update(process.version) // salt
+            .digest('hex');
+    }
+    /**
+     * @see https://github.com/telegraf/telegraf/discussions/1344#discussioncomment-335700
+     */
+    async launch(config = {}, 
+    /** @experimental */
+    onLaunch) {
+        var _a, _b;
+        const [cfg, onMe] = typeof config === 'function' ? [{}, config] : [config, onLaunch];
+        const drop_pending_updates = cfg.dropPendingUpdates;
+        const allowed_updates = cfg.allowedUpdates;
+        const webhook = cfg.webhook;
+        debug('Connecting to Telegram');
+        (_a = this.botInfo) !== null && _a !== void 0 ? _a : (this.botInfo = await this.telegram.getMe());
+        onMe === null || onMe === void 0 ? void 0 : onMe();
+        debug(`Launching @${this.botInfo.username}`);
+        if (webhook === undefined) {
+            await this.telegram.deleteWebhook({ drop_pending_updates });
+            debug('Bot started with long polling');
+            await this.startPolling(allowed_updates);
+            return;
+        }
+        const domainOpts = this.getDomainOpts({
+            domain: webhook.domain,
+            path: (_b = webhook.path) !== null && _b !== void 0 ? _b : webhook.hookPath,
+        });
+        const { tlsOptions, port, host, cb, secretToken } = webhook;
+        this.startWebhook(domainOpts.path, tlsOptions, port, host, cb, secretToken);
+        await this.telegram.setWebhook(domainOpts.url, {
+            drop_pending_updates: drop_pending_updates,
+            allowed_updates: allowed_updates,
+            ip_address: webhook.ipAddress,
+            max_connections: webhook.maxConnections,
+            secret_token: webhook.secretToken,
+            certificate: webhook.certificate,
+        });
+        debug(`Bot started with webhook @ ${domainOpts.url}`);
+    }
+    stop(reason = 'unspecified') {
+        var _a, _b;
+        debug('Stopping bot... Reason:', reason);
+        // https://github.com/telegraf/telegraf/pull/1224#issuecomment-742693770
+        if (this.polling === undefined && this.webhookServer === undefined) {
+            throw new Error('Bot is not running!');
+        }
+        (_a = this.webhookServer) === null || _a === void 0 ? void 0 : _a.close();
+        (_b = this.polling) === null || _b === void 0 ? void 0 : _b.stop();
+    }
+    async handleUpdate(update, webhookResponse) {
+        var _a, _b;
+        (_a = this.botInfo) !== null && _a !== void 0 ? _a : (this.botInfo = (debug('Update %d is waiting for `botInfo` to be initialized', update.update_id),
+            await ((_b = this.botInfoCall) !== null && _b !== void 0 ? _b : (this.botInfoCall = this.telegram.getMe()))));
+        debug('Processing update', update.update_id);
+        const tg = new telegram_1.default(this.token, this.telegram.options, webhookResponse);
+        const TelegrafContext = this.options.contextType;
+        const ctx = new TelegrafContext(update, tg, this.botInfo);
+        Object.assign(ctx, this.context);
+        try {
+            await (0, p_timeout_1.default)(Promise.resolve(this.middleware()(ctx, anoop)), this.options.handlerTimeout);
+        }
+        catch (err) {
+            return await this.handleError(err, ctx);
+        }
+        finally {
+            if ((webhookResponse === null || webhookResponse === void 0 ? void 0 : webhookResponse.writableEnded) === false) {
+                webhookResponse.end();
+            }
+            debug('Finished processing update', update.update_id);
+        }
+    }
+}
+exports.ElynnTelegraf = ElynnTelegraf;

package/lib/Telegram/esm-bridge.mjs

@@ -0,0 +1,21 @@
+// ESM bridge — wraps CJS telegraf compiled output untuk elynn-baileys (ESM)
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+const tg = require('./index.js');
+
+export const ElynnTelegraf   = tg.ElynnTelegraf;
+export const Composer        = tg.Composer;
+export const Context         = tg.Context;
+export const Router          = tg.Router;
+export const Telegram        = tg.Telegram;
+export const TelegramError   = tg.TelegramError;
+export const session         = tg.session;
+export const MemorySessionStore = tg.MemorySessionStore;
+export const deunionize      = tg.deunionize;
+export const Types           = tg.Types;
+export const Markup          = tg.Markup;
+export const Input           = tg.Input;
+export const Format          = tg.Format;
+export const Scenes          = tg.Scenes;
+export const TelegramButton  = tg.TelegramButton;

package/lib/Telegram/filters.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allOf = exports.anyOf = exports.callbackQuery = exports.editedChannelPost = exports.channelPost = exports.editedMessage = exports.message = void 0;
+const message = (...keys) => (update) => {
+    if (!('message' in update))
+        return false;
+    for (const key of keys) {
+        if (!(key in update.message))
+            return false;
+    }
+    return true;
+};
+exports.message = message;
+const editedMessage = (...keys) => (update) => {
+    if (!('edited_message' in update))
+        return false;
+    for (const key of keys) {
+        if (!(key in update.edited_message))
+            return false;
+    }
+    return true;
+};
+exports.editedMessage = editedMessage;
+const channelPost = (...keys) => (update) => {
+    if (!('channel_post' in update))
+        return false;
+    for (const key of keys) {
+        if (!(key in update.channel_post))
+            return false;
+    }
+    return true;
+};
+exports.channelPost = channelPost;
+const editedChannelPost = (...keys) => (update) => {
+    if (!('edited_channel_post' in update))
+        return false;
+    for (const key of keys) {
+        if (!(key in update.edited_channel_post))
+            return false;
+    }
+    return true;
+};
+exports.editedChannelPost = editedChannelPost;
+const callbackQuery = (...keys) => (update) => {
+    if (!('callback_query' in update))
+        return false;
+    for (const key of keys) {
+        if (!(key in update.callback_query))
+            return false;
+    }
+    return true;
+};
+exports.callbackQuery = callbackQuery;
+/** Any of the provided filters must match */
+const anyOf = (...filters) => (update) => {
+    for (const filter of filters)
+        if (filter(update))
+            return true;
+    return false;
+};
+exports.anyOf = anyOf;
+/** All of the provided filters must match */
+const allOf = (...filters) => (update) => {
+    for (const filter of filters)
+        if (!filter(update))
+            return false;
+    return true;
+};
+exports.allOf = allOf;

package/lib/Telegram/format.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mention = exports.link = exports.pre = exports.code = exports.quote = exports.underline = exports.strikethrough = exports.spoiler = exports.italic = exports.bold = exports.fmt = exports.join = exports.FmtString = void 0;
+exports.richTextPlain = exports.richTextBold = exports.richTextItalic = exports.richTextUnderline = exports.richTextStrikethrough = exports.richTextSpoiler = exports.richTextCode = exports.richTextCustomEmoji = exports.richTextUrl = exports.richTextEmailAddress = exports.richTextDateTime = exports.richTextTextMention = exports.richTextSubscript = exports.richTextSuperscript = exports.richTextMarked = exports.richTextMathematicalExpression = void 0;
+const formatting_1 = require("./core/helpers/formatting");
+Object.defineProperty(exports, "FmtString", { enumerable: true, get: function () { return formatting_1.FmtString; } });
+exports.join = formatting_1.join;
+exports.fmt = (0, formatting_1.createFmt)();
+exports.bold = (0, formatting_1.createFmt)('bold');
+exports.italic = (0, formatting_1.createFmt)('italic');
+exports.spoiler = (0, formatting_1.createFmt)('spoiler');
+exports.strikethrough = (0, formatting_1.createFmt)('strikethrough');
+exports.underline = (0, formatting_1.createFmt)('underline');
+exports.quote = (0, formatting_1.createFmt)('blockquote');
+exports.code = (0, formatting_1.createFmt)('code');
+const pre = (language) => (0, formatting_1.createFmt)('pre', { language });
+exports.pre = pre;
+const link = (content, url) => (0, formatting_1.linkOrMention)(content, { type: 'text_link', url });
+exports.link = link;
+const mention = (name, user) => typeof user === 'number'
+    ? (0, exports.link)(name, 'tg://user?id=' + user)
+    : (0, formatting_1.linkOrMention)(name, {
+        type: 'text_mention',
+        user,
+    });
+exports.mention = mention;
+const richTextPlain = (text) => ({ type: "plain", text });
+exports.richTextPlain = richTextPlain;
+const richTextBold = (text) => ({ type: "bold", text });
+exports.richTextBold = richTextBold;
+const richTextItalic = (text) => ({ type: "italic", text });
+exports.richTextItalic = richTextItalic;
+const richTextUnderline = (text) => ({ type: "underline", text });
+exports.richTextUnderline = richTextUnderline;
+const richTextStrikethrough = (text) => ({ type: "strikethrough", text });
+exports.richTextStrikethrough = richTextStrikethrough;
+const richTextSpoiler = (text) => ({ type: "spoiler", text });
+exports.richTextSpoiler = richTextSpoiler;
+const richTextCode = (text) => ({ type: "code", text });
+exports.richTextCode = richTextCode;
+const richTextCustomEmoji = (text, custom_emoji_id) => ({ type: "custom_emoji", text, custom_emoji_id });
+exports.richTextCustomEmoji = richTextCustomEmoji;
+const richTextUrl = (text, url) => ({ type: "url", text, url });
+exports.richTextUrl = richTextUrl;
+const richTextEmailAddress = (text, email_address) => ({ type: "email_address", text, email_address });
+exports.richTextEmailAddress = richTextEmailAddress;
+const richTextDateTime = (text, unix_time, date_time_format) => ({ type: "date_time", text, unix_time, date_time_format });
+exports.richTextDateTime = richTextDateTime;
+const richTextTextMention = (text, user) => ({ type: "text_mention", text, user });
+exports.richTextTextMention = richTextTextMention;
+const richTextSubscript = (text) => ({ type: "subscript", text });
+exports.richTextSubscript = richTextSubscript;
+const richTextSuperscript = (text) => ({ type: "superscript", text });
+exports.richTextSuperscript = richTextSuperscript;
+const richTextMarked = (text) => ({ type: "marked", text });
+exports.richTextMarked = richTextMarked;
+const richTextMathematicalExpression = (text, mathematical_expression) => ({ type: "mathematical_expression", text, mathematical_expression });
+exports.richTextMathematicalExpression = richTextMathematicalExpression;