balebaazoo 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1047 @@
+'use strict';
+
+var fs = require('fs');
+var promises = require('fs/promises');
+var path = require('path');
+var stream = require('stream');
+
+// src/errors.ts
+var BaleError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "BaleError";
+  }
+};
+var BaleAPIError = class extends BaleError {
+  errorCode;
+  description;
+  parameters;
+  constructor(errorCode, description, parameters) {
+    super(`Bale API error ${errorCode}: ${description}`);
+    this.name = "BaleAPIError";
+    this.errorCode = errorCode;
+    this.description = description;
+    this.parameters = parameters;
+  }
+};
+var BaleNetworkError = class extends BaleError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "BaleNetworkError";
+  }
+};
+var InputFile = class _InputFile {
+  source;
+  filename;
+  constructor(source, filename) {
+    this.source = source;
+    this.filename = filename ?? inferFilename(source);
+  }
+  static fromPath(path$1, filename) {
+    return new _InputFile(fs.createReadStream(path$1), filename ?? path.basename(path$1));
+  }
+  async toBlob() {
+    if (this.source instanceof Blob) {
+      return this.source;
+    }
+    if (typeof this.source === "string") {
+      if (this.source.startsWith("http://") || this.source.startsWith("https://")) {
+        throw new Error("URL sources cannot be converted to Blob for upload");
+      }
+      return new Blob([this.source]);
+    }
+    if (Buffer.isBuffer(this.source) || this.source instanceof Uint8Array) {
+      const bytes = Buffer.isBuffer(this.source) ? this.source : Buffer.from(this.source);
+      return new Blob([bytes]);
+    }
+    if (this.source instanceof stream.Readable) {
+      const chunks = [];
+      for await (const chunk of this.source) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      }
+      return new Blob(chunks);
+    }
+    if (this.source instanceof ReadableStream) {
+      const reader = this.source.getReader();
+      const chunks = [];
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) chunks.push(value);
+      }
+      return new Blob(chunks);
+    }
+    throw new Error("Unsupported InputFile source");
+  }
+};
+function inferFilename(source) {
+  if (typeof source === "string") {
+    if (source.includes("/") || source.includes("\\")) {
+      return path.basename(source);
+    }
+    return "file.bin";
+  }
+  if (source instanceof stream.Readable && "path" in source) {
+    const path$1 = source.path;
+    if (typeof path$1 === "string") {
+      return path.basename(path$1);
+    }
+  }
+  return "file.bin";
+}
+async function isFilePath(source) {
+  if (typeof source !== "string") return false;
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    return false;
+  }
+  try {
+    const info = await promises.stat(source);
+    return info.isFile();
+  } catch {
+    return false;
+  }
+}
+
+// src/api/client.ts
+var DEFAULT_API_BASE = "https://tapi.bale.ai";
+var Api = class {
+  token;
+  baseUrl;
+  fetchFn;
+  maxRetries;
+  retryDelayMs;
+  constructor(options) {
+    this.token = options.token;
+    this.baseUrl = options.baseUrl ?? DEFAULT_API_BASE;
+    this.fetchFn = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.maxRetries = options.maxRetries ?? 3;
+    this.retryDelayMs = options.retryDelayMs ?? 500;
+  }
+  get fileBaseUrl() {
+    return `${this.baseUrl}/file/bot${this.token}`;
+  }
+  methodUrl(method) {
+    return `${this.baseUrl}/bot${this.token}/${method}`;
+  }
+  async call(method, params) {
+    let attempt = 0;
+    while (true) {
+      try {
+        return await this.invoke(method, params);
+      } catch (error) {
+        if (error instanceof BaleAPIError && error.errorCode === 429 && attempt < this.maxRetries) {
+          const retryAfter = (error.parameters?.retry_after ?? 1) * 1e3;
+          await sleep(retryAfter);
+          attempt++;
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
+  async invoke(method, params) {
+    const { body } = await this.prepareBody(params ?? {});
+    const headers = {};
+    if (!(body instanceof FormData)) {
+      headers["Content-Type"] = "application/json";
+    }
+    return this.request(method, {
+      method: "POST",
+      headers,
+      body: body instanceof FormData ? body : JSON.stringify(body ?? {})
+    });
+  }
+  async downloadFile(filePath) {
+    const url = `${this.fileBaseUrl}/${filePath}`;
+    const response = await this.fetchWithRetry(url, { method: "GET" });
+    if (!response.ok) {
+      throw new BaleNetworkError(
+        `Failed to download file: HTTP ${response.status}`
+      );
+    }
+    return response.arrayBuffer();
+  }
+  async prepareBody(params) {
+    const entries = Object.entries(params).filter(([, value]) => value !== void 0);
+    const fileEntries = [];
+    for (const [key, value] of entries) {
+      if (value instanceof InputFile) {
+        fileEntries.push([key, value]);
+      } else if (typeof value === "string" && await isFilePath(value)) {
+        fileEntries.push([key, InputFile.fromPath(value)]);
+      }
+    }
+    if (fileEntries.length === 0) {
+      const jsonBody = {};
+      for (const [key, value] of entries) {
+        jsonBody[key] = serializeValue(value);
+      }
+      return { body: jsonBody, isMultipart: false };
+    }
+    const formData = new FormData();
+    for (const [key, value] of entries) {
+      if (value instanceof InputFile || typeof value === "string" && await isFilePath(value)) {
+        continue;
+      }
+      appendFormValue(formData, key, value);
+    }
+    for (const [key, file] of fileEntries) {
+      const blob = await file.toBlob();
+      formData.append(key, blob, file.filename);
+    }
+    return { body: formData, isMultipart: true };
+  }
+  async request(method, init) {
+    const response = await this.fetchWithRetry(this.methodUrl(method), init);
+    const payload = await response.json();
+    if (!payload.ok) {
+      throw new BaleAPIError(
+        payload.error_code ?? response.status,
+        payload.description ?? "Unknown API error",
+        payload.parameters
+      );
+    }
+    return payload.result;
+  }
+  async fetchWithRetry(url, init) {
+    let attempt = 0;
+    let lastError;
+    while (attempt <= this.maxRetries) {
+      try {
+        const response = await this.fetchFn(url, init);
+        if (response.status === 429) {
+          const retryAfter = Number(response.headers.get("retry-after") ?? "1");
+          await sleep(retryAfter * 1e3);
+          attempt++;
+          continue;
+        }
+        if (!response.ok && response.status >= 500 && attempt < this.maxRetries) {
+          await sleep(this.retryDelayMs * 2 ** attempt);
+          attempt++;
+          continue;
+        }
+        return response;
+      } catch (error) {
+        lastError = error;
+        if (attempt >= this.maxRetries) {
+          break;
+        }
+        await sleep(this.retryDelayMs * 2 ** attempt);
+        attempt++;
+      }
+    }
+    throw new BaleNetworkError(
+      `Network request failed after ${this.maxRetries + 1} attempts`,
+      { cause: lastError }
+    );
+  }
+  getMe() {
+    return this.call("getMe");
+  }
+  getUpdates(params) {
+    return this.call("getUpdates", asParams(params));
+  }
+  setWebhook(params) {
+    return this.call("setWebhook", asParams(params));
+  }
+  deleteWebhook() {
+    return this.call("deleteWebhook");
+  }
+  getWebhookInfo() {
+    return this.call("getWebhookInfo");
+  }
+  sendMessage(params) {
+    return this.call("sendMessage", asParams(params));
+  }
+  forwardMessage(params) {
+    return this.call("forwardMessage", asParams(params));
+  }
+  copyMessage(params) {
+    return this.call("copyMessage", asParams(params));
+  }
+  sendPhoto(params) {
+    return this.call("sendPhoto", asParams(params));
+  }
+  sendAudio(params) {
+    return this.call("sendAudio", asParams(params));
+  }
+  sendDocument(params) {
+    return this.call("sendDocument", asParams(params));
+  }
+  sendVideo(params) {
+    return this.call("sendVideo", asParams(params));
+  }
+  sendAnimation(params) {
+    return this.call("sendAnimation", asParams(params));
+  }
+  sendVoice(params) {
+    return this.call("sendVoice", asParams(params));
+  }
+  sendMediaGroup(params) {
+    return this.call("sendMediaGroup", {
+      ...params,
+      media: JSON.stringify(params.media)
+    });
+  }
+  sendLocation(params) {
+    return this.call("sendLocation", asParams(params));
+  }
+  sendContact(params) {
+    return this.call("sendContact", asParams(params));
+  }
+  sendChatAction(params) {
+    return this.call("sendChatAction", asParams(params));
+  }
+  getFile(params) {
+    return this.call("getFile", asParams(params));
+  }
+  answerCallbackQuery(params) {
+    return this.call("answerCallbackQuery", asParams(params));
+  }
+  askReview(params) {
+    return this.call("askReview", asParams(params));
+  }
+  banChatMember(params) {
+    return this.call("banChatMember", asParams(params));
+  }
+  unbanChatMember(params) {
+    return this.call("unbanChatMember", asParams(params));
+  }
+  promoteChatMember(params) {
+    return this.call("promoteChatMember", asParams(params));
+  }
+  setChatPhoto(params) {
+    return this.call("setChatPhoto", asParams(params));
+  }
+  leaveChat(params) {
+    return this.call("leaveChat", asParams(params));
+  }
+  getChat(params) {
+    return this.call("getChat", asParams(params));
+  }
+  getChatAdministrators(params) {
+    return this.call("getChatAdministrators", asParams(params));
+  }
+  getChatMembersCount(params) {
+    return this.call("getChatMembersCount", asParams(params));
+  }
+  getChatMember(params) {
+    return this.call("getChatMember", asParams(params));
+  }
+  pinChatMessage(params) {
+    return this.call("pinChatMessage", asParams(params));
+  }
+  unPinChatMessage(params) {
+    return this.call("unPinChatMessage", asParams(params));
+  }
+  unpinAllChatMessages(params) {
+    return this.call("unpinAllChatMessages", asParams(params));
+  }
+  setChatTitle(params) {
+    return this.call("setChatTitle", asParams(params));
+  }
+  setChatDescription(params) {
+    return this.call("setChatDescription", asParams(params));
+  }
+  deleteChatPhoto(params) {
+    return this.call("deleteChatPhoto", asParams(params));
+  }
+  createChatInviteLink(params) {
+    return this.call("createChatInviteLink", asParams(params));
+  }
+  revokeChatInviteLink(params) {
+    return this.call("revokeChatInviteLink", asParams(params));
+  }
+  exportChatInviteLink(params) {
+    return this.call("exportChatInviteLink", asParams(params));
+  }
+  editMessageText(params) {
+    return this.call("editMessageText", asParams(params));
+  }
+  editMessageCaption(params) {
+    return this.call("editMessageCaption", asParams(params));
+  }
+  editMessageReplyMarkup(params) {
+    return this.call("editMessageReplyMarkup", asParams(params));
+  }
+  deleteMessage(params) {
+    return this.call("deleteMessage", asParams(params));
+  }
+  uploadStickerFile(params) {
+    return this.call("uploadStickerFile", asParams(params));
+  }
+  createNewStickerSet(params) {
+    return this.call("createNewStickerSet", {
+      ...params,
+      sticker: JSON.stringify(params.sticker)
+    });
+  }
+  addStickerToSet(params) {
+    return this.call("addStickerToSet", {
+      ...params,
+      sticker: JSON.stringify(params.sticker)
+    });
+  }
+  sendInvoice(params) {
+    return this.call("sendInvoice", {
+      ...params,
+      prices: JSON.stringify(params.prices)
+    });
+  }
+  createInvoiceLink(params) {
+    return this.call("createInvoiceLink", {
+      ...params,
+      prices: JSON.stringify(params.prices)
+    });
+  }
+  answerPreCheckoutQuery(params) {
+    return this.call("answerPreCheckoutQuery", asParams(params));
+  }
+  inquireTransaction(params) {
+    return this.call("inquireTransaction", asParams(params));
+  }
+};
+function asParams(params) {
+  return params;
+}
+function serializeValue(value) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value) || typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return value;
+}
+function appendFormValue(formData, key, value) {
+  if (value === void 0 || value === null) return;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    formData.append(key, String(value));
+    return;
+  }
+  formData.append(key, JSON.stringify(value));
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/middleware/types.ts
+function isMiddlewareObject(value) {
+  return typeof value === "object" && value !== null && "middleware" in value && typeof value.middleware === "function";
+}
+function normalizeMiddleware(middleware) {
+  return isMiddlewareObject(middleware) ? middleware.middleware() : middleware;
+}
+async function runMiddleware(middleware, ctx) {
+  let index = -1;
+  async function dispatch(current) {
+    if (current <= index) {
+      throw new Error("next() called multiple times");
+    }
+    index = current;
+    const handler = middleware[current];
+    if (!handler) return;
+    await handler(ctx, () => dispatch(current + 1));
+  }
+  await dispatch(0);
+}
+function matchUpdate(update) {
+  const matches = [];
+  if (update.message) {
+    matches.push("message");
+    if (update.message.text !== void 0) matches.push("message:text");
+    if (update.message.photo) matches.push("message:photo");
+    if (update.message.document) matches.push("message:document");
+    if (update.message.voice) matches.push("message:voice");
+    if (update.message.audio) matches.push("message:audio");
+    if (update.message.video) matches.push("message:video");
+    if (update.message.location) matches.push("message:location");
+    if (update.message.contact) matches.push("message:contact");
+    if (update.message.sticker) matches.push("message:sticker");
+    if (update.message.successful_payment) {
+      matches.push("message:successful_payment");
+    }
+    if (update.message.web_app_data) matches.push("message:web_app_data");
+    if (update.message.text?.startsWith("/")) {
+      matches.push("message:command");
+    }
+  }
+  if (update.edited_message) {
+    matches.push("edited_message");
+    if (update.edited_message.text !== void 0) {
+      matches.push("edited_message:text");
+    }
+  }
+  if (update.callback_query) {
+    matches.push("callback_query");
+    if (update.callback_query.data !== void 0) {
+      matches.push("callback_query:data");
+    }
+  }
+  if (update.pre_checkout_query) {
+    matches.push("pre_checkout_query");
+  }
+  return matches;
+}
+function extractCommand(text) {
+  const match = text.trim().match(/^\/([a-zA-Z0-9_]+)(?:@[\w_]+)?(?:\s+([\s\S]*))?$/);
+  if (!match) return null;
+  return {
+    command: match[1].toLowerCase(),
+    args: match[2]?.trim() ?? ""
+  };
+}
+
+// src/filters/query.ts
+function matchesFilter(ctx, filter) {
+  const updateMatches = matchUpdate(ctx.update);
+  return updateMatches.includes(filter);
+}
+function matchesAnyFilter(ctx, filters) {
+  const updateMatches = matchUpdate(ctx.update);
+  return filters.some((filter) => updateMatches.includes(filter));
+}
+function matchesChatType(ctx, chatType) {
+  const chat = ctx.chat;
+  if (!chat) return false;
+  const types = Array.isArray(chatType) ? chatType : [chatType];
+  return types.includes(chat.type);
+}
+
+// src/composer.ts
+var Composer = class _Composer {
+  handler;
+  registered = [];
+  constructor(...middleware) {
+    this.registered.push(...middleware.map(normalizeMiddleware));
+    this.handler = async (ctx, next) => {
+      await runMiddleware(this.registered, ctx);
+      await next();
+    };
+  }
+  middleware() {
+    return this.handler;
+  }
+  use(...middleware) {
+    this.registered.push(...middleware.map(normalizeMiddleware));
+    return this;
+  }
+  on(filter, ...middleware) {
+    const filters = Array.isArray(filter) ? filter : [filter];
+    return this.filter(
+      (ctx) => matchesAnyFilter(ctx, filters),
+      ...middleware
+    );
+  }
+  filter(predicate, ...middleware) {
+    const composer = new _Composer();
+    this.registered.push(async (ctx, next) => {
+      const matches = await predicate(ctx);
+      if (!matches) {
+        await next();
+        return;
+      }
+      await runMiddleware(
+        [...composer.registered, async (_ctx, innerNext) => innerNext()],
+        ctx
+      );
+    });
+    composer.registered.push(...middleware);
+    return this;
+  }
+  command(command, ...middleware) {
+    const commands = new Set(
+      (Array.isArray(command) ? command : [command]).map(
+        (value) => value.toLowerCase().replace(/^\//, "")
+      )
+    );
+    return this.filter((ctx) => {
+      const text = ctx.text;
+      if (!text) return false;
+      const parsed = extractCommand(text);
+      if (!parsed) return false;
+      return commands.has(parsed.command);
+    }, async (ctx) => {
+      const text = ctx.text;
+      if (text) {
+        const parsed = extractCommand(text);
+        if (parsed) {
+          Object.defineProperty(ctx, "match", {
+            value: [parsed.command, parsed.args],
+            writable: true,
+            configurable: true
+          });
+        }
+      }
+      await runMiddleware(middleware, ctx);
+    });
+  }
+  hears(pattern, ...middleware) {
+    const regex = typeof pattern === "string" ? new RegExp(`^${escapeRegex(pattern)}$`) : pattern;
+    return this.filter((ctx) => {
+      const text = ctx.text;
+      if (!text) return false;
+      return regex.test(text);
+    }, async (ctx) => {
+      const text = ctx.text;
+      if (text) {
+        const match = text.match(regex);
+        Object.defineProperty(ctx, "match", {
+          value: match,
+          writable: true,
+          configurable: true
+        });
+      }
+      await runMiddleware(middleware, ctx);
+    });
+  }
+  chatType(chatType, ...middleware) {
+    return this.filter(
+      (ctx) => matchesChatType(ctx, chatType),
+      ...middleware
+    );
+  }
+};
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/context.ts
+var Context = class {
+  api;
+  update;
+  botInfo;
+  callbackQueryAnswered = false;
+  constructor(options) {
+    this.api = options.api;
+    this.update = options.update;
+    this.botInfo = options.botInfo;
+  }
+  get updateId() {
+    return this.update.update_id;
+  }
+  get message() {
+    return this.update.message ?? this.update.edited_message;
+  }
+  get editedMessage() {
+    return this.update.edited_message;
+  }
+  get callbackQuery() {
+    return this.update.callback_query;
+  }
+  get preCheckoutQuery() {
+    return this.update.pre_checkout_query;
+  }
+  get from() {
+    return this.message?.from ?? this.callbackQuery?.from ?? this.preCheckoutQuery?.from;
+  }
+  get chat() {
+    return this.message?.chat ?? this.callbackQuery?.message?.chat;
+  }
+  get chatId() {
+    return this.chat?.id;
+  }
+  get text() {
+    return this.message?.text;
+  }
+  get match() {
+    return null;
+  }
+  set match(value) {
+    Object.defineProperty(this, "match", {
+      value,
+      writable: true,
+      configurable: true
+    });
+  }
+  async reply(text, extra) {
+    const chatId = this.requireChatId();
+    return this.api.sendMessage({ chat_id: chatId, text, ...extra });
+  }
+  async replyWithPhoto(photo, extra) {
+    const chatId = this.requireChatId();
+    return this.api.sendPhoto({ chat_id: chatId, photo, ...extra });
+  }
+  async replyWithAudio(audio, extra) {
+    const chatId = this.requireChatId();
+    return this.api.sendAudio({ chat_id: chatId, audio, ...extra });
+  }
+  async replyWithDocument(document, extra) {
+    const chatId = this.requireChatId();
+    return this.api.sendDocument({ chat_id: chatId, document, ...extra });
+  }
+  async replyWithVideo(video, extra) {
+    const chatId = this.requireChatId();
+    return this.api.sendVideo({ chat_id: chatId, video, ...extra });
+  }
+  async replyWithAnimation(animation, extra) {
+    const chatId = this.requireChatId();
+    return this.api.sendAnimation({ chat_id: chatId, animation, ...extra });
+  }
+  async replyWithVoice(voice, extra) {
+    const chatId = this.requireChatId();
+    return this.api.sendVoice({ chat_id: chatId, voice, ...extra });
+  }
+  async replyWithLocation(latitude, longitude, extra) {
+    const chatId = this.requireChatId();
+    return this.api.sendLocation({
+      chat_id: chatId,
+      latitude,
+      longitude,
+      ...extra
+    });
+  }
+  async replyWithContact(phoneNumber, firstName, extra) {
+    const chatId = this.requireChatId();
+    return this.api.sendContact({
+      chat_id: chatId,
+      phone_number: phoneNumber,
+      first_name: firstName,
+      ...extra
+    });
+  }
+  async replyWithInvoice(params) {
+    const chatId = this.requireChatId();
+    return this.api.sendInvoice({ chat_id: chatId, ...params });
+  }
+  async sendChatAction(action) {
+    const chatId = this.requireChatId();
+    return this.api.sendChatAction({ chat_id: chatId, action });
+  }
+  async answerCallbackQuery(params) {
+    const callbackQuery = this.callbackQuery;
+    if (!callbackQuery) {
+      throw new Error("No callback query in context");
+    }
+    if (callbackQuery.id.startsWith("1")) {
+      console.warn(
+        "[balebaazoo] callback_query_id starts with '1' \u2014 client may not support answerCallbackQuery"
+      );
+    }
+    this.callbackQueryAnswered = true;
+    return this.api.answerCallbackQuery({
+      callback_query_id: callbackQuery.id,
+      ...params
+    });
+  }
+  async answerPreCheckoutQuery(params) {
+    const query = this.preCheckoutQuery;
+    if (!query) {
+      throw new Error("No pre_checkout_query in context");
+    }
+    return this.api.answerPreCheckoutQuery({
+      pre_checkout_query_id: query.id,
+      ...params
+    });
+  }
+  async askReview(userId, delaySeconds) {
+    return this.api.askReview({ user_id: userId, delay_seconds: delaySeconds });
+  }
+  async inquireTransaction(params) {
+    return this.api.inquireTransaction(params);
+  }
+  async downloadFile(fileId) {
+    const file = await this.api.getFile({ file_id: fileId });
+    if (!file.file_path) {
+      throw new Error("File path not available");
+    }
+    return this.api.downloadFile(file.file_path);
+  }
+  async downloadToBuffer(fileId) {
+    const data = await this.downloadFile(fileId);
+    return Buffer.from(data);
+  }
+  requireChatId() {
+    const chatId = this.chatId;
+    if (chatId === void 0) {
+      throw new Error("No chat_id available in context");
+    }
+    return chatId;
+  }
+  requireFrom() {
+    const from = this.from;
+    if (!from) {
+      throw new Error("No user available in context");
+    }
+    return from;
+  }
+};
+
+// src/middleware/auto-answer-callback.ts
+function autoAnswerCallback() {
+  return async (ctx, next) => {
+    try {
+      await next();
+    } finally {
+      if (ctx.callbackQuery && !ctx.callbackQueryAnswered) {
+        await ctx.answerCallbackQuery().catch(() => void 0);
+      }
+    }
+  };
+}
+function errorHandler(onError) {
+  return async (ctx, next) => {
+    try {
+      await next();
+    } catch (error) {
+      await onError(error, ctx);
+    }
+  };
+}
+
+// src/runner/polling.ts
+var PollingRunner = class {
+  running = false;
+  abortController;
+  offset = 0;
+  async start(bot, options = {}) {
+    if (this.running) {
+      throw new Error("Polling is already running");
+    }
+    this.running = true;
+    this.abortController = new AbortController();
+    const signal = options.signal ?? this.abortController.signal;
+    const onError = options.onError ?? ((error) => {
+      console.error("[balebaazoo] polling error:", error);
+    });
+    while (this.running && !signal.aborted) {
+      try {
+        const updates = await bot.api.getUpdates({
+          offset: this.offset,
+          limit: options.limit ?? 100,
+          timeout: options.timeout ?? 30,
+          allowed_updates: options.allowedUpdates
+        });
+        for (const update of updates) {
+          this.offset = update.update_id + 1;
+          try {
+            await bot.handleUpdate(update);
+          } catch (error) {
+            onError(error);
+          }
+        }
+        if (updates.length === 0 && signal.aborted) {
+          break;
+        }
+      } catch (error) {
+        if (signal.aborted) break;
+        onError(error);
+        await sleep2(1e3);
+      }
+    }
+  }
+  async stop() {
+    this.running = false;
+    this.abortController?.abort();
+  }
+};
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function createWebhookHandler(bot, getUpdate, options = {}) {
+  await bot.init();
+  const maxBodyBytes = options.maxBodyBytes ?? 1024 * 1024;
+  return async (request) => {
+    if (request.method !== "POST") {
+      return new Response("Method Not Allowed", { status: 405 });
+    }
+    if (options.secretToken) {
+      const token = request.headers.get("x-telegram-bot-api-secret-token");
+      if (token !== options.secretToken) {
+        return new Response("Unauthorized", { status: 401 });
+      }
+    }
+    try {
+      const rawBody = await request.text();
+      if (rawBody.length > maxBodyBytes) {
+        return new Response("Payload Too Large", { status: 413 });
+      }
+      const syntheticRequest = new Request(request.url, {
+        method: "POST",
+        headers: request.headers,
+        body: rawBody
+      });
+      const update = await getUpdate(syntheticRequest);
+      await bot.handleUpdate(update);
+      return new Response("OK", { status: 200 });
+    } catch (error) {
+      console.error("[balebaazoo] webhook error:", error);
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  };
+}
+async function webhookFromJson(bot) {
+  return createWebhookHandler(bot, async (request) => {
+    return await request.json();
+  });
+}
+
+// src/bot.ts
+var Bot = class extends Composer {
+  api;
+  botInfo;
+  polling = new PollingRunner();
+  autoAnswer;
+  constructor(token, options = {}) {
+    const api = new Api({ token, ...options });
+    super();
+    this.api = api;
+    this.botInfo = options.botInfo;
+    this.autoAnswer = options.autoAnswerCallback ?? true;
+    if (this.autoAnswer) {
+      this.use(autoAnswerCallback());
+    }
+  }
+  async init() {
+    if (!this.botInfo) {
+      this.botInfo = await this.api.getMe();
+    }
+    return this.botInfo;
+  }
+  async handleUpdate(update) {
+    const ctx = this.createContext(update);
+    await this.middleware()(ctx, async () => void 0);
+  }
+  createContext(update) {
+    return new Context({
+      api: this.api,
+      update,
+      botInfo: this.botInfo
+    });
+  }
+  async start(options = {}) {
+    await this.init();
+    await this.polling.start(this, options);
+  }
+  async stop() {
+    await this.polling.stop();
+  }
+  webhookCallback() {
+    return async (update) => {
+      await this.handleUpdate(update);
+    };
+  }
+  use(...middleware) {
+    return super.use(...middleware);
+  }
+};
+
+// src/formatting/markdown.ts
+var bold = (text) => ` *${text}* `;
+var italic = (text) => ` _${text}_ `;
+var link = (text, url) => `[${text}](${url})`;
+var spoiler = (text, description) => `\`\`\`[${text}]${description}\`\`\``;
+var md = {
+  bold,
+  italic,
+  link,
+  spoiler
+};
+
+// src/keyboard/inline.ts
+var InlineKeyboard = class {
+  inline_keyboard;
+  constructor(rows = []) {
+    this.inline_keyboard = rows;
+  }
+  row(...buttons) {
+    this.inline_keyboard.push(buttons);
+    return this;
+  }
+  text(text, callbackData) {
+    return this.row({ text, callback_data: callbackData });
+  }
+  url(text, url) {
+    return this.row({ text, url });
+  }
+  webApp(text, webApp) {
+    return this.row({ text, web_app: webApp });
+  }
+  copyText(text, copyText) {
+    return this.row({ text, copy_text: copyText });
+  }
+  toJSON() {
+    return { inline_keyboard: this.inline_keyboard };
+  }
+};
+
+// src/keyboard/reply.ts
+var ReplyKeyboard = class {
+  keyboard;
+  resize_keyboard;
+  one_time_keyboard;
+  selective;
+  constructor(rows = []) {
+    this.keyboard = rows;
+  }
+  row(...buttons) {
+    this.keyboard.push(buttons);
+    return this;
+  }
+  text(text) {
+    return this.row({ text });
+  }
+  webApp(text, webApp) {
+    return this.row({ text, web_app: webApp });
+  }
+  resized(value = true) {
+    this.resize_keyboard = value;
+    return this;
+  }
+  oneTime(value = true) {
+    this.one_time_keyboard = value;
+    return this;
+  }
+  onlySelective(value = true) {
+    this.selective = value;
+    return this;
+  }
+  toJSON() {
+    return {
+      keyboard: this.keyboard,
+      resize_keyboard: this.resize_keyboard,
+      one_time_keyboard: this.one_time_keyboard,
+      selective: this.selective
+    };
+  }
+};
+function removeKeyboard() {
+  return { remove_keyboard: true };
+}
+
+exports.Api = Api;
+exports.BaleAPIError = BaleAPIError;
+exports.BaleError = BaleError;
+exports.BaleNetworkError = BaleNetworkError;
+exports.Bot = Bot;
+exports.Composer = Composer;
+exports.Context = Context;
+exports.DEFAULT_API_BASE = DEFAULT_API_BASE;
+exports.InlineKeyboard = InlineKeyboard;
+exports.InputFile = InputFile;
+exports.PollingRunner = PollingRunner;
+exports.ReplyKeyboard = ReplyKeyboard;
+exports.autoAnswerCallback = autoAnswerCallback;
+exports.bold = bold;
+exports.createWebhookHandler = createWebhookHandler;
+exports.errorHandler = errorHandler;
+exports.extractCommand = extractCommand;
+exports.isFilePath = isFilePath;
+exports.isMiddlewareObject = isMiddlewareObject;
+exports.italic = italic;
+exports.link = link;
+exports.matchUpdate = matchUpdate;
+exports.matchesAnyFilter = matchesAnyFilter;
+exports.matchesChatType = matchesChatType;
+exports.matchesFilter = matchesFilter;
+exports.md = md;
+exports.normalizeMiddleware = normalizeMiddleware;
+exports.removeKeyboard = removeKeyboard;
+exports.runMiddleware = runMiddleware;
+exports.spoiler = spoiler;
+exports.webhookFromJson = webhookFromJson;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map