@mtcute/dispatcher 0.16.7 → 0.16.13

package/index.cjs

@@ -0,0 +1,2534 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/dispatcher] CommonJS support is deprecated and will be removed soon. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/dispatcher] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@mtcute/core");
+const utils_js = require("@mtcute/core/utils.js");
+class CallbackDataBuilder {
+  /**
+   * @param prefix  Prefix for the data. Use something unique across your bot.
+   * @param fields  Field names in the order they will be serialized.
+   */
+  constructor(prefix, ...fields) {
+    this.prefix = prefix;
+    this._fields = fields;
+  }
+  _fields;
+  sep = ":";
+  /**
+   * Build a callback data string
+   *
+   * @param obj  Object containing the data
+   */
+  build(obj) {
+    const ret = this.prefix + this.sep + this._fields.map((f) => {
+      const val = obj[f];
+      if (val.includes(this.sep)) {
+        throw new core.MtArgumentError(
+          `Value for ${f} ${val} contains separator ${this.sep} and cannot be used.`
+        );
+      }
+      return val;
+    }).join(this.sep);
+    if (ret.length > 64) {
+      throw new core.MtArgumentError("Resulting callback data is too long.");
+    }
+    return ret;
+  }
+  parse(data, safe = false) {
+    const parts = data.split(this.sep);
+    if (parts[0] !== this.prefix) {
+      if (safe) return null;
+      throw new core.MtArgumentError(
+        `Invalid data passed: "${data}" (bad prefix, expected ${this.prefix}, got ${parts[0]})`
+      );
+    }
+    if (parts.length !== this._fields.length + 1) {
+      if (safe) return null;
+      throw new core.MtArgumentError(
+        `Invalid data passed: "${data}" (bad parts count, expected ${this._fields.length}, got ${parts.length - 1})`
+      );
+    }
+    const ret = {};
+    parts.forEach((it, idx) => {
+      if (idx === 0) return;
+      ret[this._fields[idx - 1]] = it;
+    });
+    return ret;
+  }
+  /**
+   * Create a filter for this callback data.
+   *
+   * You can either pass an object with field names as keys and values as strings or regexes,
+   * which will be compiled to a RegExp, or a function that will be called with the parsed data.
+   * Note that the strings will be passed to `RegExp` **directly**, so you may want to escape them.
+   *
+   * When using a function, you can either return a boolean, or an object with field names as keys
+   * and values as strings or regexes. In the latter case, the resulting object will be matched
+   * against the parsed data the same way as if you passed it directly.
+   *
+   * @param params
+   */
+  filter(params = {}) {
+    if (typeof params === "function") {
+      return async (query) => {
+        if (!query.dataStr) return false;
+        const data = this.parse(query.dataStr, true);
+        if (!data) return false;
+        const fnResult = await params(query, data);
+        if (typeof fnResult === "boolean") {
+          query.match = data;
+          return fnResult;
+        }
+        for (const key in fnResult) {
+          const value = data[key];
+          if (value === void 0) return false;
+          let matchers = fnResult[key];
+          if (!Array.isArray(matchers)) matchers = [matchers];
+          for (const matcher of matchers) {
+            if (typeof matcher === "string") {
+              if (value !== matcher) return false;
+            } else if (!matcher.test(value)) {
+              return false;
+            }
+          }
+        }
+        query.match = data;
+        return true;
+      };
+    }
+    const parts = [];
+    this._fields.forEach((field) => {
+      if (!(field in params)) {
+        parts.push(`[^${this.sep}]*?`);
+        return;
+      }
+      const value = params[field];
+      if (Array.isArray(value)) {
+        parts.push(`(${value.map((i) => typeof i === "string" ? i : i.source).join("|")})`);
+      } else {
+        parts.push(typeof value === "string" ? value : value.source);
+      }
+    });
+    const regex2 = new RegExp(`^${this.prefix}${this.sep}${parts.join(this.sep)}$`);
+    return (query) => {
+      const m = query.dataStr?.match(regex2);
+      if (!m) {
+        return false;
+      }
+      query.match = this.parse(m[0]);
+      return true;
+    };
+  }
+}
+class BusinessMessageContext extends core.BusinessMessage {
+  constructor(client, message) {
+    const msg = Array.isArray(message) ? message[message.length - 1] : message;
+    super(msg.update, msg._peers);
+    this.client = client;
+    this.messages = Array.isArray(message) ? message.map((it) => new BusinessMessageContext(client, it)) : [this];
+    this.isMessageGroup = Array.isArray(message);
+  }
+  // this is primarily for proper types in filters, so don't bother much with actual value
+  _name = "new_business_message";
+  /**
+   * List of messages in the message group.
+   *
+   * For other updates, this is a list with a single element (`this`).
+   */
+  messages;
+  /** Whether this update is about a message group */
+  isMessageGroup;
+  /** Get all custom emojis contained in this message (message group), if any */
+  getCustomEmojis() {
+    return this.client.getCustomEmojisFromMessages(this.messages);
+  }
+  /** Send a text message to the same chat (and topic, if applicable) as a given message */
+  answerText(...params) {
+    const [send, params_ = {}] = params;
+    params_.businessConnectionId = this.update.connectionId;
+    return this.client.answerText(this, send, params_);
+  }
+  /** Send a media to the same chat (and topic, if applicable) as a given message */
+  answerMedia(...params) {
+    const [send, params_ = {}] = params;
+    params_.businessConnectionId = this.update.connectionId;
+    return this.client.answerMedia(this, send, params_);
+  }
+  /** Send a media group to the same chat (and topic, if applicable) as a given message */
+  answerMediaGroup(...params) {
+    const [send, params_ = {}] = params;
+    params_.businessConnectionId = this.update.connectionId;
+    return this.client.answerMediaGroup(this, send, params_);
+  }
+  /** Send a text message in reply to this message */
+  replyText(...params) {
+    const [send, params_ = {}] = params;
+    params_.businessConnectionId = this.update.connectionId;
+    return this.client.replyText(this, send, params_);
+  }
+  /** Send a media in reply to this message */
+  replyMedia(...params) {
+    const [send, params_ = {}] = params;
+    params_.businessConnectionId = this.update.connectionId;
+    return this.client.replyMedia(this, send, params_);
+  }
+  /** Send a media group in reply to this message */
+  replyMediaGroup(...params) {
+    const [send, params_ = {}] = params;
+    params_.businessConnectionId = this.update.connectionId;
+    return this.client.replyMediaGroup(this, send, params_);
+  }
+  /** Send a text message in reply to this message */
+  quoteWithText(params) {
+    params.businessConnectionId = this.update.connectionId;
+    return this.client.quoteWithText(this, params);
+  }
+  /** Send a media in reply to this message */
+  quoteWithMedia(params) {
+    params.businessConnectionId = this.update.connectionId;
+    return this.client.quoteWithMedia(this, params);
+  }
+  /** Send a media group in reply to this message */
+  quoteWithMediaGroup(params) {
+    params.businessConnectionId = this.update.connectionId;
+    return this.client.quoteWithMediaGroup(this, params);
+  }
+  /** Delete this message (message group) */
+  delete(params) {
+    return this.client.deleteMessagesById(
+      this.chat.inputPeer,
+      this.messages.map((it) => it.id),
+      params
+    );
+  }
+  /** Pin this message */
+  pin(params) {
+    return this.client.pinMessage({
+      chatId: this.chat.inputPeer,
+      message: this.id,
+      ...params
+    });
+  }
+  /** Unpin this message */
+  unpin() {
+    return this.client.unpinMessage({
+      chatId: this.chat.inputPeer,
+      message: this.id
+    });
+  }
+  /** Edit this message */
+  edit(params) {
+    return this.client.editMessage({
+      chatId: this.chat.inputPeer,
+      message: this.id,
+      ...params
+    });
+  }
+  /** Forward this message (message group) */
+  forwardTo(params) {
+    return this.client.forwardMessagesById({
+      fromChatId: this.chat.inputPeer,
+      messages: this.messages.map((it) => it.id),
+      ...params
+    });
+  }
+  /** Send a copy of this message (message group) */
+  copy(params) {
+    if (this.isMessageGroup) {
+      return this.client.sendCopyGroup({
+        messages: this.messages,
+        ...params
+      });
+    }
+    return this.client.sendCopy({
+      message: this,
+      ...params
+    });
+  }
+  /** React to this message */
+  react(params) {
+    return this.client.sendReaction({
+      chatId: this.chat.inputPeer,
+      message: this.id,
+      ...params
+    });
+  }
+}
+class CallbackQueryContext extends core.CallbackQuery {
+  constructor(client, query) {
+    super(query.raw, query._peers);
+    this.client = client;
+  }
+  _name = "callback_query";
+  /** Answer to this callback query */
+  answer(params) {
+    return this.client.answerCallbackQuery(this.id, params);
+  }
+  /**
+   * Get the message containing the callback button being clicked.
+   *
+   * Note that the message may have been deleted, in which case
+   * `null` will be returned.
+   */
+  async getMessage() {
+    return this.client.getCallbackQueryMessage(this);
+  }
+  /**
+   * Edit the message that contained the callback button that was clicked.
+   */
+  async editMessage(params) {
+    return this.client.editMessage({
+      chatId: this.raw.peer,
+      message: this.raw.msgId,
+      ...params
+    });
+  }
+  /**
+   * Shortcut for getting the message and editing it.
+   */
+  async editMessageWith(handler) {
+    const msg = await this.getMessage();
+    if (!msg) return;
+    const res = await handler(msg);
+    if (!res) return;
+    return this.editMessage(res);
+  }
+}
+class InlineCallbackQueryContext extends core.InlineCallbackQuery {
+  constructor(client, query) {
+    super(query.raw, query._peers);
+    this.client = client;
+  }
+  _name = "inline_callback_query";
+  /** Answer to this callback query */
+  answer(params) {
+    return this.client.answerCallbackQuery(this.id, params);
+  }
+  /**
+   * Edit the message that contained the callback button that was clicked.
+   */
+  async editMessage(params) {
+    return this.client.editInlineMessage({
+      messageId: this.raw.msgId,
+      ...params
+    });
+  }
+}
+class BusinessCallbackQueryContext extends core.BusinessCallbackQuery {
+  constructor(client, query) {
+    super(query.raw, query._peers);
+    this.client = client;
+  }
+  _name = "business_callback_query";
+  /** Answer to this callback query */
+  answer(params) {
+    return this.client.answerCallbackQuery(this.id, params);
+  }
+  /**
+   * Edit the message that contained the callback button that was clicked.
+   */
+  async editMessage(params) {
+    return this.client.editMessage({
+      message: this.message,
+      businessConnectionId: this.connectionId,
+      ...params
+    });
+  }
+}
+class ChatJoinRequestUpdateContext extends core.BotChatJoinRequestUpdate {
+  constructor(client, update) {
+    super(update.raw, update._peers);
+    this.client = client;
+  }
+  _name = "bot_chat_join_request";
+  /** Approve the request */
+  approve() {
+    return this.client.hideJoinRequest({
+      action: "approve",
+      user: this.user.inputPeer,
+      chatId: this.chat.inputPeer
+    });
+  }
+  /** Decline the request */
+  decline() {
+    return this.client.hideJoinRequest({
+      action: "decline",
+      user: this.user.inputPeer,
+      chatId: this.chat.inputPeer
+    });
+  }
+}
+class ChosenInlineResultContext extends core.ChosenInlineResult {
+  constructor(client, result) {
+    super(result.raw, result._peers);
+    this.client = client;
+  }
+  _name = "chosen_inline_result";
+  /**
+   * Edit the message that was sent when this inline result that was chosen.
+   *
+   * > **Note**: This method can only be used if the message contained a reply markup
+   */
+  async editMessage(params) {
+    if (!this.raw.msgId) {
+      throw new core.MtArgumentError("No message ID, make sure you have included reply markup!");
+    }
+    return this.client.editInlineMessage({
+      ...params,
+      messageId: this.raw.msgId
+    });
+  }
+}
+class InlineQueryContext extends core.InlineQuery {
+  constructor(client, query) {
+    super(query.raw, query._peers);
+    this.client = client;
+  }
+  _name = "inline_query";
+  /** Answer to this inline query */
+  answer(...params) {
+    return this.client.answerInlineQuery(this.id, ...params);
+  }
+}
+class MessageContext extends core.Message {
+  constructor(client, message) {
+    const msg = Array.isArray(message) ? message[message.length - 1] : message;
+    super(msg.raw, msg._peers, msg.isScheduled);
+    this.client = client;
+    this.messages = Array.isArray(message) ? message.map((it) => new MessageContext(client, it)) : [this];
+    this.isMessageGroup = Array.isArray(message);
+  }
+  // this is primarily for proper types in filters, so don't bother much with actual value
+  _name = "new_message";
+  /**
+   * List of messages in the message group.
+   *
+   * For other updates, this is a list with a single element (`this`).
+   */
+  messages;
+  /** Whether this update is about a message group */
+  isMessageGroup;
+  /**
+   * Get complete information about {@link sender}
+   *
+   * Learn more: [Incomplete peers](https://mtcute.dev/guide/topics/peers.html#incomplete-peers)
+   */
+  async getCompleteSender() {
+    if (!this.sender.isMin) return this.sender;
+    let res;
+    if (this.sender.type === "user") {
+      [res] = await this.client.getUsers(this.sender);
+    } else {
+      res = await this.client.getChat(this.sender);
+    }
+    if (!res) throw new core.MtPeerNotFoundError("Failed to fetch sender");
+    Object.defineProperty(this, "sender", { value: res });
+    return res;
+  }
+  /**
+   * Get complete information about {@link chat}
+   *
+   * Learn more: [Incomplete peers](https://mtcute.dev/guide/topics/peers.html#incomplete-peers)
+   */
+  async getCompleteChat() {
+    if (!this.chat.isMin) return this.chat;
+    const res = await this.client.getChat(this.chat);
+    if (!res) throw new core.MtPeerNotFoundError("Failed to fetch chat");
+    Object.defineProperty(this, "chat", { value: res });
+    return res;
+  }
+  /** Get a message that this message is a reply to */
+  getReplyTo() {
+    return this.client.getReplyTo(this);
+  }
+  /** If this is a channel post, get its automatic forward in the discussion group */
+  getDiscussionMessage() {
+    return this.client.getDiscussionMessage({ chatId: this.chat.inputPeer, message: this.id });
+  }
+  /** Get all custom emojis contained in this message (message group), if any */
+  getCustomEmojis() {
+    return this.client.getCustomEmojisFromMessages(this.messages);
+  }
+  /** Send a text message to the same chat (and topic, if applicable) as a given message */
+  answerText(...params) {
+    return this.client.answerText(this, ...params);
+  }
+  /** Send a media to the same chat (and topic, if applicable) as a given message */
+  answerMedia(...params) {
+    return this.client.answerMedia(this, ...params);
+  }
+  /** Send a media group to the same chat (and topic, if applicable) as a given message */
+  answerMediaGroup(...params) {
+    return this.client.answerMediaGroup(this, ...params);
+  }
+  /** Send a text message in reply to this message */
+  replyText(...params) {
+    return this.client.replyText(this, ...params);
+  }
+  /** Send a media in reply to this message */
+  replyMedia(...params) {
+    return this.client.replyMedia(this, ...params);
+  }
+  /** Send a media group in reply to this message */
+  replyMediaGroup(...params) {
+    return this.client.replyMediaGroup(this, ...params);
+  }
+  /** Send a text message in reply to this message */
+  quoteWithText(params) {
+    return this.client.quoteWithText(this, params);
+  }
+  /** Send a media in reply to this message */
+  quoteWithMedia(params) {
+    return this.client.quoteWithMedia(this, params);
+  }
+  /** Send a media group in reply to this message */
+  quoteWithMediaGroup(params) {
+    return this.client.quoteWithMediaGroup(this, params);
+  }
+  /** Send a text as a comment to this message */
+  commentText(...params) {
+    return this.client.commentText(this, ...params);
+  }
+  /** Send a media as a comment to this message */
+  commentMedia(...params) {
+    return this.client.commentMedia(this, ...params);
+  }
+  /** Send a media group as a comment to this message */
+  commentMediaGroup(...params) {
+    return this.client.commentMediaGroup(this, ...params);
+  }
+  /** Delete this message (message group) */
+  delete(params) {
+    return this.client.deleteMessagesById(
+      this.chat.inputPeer,
+      this.messages.map((it) => it.id),
+      params
+    );
+  }
+  /** Pin this message */
+  pin(params) {
+    return this.client.pinMessage({
+      chatId: this.chat.inputPeer,
+      message: this.id,
+      ...params
+    });
+  }
+  /** Unpin this message */
+  unpin() {
+    return this.client.unpinMessage({
+      chatId: this.chat.inputPeer,
+      message: this.id
+    });
+  }
+  /** Edit this message */
+  edit(params) {
+    return this.client.editMessage({
+      chatId: this.chat.inputPeer,
+      message: this.id,
+      ...params
+    });
+  }
+  /** Forward this message (message group) */
+  forwardTo(params) {
+    return this.client.forwardMessagesById({
+      fromChatId: this.chat.inputPeer,
+      messages: this.messages.map((it) => it.id),
+      ...params
+    });
+  }
+  /** Send a copy of this message (message group) */
+  copy(params) {
+    if (this.isMessageGroup) {
+      return this.client.sendCopyGroup({
+        messages: this.messages,
+        ...params
+      });
+    }
+    return this.client.sendCopy({
+      message: this,
+      ...params
+    });
+  }
+  /** React to this message */
+  react(params) {
+    return this.client.sendReaction({
+      chatId: this.chat.inputPeer,
+      message: this.id,
+      ...params
+    });
+  }
+}
+class PreCheckoutQueryContext extends core.PreCheckoutQuery {
+  constructor(client, query) {
+    super(query.raw, query._peers);
+    this.client = client;
+  }
+  _name = "pre_checkout_query";
+  /** Approve the query */
+  approve() {
+    return this.client.answerPreCheckoutQuery(this.raw.queryId);
+  }
+  /** Decline the query, optionally with an error */
+  decline(error = "") {
+    return this.client.answerPreCheckoutQuery(this.raw.queryId, { error });
+  }
+}
+function _parsedUpdateToContext(client, update) {
+  switch (update.name) {
+    case "new_message":
+    case "edit_message":
+    case "message_group":
+      return new MessageContext(client, update.data);
+    case "inline_query":
+      return new InlineQueryContext(client, update.data);
+    case "chosen_inline_result":
+      return new ChosenInlineResultContext(client, update.data);
+    case "callback_query":
+      return new CallbackQueryContext(client, update.data);
+    case "inline_callback_query":
+      return new InlineCallbackQueryContext(client, update.data);
+    case "business_callback_query":
+      return new BusinessCallbackQueryContext(client, update.data);
+    case "bot_chat_join_request":
+      return new ChatJoinRequestUpdateContext(client, update.data);
+    case "pre_checkout_query":
+      return new PreCheckoutQueryContext(client, update.data);
+    case "new_business_message":
+    case "edit_business_message":
+    case "business_message_group":
+      return new BusinessMessageContext(client, update.data);
+  }
+  const _update = update.data;
+  _update.client = client;
+  _update._name = update.name;
+  return _update;
+}
+class SceneTransitionContext {
+  constructor(previousScene, update) {
+    this.previousScene = previousScene;
+    this.update = update;
+  }
+  /** Get {@link update}, asserting it is a message-related update */
+  get message() {
+    if (this.update instanceof MessageContext) {
+      return this.update;
+    }
+    throw new core.MtTypeAssertionError("SceneTransitionContext.message", "message", this.update._name);
+  }
+  /** Get {@link update}, asserting it is a business message-related update */
+  get businessMessage() {
+    if (this.update instanceof BusinessMessageContext) {
+      return this.update;
+    }
+    throw new core.MtTypeAssertionError("SceneTransitionContext.businessMessage", "business message", this.update._name);
+  }
+  /** Get {@link update}, asserting it is a callback query update */
+  get callbackQuery() {
+    if (this.update instanceof CallbackQueryContext) {
+      return this.update;
+    }
+    throw new core.MtTypeAssertionError("SceneTransitionContext.callbackQuery", "callback query", this.update._name);
+  }
+  /** Get {@link update}, asserting it is an inline callback query update */
+  get inlineCallbackQuery() {
+    if (this.update instanceof InlineCallbackQueryContext) {
+      return this.update;
+    }
+    throw new core.MtTypeAssertionError(
+      "SceneTransitionContext.inlineCallbackQuery",
+      "inline callback query",
+      this.update._name
+    );
+  }
+}
+utils_js.makeInspectable(SceneTransitionContext);
+const defaultStateKeyDelegate = (upd) => {
+  if ("type" in upd) {
+    return String(upd.id);
+  }
+  if (upd._name === "new_message" || upd._name === "new_business_message") {
+    switch (upd.chat.chatType) {
+      case "private":
+      case "bot":
+      case "channel":
+        return String(upd.chat.id);
+      case "group":
+      case "supergroup":
+      case "gigagroup":
+        return `${upd.chat.id}_${upd.sender.id}`;
+      default:
+        core.assertNever(upd.chat.chatType);
+    }
+  }
+  if (upd._name === "callback_query") {
+    if (upd.chat.chatType === "private") return `${upd.user.id}`;
+    return `${upd.chat.id}_${upd.user.id}`;
+  }
+  return null;
+};
+class MemoryStateRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    this.state = this._driver.getState("dispatcher_fsm", () => /* @__PURE__ */ new Map());
+    this.rl = this._driver.getState("rl", () => /* @__PURE__ */ new Map());
+  }
+  state;
+  rl;
+  setState(key, state2, ttl) {
+    this.state.set(key, {
+      value: state2,
+      expiresAt: ttl ? Date.now() + ttl * 1e3 : void 0
+    });
+  }
+  getState(key, now) {
+    const state2 = this.state.get(key);
+    if (!state2) return null;
+    if (state2.expiresAt && state2.expiresAt < now) {
+      this.state.delete(key);
+      return null;
+    }
+    return state2.value;
+  }
+  deleteState(key) {
+    this.state.delete(key);
+  }
+  vacuum(now) {
+    for (const [key, state2] of this.state.entries()) {
+      if (state2.expiresAt && state2.expiresAt < now) {
+        this.state.delete(key);
+      }
+    }
+    for (const [key, state2] of this.rl.entries()) {
+      if (state2.reset < now) {
+        this.rl.delete(key);
+      }
+    }
+  }
+  getRateLimit(key, now, limit, window) {
+    const item = this.rl.get(key);
+    if (!item) {
+      const state2 = {
+        reset: now + window * 1e3,
+        remaining: limit
+      };
+      this.rl.set(key, state2);
+      return [state2.remaining, state2.reset];
+    }
+    if (item.reset < now) {
+      const state2 = {
+        reset: now + window * 1e3,
+        remaining: limit
+      };
+      this.rl.set(key, state2);
+      return [state2.remaining, state2.reset];
+    }
+    item.remaining = item.remaining > 0 ? item.remaining - 1 : 0;
+    return [item.remaining, item.reset];
+  }
+  resetRateLimit(key) {
+    this.rl.delete(key);
+  }
+}
+class MemoryStateStorage {
+  constructor(driver = new core.MemoryStorageDriver()) {
+    this.driver = driver;
+    this.state = new MemoryStateRepository(this.driver);
+  }
+  state;
+}
+class SqliteStateRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration("state", 1, (db) => {
+      db.exec(`
+                create table fsm_state (
+                    key text primary key,
+                    value text not null,
+                    expires_at integer
+                );
+                create table rl_state (
+                    key text primary key,
+                    reset integer not null,
+                    remaining integer not null
+                );
+            `);
+    });
+    _driver.onLoad(() => {
+      this._setState = _driver.db.prepare(
+        "insert or replace into fsm_state (key, value, expires_at) values (?, ?, ?)"
+      );
+      this._getState = _driver.db.prepare("select value, expires_at from fsm_state where key = ?");
+      this._deleteState = _driver.db.prepare("delete from fsm_state where key = ?");
+      this._deleteOldState = _driver.db.prepare("delete from fsm_state where expires_at < ?");
+      this._setRl = _driver.db.prepare("insert or replace into rl_state (key, reset, remaining) values (?, ?, ?)");
+      this._getRl = _driver.db.prepare("select reset, remaining from rl_state where key = ?");
+      this._deleteRl = _driver.db.prepare("delete from rl_state where key = ?");
+      this._deleteOldRl = _driver.db.prepare("delete from rl_state where reset < ?");
+    });
+    _driver.registerLegacyMigration("state", (db) => {
+      db.exec("drop table state");
+    });
+  }
+  _setState;
+  setState(key, state2, ttl) {
+    this._setState.run(key, state2, ttl ? Date.now() + ttl * 1e3 : void 0);
+  }
+  _getState;
+  getState(key, now) {
+    const res_ = this._getState.get(key);
+    if (!res_) return null;
+    const res = res_;
+    if (res.expires_at && res.expires_at < now) {
+      this._deleteState.run(key);
+      return null;
+    }
+    return res.value;
+  }
+  _deleteState;
+  deleteState(key) {
+    this._deleteState.run(key);
+  }
+  _deleteOldState;
+  _deleteOldRl;
+  vacuum(now) {
+    this._deleteOldState.run(now);
+    this._deleteOldRl.run(now);
+  }
+  _setRl;
+  _getRl;
+  _deleteRl;
+  getRateLimit(key, now, limit, window) {
+    const val = this._getRl.get(key);
+    if (!val || val.reset < now) {
+      const item = {
+        reset: now + window * 1e3,
+        remaining: limit
+      };
+      this._setRl.run(key, item.reset, item.remaining);
+      return [item.remaining, item.reset];
+    }
+    if (val.remaining > 0) {
+      val.remaining -= 1;
+      this._setRl.run(key, val.reset, val.remaining);
+    }
+    return [val.remaining, val.reset];
+  }
+  resetRateLimit(key) {
+    this._deleteRl.run(key);
+  }
+}
+class SqliteStateStorage {
+  constructor(driver) {
+    this.driver = driver;
+    this.state = new SqliteStateRepository(driver);
+  }
+  state;
+  static from(provider) {
+    return new SqliteStateStorage(provider.driver);
+  }
+}
+class RateLimitError extends core.MtcuteError {
+  constructor(reset) {
+    super("You are being rate limited.");
+    this.reset = reset;
+  }
+}
+class UpdateState {
+  _key;
+  _localKey;
+  _storage;
+  _scene;
+  _scoped;
+  _cached;
+  _localStorage;
+  _localKeyBase;
+  constructor(storage, key, scene, scoped, customStorage, customKey) {
+    this._storage = storage;
+    this._key = key;
+    this._scene = scene;
+    this._scoped = scoped;
+    this._localStorage = customStorage ?? storage;
+    this._localKeyBase = customKey ?? key;
+    this._updateLocalKey();
+  }
+  /** Name of the current scene */
+  get scene() {
+    return this._scene;
+  }
+  _updateLocalKey() {
+    if (!this._scoped) {
+      this._localKey = this._localKeyBase;
+    } else {
+      this._localKey = this._scene ? `${this._scene}_${this._localKeyBase}` : this._localKeyBase;
+    }
+  }
+  async get(fallback, force) {
+    if (typeof fallback === "boolean") {
+      force = fallback;
+      fallback = void 0;
+    }
+    if (!force && this._cached !== void 0) {
+      if (!this._cached && fallback) {
+        return typeof fallback === "function" ? fallback() : fallback;
+      }
+      return this._cached;
+    }
+    let res = await this._localStorage.getState(this._localKey);
+    if (!res && fallback) {
+      res = typeof fallback === "function" ? fallback() : fallback;
+    }
+    this._cached = res;
+    return res;
+  }
+  /**
+   * Set new state to the storage
+   *
+   * @param state  New state
+   * @param ttl  TTL for the new state (in seconds)
+   */
+  async set(state2, ttl) {
+    this._cached = state2;
+    await this._localStorage.setState(this._localKey, state2, ttl);
+  }
+  /**
+   * Merge the given object to the current state.
+   *
+   * > **Note**: If the storage currently has no state,
+   * > then `fallback` must be provided.
+   *
+   * Basically a shorthand to calling `.get()`,
+   * modifying and then calling `.set()`
+   *
+   * @param state  State to be merged
+   * @param fallback  Default state
+   * @param ttl  TTL for the new state (in seconds)
+   * @param forceLoad  Whether to force load the old state from storage
+   */
+  async merge(state2, params = {}) {
+    const { fallback, ttl, forceLoad } = params;
+    const old = await this.get(forceLoad);
+    if (!old) {
+      if (!fallback) {
+        throw new core.MtArgumentError("Cannot use merge on empty state without fallback.");
+      }
+      const fallback_ = typeof fallback === "function" ? fallback() : fallback;
+      await this.set({ ...fallback_, ...state2 }, ttl);
+    } else {
+      await this.set({ ...old, ...state2 }, ttl);
+    }
+    return this._cached;
+  }
+  /**
+   * Delete the state from the storage
+   */
+  async delete() {
+    this._cached = null;
+    await this._localStorage.deleteState(this._localKey);
+  }
+  /**
+   * Enter some scene
+   */
+  async enter(scene, params) {
+    const { with: with_, ttl, reset = true } = params ?? {};
+    if (reset && this._scoped) await this.delete();
+    if (!scene["_scene"]) {
+      throw new core.MtArgumentError("Cannot enter a non-scene Dispatcher");
+    }
+    if (!scene["_parent"]) {
+      throw new core.MtArgumentError("This scene has not been registered");
+    }
+    this._scene = scene["_scene"];
+    this._scoped = scene["_sceneScoped"];
+    this._updateLocalKey();
+    await this._storage.setCurrentScene(this._key, this._scene, ttl);
+    if (with_) {
+      if (scene["_customStateKeyDelegate"]) {
+        throw new core.MtArgumentError("Cannot use `with` parameter when the scene uses a custom state key delegate");
+      }
+      await scene.getState(this._key).set(with_, ttl);
+    }
+  }
+  /**
+   * Exit from current scene to the root
+   *
+   * @param reset
+   *     Whether to reset scene state (only applicable in case this is a scoped scene)
+   */
+  async exit(reset = true) {
+    if (reset && this._scoped) await this.delete();
+    this._scene = null;
+    this._updateLocalKey();
+    await this._storage.deleteCurrentScene(this._key);
+  }
+  /**
+   * Rate limit some handler.
+   *
+   * When the rate limit exceeds, {@link RateLimitError} is thrown.
+   *
+   * This is a simple rate-limiting solution that uses
+   * the same key as the state. If you need something more
+   * sophisticated and/or customizable, you'll have to implement
+   * your own rate-limiter.
+   *
+   * > **Note**: `key` is used to prefix the local key
+   * > derived using the given key delegate.
+   *
+   * @param key  Key of the rate limit
+   * @param limit  Maximum number of requests in `window`
+   * @param window  Window size in seconds
+   * @returns  Tuple containing the number of remaining and
+   *   unix time in ms when the user can try again
+   */
+  async rateLimit(key, limit, window) {
+    const [remaining, reset] = await this._localStorage.getRateLimit(`${key}:${this._localKey}`, limit, window);
+    if (!remaining) {
+      throw new RateLimitError(reset);
+    }
+    return [remaining - 1, reset];
+  }
+  /**
+   * Throttle some handler.
+   *
+   * When the rate limit exceeds, this function waits for it to reset.
+   *
+   * This is a simple wrapper over {@link rateLimit}, and follows the same logic.
+   *
+   * > **Note**: `key` is used to prefix the local key
+   * > derived using the given key delegate.
+   *
+   * @param key  Key of the rate limit
+   * @param limit  Maximum number of requests in `window`
+   * @param window  Window size in seconds
+   * @returns  Tuple containing the number of remaining and
+   *   unix time in ms when the user can try again
+   */
+  async throttle(key, limit, window) {
+    try {
+      return await this.rateLimit(key, limit, window);
+    } catch (e) {
+      if (e instanceof RateLimitError) {
+        await utils_js.sleep(e.reset - Date.now());
+        return this.throttle(key, limit, window);
+      }
+      throw e;
+    }
+  }
+  /**
+   * Reset the rate limit
+   *
+   * @param key  Key of the rate limit
+   */
+  async resetRateLimit(key) {
+    await this._localStorage.resetRateLimit(`${key}:${this._localKey}`);
+  }
+}
+const makeCurrentSceneKey = (key) => `$current_scene_${key}`;
+class StateService {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  _cache = new utils_js.LruMap(100);
+  _vacuumTimer;
+  _loaded = false;
+  _load = utils_js.asyncResettable(async () => {
+    await this.provider.driver.load?.();
+    this._loaded = true;
+  });
+  async load() {
+    await this._load.run();
+    this._vacuumTimer = utils_js.timers.setInterval(() => {
+      Promise.resolve(this.provider.state.vacuum(Date.now())).catch(() => {
+      });
+    }, 3e5);
+  }
+  async destroy() {
+    await this.provider.driver.save?.();
+    await this.provider.driver.destroy?.();
+    utils_js.timers.clearInterval(this._vacuumTimer);
+    this._loaded = false;
+  }
+  async getState(key) {
+    if (!this._loaded) await this.load();
+    const cached = this._cache.get(key);
+    if (cached) return cached;
+    const state2 = await this.provider.state.getState(key, Date.now());
+    if (!state2) return null;
+    return JSON.parse(state2);
+  }
+  async setState(key, state2, ttl) {
+    if (!this._loaded) await this.load();
+    this._cache.set(key, state2);
+    await this.provider.state.setState(key, JSON.stringify(state2), ttl);
+  }
+  async deleteState(key) {
+    if (!this._loaded) await this.load();
+    this._cache.delete(key);
+    await this.provider.state.deleteState(key);
+  }
+  getCurrentScene(key) {
+    return this.getState(makeCurrentSceneKey(key));
+  }
+  setCurrentScene(key, scene, ttl) {
+    return this.setState(makeCurrentSceneKey(key), scene, ttl);
+  }
+  deleteCurrentScene(key) {
+    return this.deleteState(makeCurrentSceneKey(key));
+  }
+  getRateLimit(key, limit, window) {
+    return this.provider.state.getRateLimit(key, Date.now(), limit, window);
+  }
+  resetRateLimit(key) {
+    return this.provider.state.resetRateLimit(key);
+  }
+}
+class Dispatcher {
+  _groups = /* @__PURE__ */ new Map();
+  _groupsOrder = [];
+  _client;
+  _parent;
+  _children = [];
+  _scenes;
+  _scene;
+  _sceneScoped;
+  _storage;
+  _stateKeyDelegate;
+  _customStateKeyDelegate;
+  _customStorage;
+  _deps = {};
+  _errorHandler;
+  _preUpdateHandler;
+  _postUpdateHandler;
+  _sceneTransitionHandler;
+  constructor(client, params) {
+    this.dispatchRawUpdate = this.dispatchRawUpdate.bind(this);
+    this.dispatchUpdate = this.dispatchUpdate.bind(this);
+    let { storage, key, sceneName } = params ?? {};
+    if (client) {
+      this.bindToClient(client);
+      if (storage) {
+        this._storage = new StateService(storage);
+        this._stateKeyDelegate = key ?? defaultStateKeyDelegate;
+      }
+    } else {
+      if (storage) {
+        this._customStorage = new StateService(storage);
+      }
+      if (key) {
+        this._customStateKeyDelegate = key;
+      }
+      if (sceneName) {
+        if (sceneName[0] === "$") {
+          throw new core.MtArgumentError("Scene name cannot start with $");
+        }
+        this._scene = sceneName;
+      }
+    }
+  }
+  static for(client, params) {
+    return new Dispatcher(client, params);
+  }
+  /**
+   * Create a new child dispatcher.
+   */
+  static child(params) {
+    return new Dispatcher(void 0, params);
+  }
+  /**
+   * Create a new scene dispatcher
+   */
+  static scene(name, params) {
+    return new Dispatcher(void 0, { sceneName: name, ...params });
+  }
+  /** For scene dispatchers, name of the scene */
+  get sceneName() {
+    return this._scene;
+  }
+  inject(name, value) {
+    if (this._parent) {
+      throw new core.MtArgumentError("Cannot inject dependencies to child dispatchers");
+    }
+    if (typeof name === "object") {
+      for (const [k, v] of Object.entries(name)) {
+        this._deps[k] = v;
+      }
+    } else {
+      this._deps[name] = value;
+    }
+  }
+  /**
+   * Get the dependencies injected into this dispatcher.
+   */
+  get deps() {
+    return this._deps;
+  }
+  /**
+   * Bind the dispatcher to the client.
+   * Called by the constructor automatically if
+   * `client` was passed.
+   *
+   * Dispatcher also uses bound client to throw errors
+   */
+  bindToClient(client) {
+    client.on("update", this.dispatchUpdate);
+    client.on("raw_update", this.dispatchRawUpdate);
+    this._client = client;
+  }
+  /**
+   * Unbind a dispatcher from the client.
+   */
+  unbind() {
+    if (this._client) {
+      this._client.off("update", this.dispatchUpdate);
+      this._client.off("raw_update", this.dispatchRawUpdate);
+      this._client = void 0;
+    }
+  }
+  /**
+   * Destroy the dispatcher and all its children.
+   *
+   * When destroying, all the registered handlers are removed,
+   * and the underlying storage is freed.
+   */
+  async destroy() {
+    if (this._parent && this._customStorage) {
+      await this._customStorage.destroy();
+    } else if (!this._parent && this._storage) {
+      await this._storage.destroy();
+    }
+    this.removeUpdateHandler("all");
+    for (const child of this._children) {
+      await child.destroy();
+    }
+    for (const scene of this._scenes?.values() ?? []) {
+      await scene.destroy();
+    }
+  }
+  /**
+   * Process a raw update with this dispatcher.
+   * Calling this method without bound client will not work.
+   *
+   * Under the hood asynchronously calls {@link dispatchRawUpdateNow}
+   * with error handler set to client's one.
+   *
+   * @param update  Update to process
+   * @param peers Peers index
+   */
+  dispatchRawUpdate(update, peers) {
+    if (!this._client) return;
+    this.dispatchRawUpdateNow(update, peers).catch((err) => this._client.emitError(err));
+  }
+  /**
+   * Process a raw update right now in the current stack.
+   *
+   * Unlike {@link dispatchRawUpdate}, this does not schedule
+   * the update to be dispatched, but dispatches it immediately,
+   * and after `await`ing this method you can be certain that the update
+   * was fully processed by all the registered handlers, including children.
+   *
+   * @param update  Update to process
+   * @param peers  Peers map
+   * @returns  Whether the update was handled
+   */
+  async dispatchRawUpdateNow(update, peers) {
+    if (!this._client) return false;
+    let handled = false;
+    outer: for (const grp of this._groupsOrder) {
+      const group = this._groups.get(grp);
+      if (group.has("raw")) {
+        const handlers = group.get("raw");
+        for (const h of handlers) {
+          let result;
+          if (!h.check || await h.check(this._client, update, peers)) {
+            result = await h.callback(this._client, update, peers);
+            handled = true;
+          } else {
+            continue;
+          }
+          switch (result) {
+            case "continue":
+              continue;
+            case "stop":
+              break outer;
+            case "stop-children":
+              return handled;
+          }
+          break;
+        }
+      }
+    }
+    for (const child of this._children) {
+      const childHandled = await child.dispatchRawUpdateNow(update, peers);
+      handled ||= childHandled;
+    }
+    return handled;
+  }
+  /**
+   * Process an update with this dispatcher.
+   * Calling this method without bound client will not work.
+   *
+   * Under the hood asynchronously calls {@link dispatchUpdateNow}
+   * with error handler set to client's one.
+   *
+   * @param update  Update to process
+   */
+  dispatchUpdate(update) {
+    if (!this._client) return;
+    this.dispatchUpdateNow(update).catch((err) => this._client.emitError(err));
+  }
+  /**
+   * Process an update right now in the current stack.
+   *
+   * Unlike {@link dispatchUpdate}, this does not schedule
+   * the update to be dispatched, but dispatches it immediately,
+   * and after `await`ing this method you can be certain that the update
+   * was fully processed by all the registered handlers, including children.
+   *
+   * @param update  Update to process
+   * @returns  Whether the update was handled
+   */
+  async dispatchUpdateNow(update) {
+    return this._dispatchUpdateNowImpl(update);
+  }
+  async _dispatchUpdateNowImpl(update, parsedState, parsedScene, forceScene, parsedContext) {
+    if (!this._client) return false;
+    if (parsedScene === void 0) {
+      if (this._storage && this._scenes && (update.name === "new_message" || update.name === "edit_message" || update.name === "callback_query" || update.name === "message_group" || update.name === "new_business_message" || update.name === "edit_business_message" || update.name === "business_message_group")) {
+        if (!parsedContext) parsedContext = _parsedUpdateToContext(this._client, update);
+        const key = await this._stateKeyDelegate(parsedContext);
+        if (key) {
+          parsedScene = await this._storage.getCurrentScene(key);
+        } else {
+          parsedScene = null;
+        }
+      } else {
+        parsedScene = null;
+      }
+    }
+    if (!forceScene && parsedScene !== null) {
+      if (this._scene) {
+        if (this._scene !== parsedScene) {
+          return false;
+        }
+      } else {
+        if (!this._scenes || !this._scenes.has(parsedScene)) {
+          return false;
+        }
+        return this._scenes.get(parsedScene)._dispatchUpdateNowImpl(update, parsedState, parsedScene, true);
+      }
+    }
+    if (parsedState === void 0) {
+      if (this._storage && (update.name === "new_message" || update.name === "edit_message" || update.name === "callback_query" || update.name === "message_group" || update.name === "new_business_message" || update.name === "edit_business_message" || update.name === "business_message_group")) {
+        if (!parsedContext) parsedContext = _parsedUpdateToContext(this._client, update);
+        const key = await this._stateKeyDelegate(parsedContext);
+        if (key) {
+          let customKey;
+          if (!this._customStateKeyDelegate || (customKey = await this._customStateKeyDelegate(parsedContext))) {
+            parsedState = new UpdateState(
+              this._storage,
+              key,
+              this._scene ?? null,
+              this._sceneScoped,
+              this._customStorage,
+              customKey
+            );
+          }
+        } else {
+          parsedState = null;
+        }
+      } else {
+        parsedState = null;
+      }
+    }
+    let shouldDispatch = true;
+    let shouldDispatchChildren = true;
+    let handled = false;
+    switch (await this._preUpdateHandler?.(update, parsedState)) {
+      case "stop":
+        shouldDispatch = false;
+        break;
+      case "stop-children":
+        return false;
+    }
+    if (shouldDispatch) {
+      outer: for (const grp of this._groupsOrder) {
+        const group = this._groups.get(grp);
+        if (group.has(update.name)) {
+          const handlers = group.get(update.name);
+          try {
+            for (const h of handlers) {
+              let result;
+              if (!parsedContext) parsedContext = _parsedUpdateToContext(this._client, update);
+              if (!h.check || await h.check(parsedContext, parsedState)) {
+                result = await h.callback(parsedContext, parsedState);
+                handled = true;
+              } else {
+                continue;
+              }
+              if (parsedState && this._scenes) {
+                const newScene = parsedState.scene;
+                if (parsedScene !== newScene) {
+                  const nextDp = newScene ? this._scenes.get(newScene) : this._parent;
+                  if (!nextDp) {
+                    throw new core.MtArgumentError(`Scene ${newScene} not found`);
+                  }
+                  if (nextDp._sceneTransitionHandler) {
+                    const transition = new SceneTransitionContext(parsedScene, parsedContext);
+                    const transitionResult = await nextDp._sceneTransitionHandler?.(
+                      transition,
+                      parsedState
+                    );
+                    switch (transitionResult) {
+                      case "stop":
+                        return true;
+                      case "continue":
+                        continue;
+                      case "scene": {
+                        const scene = parsedState.scene;
+                        const dp = scene ? nextDp._scenes.get(scene) : nextDp._parent;
+                        return dp._dispatchUpdateNowImpl(update, void 0, scene, true);
+                      }
+                    }
+                  }
+                }
+              }
+              switch (result) {
+                case "continue":
+                  continue;
+                case "stop":
+                  break outer;
+                case "stop-children":
+                  shouldDispatchChildren = false;
+                  break outer;
+                case "scene": {
+                  if (!parsedState) {
+                    throw new core.MtArgumentError("Cannot use ToScene without state");
+                  }
+                  const scene = parsedState.scene;
+                  const dp = scene ? this._scenes.get(scene) : this._parent;
+                  return dp._dispatchUpdateNowImpl(update, void 0, scene, true);
+                }
+              }
+              break;
+            }
+          } catch (e) {
+            if (this._errorHandler) {
+              const handled2 = await this._errorHandler(e, update, parsedState);
+              if (!handled2) throw e;
+            } else {
+              throw e;
+            }
+          }
+        }
+      }
+    }
+    if (shouldDispatchChildren) {
+      for (const child of this._children) {
+        const childHandled = await child._dispatchUpdateNowImpl(update);
+        handled ||= childHandled;
+      }
+    }
+    await this._postUpdateHandler?.(handled, update, parsedState);
+    return handled;
+  }
+  /**
+   * Add an update handler to a given handlers group
+   *
+   * @param handler  Update handler
+   * @param group  Handler group index
+   */
+  addUpdateHandler(handler, group = 0) {
+    if (!this._groups.has(group)) {
+      this._groups.set(group, /* @__PURE__ */ new Map());
+      this._groupsOrder.push(group);
+      this._groupsOrder.sort((a, b) => a - b);
+    }
+    if (!this._groups.get(group).has(handler.name)) {
+      this._groups.get(group).set(handler.name, []);
+    }
+    this._groups.get(group).get(handler.name).push(handler);
+  }
+  /**
+   * Remove an update handler (or handlers) from a given
+   * handler group.
+   *
+   * @param handler  Update handler to remove, its name or `'all'` to remove all
+   * @param group  Handler group index (null to affect all groups)
+   */
+  removeUpdateHandler(handler, group = 0) {
+    if (group !== null && !this._groups.has(group)) {
+      return;
+    }
+    if (typeof handler === "string") {
+      if (handler === "all") {
+        if (group === null) {
+          this._groups = /* @__PURE__ */ new Map();
+        } else {
+          this._groups.delete(group);
+        }
+      } else if (group !== null) {
+        this._groups.get(group).delete(handler);
+      }
+      return;
+    }
+    if (group === null) return;
+    if (!this._groups.get(group).has(handler.name)) {
+      return;
+    }
+    const idx = this._groups.get(group).get(handler.name).indexOf(handler);
+    if (idx > -1) {
+      this._groups.get(group).get(handler.name).splice(idx, 1);
+    }
+  }
+  /**
+   * Register an error handler.
+   *
+   * This is used locally within this dispatcher
+   * (does not affect children/parent) whenever
+   * an error is thrown inside an update handler.
+   * Not used for raw update handlers
+   *
+   * When an error is thrown, but there is no error
+   * handler, it is propagated to `TelegramClient`.
+   *
+   * There can be at most one error handler.
+   * Pass `null` to remove it.
+   *
+   * @param handler  Error handler
+   */
+  onError(handler) {
+    if (handler) this._errorHandler = handler;
+    else this._errorHandler = void 0;
+  }
+  /**
+   * Register pre-update middleware.
+   *
+   * This is used locally within this dispatcher
+   * (does not affect children/parent) before processing
+   * an update, and can be used to skip this update.
+   *
+   * There can be at most one pre-update middleware.
+   * Pass `null` to remove it.
+   *
+   * @param handler  Pre-update middleware
+   */
+  onPreUpdate(handler) {
+    if (handler) this._preUpdateHandler = handler;
+    else this._preUpdateHandler = void 0;
+  }
+  /**
+   * Register post-update middleware.
+   *
+   * This is used locally within this dispatcher
+   * (does not affect children/parent) after successfully
+   * processing an update, and can be used for stats.
+   *
+   * There can be at most one post-update middleware.
+   * Pass `null` to remove it.
+   *
+   * @param handler  Pre-update middleware
+   */
+  onPostUpdate(handler) {
+    if (handler) this._postUpdateHandler = handler;
+    else this._postUpdateHandler = void 0;
+  }
+  /**
+   * Set error handler that will propagate
+   * the error to the parent dispatcher
+   */
+  propagateErrorToParent(err, update, state2) {
+    if (!this.parent) {
+      throw new core.MtArgumentError("This dispatcher is not a child");
+    }
+    if (this.parent._errorHandler) {
+      return this.parent._errorHandler(err, update, state2);
+    }
+    throw err;
+  }
+  // children //
+  /**
+   * Get parent dispatcher if current dispatcher is a child.
+   * Otherwise, return `null`
+   */
+  get parent() {
+    return this._parent ?? null;
+  }
+  _prepareChild(child) {
+    if (child._client) {
+      throw new core.MtArgumentError(
+        `Provided dispatcher is ${child._parent ? "already a child. Use parent.removeChild() before calling addChild()" : "already bound to a client. Use unbind() before calling addChild()"}`
+      );
+    }
+    child._parent = this;
+    child._client = this._client;
+    child._storage = this._storage;
+    child._deps = this._deps;
+    child._scenes = this._scenes;
+    child._stateKeyDelegate = this._stateKeyDelegate;
+    child._customStorage ??= this._customStorage;
+    child._customStateKeyDelegate ??= this._customStateKeyDelegate;
+  }
+  /**
+   * Add a child dispatcher.
+   *
+   * Child dispatchers are called when dispatching updates
+   * just like normal, except they can be controlled
+   * externally. Additionally, child dispatcher have their own
+   * independent handler grouping that does not interfere with parent's,
+   * including `StopPropagation` (i.e. returning `StopPropagation` will
+   * still call children. To entirely stop, use `StopChildrenPropagation`)
+   *
+   * Note that child dispatchers share the same TelegramClient and
+   * storage binding as the parent, don't bind them manually.
+   *
+   * @param child  Other dispatcher
+   */
+  addChild(child) {
+    if (this._children.includes(child)) return;
+    this._prepareChild(child);
+    this._children.push(child);
+  }
+  addScene(scene, scoped = true) {
+    if (!this._scenes) this._scenes = /* @__PURE__ */ new Map();
+    if (!scene._scene) {
+      throw new core.MtArgumentError(
+        "Non-scene dispatcher passed to addScene. Use `Dispatcher.scene()` to create one."
+      );
+    }
+    if (this._scenes.has(scene._scene)) {
+      throw new core.MtArgumentError(`Scene with name ${scene._scene} is already registered!`);
+    }
+    this._prepareChild(scene);
+    scene._sceneScoped = scoped;
+    this._scenes.set(scene._scene, scene);
+  }
+  /**
+   * Remove a child dispatcher.
+   *
+   * Removing child dispatcher will also remove
+   * child dispatcher's client binding.
+   *
+   * If the provided dispatcher is not a child of current,
+   * this function will silently fail.
+   *
+   * @param child  Other dispatcher
+   */
+  removeChild(child) {
+    const idx = this._children.indexOf(child);
+    if (idx > -1) {
+      child._unparent();
+      this._children.splice(idx, 1);
+    }
+  }
+  _unparent() {
+    this._parent = this._client = void 0;
+    this._deps = {};
+    this._stateKeyDelegate = void 0;
+    this._storage = void 0;
+  }
+  /**
+   * Extend current dispatcher by copying other dispatcher's
+   * handlers and children to the current.
+   *
+   * This might be more efficient for simple cases, but do note that the handler
+   * groups, children and scenes will get merged (unlike {@link addChild},
+   * where they are independent). Also note that unlike with children,
+   * when adding handlers to `other` *after* you extended
+   * the current dispatcher, changes will not be applied.
+   *
+   * @param other  Other dispatcher
+   */
+  extend(other) {
+    if (other._customStorage || other._customStateKeyDelegate) {
+      throw new core.MtArgumentError("Provided dispatcher has custom storage and cannot be extended from.");
+    }
+    other._groupsOrder.forEach((group) => {
+      if (!this._groups.has(group)) {
+        this._groups.set(group, other._groups.get(group));
+        this._groupsOrder.push(group);
+      } else {
+        const otherGrp = other._groups.get(group);
+        const selfGrp = this._groups.get(group);
+        for (const typ of otherGrp.keys()) {
+          if (!selfGrp.has(typ)) {
+            selfGrp.set(typ, otherGrp.get(typ));
+          } else {
+            selfGrp.get(typ).push(...otherGrp.get(typ));
+          }
+        }
+      }
+    });
+    other._children.forEach((it) => {
+      it._unparent();
+      this.addChild(it);
+    });
+    if (other._scenes) {
+      const otherScenes = other._scenes;
+      if (!this._scenes) this._scenes = /* @__PURE__ */ new Map();
+      const myScenes = this._scenes;
+      for (const key of otherScenes.keys()) {
+        otherScenes.get(key)._unparent();
+        if (myScenes.has(key)) {
+          myScenes.delete(key);
+        }
+        this.addScene(otherScenes.get(key), otherScenes.get(key)._sceneScoped);
+      }
+    }
+    this._groupsOrder.sort((a, b) => a - b);
+  }
+  /**
+   * Create a clone of this dispatcher, that has the same handlers,
+   * but is not bound to a client or to a parent dispatcher.
+   *
+   * Custom Storage and key delegate are copied too.
+   *
+   * By default, child dispatchers (and scenes) are ignored, since
+   * that requires cloning every single one of them recursively
+   * and then binding them back.
+   *
+   * @param children  Whether to also clone children and scenes
+   */
+  clone(children = false) {
+    const dp = new Dispatcher();
+    for (const key of this._groups.keys()) {
+      const idx = key;
+      dp._groups.set(idx, /* @__PURE__ */ new Map());
+      for (const type of this._groups.get(idx).keys()) {
+        dp._groups.get(idx).set(type, [...this._groups.get(idx).get(type)]);
+      }
+    }
+    dp._groupsOrder = [...this._groupsOrder];
+    dp._errorHandler = this._errorHandler;
+    dp._customStateKeyDelegate = this._customStateKeyDelegate;
+    dp._customStorage = this._customStorage;
+    if (children) {
+      this._children.forEach((it) => {
+        const child = it.clone(true);
+        dp.addChild(child);
+      });
+      if (this._scenes) {
+        for (const key of this._scenes.keys()) {
+          const scene = this._scenes.get(key).clone(true);
+          dp.addScene(scene, this._scenes.get(key)._sceneScoped);
+        }
+      }
+    }
+    return dp;
+  }
+  getState(object) {
+    if (!this._storage) {
+      throw new core.MtArgumentError("Cannot use getUpdateState() filter without state storage");
+    }
+    if (typeof object === "string") {
+      return new UpdateState(this._storage, object, this._scene ?? null, this._sceneScoped, this._customStorage);
+    }
+    return Promise.resolve(this._stateKeyDelegate(object)).then((key) => {
+      if (!key) {
+        throw new core.MtArgumentError("Cannot derive key from given object");
+      }
+      if (!this._customStateKeyDelegate) {
+        return new UpdateState(this._storage, key, this._scene ?? null, this._sceneScoped, this._customStorage);
+      }
+      return Promise.resolve(this._customStateKeyDelegate(object)).then((customKey) => {
+        if (!customKey) {
+          throw new core.MtArgumentError("Cannot derive custom key from given object");
+        }
+        return new UpdateState(
+          this._storage,
+          key,
+          this._scene ?? null,
+          this._sceneScoped,
+          this._customStorage,
+          customKey
+        );
+      });
+    });
+  }
+  /**
+   * Get global state.
+   *
+   * This will load the state for the given object
+   * ignoring local custom storage, key delegate and scene scope.
+   */
+  getGlobalState(object) {
+    if (!this._parent) {
+      throw new core.MtArgumentError("This dispatcher does not have a parent");
+    }
+    return Promise.resolve(this._stateKeyDelegate(object)).then((key) => {
+      if (!key) {
+        throw new core.MtArgumentError("Cannot derive key from given object");
+      }
+      return new UpdateState(this._storage, key, this._scene ?? null, false);
+    });
+  }
+  // addUpdateHandler convenience wrappers //
+  _addKnownHandler(name, filter, handler, group) {
+    if (typeof handler === "number" || typeof handler === "undefined") {
+      this.addUpdateHandler(
+        {
+          name,
+          callback: filter
+        },
+        handler
+      );
+    } else {
+      this.addUpdateHandler(
+        {
+          name,
+          callback: handler,
+          check: filter
+        },
+        group
+      );
+    }
+  }
+  /** @internal */
+  onRawUpdate(filter, handler, group) {
+    this._addKnownHandler("raw", filter, handler, group);
+  }
+  /**
+   * Register a scene transition handler
+   *
+   * This handler is called whenever a scene transition occurs
+   * in the context of the scene that is being entered,
+   * and before any of the its own handlers are called,
+   * and can be used to customize the transition behavior:
+   *   - `Stop` to prevent dispatching the update any further **even if ToScene/ToRoot was used**
+   *   - `Continue` same as Stop, but still dispatch the update to children
+   *   - `ToScene` to prevent the transition and dispatch the update to the scene entered in the transition handler
+   *
+   * > **Note**: if multiple `state.enter()` calls were made within the same update,
+   * > this handler will only be called for the last one.
+   *
+   * @param handler  Raw update handler
+   * @param group  Handler group index
+   */
+  onSceneTransition(handler) {
+    if (handler) this._sceneTransitionHandler = handler;
+    else this._sceneTransitionHandler = void 0;
+  }
+  /** @internal */
+  onAnyCallbackQuery(filter, handler, group) {
+    this._addKnownHandler("callback_query", filter, handler, group);
+    this._addKnownHandler("inline_callback_query", filter, handler, group);
+    this._addKnownHandler("business_callback_query", filter, handler, group);
+  }
+  /** @internal */
+  onNewMessage(filter, handler, group) {
+    this._addKnownHandler("new_message", filter, handler, group);
+  }
+  /** @internal */
+  onEditMessage(filter, handler, group) {
+    this._addKnownHandler("edit_message", filter, handler, group);
+  }
+  /** @internal */
+  onMessageGroup(filter, handler, group) {
+    this._addKnownHandler("message_group", filter, handler, group);
+  }
+  /** @internal */
+  onDeleteMessage(filter, handler, group) {
+    this._addKnownHandler("delete_message", filter, handler, group);
+  }
+  /** @internal */
+  onChatMemberUpdate(filter, handler, group) {
+    this._addKnownHandler("chat_member", filter, handler, group);
+  }
+  /** @internal */
+  onInlineQuery(filter, handler, group) {
+    this._addKnownHandler("inline_query", filter, handler, group);
+  }
+  /** @internal */
+  onChosenInlineResult(filter, handler, group) {
+    this._addKnownHandler("chosen_inline_result", filter, handler, group);
+  }
+  /** @internal */
+  onCallbackQuery(filter, handler, group) {
+    this._addKnownHandler("callback_query", filter, handler, group);
+  }
+  /** @internal */
+  onInlineCallbackQuery(filter, handler, group) {
+    this._addKnownHandler("inline_callback_query", filter, handler, group);
+  }
+  /** @internal */
+  onBusinessCallbackQuery(filter, handler, group) {
+    this._addKnownHandler("business_callback_query", filter, handler, group);
+  }
+  /** @internal */
+  onPollUpdate(filter, handler, group) {
+    this._addKnownHandler("poll", filter, handler, group);
+  }
+  /** @internal */
+  onPollVote(filter, handler, group) {
+    this._addKnownHandler("poll_vote", filter, handler, group);
+  }
+  /** @internal */
+  onUserStatusUpdate(filter, handler, group) {
+    this._addKnownHandler("user_status", filter, handler, group);
+  }
+  /** @internal */
+  onUserTyping(filter, handler, group) {
+    this._addKnownHandler("user_typing", filter, handler, group);
+  }
+  /** @internal */
+  onHistoryRead(filter, handler, group) {
+    this._addKnownHandler("history_read", filter, handler, group);
+  }
+  /** @internal */
+  onBotStopped(filter, handler, group) {
+    this._addKnownHandler("bot_stopped", filter, handler, group);
+  }
+  /** @internal */
+  onBotChatJoinRequest(filter, handler, group) {
+    this._addKnownHandler("bot_chat_join_request", filter, handler, group);
+  }
+  /** @internal */
+  onChatJoinRequest(filter, handler, group) {
+    this._addKnownHandler("chat_join_request", filter, handler, group);
+  }
+  /** @internal */
+  onPreCheckoutQuery(filter, handler, group) {
+    this._addKnownHandler("pre_checkout_query", filter, handler, group);
+  }
+  /** @internal */
+  onStoryUpdate(filter, handler, group) {
+    this._addKnownHandler("story", filter, handler, group);
+  }
+  /** @internal */
+  onDeleteStory(filter, handler, group) {
+    this._addKnownHandler("delete_story", filter, handler, group);
+  }
+  /** @internal */
+  onBotReactionUpdate(filter, handler, group) {
+    this._addKnownHandler("bot_reaction", filter, handler, group);
+  }
+  /** @internal */
+  onBotReactionCountUpdate(filter, handler, group) {
+    this._addKnownHandler("bot_reaction_count", filter, handler, group);
+  }
+  /** @internal */
+  onBusinessConnectionUpdate(filter, handler, group) {
+    this._addKnownHandler("business_connection", filter, handler, group);
+  }
+  /** @internal */
+  onNewBusinessMessage(filter, handler, group) {
+    this._addKnownHandler("new_business_message", filter, handler, group);
+  }
+  /** @internal */
+  onEditBusinessMessage(filter, handler, group) {
+    this._addKnownHandler("edit_business_message", filter, handler, group);
+  }
+  /** @internal */
+  onBusinessMessageGroup(filter, handler, group) {
+    this._addKnownHandler("business_message_group", filter, handler, group);
+  }
+  /** @internal */
+  onDeleteBusinessMessage(filter, handler, group) {
+    this._addKnownHandler("delete_business_message", filter, handler, group);
+  }
+  // end-codegen
+}
+function chat(type) {
+  return (msg) => msg.chat.chatType === type;
+}
+const chatId = (id) => {
+  const indexId = /* @__PURE__ */ new Set();
+  const indexUsername = /* @__PURE__ */ new Set();
+  let matchSelf = false;
+  if (!Array.isArray(id)) id = [id];
+  id.forEach((id2) => {
+    if (id2 === "me" || id2 === "self") {
+      matchSelf = true;
+    } else if (typeof id2 === "number") {
+      indexId.add(id2);
+    } else {
+      indexUsername.add(id2);
+    }
+  });
+  return (upd) => {
+    switch (upd._name) {
+      case "poll_vote": {
+        const peer = upd.peer;
+        return peer.type === "chat" && (indexId.has(peer.id) || Boolean(peer.usernames?.some((u) => indexUsername.has(u.username))));
+      }
+      case "history_read":
+      case "user_typing": {
+        const id2 = upd.chatId;
+        return matchSelf && id2 === upd.client.storage.self.getCached()?.userId || indexId.has(id2);
+      }
+    }
+    const chat2 = upd.chat;
+    return matchSelf && chat2.isSelf || indexId.has(chat2.id) || Boolean(chat2.usernames?.some((u) => indexUsername.has(u.username)));
+  };
+};
+const any = () => true;
+function not(fn) {
+  return (upd, state2) => {
+    const res = fn(upd, state2);
+    if (typeof res === "boolean") return !res;
+    return res.then((r) => !r);
+  };
+}
+function and(...fns) {
+  return (upd, state2) => {
+    let i = 0;
+    const max = fns.length;
+    const next = () => {
+      if (i === max) return true;
+      const res = fns[i++](upd, state2);
+      if (typeof res === "boolean") {
+        if (!res) return false;
+        return next();
+      }
+      return res.then((r) => {
+        if (!r) return false;
+        return next();
+      });
+    };
+    return next();
+  };
+}
+function or(...fns) {
+  return (upd, state2) => {
+    let i = 0;
+    const max = fns.length;
+    const next = () => {
+      if (i === max) return false;
+      const res = fns[i++](upd, state2);
+      if (typeof res === "boolean") {
+        if (res) return true;
+        return next();
+      }
+      return res.then((r) => {
+        if (r) return true;
+        return next();
+      });
+    };
+    return next();
+  };
+}
+function command(commands, {
+  prefixes = "/",
+  caseSensitive = false
+} = {}) {
+  if (!Array.isArray(commands)) commands = [commands];
+  if (!caseSensitive) {
+    commands = commands.map((i) => typeof i === "string" ? i.toLowerCase() : i);
+  }
+  const argumentsRe = /(["'])(.*?)(?<!\\)\1|(\S+)/g;
+  const unescapeRe = /\\(['"])/;
+  const commandsRe = [];
+  commands.forEach((cmd) => {
+    if (typeof cmd !== "string") cmd = cmd.source;
+    commandsRe.push(new RegExp(`^(${cmd})(?:\\s|$|@([a-zA-Z0-9_]+?bot)(?:\\s|$))`, caseSensitive ? "" : "i"));
+  });
+  if (prefixes === null) prefixes = [];
+  if (typeof prefixes === "string") prefixes = [prefixes];
+  const _prefixes = prefixes;
+  const check = (msg) => {
+    if (msg.isMessageGroup) return check(msg.messages[0]);
+    for (const pref of _prefixes) {
+      if (!msg.text.startsWith(pref)) continue;
+      const withoutPrefix = msg.text.slice(pref.length);
+      for (const regex2 of commandsRe) {
+        const m = withoutPrefix.match(regex2);
+        if (!m) continue;
+        const lastGroup = m[m.length - 1];
+        if (lastGroup) {
+          const self = msg.client.storage.self.getCached();
+          if (self && self.isBot && !self.usernames.includes(lastGroup)) {
+            return false;
+          }
+        }
+        const match = m.slice(1, -1);
+        if (!caseSensitive) match[0] = match[0].toLowerCase();
+        withoutPrefix.slice(m[0].length).replace(argumentsRe, ($0, $1, $2, $3) => {
+          match.push(($2 || $3 || "").replace(unescapeRe, "$1"));
+          return "";
+        });
+        msg.command = match;
+        return true;
+      }
+    }
+    return false;
+  };
+  return check;
+}
+const start = and(chat("private"), command("start"));
+const startGroup = and(or(chat("supergroup"), chat("group")), command("start"));
+function deeplinkBase(base) {
+  return (params) => {
+    if (!Array.isArray(params)) {
+      return and(start, (_msg) => {
+        const msg = _msg;
+        if (msg.command.length !== 2) return false;
+        const p = msg.command[1];
+        if (typeof params === "string" && p === params) return true;
+        const m = p.match(params);
+        if (!m) return false;
+        msg.command.push(...m.slice(1));
+        return true;
+      });
+    }
+    return and(base, (_msg) => {
+      const msg = _msg;
+      if (msg.command.length !== 2) return false;
+      const p = msg.command[1];
+      for (const param of params) {
+        if (typeof param === "string" && p === param) return true;
+        const m = p.match(param);
+        if (!m) continue;
+        msg.command.push(...m.slice(1));
+        return true;
+      }
+      return false;
+    });
+  };
+}
+const deeplink = deeplinkBase(start);
+const deeplinkGroup = deeplinkBase(startGroup);
+function every(filter) {
+  return (ctx, state2) => {
+    let i = 0;
+    const upds = ctx.messages;
+    const max = upds.length;
+    const next = () => {
+      if (i === max) return true;
+      const res = filter(upds[i++], state2);
+      if (typeof res === "boolean") {
+        if (!res) return false;
+        return next();
+      }
+      return res.then((r) => {
+        if (!r) return false;
+        return next();
+      });
+    };
+    return next();
+  };
+}
+function some(filter) {
+  return (ctx, state2) => {
+    let i = 0;
+    const upds = ctx.messages;
+    const max = upds.length;
+    const next = () => {
+      if (i === max) return false;
+      const res = filter(upds[i++], state2);
+      if (typeof res === "boolean") {
+        if (res) return true;
+        return next();
+      }
+      return res.then((r) => {
+        if (r) return true;
+        return next();
+      });
+    };
+    return next();
+  };
+}
+const incoming = (msg) => !msg.isOutgoing;
+const outgoing = (msg) => msg.isOutgoing;
+const scheduled = (msg) => msg.isScheduled;
+const reply = (msg) => msg.replyToMessage !== null;
+function replyOrigin(origin) {
+  return (msg) => msg.replyToMessage?.originIs(origin) ?? false;
+}
+const media = (msg) => msg.media !== null;
+function mediaOf(type) {
+  return (msg) => msg.media?.type === type;
+}
+const photo = mediaOf("photo");
+const dice = mediaOf("dice");
+const contact = mediaOf("contact");
+const audio = mediaOf("audio");
+const voice = mediaOf("voice");
+const sticker = mediaOf("sticker");
+const document = mediaOf("document");
+const anyVideo = mediaOf("video");
+const location = mediaOf("location");
+const liveLocation = mediaOf("live_location");
+const game = mediaOf("game");
+const webpage = mediaOf("webpage");
+const venue = mediaOf("venue");
+const poll = mediaOf("poll");
+const invoice = mediaOf("invoice");
+const anyLocation = (msg) => msg.media instanceof core.RawLocation;
+const anyDocument = (msg) => msg.media instanceof core.RawDocument;
+const video = (msg) => msg.media?.type === "video" && !msg.media.isAnimation && !msg.media.isRound;
+const animation = (msg) => msg.media?.type === "video" && msg.media.isAnimation && !msg.media.isRound;
+const roundMessage = (msg) => msg.media?.type === "video" && !msg.media.isAnimation && msg.media.isRound;
+function stickerByType(type) {
+  return (msg) => msg.media?.type === "sticker" && msg.media.stickerType === type;
+}
+function stickerBySourceType(type) {
+  return (msg) => msg.media?.type === "sticker" && msg.media.sourceType === type;
+}
+const text = (msg) => msg.media === null && !msg.isService;
+const service = (msg) => msg.isService;
+function action(type) {
+  if (Array.isArray(type)) {
+    const index = {};
+    type.forEach((it) => index[it] = true);
+    return (msg) => msg.action?.type in index;
+  }
+  return (msg) => msg.action?.type === type;
+}
+function sender(type) {
+  return (msg) => msg.sender.type === type;
+}
+function replyTo(filter) {
+  return async (msg, state2) => {
+    if (!msg.replyToMessage?.id) return false;
+    const reply2 = msg._name === "new_message" ? await msg.getReplyTo() : msg.replyTo;
+    if (!reply2) return false;
+    if (msg._name === "new_message") {
+      msg.getReplyTo = () => Promise.resolve(reply2);
+    }
+    if (!filter) return true;
+    return filter(reply2, state2);
+  };
+}
+function withCompleteSender(filter) {
+  return async (msg, state2) => {
+    try {
+      await msg.getCompleteSender();
+    } catch {
+      return false;
+    }
+    if (!filter) return true;
+    return filter(msg, state2);
+  };
+}
+function withCompleteChat(filter) {
+  return async (msg, state2) => {
+    try {
+      await msg.getCompleteChat();
+    } catch {
+      return false;
+    }
+    if (!filter) return true;
+    return filter(msg, state2);
+  };
+}
+const stateEmpty = async (upd, state2) => {
+  if (!state2) return false;
+  return !await state2.get();
+};
+function state(predicate) {
+  return async (upd, state2) => {
+    if (!state2) return false;
+    const data = await state2.get();
+    if (!data) return false;
+    return predicate(data);
+  };
+}
+function extractText(obj) {
+  switch (obj._name) {
+    case "new_message":
+    case "new_business_message":
+      return obj.text;
+    case "inline_query":
+      return obj.query;
+    case "chosen_inline_result":
+      return obj.id;
+    case "callback_query":
+    case "inline_callback_query":
+    case "business_callback_query":
+      if (obj.raw.data) return obj.dataStr;
+  }
+  return null;
+}
+function regex(regex2) {
+  return (obj) => {
+    const txt = extractText(obj);
+    if (!txt) return false;
+    const m = txt.match(regex2);
+    if (m) {
+      obj.match = m;
+      return true;
+    }
+    return false;
+  };
+}
+function equals(str, ignoreCase = false) {
+  if (ignoreCase) {
+    str = str.toLowerCase();
+    return (obj) => extractText(obj)?.toLowerCase() === str;
+  }
+  return (obj) => extractText(obj) === str;
+}
+function contains(str, ignoreCase = false) {
+  if (ignoreCase) {
+    str = str.toLowerCase();
+    return (obj) => {
+      const txt = extractText(obj);
+      return txt != null && txt.toLowerCase().includes(str);
+    };
+  }
+  return (obj) => {
+    const txt = extractText(obj);
+    return txt != null && txt.includes(str);
+  };
+}
+function startsWith(str, ignoreCase = false) {
+  if (ignoreCase) {
+    str = str.toLowerCase();
+    return (obj) => {
+      const txt = extractText(obj);
+      return txt != null && txt.toLowerCase().substring(0, str.length) === str;
+    };
+  }
+  return (obj) => {
+    const txt = extractText(obj);
+    return txt != null && txt.substring(0, str.length) === str;
+  };
+}
+function endsWith(str, ignoreCase = false) {
+  if (ignoreCase) {
+    str = str.toLowerCase();
+    return (obj) => {
+      const txt = extractText(obj);
+      return txt != null && txt.toLowerCase().substring(0, str.length) === str;
+    };
+  }
+  return (obj) => {
+    const txt = extractText(obj);
+    return txt != null && txt.substring(0, str.length) === str;
+  };
+}
+const chatMember = (types) => {
+  if (Array.isArray(types)) {
+    const index = {};
+    types.forEach((typ) => index[typ] = true);
+    return (upd) => upd.type in index;
+  }
+  return (upd) => upd.type === types;
+};
+const userStatus = (statuses) => {
+  if (Array.isArray(statuses)) {
+    const index = {};
+    statuses.forEach((typ) => index[typ] = true);
+    return (upd) => upd.status in index;
+  }
+  return (upd) => upd.status === statuses;
+};
+const chatMemberSelf = (upd) => upd.isSelf;
+const me = (msg) => msg.sender.type === "user" && msg.sender.isSelf || msg.isOutgoing;
+const bot = (msg) => msg.sender.constructor === core.User && msg.sender.isBot;
+const userId = (id) => {
+  const indexId = /* @__PURE__ */ new Set();
+  const indexUsername = /* @__PURE__ */ new Set();
+  let matchSelf = false;
+  if (!Array.isArray(id)) id = [id];
+  id.forEach((id2) => {
+    if (id2 === "me" || id2 === "self") {
+      matchSelf = true;
+    } else if (typeof id2 === "string") {
+      indexUsername.add(id2);
+    } else {
+      indexId.add(id2);
+    }
+  });
+  return (upd) => {
+    switch (upd._name) {
+      case "new_message":
+      case "edit_message":
+      case "new_business_message":
+      case "edit_business_message": {
+        const sender2 = upd.sender;
+        return matchSelf && sender2.isSelf || indexId.has(sender2.id) || indexUsername.has(sender2.username);
+      }
+      case "user_status":
+      case "user_typing": {
+        const id2 = upd.userId;
+        return matchSelf && id2 === upd.client.storage.self.getCached()?.userId || indexId.has(id2);
+      }
+      case "poll_vote":
+      case "story":
+      case "delete_story": {
+        const peer = upd.peer;
+        if (peer.type !== "user") return false;
+        return matchSelf && peer.isSelf || indexId.has(peer.id) || Boolean(peer.usernames?.some((u) => indexUsername.has(u.username)));
+      }
+      case "history_read": {
+        const id2 = upd.chatId;
+        return matchSelf && id2 === upd.client.storage.self.getCached()?.userId || indexId.has(id2);
+      }
+    }
+    const user = upd.user;
+    return matchSelf && user.isSelf || indexId.has(user.id) || Boolean(user.usernames?.some((u) => indexUsername.has(u.username)));
+  };
+};
+const bundle = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  action,
+  and,
+  animation,
+  any,
+  anyDocument,
+  anyLocation,
+  anyVideo,
+  audio,
+  bot,
+  chat,
+  chatId,
+  chatMember,
+  chatMemberSelf,
+  command,
+  contact,
+  contains,
+  deeplink,
+  deeplinkGroup,
+  dice,
+  document,
+  endsWith,
+  equals,
+  every,
+  game,
+  incoming,
+  invoice,
+  liveLocation,
+  location,
+  me,
+  media,
+  mediaOf,
+  not,
+  or,
+  outgoing,
+  photo,
+  poll,
+  regex,
+  reply,
+  replyOrigin,
+  replyTo,
+  roundMessage,
+  scheduled,
+  sender,
+  service,
+  some,
+  start,
+  startGroup,
+  startsWith,
+  state,
+  stateEmpty,
+  sticker,
+  stickerBySourceType,
+  stickerByType,
+  text,
+  userId,
+  userStatus,
+  venue,
+  video,
+  voice,
+  webpage,
+  withCompleteChat,
+  withCompleteSender
+}, Symbol.toStringTag, { value: "Module" }));
+var PropagationAction = /* @__PURE__ */ ((PropagationAction2) => {
+  PropagationAction2["Stop"] = "stop";
+  PropagationAction2["StopChildren"] = "stop-children";
+  PropagationAction2["Continue"] = "continue";
+  PropagationAction2["ToScene"] = "scene";
+  return PropagationAction2;
+})(PropagationAction || {});
+var WizardSceneAction = /* @__PURE__ */ ((WizardSceneAction2) => {
+  WizardSceneAction2["Next"] = "next";
+  WizardSceneAction2["Stay"] = "stay";
+  WizardSceneAction2["Exit"] = "exit";
+  return WizardSceneAction2;
+})(WizardSceneAction || {});
+class WizardScene extends Dispatcher {
+  _steps = 0;
+  _defaultState = {};
+  constructor(name, params) {
+    super(void 0, { sceneName: name, ...params });
+  }
+  setDefaultState(defaultState) {
+    this._defaultState = defaultState;
+  }
+  /**
+   * Get the total number of registered steps
+   */
+  get totalSteps() {
+    return this._steps;
+  }
+  /**
+   * Go to the Nth step
+   */
+  async goToStep(state2, step) {
+    if (step >= this._steps) {
+      await state2.exit();
+    } else {
+      await state2.merge({ $step: step }, this._defaultState);
+    }
+  }
+  /**
+   * Skip N steps
+   */
+  async skip(state2, count = 1) {
+    const { $step } = await state2.get() || {};
+    if ($step === void 0) throw new Error("Wizard state is not initialized");
+    return this.goToStep(state2, $step + count);
+  }
+  /**
+   * Filter that will only pass if the current step is `step`
+   */
+  // eslint-disable-next-line ts/no-empty-object-type
+  static onNthStep(step) {
+    const filter = state((it) => it.$step === step);
+    if (step === 0) return or(stateEmpty, filter);
+    return filter;
+  }
+  /**
+   * Filter that will only pass if the current step is the one after last one added
+   */
+  // eslint-disable-next-line ts/no-empty-object-type
+  onCurrentStep() {
+    return WizardScene.onNthStep(this._steps);
+  }
+  /**
+   * Add a step to the wizard
+   */
+  addStep(handler) {
+    const step = this._steps++;
+    this.onNewMessage(WizardScene.onNthStep(step), async (msg, state2) => {
+      const result = await handler(msg, state2);
+      if (typeof result === "number") {
+        await this.goToStep(state2, result);
+        return;
+      }
+      switch (result) {
+        case "next": {
+          await this.goToStep(state2, step + 1);
+          break;
+        }
+        case "exit":
+          await state2.exit();
+          break;
+      }
+    });
+  }
+}
+exports.BusinessCallbackQueryContext = BusinessCallbackQueryContext;
+exports.BusinessMessageContext = BusinessMessageContext;
+exports.CallbackDataBuilder = CallbackDataBuilder;
+exports.CallbackQueryContext = CallbackQueryContext;
+exports.ChatJoinRequestUpdateContext = ChatJoinRequestUpdateContext;
+exports.ChosenInlineResultContext = ChosenInlineResultContext;
+exports.Dispatcher = Dispatcher;
+exports.InlineCallbackQueryContext = InlineCallbackQueryContext;
+exports.InlineQueryContext = InlineQueryContext;
+exports.MemoryStateStorage = MemoryStateStorage;
+exports.MessageContext = MessageContext;
+exports.PreCheckoutQueryContext = PreCheckoutQueryContext;
+exports.PropagationAction = PropagationAction;
+exports.RateLimitError = RateLimitError;
+exports.SqliteStateStorage = SqliteStateStorage;
+exports.UpdateState = UpdateState;
+exports.WizardScene = WizardScene;
+exports.WizardSceneAction = WizardSceneAction;
+exports.defaultStateKeyDelegate = defaultStateKeyDelegate;
+exports.filters = bundle;