gramio 0.0.50 → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1191 @@
+'use strict';
+
+var fs = require('node:fs/promises');
+var node_stream = require('node:stream');
+var callbackData = require('@gramio/callback-data');
+var contexts = require('@gramio/contexts');
+var files = require('@gramio/files');
+var format = require('@gramio/format');
+var debug = require('debug');
+var inspectable = require('inspectable');
+var middlewareIo = require('middleware-io');
+var keyboards = require('@gramio/keyboards');
+
+const ErrorKind = Symbol("ErrorKind");
+class TelegramError extends Error {
+  /** Name of the API Method */
+  method;
+  /** Params that were sent */
+  params;
+  /** See  {@link TelegramAPIResponseError.error_code}*/
+  code;
+  /** Describes why a request was unsuccessful. */
+  payload;
+  /** Construct new TelegramError */
+  constructor(error, method, params) {
+    super(error.description);
+    this.name = method;
+    this.method = method;
+    this.params = params;
+    this.code = error.error_code;
+    if (error.parameters) this.payload = error.parameters;
+  }
+}
+TelegramError.constructor[ErrorKind] = "TELEGRAM";
+
+class Composer {
+  composer = middlewareIo.Composer.builder();
+  length = 0;
+  composed;
+  onError;
+  constructor(onError) {
+    this.onError = onError || ((_, error) => {
+      throw error;
+    });
+    this.recompose();
+  }
+  /** Register handler to one or many Updates */
+  on(updateName, handler) {
+    return this.use(async (context, next) => {
+      if (context.is(updateName)) return await handler(context, next);
+      return await next();
+    });
+  }
+  /** Register handler to any Update */
+  use(handler) {
+    this.composer.caught(this.onError).use(handler);
+    return this.recompose();
+  }
+  /**
+   * Derive some data to handlers
+   *
+   * @example
+   * ```ts
+   * new Bot("token").derive((context) => {
+   * 		return {
+   * 			superSend: () => context.send("Derived method")
+   * 		}
+   * })
+   * ```
+   */
+  derive(updateNameOrHandler, handler) {
+    if (typeof updateNameOrHandler === "function")
+      this.use(async (context, next) => {
+        for (const [key, value] of Object.entries(
+          await updateNameOrHandler(context)
+        )) {
+          context[key] = value;
+        }
+        next();
+      });
+    else if (handler)
+      this.on(updateNameOrHandler, async (context, next) => {
+        for (const [key, value] of Object.entries(await handler(context))) {
+          context[key] = value;
+        }
+        next();
+      });
+    return this;
+  }
+  recompose() {
+    this.composed = this.composer.compose();
+    this.length = this.composer.length;
+    return this;
+  }
+  compose(context, next = middlewareIo.noopNext) {
+    this.composed(context, next);
+  }
+}
+
+var __create$1 = Object.create;
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __knownSymbol$1 = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError$1 = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name$1 = (target, value) => __defProp$1(target, "name", { value, configurable: true });
+var __decoratorStart$1 = (base) => [, , , __create$1(null)];
+var __decoratorStrings$1 = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn$1 = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError$1("Function expected") : fn;
+var __decoratorContext$1 = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings$1[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError$1("Already initialized") : fns.push(__expectFn$1(fn || null)) });
+var __decoratorMetadata$1 = (array, target) => __defNormalProp$1(target, __knownSymbol$1("metadata"), array[3]);
+var __runInitializers$1 = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) fns[i].call(self) ;
+  return value;
+};
+var __decorateElement$1 = (array, flags, name, decorators, target, extra) => {
+  var it, done, ctx, k = flags & 7, p = !!(flags & 16);
+  var j = 0;
+  var extraInitializers = array[j] || (array[j] = []);
+  var desc = k && ((target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc$1(target , name));
+  __name$1(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext$1(k, name, done = {}, array[3], extraInitializers);
+    it = (0, decorators[i])(target, ctx), done._ = 1;
+    __expectFn$1(it) && (target = it);
+  }
+  return __decoratorMetadata$1(array, target), desc && __defProp$1(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var _Plugin_decorators, _init$1;
+_Plugin_decorators = [inspectable.Inspectable({
+  serialize: (plugin) => ({
+    name: plugin._.name,
+    dependencies: plugin._.dependencies
+  })
+})];
+class Plugin {
+  /**
+   * 	@internal
+   * 	Set of Plugin data
+   *
+   *
+   */
+  _ = {
+    /** Name of plugin */
+    name: "",
+    /** List of plugin dependencies. If user does't extend from listed there dependencies it throw a error */
+    dependencies: [],
+    /** remap generic type. {} in runtime */
+    Errors: {},
+    /** remap generic type. {} in runtime */
+    Derives: {},
+    /**	Composer */
+    composer: new Composer(),
+    /** Store plugin preRequests hooks */
+    preRequests: [],
+    /** Store plugin onResponses hooks */
+    onResponses: [],
+    /** Store plugin onResponseErrors hooks */
+    onResponseErrors: [],
+    /**
+     * Store plugin groups
+     *
+     * If you use `on` or `use` in group and on plugin-level groups handlers are registered after plugin-level handlers
+     *  */
+    groups: [],
+    /** Store plugin onStarts hooks */
+    onStarts: [],
+    /** Store plugin onStops hooks */
+    onStops: [],
+    /** Store plugin onErrors hooks */
+    onErrors: [],
+    /** Map of plugin errors */
+    errorsDefinitions: {},
+    decorators: {}
+  };
+  /** Create new Plugin. Please provide `name` */
+  constructor(name, { dependencies } = {}) {
+    this._.name = name;
+    if (dependencies) this._.dependencies = dependencies;
+  }
+  /** Currently not isolated!!!
+   *
+   * > [!WARNING]
+   * > If you use `on` or `use` in a `group` and at the plugin level, the group handlers are registered **after** the handlers at the plugin level
+   */
+  group(grouped) {
+    this._.groups.push(grouped);
+    return this;
+  }
+  /**
+   * Register custom class-error in plugin
+   **/
+  error(kind, error) {
+    error[ErrorKind] = kind;
+    this._.errorsDefinitions[kind] = error;
+    return this;
+  }
+  derive(updateNameOrHandler, handler) {
+    this._.composer.derive(updateNameOrHandler, handler);
+    return this;
+  }
+  decorate(nameOrValue, value) {
+    if (typeof nameOrValue === "string") this._.decorators[nameOrValue] = value;
+    else {
+      for (const [name, value2] of Object.entries(nameOrValue)) {
+        this._.decorators[name] = value2;
+      }
+    }
+    return this;
+  }
+  /** Register handler to one or many Updates */
+  on(updateName, handler) {
+    this._.composer.on(updateName, handler);
+    return this;
+  }
+  /** Register handler to any Updates */
+  use(handler) {
+    this._.composer.use(handler);
+    return this;
+  }
+  preRequest(methodsOrHandler, handler) {
+    if ((typeof methodsOrHandler === "string" || Array.isArray(methodsOrHandler)) && handler)
+      this._.preRequests.push([handler, methodsOrHandler]);
+    else if (typeof methodsOrHandler === "function")
+      this._.preRequests.push([methodsOrHandler, void 0]);
+    return this;
+  }
+  onResponse(methodsOrHandler, handler) {
+    if ((typeof methodsOrHandler === "string" || Array.isArray(methodsOrHandler)) && handler)
+      this._.onResponses.push([handler, methodsOrHandler]);
+    else if (typeof methodsOrHandler === "function")
+      this._.onResponses.push([methodsOrHandler, void 0]);
+    return this;
+  }
+  onResponseError(methodsOrHandler, handler) {
+    if ((typeof methodsOrHandler === "string" || Array.isArray(methodsOrHandler)) && handler)
+      this._.onResponseErrors.push([handler, methodsOrHandler]);
+    else if (typeof methodsOrHandler === "function")
+      this._.onResponseErrors.push([methodsOrHandler, void 0]);
+    return this;
+  }
+  /**
+   * This hook called when the bot is `started`.
+   *
+   * @example
+   * ```typescript
+   * import { Bot } from "gramio";
+   *
+   * const bot = new Bot(process.env.TOKEN!).onStart(
+   *     ({ plugins, info, updatesFrom }) => {
+   *         console.log(`plugin list - ${plugins.join(", ")}`);
+   *         console.log(`bot username is @${info.username}`);
+   * 		   console.log(`updates from ${updatesFrom}`);
+   *     }
+   * );
+   *
+   * bot.start();
+   * ```
+   *
+   * [Documentation](https://gramio.dev/hooks/on-start.html)
+   *  */
+  onStart(handler) {
+    this._.onStarts.push(handler);
+    return this;
+  }
+  /**
+   * This hook called when the bot stops.
+   *
+   * @example
+   * ```typescript
+   * import { Bot } from "gramio";
+   *
+   * const bot = new Bot(process.env.TOKEN!).onStop(
+   *     ({ plugins, info, updatesFrom }) => {
+   *         console.log(`plugin list - ${plugins.join(", ")}`);
+   *         console.log(`bot username is @${info.username}`);
+   *     }
+   * );
+   *
+   * bot.start();
+   * bot.stop();
+   * ```
+   *
+   * [Documentation](https://gramio.dev/hooks/on-stop.html)
+   *  */
+  onStop(handler) {
+    this._.onStops.push(handler);
+    return this;
+  }
+  onError(updateNameOrHandler, handler) {
+    if (typeof updateNameOrHandler === "function") {
+      this._.onErrors.push(updateNameOrHandler);
+      return this;
+    }
+    if (handler) {
+      this._.onErrors.push(async (errContext) => {
+        if (errContext.context.is(updateNameOrHandler))
+          await handler(errContext);
+      });
+    }
+    return this;
+  }
+}
+_init$1 = __decoratorStart$1();
+Plugin = __decorateElement$1(_init$1, 0, "Plugin", _Plugin_decorators, Plugin);
+__runInitializers$1(_init$1, 1, Plugin);
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+class Updates {
+  bot;
+  isStarted = false;
+  offset = 0;
+  composer;
+  constructor(bot, onError) {
+    this.bot = bot;
+    this.composer = new Composer(onError);
+  }
+  async handleUpdate(data) {
+    const updateType = Object.keys(data).at(1);
+    this.offset = data.update_id + 1;
+    const UpdateContext = contexts.contextsMappings[updateType];
+    if (!UpdateContext) throw new Error(updateType);
+    const updatePayload = data[updateType];
+    if (!updatePayload) throw new Error("");
+    try {
+      let context = new UpdateContext({
+        bot: this.bot,
+        update: data,
+        // @ts-expect-error
+        payload: updatePayload,
+        type: updateType,
+        updateId: data.update_id
+      });
+      if ("isEvent" in context && context.isEvent() && context.eventType) {
+        const payload = data.message ?? data.edited_message ?? data.channel_post ?? data.edited_channel_post ?? data.business_message;
+        if (!payload) throw new Error("Unsupported event??");
+        context = new contexts.contextsMappings[context.eventType]({
+          bot: this.bot,
+          update: data,
+          payload,
+          // @ts-expect-error
+          type: context.eventType,
+          updateId: data.update_id
+        });
+      }
+      this.composer.compose(context);
+    } catch (error) {
+      throw new Error(`[UPDATES] Update type ${updateType} not supported.`);
+    }
+  }
+  /** @deprecated use bot.start instead @internal */
+  async startPolling(params = {}) {
+    if (this.isStarted) throw new Error("[UPDATES] Polling already started!");
+    this.isStarted = true;
+    this.startFetchLoop(params);
+    return;
+  }
+  async startFetchLoop(params = {}) {
+    while (this.isStarted) {
+      try {
+        const updates = await this.bot.api.getUpdates({
+          ...params,
+          offset: this.offset
+        });
+        for await (const update of updates) {
+          await this.handleUpdate(update).catch(console.error);
+        }
+      } catch (error) {
+        console.error("Error received when fetching updates", error);
+        await sleep(this.bot.options.api.retryGetUpdatesWait ?? 1e3);
+      }
+    }
+  }
+  stopPolling() {
+    this.isStarted = false;
+  }
+}
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name2, symbol) => (symbol = Symbol[name2]) ? symbol : Symbol.for("Symbol." + name2);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name2, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name: name2, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) fns[i].call(self) ;
+  return value;
+};
+var __decorateElement = (array, flags, name2, decorators, target, extra) => {
+  var it, done, ctx, k = flags & 7, p = !!(flags & 16);
+  var j = 0;
+  var extraInitializers = array[j] || (array[j] = []);
+  var desc = k && ((target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(target , name2));
+  __name(target, name2);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name2, done = {}, array[3], extraInitializers);
+    it = (0, decorators[i])(target, ctx), done._ = 1;
+    __expectFn(it) && (target = it);
+  }
+  return __decoratorMetadata(array, target), desc && __defProp(target, name2, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var _Bot_decorators, _init;
+const $debugger = debug("gramio");
+const debug$api = $debugger.extend("api");
+_Bot_decorators = [inspectable.Inspectable({
+  serialize: () => ({})
+})];
+class Bot {
+  _ = {
+    /** @internal. Remap generic */
+    derives: {}
+  };
+  /** @internal. Remap generic */
+  __Derives;
+  filters = {
+    context: (name2) => (context) => context.is(name2)
+  };
+  /** Options provided to instance */
+  options;
+  /** Bot data (filled in when calling bot.init/bot.start) */
+  info;
+  /**
+   * Send API Request to Telegram Bot API
+   *
+   * @example
+   * ```ts
+   * const response = await bot.api.sendMessage({
+   *     chat_id: "@gramio_forum",
+   *     text: "some text",
+   * });
+   * ```
+   *
+   * [Documentation](https://gramio.dev/bot-api.html)
+   */
+  api = new Proxy({}, {
+    get: (_target, method) => (
+      // @ts-expect-error
+      // biome-ignore lint/suspicious/noAssignInExpressions: <explanation>
+      _target[method] ??= (args) => this._callApi(method, args)
+    )
+  });
+  lazyloadPlugins = [];
+  dependencies = [];
+  errorsDefinitions = {
+    TELEGRAM: TelegramError
+  };
+  errorHandler(context, error) {
+    if (!this.hooks.onError.length)
+      return console.error("[Default Error Handler]", context, error);
+    return this.runImmutableHooks("onError", {
+      context,
+      //@ts-expect-error ErrorKind exists if user register error-class with .error("kind", SomeError);
+      kind: error.constructor[ErrorKind] ?? "UNKNOWN",
+      error
+    });
+  }
+  /** This instance handle updates */
+  updates = new Updates(this, this.errorHandler.bind(this));
+  hooks = {
+    preRequest: [],
+    onResponse: [],
+    onResponseError: [],
+    onError: [],
+    onStart: [],
+    onStop: []
+  };
+  constructor(tokenOrOptions, optionsRaw) {
+    const token = typeof tokenOrOptions === "string" ? tokenOrOptions : tokenOrOptions?.token;
+    const options = typeof tokenOrOptions === "object" ? tokenOrOptions : optionsRaw;
+    if (!token || typeof token !== "string")
+      throw new Error(`Token is ${typeof token} but it should be a string!`);
+    this.options = {
+      ...options,
+      token,
+      api: {
+        baseURL: "https://api.telegram.org/bot",
+        retryGetUpdatesWait: 1e3,
+        ...options?.api
+      }
+    };
+    if (options?.info) this.info = options.info;
+    if (!(optionsRaw?.plugins && "format" in optionsRaw.plugins && !optionsRaw.plugins.format))
+      this.extend(
+        new Plugin("@gramio/format").preRequest((context) => {
+          if (!context.params) return context;
+          const formattable = format.FormattableMap[context.method];
+          if (formattable) context.params = formattable(context.params);
+          return context;
+        })
+      );
+  }
+  async runHooks(type, context) {
+    let data = context;
+    for await (const hook of this.hooks[type]) {
+      data = await hook(data);
+    }
+    return data;
+  }
+  async runImmutableHooks(type, ...context) {
+    for await (const hook of this.hooks[type]) {
+      await hook(...context);
+    }
+  }
+  async _callApi(method, params = {}) {
+    const debug$api$method = debug$api.extend(method);
+    const url = `${this.options.api.baseURL}${this.options.token}/${method}`;
+    const reqOptions = {
+      method: "POST",
+      ...this.options.api.fetchOptions,
+      // @ts-ignore types node/bun and global missmatch
+      headers: new Headers(this.options.api.fetchOptions?.headers)
+    };
+    const context = await this.runHooks(
+      "preRequest",
+      // TODO: fix type error
+      // @ts-expect-error
+      {
+        method,
+        params
+      }
+    );
+    params = context.params;
+    if (params && files.isMediaUpload(method, params)) {
+      const formData = await files.convertJsonToFormData(method, params);
+      reqOptions.body = formData;
+    } else {
+      reqOptions.headers.set("Content-Type", "application/json");
+      reqOptions.body = JSON.stringify(params);
+    }
+    debug$api$method("options: %j", reqOptions);
+    const response = await fetch(url, reqOptions);
+    const data = await response.json();
+    debug$api$method("response: %j", data);
+    if (!data.ok) {
+      const err = new TelegramError(data, method, params);
+      this.runImmutableHooks("onResponseError", err, this.api);
+      if (!params?.suppress) throw err;
+      return err;
+    }
+    this.runImmutableHooks(
+      "onResponse",
+      // TODO: fix type error
+      // @ts-expect-error
+      {
+        method,
+        params,
+        response: data.result
+      }
+    );
+    return data.result;
+  }
+  async downloadFile(attachment, path) {
+    function getFileId(attachment2) {
+      if (attachment2 instanceof contexts.PhotoAttachment) {
+        return attachment2.bigSize.fileId;
+      }
+      if ("fileId" in attachment2 && typeof attachment2.fileId === "string")
+        return attachment2.fileId;
+      if ("file_id" in attachment2) return attachment2.file_id;
+      throw new Error("Invalid attachment");
+    }
+    const fileId = typeof attachment === "string" ? attachment : getFileId(attachment);
+    const file = await this.api.getFile({ file_id: fileId });
+    const url = `${this.options.api.baseURL.replace("/bot", "/file/bot")}${this.options.token}/${file.file_path}`;
+    const res = await fetch(url);
+    if (path) {
+      if (!res.body)
+        throw new Error("Response without body (should be never throw)");
+      await fs.writeFile(path, node_stream.Readable.fromWeb(res.body));
+      return path;
+    }
+    const buffer = await res.arrayBuffer();
+    return buffer;
+  }
+  /**
+   * Register custom class-error for type-safe catch in `onError` hook
+   *
+   * @example
+   * ```ts
+   * export class NoRights extends Error {
+   *     needRole: "admin" | "moderator";
+   *
+   *     constructor(role: "admin" | "moderator") {
+   *         super();
+   *         this.needRole = role;
+   *     }
+   * }
+   *
+   * const bot = new Bot(process.env.TOKEN!)
+   *     .error("NO_RIGHTS", NoRights)
+   *     .onError(({ context, kind, error }) => {
+   *         if (context.is("message") && kind === "NO_RIGHTS")
+   *             return context.send(
+   *                 format`You don't have enough rights! You need to have an «${bold(
+   *                     error.needRole
+   *                 )}» role.`
+   *             );
+   *     });
+   *
+   * bot.updates.on("message", (context) => {
+   *     if (context.text === "bun") throw new NoRights("admin");
+   * });
+   * ```
+   */
+  error(kind, error) {
+    error[ErrorKind] = kind;
+    this.errorsDefinitions[kind] = error;
+    return this;
+  }
+  onError(updateNameOrHandler, handler) {
+    if (typeof updateNameOrHandler === "function") {
+      this.hooks.onError.push(updateNameOrHandler);
+      return this;
+    }
+    if (handler) {
+      this.hooks.onError.push(async (errContext) => {
+        if (errContext.context.is(updateNameOrHandler))
+          await handler(errContext);
+      });
+    }
+    return this;
+  }
+  derive(updateNameOrHandler, handler) {
+    this.updates.composer.derive(updateNameOrHandler, handler);
+    return this;
+  }
+  decorate(nameOrRecordValue, value) {
+    for (const contextName of Object.keys(contexts.contextsMappings)) {
+      if (typeof nameOrRecordValue === "string")
+        Object.defineProperty(contexts.contextsMappings[contextName].prototype, name, {
+          value
+        });
+      else
+        Object.defineProperties(
+          // @ts-expect-error
+          contexts.contextsMappings[contextName].prototype,
+          Object.keys(nameOrRecordValue).reduce(
+            (acc, key) => {
+              acc[key] = { value: nameOrRecordValue[key] };
+              return acc;
+            },
+            {}
+          )
+        );
+    }
+    return this;
+  }
+  /**
+   * This hook called when the bot is `started`.
+   *
+   * @example
+   * ```typescript
+   * import { Bot } from "gramio";
+   *
+   * const bot = new Bot(process.env.TOKEN!).onStart(
+   *     ({ plugins, info, updatesFrom }) => {
+   *         console.log(`plugin list - ${plugins.join(", ")}`);
+   *         console.log(`bot username is @${info.username}`);
+   * 		   console.log(`updates from ${updatesFrom}`);
+   *     }
+   * );
+   *
+   * bot.start();
+   * ```
+   *
+   * [Documentation](https://gramio.dev/hooks/on-start.html)
+   *  */
+  onStart(handler) {
+    this.hooks.onStart.push(handler);
+    return this;
+  }
+  /**
+   * This hook called when the bot stops.
+   *
+   * @example
+   * ```typescript
+   * import { Bot } from "gramio";
+   *
+   * const bot = new Bot(process.env.TOKEN!).onStop(
+   *     ({ plugins, info, updatesFrom }) => {
+   *         console.log(`plugin list - ${plugins.join(", ")}`);
+   *         console.log(`bot username is @${info.username}`);
+   *     }
+   * );
+   *
+   * bot.start();
+   * bot.stop();
+   * ```
+   *
+   * [Documentation](https://gramio.dev/hooks/on-stop.html)
+   *  */
+  onStop(handler) {
+    this.hooks.onStop.push(handler);
+    return this;
+  }
+  preRequest(methodsOrHandler, handler) {
+    if (typeof methodsOrHandler === "string" || Array.isArray(methodsOrHandler)) {
+      if (!handler) throw new Error("TODO:");
+      const methods = typeof methodsOrHandler === "string" ? [methodsOrHandler] : methodsOrHandler;
+      this.hooks.preRequest.push(async (context) => {
+        if (methods.includes(context.method)) return handler(context);
+        return context;
+      });
+    } else this.hooks.preRequest.push(methodsOrHandler);
+    return this;
+  }
+  onResponse(methodsOrHandler, handler) {
+    if (typeof methodsOrHandler === "string" || Array.isArray(methodsOrHandler)) {
+      if (!handler) throw new Error("TODO:");
+      const methods = typeof methodsOrHandler === "string" ? [methodsOrHandler] : methodsOrHandler;
+      this.hooks.onResponse.push(async (context) => {
+        if (methods.includes(context.method)) return handler(context);
+        return context;
+      });
+    } else this.hooks.onResponse.push(methodsOrHandler);
+    return this;
+  }
+  onResponseError(methodsOrHandler, handler) {
+    if (typeof methodsOrHandler === "string" || Array.isArray(methodsOrHandler)) {
+      if (!handler) throw new Error("TODO:");
+      const methods = typeof methodsOrHandler === "string" ? [methodsOrHandler] : methodsOrHandler;
+      this.hooks.onResponseError.push(async (context) => {
+        if (methods.includes(context.method)) return handler(context);
+        return context;
+      });
+    } else this.hooks.onResponseError.push(methodsOrHandler);
+    return this;
+  }
+  // onExperimental(
+  // 	// filter: Filters,
+  // 	filter: (
+  // 		f: Filters<
+  // 			Context<typeof this> & Derives["global"],
+  // 			[{ equal: { prop: number }; addition: { some: () => 2 } }]
+  // 		>,
+  // 	) => Filters,
+  // 	handler: Handler<Context<typeof this> & Derives["global"]>,
+  // ) {}
+  /** Register handler to one or many Updates */
+  on(updateName, handler) {
+    this.updates.composer.on(updateName, handler);
+    return this;
+  }
+  /** Register handler to any Updates */
+  use(handler) {
+    this.updates.composer.use(handler);
+    return this;
+  }
+  /**
+   * Extend {@link Plugin} logic and types
+   *
+   * @example
+   * ```ts
+   * import { Plugin, Bot } from "gramio";
+   *
+   * export class PluginError extends Error {
+   *     wow: "type" | "safe" = "type";
+   * }
+   *
+   * const plugin = new Plugin("gramio-example")
+   *     .error("PLUGIN", PluginError)
+   *     .derive(() => {
+   *         return {
+   *             some: ["derived", "props"] as const,
+   *         };
+   *     });
+   *
+   * const bot = new Bot(process.env.TOKEN!)
+   *     .extend(plugin)
+   *     .onError(({ context, kind, error }) => {
+   *         if (context.is("message") && kind === "PLUGIN") {
+   *             console.log(error.wow);
+   *         }
+   *     })
+   *     .use((context) => {
+   *         console.log(context.some);
+   *     });
+   * ```
+   */
+  extend(plugin) {
+    if (plugin instanceof Promise) {
+      this.lazyloadPlugins.push(plugin);
+      return this;
+    }
+    if (plugin._.dependencies.some((dep) => !this.dependencies.includes(dep)))
+      throw new Error(
+        `The \xAB${plugin._.name}\xBB plugin needs dependencies registered before: ${plugin._.dependencies.filter((dep) => !this.dependencies.includes(dep)).join(", ")}`
+      );
+    if (plugin._.composer.length) {
+      this.use(plugin._.composer.composed);
+    }
+    this.decorate(plugin._.decorators);
+    for (const [key, value] of Object.entries(plugin._.errorsDefinitions)) {
+      if (this.errorsDefinitions[key]) this.errorsDefinitions[key] = value;
+    }
+    for (const value of plugin._.preRequests) {
+      const [preRequest, updateName] = value;
+      if (!updateName) this.preRequest(preRequest);
+      else this.preRequest(updateName, preRequest);
+    }
+    for (const value of plugin._.onResponses) {
+      const [onResponse, updateName] = value;
+      if (!updateName) this.onResponse(onResponse);
+      else this.onResponse(updateName, onResponse);
+    }
+    for (const value of plugin._.onResponseErrors) {
+      const [onResponseError, updateName] = value;
+      if (!updateName) this.onResponseError(onResponseError);
+      else this.onResponseError(updateName, onResponseError);
+    }
+    for (const handler of plugin._.groups) {
+      this.group(handler);
+    }
+    this.dependencies.push(plugin._.name);
+    return this;
+  }
+  /**
+   * Register handler to reaction (`message_reaction` update)
+   *
+   * @example
+   * ```ts
+   * new Bot().reaction("👍", async (context) => {
+   *     await context.reply(`Thank you!`);
+   * });
+   * ```
+   * */
+  reaction(trigger, handler) {
+    const reactions = Array.isArray(trigger) ? trigger : [trigger];
+    return this.on("message_reaction", (context, next) => {
+      const newReactions = [];
+      for (const reaction of context.newReactions) {
+        if (reaction.type !== "emoji") continue;
+        const foundIndex = context.oldReactions.findIndex(
+          (oldReaction) => oldReaction.type === "emoji" && oldReaction.emoji === reaction.emoji
+        );
+        if (foundIndex === -1) {
+          newReactions.push(reaction);
+        } else {
+          context.oldReactions.splice(foundIndex, 1);
+        }
+      }
+      if (!newReactions.some(
+        (x) => x.type === "emoji" && reactions.includes(x.emoji)
+      ))
+        return next();
+      return handler(context);
+    });
+  }
+  /**
+   * Register handler to `callback_query` event
+   *
+   * @example
+   * ```ts
+   * const someData = new CallbackData("example").number("id");
+   *
+   * new Bot()
+   *     .command("start", (context) =>
+   *         context.send("some", {
+   *             reply_markup: new InlineKeyboard().text(
+   *                 "example",
+   *                 someData.pack({
+   *                     id: 1,
+   *                 })
+   *             ),
+   *         })
+   *     )
+   *     .callbackQuery(someData, (context) => {
+   *         context.queryData; // is type-safe
+   *     });
+   * ```
+   */
+  callbackQuery(trigger, handler) {
+    return this.on("callback_query", (context, next) => {
+      if (!context.data) return next();
+      if (typeof trigger === "string" && context.data !== trigger)
+        return next();
+      if (trigger instanceof callbackData.CallbackData && !trigger.regexp().test(context.data))
+        return next();
+      if (trigger instanceof RegExp && !trigger.test(context.data))
+        return next();
+      if (trigger instanceof callbackData.CallbackData)
+        context.queryData = trigger.unpack(context.data);
+      return handler(context);
+    });
+  }
+  /** Register handler to `chosen_inline_result` update */
+  chosenInlineResult(trigger, handler) {
+    return this.on("chosen_inline_result", (context, next) => {
+      if (typeof trigger === "string" && context.query === trigger || // @ts-expect-error
+      typeof trigger === "function" && trigger(context) || trigger instanceof RegExp && trigger.test(context.query)) {
+        context.args = trigger instanceof RegExp ? context.query?.match(trigger) : null;
+        return handler(context);
+      }
+      return next();
+    });
+  }
+  /**
+   * Register handler to `inline_query` update
+   *
+   * @example
+   * ```ts
+   * new Bot().inlineQuery(
+   *     /regular expression with (.*)/i,
+   *     async (context) => {
+   *         if (context.args) {
+   *             await context.answer(
+   *                 [
+   *                     InlineQueryResult.article(
+   *                         "id-1",
+   *                         context.args[1],
+   *                         InputMessageContent.text("some"),
+   *                         {
+   *                             reply_markup: new InlineKeyboard().text(
+   *                                 "some",
+   *                                 "callback-data"
+   *                             ),
+   *                         }
+   *                     ),
+   *                 ],
+   *                 {
+   *                     cache_time: 0,
+   *                 }
+   *             );
+   *         }
+   *     },
+   *     {
+   *         onResult: (context) => context.editText("Message edited!"),
+   *     }
+   * );
+   * ```
+   * */
+  inlineQuery(trigger, handler, options = {}) {
+    if (options.onResult) this.chosenInlineResult(trigger, options.onResult);
+    return this.on("inline_query", (context, next) => {
+      if (typeof trigger === "string" && context.query === trigger || // @ts-expect-error
+      typeof trigger === "function" && trigger(context) || trigger instanceof RegExp && trigger.test(context.query)) {
+        context.args = trigger instanceof RegExp ? context.query?.match(trigger) : null;
+        return handler(context);
+      }
+      return next();
+    });
+  }
+  /**
+   * Register handler to `message` and `business_message` event
+   *
+   * new Bot().hears(/regular expression with (.*)/i, async (context) => {
+   *     if (context.args) await context.send(`Params ${context.args[1]}`);
+   * });
+   */
+  hears(trigger, handler) {
+    return this.on("message", (context, next) => {
+      const text = context.text ?? context.caption;
+      if (typeof trigger === "string" && text === trigger || // @ts-expect-error
+      typeof trigger === "function" && trigger(context) || trigger instanceof RegExp && text && trigger.test(text)) {
+        context.args = trigger instanceof RegExp ? text?.match(trigger) : null;
+        return handler(context);
+      }
+      return next();
+    });
+  }
+  /**
+   * Register handler to `message` and `business_message` event when entities contains a command
+   *
+   * new Bot().command("start", async (context) => {
+   *     return context.send(`You message is /start ${context.args}`);
+   * });
+   */
+  command(command, handler, options) {
+    if (command.startsWith("/"))
+      throw new Error("Do not use / in command name");
+    return this.on(["message", "business_message"], (context, next) => {
+      if (context.entities?.some((entity) => {
+        if (entity.type !== "bot_command" || entity.offset > 0) return false;
+        const cmd = context.text?.slice(1, entity.length)?.replace(`@${this.info.username}`, "");
+        context.args = context.text?.slice(entity.length).trim() || null;
+        return cmd === command;
+      }))
+        return handler(context);
+      return next();
+    });
+  }
+  /** Currently not isolated!!! */
+  group(grouped) {
+    return grouped(this);
+  }
+  /**
+   * Init bot. Call it manually only if you doesn't use {@link Bot.start}
+   */
+  async init() {
+    await Promise.all(
+      this.lazyloadPlugins.map(async (plugin) => this.extend(await plugin))
+    );
+    if (!this.info) {
+      const info = await this.api.getMe({
+        suppress: true
+      });
+      if (info instanceof TelegramError) {
+        if (info.code === 404)
+          info.message = "The bot token is incorrect. Check it in BotFather.";
+        throw info;
+      }
+      this.info = info;
+    }
+  }
+  /**
+   * Start receive updates via long-polling or webhook
+   *
+   * @example
+   * ```ts
+   * import { Bot } from "gramio";
+   *
+   * const bot = new Bot("") // put you token here
+   *     .command("start", (context) => context.send("Hi!"))
+   *     .onStart(console.log);
+   *
+   * bot.start();
+   * ```
+   */
+  async start({
+    webhook,
+    dropPendingUpdates,
+    allowedUpdates
+  } = {}) {
+    await this.init();
+    if (!webhook) {
+      await this.api.deleteWebhook({
+        drop_pending_updates: dropPendingUpdates
+      });
+      await this.updates.startPolling({
+        allowed_updates: allowedUpdates
+      });
+      this.runImmutableHooks("onStart", {
+        plugins: this.dependencies,
+        // biome-ignore lint/style/noNonNullAssertion: bot.init() guarantees this.info
+        info: this.info,
+        updatesFrom: "long-polling"
+      });
+      return this.info;
+    }
+    if (this.updates.isStarted) this.updates.stopPolling();
+    await this.api.setWebhook({
+      ...webhook,
+      drop_pending_updates: dropPendingUpdates,
+      allowed_updates: allowedUpdates
+    });
+    this.runImmutableHooks("onStart", {
+      plugins: this.dependencies,
+      // biome-ignore lint/style/noNonNullAssertion: bot.init() guarantees this.info
+      info: this.info,
+      updatesFrom: "webhook"
+    });
+    return this.info;
+  }
+  /**
+   * Stops receiving events via long-polling or webhook
+   * Currently does not implement graceful shutdown
+   * */
+  async stop() {
+    if (this.updates.isStarted) this.updates.stopPolling();
+    else await this.api.deleteWebhook();
+    await this.runImmutableHooks("onStop", {
+      plugins: this.dependencies,
+      // biome-ignore lint/style/noNonNullAssertion: bot.init() guarantees this.info
+      info: this.info
+    });
+  }
+}
+_init = __decoratorStart();
+Bot = __decorateElement(_init, 0, "Bot", _Bot_decorators, Bot);
+__runInitializers(_init, 1, Bot);
+
+const SECRET_TOKEN_HEADER = "X-Telegram-Bot-Api-Secret-Token";
+const WRONG_TOKEN_ERROR = "secret token is invalid";
+const responseOK = new Response("ok!");
+const responseUnauthorized = new Response(WRONG_TOKEN_ERROR, {
+  status: 401
+  // @ts-ignore
+});
+const frameworks = {
+  elysia: ({ body, headers }) => ({
+    update: body,
+    header: headers[SECRET_TOKEN_HEADER],
+    unauthorized: () => responseUnauthorized
+  }),
+  fastify: (request, reply) => ({
+    update: request.body,
+    header: request.headers[SECRET_TOKEN_HEADER],
+    unauthorized: () => reply.code(401).send(WRONG_TOKEN_ERROR)
+  }),
+  hono: (c) => ({
+    update: c.req.json(),
+    header: c.req.header(SECRET_TOKEN_HEADER),
+    unauthorized: () => c.text(WRONG_TOKEN_ERROR, 401)
+  }),
+  express: (req, res) => ({
+    update: req.body,
+    header: req.header(SECRET_TOKEN_HEADER),
+    unauthorized: () => res.status(401).send(WRONG_TOKEN_ERROR)
+  }),
+  koa: (ctx) => ({
+    update: ctx.request.body,
+    header: ctx.get(SECRET_TOKEN_HEADER),
+    unauthorized: () => {
+      ctx.status === 401;
+      ctx.body = WRONG_TOKEN_ERROR;
+    }
+  }),
+  http: (req, res) => ({
+    update: new Promise((resolve) => {
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk.toString();
+      });
+      req.on("end", () => resolve(JSON.parse(body)));
+    }),
+    header: req.headers[SECRET_TOKEN_HEADER.toLowerCase()],
+    unauthorized: () => res.writeHead(401).end(WRONG_TOKEN_ERROR)
+  }),
+  "std/http": (req) => ({
+    update: req.json(),
+    header: req.headers.get(SECRET_TOKEN_HEADER),
+    response: () => responseOK,
+    unauthorized: () => responseUnauthorized
+  }),
+  "Bun.serve": (req) => ({
+    update: req.json(),
+    header: req.headers.get(SECRET_TOKEN_HEADER),
+    response: () => responseOK,
+    unauthorized: () => responseUnauthorized
+  })
+};
+
+function webhookHandler(bot, framework, secretToken) {
+  const frameworkAdapter = frameworks[framework];
+  return async (...args) => {
+    const { update, response, header, unauthorized } = frameworkAdapter(
+      ...args
+    );
+    if (secretToken && header !== secretToken) return unauthorized();
+    await bot.updates.handleUpdate(await update);
+    if (response) return response();
+  };
+}
+
+Symbol.metadata ??= Symbol("Symbol.metadata");
+
+exports.Bot = Bot;
+exports.ErrorKind = ErrorKind;
+exports.Plugin = Plugin;
+exports.TelegramError = TelegramError;
+exports.webhookHandler = webhookHandler;
+Object.keys(callbackData).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return callbackData[k]; }
+	});
+});
+Object.keys(contexts).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return contexts[k]; }
+	});
+});
+Object.keys(files).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return files[k]; }
+	});
+});
+Object.keys(format).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return format[k]; }
+	});
+});
+Object.keys(keyboards).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return keyboards[k]; }
+	});
+});