@prajwalshete/telegram-plugin 0.0.0-stage → 0.1.0

package/dist/testing/fake-telegram.js

@@ -0,0 +1,856 @@
+import { checkTelegramHtml } from "./fake-html.js";
+// src/testing/fake-telegram.ts
+/** A Bot API error reply, thrown inside method handlers. */
+var Fail = class {
+	status;
+	description;
+	parameters;
+	constructor(status, description, parameters) {
+		this.status = status;
+		this.description = description;
+		this.parameters = parameters;
+	}
+};
+const MAX_TEXT = 4096;
+const MAX_CAPTION = 1024;
+const MAX_UPLOAD = 52428800;
+const MAX_PHOTO = 10485760;
+const SEND_METHODS = /* @__PURE__ */ new Set([
+	"sendmessage",
+	"senddocument",
+	"sendphoto"
+]);
+const METHOD_BY_LOWER = new Map([
+	"getMe",
+	"setWebhook",
+	"deleteWebhook",
+	"getWebhookInfo",
+	"getUpdates",
+	"setMyCommands",
+	"deleteMyCommands",
+	"getMyCommands",
+	"sendMessage",
+	"sendDocument",
+	"sendPhoto",
+	"sendChatAction",
+	"editMessageText",
+	"editMessageReplyMarkup",
+	"deleteMessage",
+	"answerCallbackQuery",
+	"getFile",
+	"getChat",
+	"getChatMember",
+	"leaveChat"
+].map((m) => [m.toLowerCase(), m]));
+const JSON_FIELDS = /* @__PURE__ */ new Set([
+	"reply_markup",
+	"link_preview_options",
+	"allowed_updates",
+	"commands",
+	"scope",
+	"reply_parameters"
+]);
+function randomToken(id) {
+	const bytes = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(26));
+	const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-";
+	let s = "AA";
+	for (const b of bytes) s += alphabet[b % 64];
+	return `${id}:${s}${"x".repeat(7)}`;
+}
+function num(v) {
+	if (typeof v === "number") return v;
+	if (typeof v === "string" && v.trim() !== "" && !Number.isNaN(Number(v))) return Number(v);
+}
+function str(v) {
+	if (typeof v === "string") return v;
+	if (typeof v === "number") return String(v);
+}
+function bool(v) {
+	return v === true || v === "true";
+}
+function jsonReply(status, body) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json" }
+	});
+}
+function fileLike(v) {
+	return typeof Blob !== "undefined" && v instanceof Blob;
+}
+/** In-memory Telegram Bot API. */
+var FakeTelegram = class {
+	/** Every call, in order. */
+	calls = [];
+	/** Every text message sent. */
+	messages = [];
+	/** Every document and photo sent. */
+	files = [];
+	/** Every `answerCallbackQuery`. */
+	callbackAnswers = [];
+	/** Every `sendChatAction`. */
+	chatActions = [];
+	#bots = [];
+	#failures = /* @__PURE__ */ new Map();
+	#opts;
+	#nextBotId = 7000000001;
+	#nextFile = 1;
+	constructor(opts = {}) {
+		this.#opts = opts;
+		if (!opts.noDefaultBot) this.addBot({
+			id: 7000000001,
+			username: "FakeTestBot",
+			firstName: "Fake Test"
+		});
+	}
+	/** Use as `fetchTelegram({ fetch: fake.fetch })`. */
+	fetch = async (input, init) => {
+		const request = new Request(input, init);
+		return this.#handle(request);
+	};
+	/** The first bot (created by default). */
+	get defaultBot() {
+		const first = this.#bots[0];
+		if (!first) throw new Error("FakeTelegram has no bots");
+		return first.info;
+	}
+	/** All bots, in creation order. */
+	get bots() {
+		return this.#bots.map((b) => b.info);
+	}
+	/** Adds a bot; returns its token, id and username. */
+	addBot(init = {}) {
+		const id = init.id ?? this.#nextBotId;
+		this.#nextBotId = Math.max(this.#nextBotId, id) + 1;
+		const info = {
+			token: init.token ?? randomToken(id),
+			id,
+			username: init.username ?? `Fake${id}Bot`,
+			firstName: init.firstName ?? "Fake"
+		};
+		this.#bots.push({
+			info,
+			webhook: null,
+			webhookError: null,
+			updates: [],
+			commands: /* @__PURE__ */ new Map(),
+			chats: /* @__PURE__ */ new Map(),
+			files: /* @__PURE__ */ new Map()
+		});
+		return info;
+	}
+	/** Revokes a token (later calls get 401), like `/revoke` in BotFather. */
+	revokeToken(bot) {
+		const s = this.#bot(bot);
+		s.info.token = `${s.info.id}:revoked-${crypto.randomUUID()}`;
+	}
+	/** Creates or changes a chat known to a bot. */
+	setChat(chatId, init = {}, bot) {
+		const s = this.#bot(bot);
+		const chat = s.chats.get(String(chatId)) ?? this.#newChat(chatId);
+		if (init.type) chat.type = init.type;
+		if (init.title !== void 0) chat.title = init.title;
+		if (init.username !== void 0) chat.username = init.username;
+		if (init.firstName !== void 0) chat.firstName = init.firstName;
+		if (init.isForum !== void 0) chat.isForum = init.isForum;
+		if (init.topics) chat.topics = new Set(init.topics);
+		if (init.status) chat.status = init.status;
+		if (init.migratedTo !== void 0) chat.migratedTo = init.migratedTo;
+		if (init.members) for (const [k, v] of Object.entries(init.members)) chat.members.set(Number(k), v);
+		s.chats.set(String(chatId), chat);
+	}
+	/** Current state of a chat as the fake sees it, or undefined. */
+	chat(chatId, bot) {
+		return this.#bot(bot).chats.get(String(chatId));
+	}
+	/** The next matching call(s) fail. */
+	failNext(method, failure = {}) {
+		const key = method.toLowerCase();
+		const list = this.#failures.get(key) ?? [];
+		list.push({
+			times: 1,
+			...failure
+		});
+		this.#failures.set(key, list);
+	}
+	/** Stores a file the bot can `getFile` + download (for inbound photo / document tests). */
+	addFile(bytes, o = {}) {
+		const data = typeof bytes === "string" ? new TextEncoder().encode(bytes) : bytes;
+		return this.#storeFile(this.#bot(o.bot), data, o.name ?? "file.bin", o.mime ?? "application/octet-stream", "doc").fileId;
+	}
+	/** Queues an update for `getUpdates`. */
+	pushUpdate(update, bot) {
+		this.#bot(bot).updates.push(update);
+	}
+	/** Updates queued for `getUpdates` and not yet confirmed. */
+	pendingUpdates(bot) {
+		return this.#bot(bot).updates;
+	}
+	/** The registered webhook, or null. */
+	webhook(bot) {
+		return this.#bot(bot).webhook;
+	}
+	/** Makes getWebhookInfo report a delivery error. */
+	setWebhookError(message, bot) {
+		this.#bot(bot).webhookError = message === null ? null : {
+			date: this.#nowSec(),
+			message
+		};
+	}
+	/** The POST Telegram would send to the registered webhook (with the secret header). */
+	webhookRequest(update, o = {}) {
+		const s = this.#bot(o.bot);
+		const url = o.url ?? s.webhook?.url;
+		if (!url) throw new Error("no webhook registered for this bot");
+		const headers = { "content-type": "application/json" };
+		const secret = o.secret === void 0 ? s.webhook?.secretToken : o.secret;
+		if (secret) headers["x-telegram-bot-api-secret-token"] = secret;
+		return new Request(url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(update)
+		});
+	}
+	/** Commands set for a scope + language (exact match, like getMyCommands). */
+	commands(o = {}) {
+		return this.#bot(o.bot).commands.get(this.#commandKey(o.scope, o.language));
+	}
+	/** Recorded calls to one method (case-insensitive). */
+	callsTo(method) {
+		const m = method.toLowerCase();
+		return this.calls.filter((c) => c.method.toLowerCase() === m);
+	}
+	/** Text messages sent to a chat (optionally by one bot). */
+	messagesTo(chatId, bot) {
+		const botId = bot === void 0 ? void 0 : this.#bot(bot).info.id;
+		return this.messages.filter((m) => m.chatId === String(chatId) && (botId === void 0 || m.botId === botId));
+	}
+	/** Documents sent to a chat. */
+	documentsTo(chatId, bot) {
+		return this.#filesTo(chatId, "document", bot);
+	}
+	/** Photos sent to a chat. */
+	photosTo(chatId, bot) {
+		return this.#filesTo(chatId, "photo", bot);
+	}
+	/** Clears recorded calls, messages and failures (bots, chats and webhooks stay). */
+	reset() {
+		this.calls.length = 0;
+		this.messages.length = 0;
+		this.files.length = 0;
+		this.callbackAnswers.length = 0;
+		this.chatActions.length = 0;
+		this.#failures.clear();
+	}
+	#filesTo(chatId, kind, bot) {
+		const botId = bot === void 0 ? void 0 : this.#bot(bot).info.id;
+		return this.files.filter((f) => f.kind === kind && f.chatId === String(chatId) && (botId === void 0 || f.botId === botId));
+	}
+	#now() {
+		return this.#opts.now ? this.#opts.now() : Date.now();
+	}
+	#nowSec() {
+		return Math.floor(this.#now() / 1e3);
+	}
+	#bot(ref) {
+		const s = ref === void 0 ? this.#bots[0] : this.#bots.find((b) => b.info.token === ref || b.info.username === ref || b.info.id === ref);
+		if (!s) throw new Error("FakeTelegram: unknown bot");
+		return s;
+	}
+	#newChat(id) {
+		const type = id > 0 ? "private" : String(id).startsWith("-100") ? "supergroup" : "group";
+		return {
+			id,
+			type,
+			...type === "private" ? { firstName: "User" } : { title: `Chat ${id}` },
+			isForum: false,
+			topics: /* @__PURE__ */ new Set(),
+			status: "member",
+			members: /* @__PURE__ */ new Map(),
+			recentSends: [],
+			nextMessageId: 1
+		};
+	}
+	#commandKey(scope, language) {
+		const sc = typeof scope === "object" && scope !== null ? scope : { type: "default" };
+		return `${[
+			sc.type,
+			sc.chat_id,
+			sc.user_id
+		].filter((p) => p !== void 0).map(String).join(":")}|${typeof language === "string" ? language : ""}`;
+	}
+	#storeFile(s, bytes, name, mime, kind) {
+		const n = this.#nextFile++;
+		const ext = name.includes(".") ? name.slice(name.lastIndexOf(".")) : kind === "photo" ? ".jpg" : "";
+		const file = {
+			fileId: `BQAC-fake-${s.info.id}-${n}`,
+			uniqueId: `AgAD-fake-${n}`,
+			name,
+			mime,
+			bytes,
+			path: `${kind === "photo" ? "photos" : "documents"}/file_${n}${ext}`
+		};
+		s.files.set(file.fileId, file);
+		return file;
+	}
+	async #handle(request) {
+		const url = new URL(request.url);
+		const fileMatch = /\/file\/bot([^/]+)\/(.+)$/.exec(url.pathname);
+		if (fileMatch) return this.#download(fileMatch[1] ?? "", decodeURIComponent(fileMatch[2] ?? ""));
+		const m = /\/bot([^/]+)\/([A-Za-z]+)$/.exec(url.pathname);
+		if (!m) return jsonReply(404, {
+			ok: false,
+			error_code: 404,
+			description: "Not Found"
+		});
+		const token = decodeURIComponent(m[1] ?? "");
+		const rawMethod = m[2] ?? "";
+		const s = this.#bots.find((b) => b.info.token === token);
+		if (!s) return jsonReply(401, {
+			ok: false,
+			error_code: 401,
+			description: "Unauthorized"
+		});
+		const method = METHOD_BY_LOWER.get(rawMethod.toLowerCase());
+		const params = await this.#params(request, url);
+		const record = (ok, errorCode) => this.calls.push({
+			botId: s.info.id,
+			method: method ?? rawMethod,
+			params,
+			ok,
+			...errorCode === void 0 ? {} : { errorCode },
+			at: this.#now()
+		});
+		const failure = this.#takeFailure(rawMethod, s);
+		if (failure) {
+			if (failure.hang) {
+				record(false);
+				return new Promise((_, reject) => {
+					const abort = () => reject(request.signal.reason ?? new DOMException("aborted", "AbortError"));
+					if (request.signal.aborted) abort();
+					else request.signal.addEventListener("abort", abort, { once: true });
+				});
+			}
+			if (failure.network) {
+				record(false);
+				throw new TypeError(`fetch failed: ${request.url}`);
+			}
+			const status = failure.status ?? 400;
+			const parameters = {};
+			if (failure.retryAfter !== void 0) parameters.retry_after = failure.retryAfter;
+			if (failure.migrateToChatId !== void 0) parameters.migrate_to_chat_id = failure.migrateToChatId;
+			record(false, status);
+			return jsonReply(status, {
+				ok: false,
+				error_code: status,
+				description: failure.description ?? (status === 429 ? "Too Many Requests: retry after 1" : "Bad Request"),
+				...Object.keys(parameters).length > 0 ? { parameters } : {}
+			});
+		}
+		if (!method) {
+			record(false, 404);
+			return jsonReply(404, {
+				ok: false,
+				error_code: 404,
+				description: "Not Found: method not found"
+			});
+		}
+		let reply;
+		try {
+			reply = {
+				status: 200,
+				body: {
+					ok: true,
+					result: await this.#dispatch(s, method, params)
+				}
+			};
+		} catch (e) {
+			if (!(e instanceof Fail)) throw e;
+			reply = {
+				status: e.status,
+				body: {
+					ok: false,
+					error_code: e.status,
+					description: e.description,
+					...e.parameters ? { parameters: e.parameters } : {}
+				}
+			};
+		}
+		record(reply.status === 200, reply.status === 200 ? void 0 : reply.status);
+		return jsonReply(reply.status, reply.body);
+	}
+	#takeFailure(method, s) {
+		const list = this.#failures.get(method.toLowerCase());
+		if (!list) return void 0;
+		const idx = list.findIndex((f) => f.bot === void 0 || this.#bot(f.bot) === s);
+		if (idx < 0) return void 0;
+		const f = list[idx];
+		const left = (f.times ?? 1) - 1;
+		if (left <= 0) list.splice(idx, 1);
+		else list[idx] = {
+			...f,
+			times: left
+		};
+		return f;
+	}
+	async #params(request, url) {
+		const out = {};
+		for (const [k, v] of url.searchParams) out[k] = v;
+		if (request.method === "GET" || request.body === null) return out;
+		const type = request.headers.get("content-type") ?? "";
+		if (type.includes("application/json")) {
+			const body = await request.json().catch(() => ({}));
+			if (typeof body === "object" && body !== null) Object.assign(out, body);
+		} else if (type.includes("multipart/form-data") || type.includes("application/x-www-form-urlencoded")) {
+			const form = await request.formData();
+			for (const [k, v] of form.entries()) out[k] = v;
+		}
+		for (const k of JSON_FIELDS) {
+			const v = out[k];
+			if (typeof v === "string") try {
+				out[k] = JSON.parse(v);
+			} catch {
+				throw new Error(`FakeTelegram: field ${k} is not JSON`);
+			}
+		}
+		return out;
+	}
+	async #download(token, path) {
+		const s = this.#bots.find((b) => b.info.token === token);
+		if (!s) return jsonReply(401, {
+			ok: false,
+			error_code: 401,
+			description: "Unauthorized"
+		});
+		const file = [...s.files.values()].find((f) => f.path === path);
+		if (!file) return jsonReply(404, {
+			ok: false,
+			error_code: 404,
+			description: "Not Found"
+		});
+		return new Response(file.bytes.slice(), {
+			status: 200,
+			headers: { "content-type": file.mime }
+		});
+	}
+	async #dispatch(s, method, p) {
+		switch (method) {
+			case "getMe": return {
+				id: s.info.id,
+				is_bot: true,
+				first_name: s.info.firstName,
+				username: s.info.username,
+				can_join_groups: true,
+				can_read_all_group_messages: false,
+				supports_inline_queries: false
+			};
+			case "setWebhook": return this.#setWebhook(s, p);
+			case "deleteWebhook":
+				s.webhook = null;
+				if (bool(p.drop_pending_updates)) s.updates.length = 0;
+				return true;
+			case "getWebhookInfo": return {
+				url: s.webhook?.url ?? "",
+				has_custom_certificate: false,
+				pending_update_count: s.updates.length,
+				...s.webhook ? {
+					max_connections: s.webhook.maxConnections,
+					...s.webhook.allowedUpdates ? { allowed_updates: s.webhook.allowedUpdates } : {}
+				} : {},
+				...s.webhookError ? {
+					last_error_date: s.webhookError.date,
+					last_error_message: s.webhookError.message
+				} : {}
+			};
+			case "getUpdates": return this.#getUpdates(s, p);
+			case "setMyCommands": return this.#setMyCommands(s, p);
+			case "deleteMyCommands":
+				s.commands.delete(this.#commandKey(p.scope, p.language_code));
+				return true;
+			case "getMyCommands": return s.commands.get(this.#commandKey(p.scope, p.language_code)) ?? [];
+			case "sendMessage": return this.#sendMessage(s, p);
+			case "sendDocument": return this.#sendFile(s, p, "document");
+			case "sendPhoto": return this.#sendFile(s, p, "photo");
+			case "sendChatAction": {
+				const chat = this.#sendableChat(s, p, "sendchataction");
+				if (typeof p.action !== "string") throw new Fail(400, "Bad Request: wrong parameter action in request");
+				this.chatActions.push({
+					botId: s.info.id,
+					chatId: String(chat.id),
+					action: p.action
+				});
+				return true;
+			}
+			case "editMessageText": return this.#edit(s, p, "text");
+			case "editMessageReplyMarkup": return this.#edit(s, p, "markup");
+			case "deleteMessage": {
+				const msg = this.#findMessage(s, p);
+				if (!msg || msg.deleted) throw new Fail(400, "Bad Request: message to delete not found");
+				msg.deleted = true;
+				return true;
+			}
+			case "answerCallbackQuery":
+				if (typeof p.callback_query_id !== "string" || p.callback_query_id === "") throw new Fail(400, "Bad Request: query is too old and response timeout expired or query ID is invalid");
+				if (typeof p.text === "string" && p.text.length > 200) throw new Fail(400, "Bad Request: MESSAGE_TOO_LONG");
+				this.callbackAnswers.push({
+					botId: s.info.id,
+					params: p
+				});
+				return true;
+			case "getFile": {
+				const file = s.files.get(str(p.file_id) ?? "");
+				if (!file) throw new Fail(400, "Bad Request: wrong file_id or the file is temporarily unavailable");
+				return {
+					file_id: file.fileId,
+					file_unique_id: file.uniqueId,
+					file_size: file.bytes.length,
+					file_path: file.path
+				};
+			}
+			case "getChat": {
+				const chat = this.#knownChat(s, p);
+				return {
+					id: chat.id,
+					type: chat.type,
+					...chat.title === void 0 ? {} : { title: chat.title },
+					...chat.username === void 0 ? {} : { username: chat.username },
+					...chat.firstName === void 0 ? {} : { first_name: chat.firstName },
+					...chat.isForum ? { is_forum: true } : {},
+					accent_color_id: 0,
+					max_reaction_count: 11
+				};
+			}
+			case "getChatMember": {
+				const chat = this.#knownChat(s, p);
+				const userId = num(p.user_id);
+				if (userId === void 0) throw new Fail(400, "Bad Request: user_id is required");
+				const isBot = userId === s.info.id;
+				return {
+					status: chat.members.get(userId) ?? (isBot ? ["kicked", "left"].includes(chat.status) ? chat.status : "member" : "member"),
+					user: isBot ? {
+						id: userId,
+						is_bot: true,
+						first_name: s.info.firstName,
+						username: s.info.username
+					} : {
+						id: userId,
+						is_bot: false,
+						first_name: `User ${userId}`
+					}
+				};
+			}
+			case "leaveChat": {
+				const chat = this.#knownChat(s, p);
+				if (chat.type === "private") throw new Fail(400, "Bad Request: chat member status can't be changed in private chats");
+				chat.status = "left";
+				return true;
+			}
+		}
+	}
+	#setWebhook(s, p) {
+		const url = str(p.url) ?? "";
+		if (url === "") {
+			s.webhook = null;
+			return true;
+		}
+		let parsed;
+		try {
+			parsed = new URL(url);
+		} catch {
+			throw new Fail(400, "Bad Request: bad webhook: Failed to resolve host: Name or service not known");
+		}
+		if (parsed.protocol !== "https:") throw new Fail(400, "Bad Request: bad webhook: An HTTPS URL must be provided for webhook");
+		if (parsed.port !== "" && ![
+			"443",
+			"80",
+			"88",
+			"8443"
+		].includes(parsed.port)) throw new Fail(400, "Bad Request: bad webhook: Webhook can be set up only on ports 80, 88, 443 or 8443");
+		const secret = str(p.secret_token);
+		if (secret !== void 0 && !/^[A-Za-z0-9_-]{1,256}$/.test(secret)) throw new Fail(400, "Bad Request: secret token contains unallowed characters");
+		const max = num(p.max_connections) ?? 40;
+		if (max < 1 || max > 100) throw new Fail(400, "Bad Request: bad webhook: max_connections must be between 1 and 100");
+		const allowed = Array.isArray(p.allowed_updates) ? p.allowed_updates.map(String) : s.webhook?.allowedUpdates;
+		const drop = bool(p.drop_pending_updates);
+		if (drop) s.updates.length = 0;
+		s.webhook = {
+			url,
+			secretToken: secret,
+			allowedUpdates: allowed,
+			maxConnections: max,
+			dropPendingUpdates: drop
+		};
+		s.webhookError = null;
+		return true;
+	}
+	#getUpdates(s, p) {
+		if (s.webhook) throw new Fail(409, "Conflict: can't use getUpdates method while webhook is active; use deleteWebhook to delete the webhook first");
+		const offset = num(p.offset);
+		if (offset !== void 0) {
+			const keep = s.updates.filter((u) => u.update_id >= offset);
+			s.updates.length = 0;
+			s.updates.push(...keep);
+		}
+		const limit = Math.min(100, Math.max(1, num(p.limit) ?? 100));
+		return s.updates.slice(0, limit);
+	}
+	#setMyCommands(s, p) {
+		if (!Array.isArray(p.commands)) throw new Fail(400, "Bad Request: commands must be an array");
+		if (p.commands.length > 100) throw new Fail(400, "Bad Request: too many commands specified");
+		const commands = [];
+		for (const raw of p.commands) {
+			const command = str(raw.command) ?? "";
+			const description = str(raw.description) ?? "";
+			if (!/^[a-z0-9_]{1,32}$/.test(command)) throw new Fail(400, "Bad Request: BOT_COMMAND_INVALID");
+			if (description.length < 1 || description.length > 256) throw new Fail(400, "Bad Request: BOT_COMMAND_DESCRIPTION_INVALID");
+			commands.push({
+				command,
+				description,
+				...raw.is_ephemeral === true ? { is_ephemeral: true } : {}
+			});
+		}
+		s.commands.set(this.#commandKey(p.scope, p.language_code), commands);
+		return true;
+	}
+	/** A chat the bot knows (auto-created unless `strictChats`). Applies migration errors. */
+	#knownChat(s, p) {
+		const id = num(p.chat_id);
+		if (id === void 0) throw new Fail(400, "Bad Request: chat_id is empty");
+		let chat = s.chats.get(String(id));
+		if (!chat) {
+			if (this.#opts.strictChats) throw new Fail(400, "Bad Request: chat not found");
+			chat = this.#newChat(id);
+			s.chats.set(String(id), chat);
+		}
+		if (chat.migratedTo !== void 0) throw new Fail(400, "Bad Request: group chat was upgraded to a supergroup chat", { migrate_to_chat_id: chat.migratedTo });
+		return chat;
+	}
+	/** A chat the bot may write to now (status, topic and rate-limit checks). */
+	#sendableChat(s, p, method) {
+		const chat = this.#knownChat(s, p);
+		const kind = chat.type === "channel" ? "channel" : chat.type === "supergroup" ? "supergroup" : "group";
+		switch (chat.status) {
+			case "blocked": throw new Fail(403, "Forbidden: bot was blocked by the user");
+			case "deactivated": throw new Fail(403, "Forbidden: user is deactivated");
+			case "not_started": throw new Fail(403, "Forbidden: bot can't initiate conversation with a user");
+			case "kicked": throw new Fail(403, kind === "channel" ? "Forbidden: bot is not a member of the channel chat" : `Forbidden: bot was kicked from the ${kind} chat`);
+			case "left": throw new Fail(403, `Forbidden: bot is not a member of the ${kind} chat`);
+		}
+		const thread = num(p.message_thread_id);
+		if (thread !== void 0 && chat.isForum && !chat.topics.has(thread)) throw new Fail(400, "Bad Request: message thread not found");
+		if (this.#opts.rateLimit && SEND_METHODS.has(method)) this.#rateLimit(chat);
+		return chat;
+	}
+	#rateLimit(chat) {
+		const now = this.#now();
+		if (chat.type === "private") {
+			if (chat.lastSendAt !== void 0 && now - chat.lastSendAt < 1e3) {
+				const wait = Math.max(1, Math.ceil((1e3 - (now - chat.lastSendAt)) / 1e3));
+				throw new Fail(429, `Too Many Requests: retry after ${wait}`, { retry_after: wait });
+			}
+		} else {
+			chat.recentSends = chat.recentSends.filter((t) => now - t < 6e4);
+			const oldest = chat.recentSends[0];
+			if (chat.recentSends.length >= 20 && oldest !== void 0) {
+				const wait = Math.max(1, Math.ceil((oldest + 6e4 - now) / 1e3));
+				throw new Fail(429, `Too Many Requests: retry after ${wait}`, { retry_after: wait });
+			}
+		}
+	}
+	#markSent(chat) {
+		const now = this.#now();
+		chat.lastSendAt = now;
+		chat.recentSends.push(now);
+		return chat.nextMessageId++;
+	}
+	#chatJson(chat) {
+		return {
+			id: chat.id,
+			type: chat.type,
+			...chat.title === void 0 ? {} : { title: chat.title },
+			...chat.username === void 0 ? {} : { username: chat.username },
+			...chat.firstName === void 0 ? {} : { first_name: chat.firstName },
+			...chat.isForum ? { is_forum: true } : {}
+		};
+	}
+	#botJson(s) {
+		return {
+			id: s.info.id,
+			is_bot: true,
+			first_name: s.info.firstName,
+			username: s.info.username
+		};
+	}
+	#checkMarkup(markup) {
+		if (typeof markup !== "object" || markup === null || !("inline_keyboard" in markup)) return;
+		const rows = markup.inline_keyboard;
+		if (!Array.isArray(rows)) throw new Fail(400, "Bad Request: can't parse inline keyboard markup");
+		for (const row of rows) {
+			if (!Array.isArray(row)) throw new Fail(400, "Bad Request: can't parse inline keyboard markup");
+			for (const b of row) {
+				if (typeof b.text !== "string" || b.text === "") throw new Fail(400, "Bad Request: BUTTON_TEXT_INVALID");
+				if ([
+					"callback_data",
+					"url",
+					"copy_text",
+					"switch_inline_query_current_chat",
+					"web_app",
+					"login_url"
+				].filter((k) => k in b).length !== 1) throw new Fail(400, "Bad Request: can't parse inline keyboard button: Text buttons are unallowed in the inline keyboard");
+				if ("callback_data" in b) {
+					const bytes = new TextEncoder().encode(b.callback_data).length;
+					if (bytes < 1 || bytes > 64) throw new Fail(400, "Bad Request: BUTTON_DATA_INVALID");
+				}
+				if (b.style !== void 0 && ![
+					"danger",
+					"success",
+					"primary"
+				].includes(b.style)) throw new Fail(400, "Bad Request: BUTTON_STYLE_INVALID");
+			}
+		}
+	}
+	/** Validates text and returns what Telegram would store (plain text after entity parsing). */
+	#renderText(text, parseMode, max, field) {
+		let plain = text;
+		if (parseMode === "HTML") {
+			const check = checkTelegramHtml(text);
+			if (check.error) throw new Fail(400, check.error);
+			plain = check.text;
+		}
+		if (field === "text" && plain.trim() === "") throw new Fail(400, "Bad Request: message text is empty");
+		if (plain.length > max) throw new Fail(400, field === "text" ? "Bad Request: message is too long" : "Bad Request: message caption is too long");
+		return plain;
+	}
+	#sendMessage(s, p) {
+		const chat = this.#sendableChat(s, p, "sendmessage");
+		const text = str(p.text) ?? "";
+		const plain = this.#renderText(text, p.parse_mode, MAX_TEXT, "text");
+		this.#checkMarkup(p.reply_markup);
+		const messageId = this.#markSent(chat);
+		const thread = num(p.message_thread_id);
+		const parseMode = str(p.parse_mode);
+		this.messages.push({
+			botId: s.info.id,
+			chatId: String(chat.id),
+			messageId,
+			threadId: thread,
+			text,
+			currentText: text,
+			parseMode,
+			replyMarkup: p.reply_markup,
+			params: p,
+			edits: 0,
+			deleted: false,
+			at: this.#now()
+		});
+		return {
+			message_id: messageId,
+			date: this.#nowSec(),
+			chat: this.#chatJson(chat),
+			from: this.#botJson(s),
+			...thread === void 0 ? {} : {
+				message_thread_id: thread,
+				is_topic_message: true
+			},
+			text: plain,
+			...p.reply_markup && typeof p.reply_markup === "object" && "inline_keyboard" in p.reply_markup ? { reply_markup: p.reply_markup } : {}
+		};
+	}
+	async #sendFile(s, p, kind) {
+		const method = kind === "document" ? "senddocument" : "sendphoto";
+		const chat = this.#sendableChat(s, p, method);
+		const caption = str(p.caption);
+		if (caption !== void 0) this.#renderText(caption, p.parse_mode, MAX_CAPTION, "caption");
+		this.#checkMarkup(p.reply_markup);
+		const input = p[kind];
+		let stored;
+		let bytes = null;
+		if (fileLike(input)) {
+			bytes = new Uint8Array(await input.arrayBuffer());
+			const limit = kind === "photo" ? MAX_PHOTO : MAX_UPLOAD;
+			if (bytes.length > limit) throw new Fail(413, "Request Entity Too Large");
+			if (bytes.length === 0) throw new Fail(400, "Bad Request: file must be non-empty");
+			const name = typeof input.name === "string" && input.name !== "" ? input.name : kind === "photo" ? "photo.jpg" : "file";
+			stored = this.#storeFile(s, bytes, name, input.type || "application/octet-stream", kind === "photo" ? "photo" : "doc");
+		} else if (typeof input === "string" && /^https?:\/\//.test(input)) {
+			if (kind === "document" && !/\.(pdf|zip)(\?|$)/i.test(input)) throw new Fail(400, "Bad Request: wrong type of the web page content");
+			const name = input.split("?")[0]?.split("/").at(-1) || "file";
+			stored = this.#storeFile(s, /* @__PURE__ */ new Uint8Array(), name, kind === "photo" ? "image/jpeg" : "application/pdf", "doc");
+		} else if (typeof input === "string" && s.files.has(input)) stored = s.files.get(input);
+		else throw new Fail(400, "Bad Request: wrong file identifier/HTTP URL specified");
+		const messageId = this.#markSent(chat);
+		const thread = num(p.message_thread_id);
+		this.files.push({
+			botId: s.info.id,
+			chatId: String(chat.id),
+			messageId,
+			kind,
+			fileId: stored.fileId,
+			fileName: stored.name,
+			mime: stored.mime,
+			size: stored.bytes.length,
+			bytes,
+			caption,
+			uploaded: bytes !== null,
+			params: p,
+			at: this.#now()
+		});
+		const media = kind === "document" ? { document: {
+			file_id: stored.fileId,
+			file_unique_id: stored.uniqueId,
+			file_name: stored.name,
+			mime_type: stored.mime,
+			file_size: stored.bytes.length
+		} } : { photo: [{
+			file_id: `${stored.fileId}-s`,
+			file_unique_id: `${stored.uniqueId}-s`,
+			width: 90,
+			height: 90
+		}, {
+			file_id: stored.fileId,
+			file_unique_id: stored.uniqueId,
+			width: 1280,
+			height: 960,
+			file_size: stored.bytes.length
+		}] };
+		return {
+			message_id: messageId,
+			date: this.#nowSec(),
+			chat: this.#chatJson(chat),
+			from: this.#botJson(s),
+			...thread === void 0 ? {} : {
+				message_thread_id: thread,
+				is_topic_message: true
+			},
+			...media,
+			...caption === void 0 ? {} : { caption }
+		};
+	}
+	#findMessage(s, p) {
+		const chat = this.#knownChat(s, p);
+		const id = num(p.message_id);
+		return this.messages.find((m) => m.botId === s.info.id && m.chatId === String(chat.id) && m.messageId === id);
+	}
+	#edit(s, p, what) {
+		const msg = this.#findMessage(s, p);
+		if (!msg || msg.deleted) throw new Fail(400, "Bad Request: message to edit not found");
+		this.#checkMarkup(p.reply_markup);
+		const newText = what === "text" ? str(p.text) ?? "" : msg.currentText;
+		const plain = what === "text" ? this.#renderText(newText, p.parse_mode, MAX_TEXT, "text") : checkTelegramHtml(newText).text;
+		const newMarkup = p.reply_markup;
+		if (newText === msg.currentText && JSON.stringify(newMarkup ?? null) === JSON.stringify(msg.replyMarkup ?? null)) throw new Fail(400, "Bad Request: message is not modified: specified new message content and reply markup are exactly the same as a current content and reply markup of the message");
+		msg.currentText = newText;
+		msg.replyMarkup = newMarkup;
+		msg.edits++;
+		const chat = s.chats.get(msg.chatId);
+		return {
+			message_id: msg.messageId,
+			date: Math.floor(msg.at / 1e3),
+			edit_date: this.#nowSec(),
+			chat: this.#chatJson(chat),
+			from: this.#botJson(s),
+			text: plain,
+			...newMarkup ? { reply_markup: newMarkup } : {}
+		};
+	}
+};
+export { FakeTelegram };