diff --git a/nonebot/__init__.py b/nonebot/__init__.py
index eb5f3805..dcc52e0c 100644
--- a/nonebot/__init__.py
+++ b/nonebot/__init__.py
@@ -56,10 +56,10 @@ def get_driver() -> Driver:
     获取全局 Driver 对象。可用于在计划任务的回调中获取当前 Driver 对象。
 
     返回:
-      Driver: 全局 Driver 对象
+        Driver: 全局 Driver 对象
 
     异常:
-      ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用)
+        ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用)
 
     用法:
         ```python
@@ -76,10 +76,10 @@ def get_app() -> Any:
     获取全局 Driver 对应 Server App 对象。
 
     返回:
-      Any: Server App 对象
+        Any: Server App 对象
 
     异常:
-      ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用)
+        ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用)
 
     用法:
         ```python
@@ -98,10 +98,10 @@ def get_asgi() -> Any:
     获取全局 Driver 对应 Asgi 对象。
 
     返回:
-      Any: Asgi 对象
+        Any: Asgi 对象
 
     异常:
-      ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用)
+        ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用)
 
     用法:
         ```python
@@ -120,15 +120,15 @@ def get_bot(self_id: Optional[str] = None) -> Bot:
     当提供 self_id 时，此函数是 get_bots()[self_id] 的简写；当不提供时，返回一个 Bot。
 
     参数:
-      self_id: 用来识别 Bot 的 ID
+        self_id: 用来识别 Bot 的 ID
 
     返回:
-      Bot: Bot 对象
+        Bot: Bot 对象
 
     异常:
-      KeyError: 对应 ID 的 Bot 不存在
-      ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用)
-      ValueError: 没有传入 ID 且没有 Bot 可用
+        KeyError: 对应 ID 的 Bot 不存在
+        ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用)
+        ValueError: 没有传入 ID 且没有 Bot 可用
 
     用法:
         ```python
@@ -152,10 +152,10 @@ def get_bots() -> Dict[str, Bot]:
     获取所有通过 ws 连接 NoneBot 的 Bot 对象。
 
     返回:
-      Dict[str, Bot]: 一个以字符串 ID 为键，Bot 对象为值的字典
+        Dict[str, Bot]: 一个以字符串 ID 为键，Bot 对象为值的字典
 
     异常:
-      ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用)
+        ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用)
 
     用法:
         ```python
@@ -206,8 +206,8 @@ def init(*, _env_file: Optional[str] = None, **kwargs):
     你也可以传入自定义的 _env_file 来指定 NoneBot 从该文件读取配置。
 
     参数:
-      _env_file: 配置文件名，默认从 .env.{env_name} 中读取配置
-      **kwargs: 任意变量，将会存储到 Config 对象里
+        _env_file: 配置文件名，默认从 .env.{env_name} 中读取配置
+        **kwargs: 任意变量，将会存储到 Config 对象里
 
     用法:
         ```python
@@ -241,8 +241,8 @@ def run(*args: Any, **kwargs: Any) -> None:
     启动 NoneBot，即运行全局 Driver 对象。
 
     参数:
-      *args: 传入 Driver.run 的位置参数
-      **kwargs: 传入 Driver.run 的命名参数
+        *args: 传入 Driver.run 的位置参数
+        **kwargs: 传入 Driver.run 的命名参数
 
     用法:
         ```python
diff --git a/nonebot/adapters/_adapter.py b/nonebot/adapters/_adapter.py
index 85724723..85cd0847 100644
--- a/nonebot/adapters/_adapter.py
+++ b/nonebot/adapters/_adapter.py
@@ -66,7 +66,7 @@ class Adapter(abc.ABC):
         `adapter` 实际调用 api 的逻辑实现函数，实现该方法以调用 api。
 
         参数:
-          api: API 名称
-          **data: API 数据
+            api: API 名称
+            **data: API 数据
         """
         raise NotImplementedError
diff --git a/nonebot/adapters/_bot.py b/nonebot/adapters/_bot.py
index eb0cdc23..238c45df 100644
--- a/nonebot/adapters/_bot.py
+++ b/nonebot/adapters/_bot.py
@@ -37,8 +37,8 @@ class Bot(abc.ABC):
     def __init__(self, adapter: "Adapter", self_id: str):
         """
         参数:
-          self_id: 机器人 ID
-          request: request 连接对象
+            self_id: 机器人 ID
+            request: request 连接对象
         """
         self.adapter: "Adapter" = adapter
         self.self_id: str = self_id
@@ -60,8 +60,8 @@ class Bot(abc.ABC):
         调用机器人 API 接口，可以通过该函数或直接通过 bot 属性进行调用
 
         参数:
-          api: API 名称
-          **data: API 数据
+            api: API 名称
+            **data: API 数据
 
         用法:
             ```python
@@ -127,9 +127,8 @@ class Bot(abc.ABC):
         调用机器人基础发送消息接口
 
         参数:
-          event: 上报事件
-          message: 要发送的消息
-          **kwargs
+            event: 上报事件
+            message: 要发送的消息
         """
         raise NotImplementedError
 
@@ -139,9 +138,9 @@ class Bot(abc.ABC):
         调用 api 预处理。
 
         参数:
-          bot: 当前 bot 对象
-          api: 调用的 api 名称
-          data: api 调用的参数字典
+            bot: 当前 bot 对象
+            api: 调用的 api 名称
+            data: api 调用的参数字典
         """
         cls._calling_api_hook.add(func)
         return func
@@ -152,11 +151,11 @@ class Bot(abc.ABC):
         调用 api 后处理。
 
         参数:
-          bot: 当前 bot 对象
-          exception: 调用 api 时发生的错误
-          api: 调用的 api 名称
-          data: api 调用的参数字典
-          result: api 调用的返回
+            bot: 当前 bot 对象
+            exception: 调用 api 时发生的错误
+            api: 调用的 api 名称
+            data: api 调用的参数字典
+            result: api 调用的返回
         """
         cls._called_api_hook.add(func)
         return func
diff --git a/nonebot/adapters/_event.py b/nonebot/adapters/_event.py
index c439d0f1..e7780bb2 100644
--- a/nonebot/adapters/_event.py
+++ b/nonebot/adapters/_event.py
@@ -42,7 +42,7 @@ class Event(abc.ABC, BaseModel):
         获取事件日志信息的方法，通常你不需要修改这个方法，只有当希望 NoneBot 隐藏该事件日志时，可以抛出 `NoLogException` 异常。
 
         异常:
-          NoLogException
+            NoLogException
         """
         return f"[{self.get_event_name()}]: {self.get_event_description()}"
 
diff --git a/nonebot/adapters/_message.py b/nonebot/adapters/_message.py
index e126e3fb..52db50ee 100644
--- a/nonebot/adapters/_message.py
+++ b/nonebot/adapters/_message.py
@@ -98,7 +98,7 @@ class Message(List[TMS], abc.ABC):
     ):
         """
         参数:
-          message: 消息内容
+            message: 消息内容
         """
         super().__init__(*args, **kwargs)
         if message is None:
@@ -134,10 +134,10 @@ class Message(List[TMS], abc.ABC):
             ```
 
         参数:
-          format_string: 格式化字符串
+            format_string: 格式化字符串
 
         返回:
-          MessageFormatter[TM]: 消息格式化器
+            MessageFormatter[TM]: 消息格式化器
         """
         return MessageTemplate(format_string, cls)
 
@@ -185,7 +185,7 @@ class Message(List[TMS], abc.ABC):
         添加一个消息段到消息数组末尾
 
         参数:
-          obj: 要添加的消息段
+            obj: 要添加的消息段
         """
         if isinstance(obj, MessageSegment):
             super(Message, self).append(obj)
@@ -200,7 +200,7 @@ class Message(List[TMS], abc.ABC):
         拼接一个消息数组或多个消息段到消息数组末尾
 
         参数:
-          obj: 要添加的消息数组
+            obj: 要添加的消息数组
         """
         for segment in obj:
             self.append(segment)
diff --git a/nonebot/adapters/_template.py b/nonebot/adapters/_template.py
index cd182b41..b3edf51d 100644
--- a/nonebot/adapters/_template.py
+++ b/nonebot/adapters/_template.py
@@ -50,8 +50,8 @@ class MessageTemplate(Formatter, Generic[TF]):
         创建一个模板
 
         参数:
-          template: 模板
-          factory: 消息构造类型，默认为 `str`
+            template: 模板
+            factory: 消息构造类型，默认为 `str`
         """
         self.template: TF = template
         self.factory: Type[TF] = factory
diff --git a/nonebot/drivers/__init__.py b/nonebot/drivers/__init__.py
index 697e15db..4564ed28 100644
--- a/nonebot/drivers/__init__.py
+++ b/nonebot/drivers/__init__.py
@@ -55,8 +55,8 @@ class Driver(abc.ABC):
     def __init__(self, env: Env, config: Config):
         """
         参数:
-          env: 包含环境信息的 Env 对象
-          config: 包含配置信息的 Config 对象
+            env: 包含环境信息的 Env 对象
+            config: 包含配置信息的 Config 对象
         """
         self.env: str = env.environment
         """
@@ -83,9 +83,9 @@ class Driver(abc.ABC):
         注册一个协议适配器
 
         参数:
-          name: 适配器名称，用于在连接时进行识别
-          adapter: 适配器 Class
-          **kwargs: 其他传递给适配器的参数
+            name: 适配器名称，用于在连接时进行识别
+            adapter: 适配器 Class
+            **kwargs: 其他传递给适配器的参数
         """
         name = adapter.get_name()
         if name in self._adapters:
diff --git a/nonebot/drivers/_block_driver.py b/nonebot/drivers/_block_driver.py
index e8bcd138..bf87659b 100644
--- a/nonebot/drivers/_block_driver.py
+++ b/nonebot/drivers/_block_driver.py
@@ -40,9 +40,6 @@ class BlockDriver(Driver):
     def on_startup(self, func: STARTUP_FUNC) -> STARTUP_FUNC:
         """
         注册一个启动时执行的函数
-
-        参数:
-          func
         """
         self.startup_funcs.add(func)
         return func
@@ -51,9 +48,6 @@ class BlockDriver(Driver):
     def on_shutdown(self, func: SHUTDOWN_FUNC) -> SHUTDOWN_FUNC:
         """
         注册一个停止时执行的函数
-
-        参数:
-          func
         """
         self.shutdown_funcs.add(func)
         return func
diff --git a/nonebot/exception.py b/nonebot/exception.py
index e501c4fe..3c6bdb39 100644
--- a/nonebot/exception.py
+++ b/nonebot/exception.py
@@ -21,10 +21,6 @@ class NoneBotException(Exception):
 class ParserExit(NoneBotException):
     """
     `shell command` 处理消息失败时返回的异常
-
-    参数:
-      status
-      message
     """
 
     def __init__(self, status: int = 0, message: Optional[str] = None):
@@ -50,7 +46,7 @@ class IgnoredException(ProcessException):
     指示 NoneBot 应该忽略该事件。可由 PreProcessor 抛出。
 
     参数:
-      reason: 忽略事件的原因
+        reason: 忽略事件的原因
     """
 
     def __init__(self, reason):
@@ -68,7 +64,7 @@ class MockApiException(ProcessException):
     指示 NoneBot 阻止本次 API 调用或修改本次调用返回值，并返回自定义内容。可由 api hook 抛出。
 
     参数:
-      result: 返回的内容
+        result: 返回的内容
     """
 
     def __init__(self, result: Any):
@@ -158,7 +154,7 @@ class AdapterException(NoneBotException):
     代表 `Adapter` 抛出的异常，所有的 `Adapter` 都要在内部继承自这个 `Exception`
 
     参数:
-      adapter_name: 标识 adapter
+        adapter_name: 标识 adapter
     """
 
     def __init__(self, adapter_name: str) -> None:
diff --git a/nonebot/matcher.py b/nonebot/matcher.py
index 087c172b..2c9c8878 100644
--- a/nonebot/matcher.py
+++ b/nonebot/matcher.py
@@ -213,20 +213,20 @@ class Matcher(metaclass=MatcherMeta):
         创建一个新的事件响应器，并存储至 `matchers <#matchers>`_
 
         参数:
-          type_: 事件响应器类型，与 `event.get_type()` 一致时触发，空字符串表示任意
-          rule: 匹配规则
-          permission: 权限
-          handlers: 事件处理函数列表
-          temp: 是否为临时事件响应器，即触发一次后删除
-          priority: 响应优先级
-          block: 是否阻止事件向更低优先级的响应器传播
-          plugin: 事件响应器所在插件
-          module: 事件响应器所在模块
-          default_state: 默认状态 `state`
-          expire_time: 事件响应器最终有效时间点，过时即被删除
+            type_: 事件响应器类型，与 `event.get_type()` 一致时触发，空字符串表示任意
+            rule: 匹配规则
+            permission: 权限
+            handlers: 事件处理函数列表
+            temp: 是否为临时事件响应器，即触发一次后删除
+            priority: 响应优先级
+            block: 是否阻止事件向更低优先级的响应器传播
+            plugin: 事件响应器所在插件
+            module: 事件响应器所在模块
+            default_state: 默认状态 `state`
+            expire_time: 事件响应器最终有效时间点，过时即被删除
 
         返回:
-          Type[Matcher]: 新的事件响应器类
+            Type[Matcher]: 新的事件响应器类
         """
         NewMatcher = type(
             "Matcher",
@@ -277,11 +277,11 @@ class Matcher(metaclass=MatcherMeta):
         检查是否满足触发权限
 
         参数:
-          bot: Bot 对象
-          event: 上报事件
+            bot: Bot 对象
+            event: 上报事件
 
         返回:
-          bool: 是否满足权限
+            bool: 是否满足权限
         """
         event_type = event.get_type()
         return event_type == (cls.type or event_type) and await cls.permission(
@@ -301,12 +301,12 @@ class Matcher(metaclass=MatcherMeta):
         检查是否满足匹配规则
 
         参数:
-          bot: Bot 对象
-          event: 上报事件
-          state: 当前状态
+            bot: Bot 对象
+            event: 上报事件
+            state: 当前状态
 
         返回:
-          bool: 是否满足匹配规则
+            bool: 是否满足匹配规则
         """
         event_type = event.get_type()
         return event_type == (cls.type or event_type) and await cls.rule(
@@ -319,7 +319,7 @@ class Matcher(metaclass=MatcherMeta):
         装饰一个函数来更改当前事件响应器的默认响应事件类型更新函数
 
         参数:
-          func: 响应事件类型更新函数
+            func: 响应事件类型更新函数
         """
         cls._default_type_updater = Dependent[str].parse(
             call=func, allow_types=cls.HANDLER_PARAM_TYPES
@@ -332,7 +332,7 @@ class Matcher(metaclass=MatcherMeta):
         装饰一个函数来更改当前事件响应器的默认会话权限更新函数
 
         参数:
-          func: 会话权限更新函数
+            func: 会话权限更新函数
         """
         cls._default_permission_updater = Dependent[Permission].parse(
             call=func, allow_types=cls.HANDLER_PARAM_TYPES
@@ -359,7 +359,7 @@ class Matcher(metaclass=MatcherMeta):
         装饰一个函数来向事件响应器直接添加一个处理函数
 
         参数:
-          parameterless: 非参数类型依赖列表
+            parameterless: 非参数类型依赖列表
         """
 
         def _decorator(func: T_Handler) -> T_Handler:
@@ -376,8 +376,8 @@ class Matcher(metaclass=MatcherMeta):
         装饰一个函数来指示 NoneBot 在接收用户新的一条消息后继续运行该函数
 
         参数:
-          id: 消息 ID
-          parameterless: 非参数类型依赖列表
+            id: 消息 ID
+            parameterless: 非参数类型依赖列表
         """
 
         async def _receive(event: Event, matcher: "Matcher") -> Union[None, NoReturn]:
@@ -412,13 +412,12 @@ class Matcher(metaclass=MatcherMeta):
         parameterless: Optional[List[Any]] = None,
     ) -> Callable[[T_Handler], T_Handler]:
         """
-        装饰一个函数来指示 NoneBot 当要获取的 `key` 不存在时接收用户新的一条消息并经过 `ArgsParser` 处理后再运行该函数，如果 `key` 已存在则直接继续运行
+        装饰一个函数来指示 NoneBot 当要获取的 `key` 不存在时接收用户新的一条消息再运行该函数，如果 `key` 已存在则直接继续运行
 
         参数:
-          key: 参数名
-          prompt: 在参数不存在时向用户发送的消息
-          args_parser: 可选参数解析函数，空则使用默认解析函数
-          parameterless: 非参数类型依赖列表
+            key: 参数名
+            prompt: 在参数不存在时向用户发送的消息
+            parameterless: 非参数类型依赖列表
         """
 
         async def _key_getter(event: Event, matcher: "Matcher"):
@@ -458,8 +457,8 @@ class Matcher(metaclass=MatcherMeta):
         发送一条消息给当前交互用户
 
         参数:
-          message: 消息内容
-          **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
+            message: 消息内容
+            **kwargs: `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
         """
         bot = current_bot.get()
         event = current_event.get()
@@ -480,8 +479,8 @@ class Matcher(metaclass=MatcherMeta):
         发送一条消息给当前交互用户并结束当前事件响应器
 
         参数:
-          message: 消息内容
-          **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
+            message: 消息内容
+            **kwargs: `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
         """
         if message is not None:
             await cls.send(message, **kwargs)
@@ -497,8 +496,8 @@ class Matcher(metaclass=MatcherMeta):
         发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续下一个处理函数
 
         参数:
-          prompt: 消息内容
-          **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
+            prompt: 消息内容
+            **kwargs`: bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
         """
         if prompt is not None:
             await cls.send(prompt, **kwargs)
@@ -514,8 +513,8 @@ class Matcher(metaclass=MatcherMeta):
         最近使用 `got` / `receive` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数
 
         参数:
-          prompt: 消息内容
-          **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
+            prompt: 消息内容
+            **kwargs: `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
         """
         if prompt is not None:
             await cls.send(prompt, **kwargs)
@@ -532,9 +531,9 @@ class Matcher(metaclass=MatcherMeta):
         最近使用 `got` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数
 
         参数:
-          key: 参数名
-          prompt: 消息内容
-          **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
+            key: 参数名
+            prompt: 消息内容
+            **kwargs: `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
         """
         matcher = current_matcher.get()
         matcher.set_target(ARG_KEY.format(key=key))
@@ -553,9 +552,9 @@ class Matcher(metaclass=MatcherMeta):
         最近使用 `got` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数
 
         参数:
-          id: 消息 id
-          prompt: 消息内容
-          **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
+            id: 消息 id
+            prompt: 消息内容
+            **kwargs: `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
         """
         matcher = current_matcher.get()
         matcher.set_target(RECEIVE_KEY.format(id=id))
diff --git a/nonebot/message.py b/nonebot/message.py
index f3d83de0..877ee7ad 100644
--- a/nonebot/message.py
+++ b/nonebot/message.py
@@ -237,8 +237,8 @@ async def handle_event(bot: "Bot", event: "Event") -> None:
      处理一个事件。调用该函数以实现分发事件。
 
     参数:
-      bot: Bot 对象
-      event: Event 对象
+        bot: Bot 对象
+        event: Event 对象
 
     用法:
         ```python
diff --git a/nonebot/params.py b/nonebot/params.py
index a6c2cd01..ad1d3e63 100644
--- a/nonebot/params.py
+++ b/nonebot/params.py
@@ -59,8 +59,8 @@ def Depends(
     参数依赖注入装饰器
 
     参数:
-      dependency: 依赖函数。默认为参数的类型注释。
-      use_cache: 是否使用缓存。默认为 `True`。
+        dependency: 依赖函数。默认为参数的类型注释。
+        use_cache: 是否使用缓存。默认为 `True`。
 
     用法:
         ```python
diff --git a/nonebot/permission.py b/nonebot/permission.py
index c314aea9..18ce52df 100644
--- a/nonebot/permission.py
+++ b/nonebot/permission.py
@@ -84,10 +84,10 @@ class Permission:
         检查是否满足某个权限
 
         参数:
-          bot: Bot 对象
-          event: Event 对象
-          stack: 异步上下文栈
-          dependency_cache: 依赖缓存
+            bot: Bot 对象
+            event: Event 对象
+            stack: 异步上下文栈
+            dependency_cache: 依赖缓存
         """
         if not self.checkers:
             return True
diff --git a/nonebot/plugin/load.py b/nonebot/plugin/load.py
index 957fa12b..6ebb93bf 100644
--- a/nonebot/plugin/load.py
+++ b/nonebot/plugin/load.py
@@ -15,7 +15,7 @@ def load_plugin(module_path: str) -> Optional[Plugin]:
     使用 `PluginManager` 加载单个插件，可以是本地插件或是通过 `pip` 安装的插件。
 
     参数:
-      module_path: 插件名称 `path.to.your.plugin`
+        module_path: 插件名称 `path.to.your.plugin`
     """
 
     manager = PluginManager([module_path])
@@ -28,7 +28,7 @@ def load_plugins(*plugin_dir: str) -> Set[Plugin]:
     导入目录下多个插件，以 `_` 开头的插件不会被导入！
 
     参数:
-      plugin_dir: 插件路径
+        plugin_dir: 插件路径
     """
     manager = PluginManager(search_path=plugin_dir)
     _managers.append(manager)
@@ -42,8 +42,8 @@ def load_all_plugins(
     导入指定列表中的插件以及指定目录下多个插件，以 `_` 开头的插件不会被导入！
 
     参数:
-      module_path: 指定插件集合
-      plugin_dir: 指定插件路径集合
+        module_path: 指定插件集合
+        plugin_dir: 指定插件路径集合
     """
     manager = PluginManager(module_path, plugin_dir)
     _managers.append(manager)
@@ -55,8 +55,9 @@ def load_from_json(file_path: str, encoding: str = "utf-8") -> Set[Plugin]:
     导入指定 json 文件中的 `plugins` 以及 `plugin_dirs` 下多个插件，以 `_` 开头的插件不会被导入！
 
     参数:
-      file_path: 指定 json 文件路径
-      encoding: 指定 json 文件编码"""
+        file_path: 指定 json 文件路径
+        encoding: 指定 json 文件编码
+    """
     with open(file_path, "r", encoding=encoding) as f:
         data = json.load(f)
     plugins = data.get("plugins")
@@ -72,8 +73,9 @@ def load_from_toml(file_path: str, encoding: str = "utf-8") -> Set[Plugin]:
       以 `_` 开头的插件不会被导入！
 
     参数:
-      file_path: 指定 toml 文件路径
-      encoding: 指定 toml 文件编码"""
+        file_path: 指定 toml 文件路径
+        encoding: 指定 toml 文件编码
+    """
     with open(file_path, "r", encoding=encoding) as f:
         data = tomlkit.parse(f.read())  # type: ignore
 
@@ -113,10 +115,10 @@ def require(name: str) -> Export:
     获取一个插件的导出内容
 
     参数:
-      name: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。
+        name: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。
 
     异常:
-      RuntimeError: 插件无法加载
+        RuntimeError: 插件无法加载
     """
     plugin = get_plugin(name) or load_plugin(name)
     if not plugin:
diff --git a/nonebot/plugin/on.py b/nonebot/plugin/on.py
index f0fb8c93..d03b1965 100644
--- a/nonebot/plugin/on.py
+++ b/nonebot/plugin/on.py
@@ -58,14 +58,14 @@ def on(
     注册一个基础事件响应器，可自定义类型。
 
     参数:
-      type: 事件响应器类型
-      rule: 事件响应规则
-      permission: 事件响应权限
-      handlers: 事件处理函数列表
-      temp: 是否为临时事件响应器（仅执行一次）
-      priority: 事件响应器优先级
-      block: 是否阻止事件向更低优先级传递
-      state: 默认 state
+        type: 事件响应器类型
+        rule: 事件响应规则
+        permission: 事件响应权限
+        handlers: 事件处理函数列表
+        temp: 是否为临时事件响应器（仅执行一次）
+        priority: 事件响应器优先级
+        block: 是否阻止事件向更低优先级传递
+        state: 默认 state
     """
     matcher = Matcher.new(
         type,
@@ -97,12 +97,12 @@ def on_metaevent(
     注册一个元事件响应器。
 
     参数:
-      rule: 事件响应规则
-      handlers: 事件处理函数列表
-      temp: 是否为临时事件响应器（仅执行一次）
-      priority: 事件响应器优先级
-      block: 是否阻止事件向更低优先级传递
-      state: 默认 state
+        rule: 事件响应规则
+        handlers: 事件处理函数列表
+        temp: 是否为临时事件响应器（仅执行一次）
+        priority: 事件响应器优先级
+        block: 是否阻止事件向更低优先级传递
+        state: 默认 state
     """
     matcher = Matcher.new(
         "meta_event",
@@ -135,13 +135,13 @@ def on_message(
     注册一个消息事件响应器。
 
     参数:
-      rule: 事件响应规则
-      permission: 事件响应权限
-      handlers: 事件处理函数列表
-      temp: 是否为临时事件响应器（仅执行一次）
-      priority: 事件响应器优先级
-      block: 是否阻止事件向更低优先级传递
-      state: 默认 state
+        rule: 事件响应规则
+        permission: 事件响应权限
+        handlers: 事件处理函数列表
+        temp: 是否为临时事件响应器（仅执行一次）
+        priority: 事件响应器优先级
+        block: 是否阻止事件向更低优先级传递
+        state: 默认 state
     """
     matcher = Matcher.new(
         "message",
@@ -173,12 +173,12 @@ def on_notice(
     注册一个通知事件响应器。
 
     参数:
-      rule: 事件响应规则
-      handlers: 事件处理函数列表
-      temp: 是否为临时事件响应器（仅执行一次）
-      priority: 事件响应器优先级
-      block: 是否阻止事件向更低优先级传递
-      state: 默认 state
+        rule: 事件响应规则
+        handlers: 事件处理函数列表
+        temp: 是否为临时事件响应器（仅执行一次）
+        priority: 事件响应器优先级
+        block: 是否阻止事件向更低优先级传递
+        state: 默认 state
     """
     matcher = Matcher.new(
         "notice",
@@ -210,12 +210,12 @@ def on_request(
     注册一个请求事件响应器。
 
     参数:
-      rule: 事件响应规则
-      handlers: 事件处理函数列表
-      temp: 是否为临时事件响应器（仅执行一次）
-      priority: 事件响应器优先级
-      block: 是否阻止事件向更低优先级传递
-      state: 默认 state
+        rule: 事件响应规则
+        handlers: 事件处理函数列表
+        temp: 是否为临时事件响应器（仅执行一次）
+        priority: 事件响应器优先级
+        block: 是否阻止事件向更低优先级传递
+        state: 默认 state
     """
     matcher = Matcher.new(
         "request",
@@ -244,15 +244,15 @@ def on_startswith(
     注册一个消息事件响应器，并且当消息的**文本部分**以指定内容开头时响应。
 
     参数:
-      msg: 指定消息开头内容
-      rule: 事件响应规则
-      ignorecase: 是否忽略大小写
-      permission: 事件响应权限
-      handlers: 事件处理函数列表
-      temp: 是否为临时事件响应器（仅执行一次）
-      priority: 事件响应器优先级
-      block: 是否阻止事件向更低优先级传递
-      state: 默认 state
+        msg: 指定消息开头内容
+        rule: 事件响应规则
+        ignorecase: 是否忽略大小写
+        permission: 事件响应权限
+        handlers: 事件处理函数列表
+        temp: 是否为临时事件响应器（仅执行一次）
+        priority: 事件响应器优先级
+        block: 是否阻止事件向更低优先级传递
+        state: 默认 state
     """
     return on_message(startswith(msg, ignorecase) & rule, **kwargs, _depth=_depth + 1)
 
@@ -268,15 +268,15 @@ def on_endswith(
     注册一个消息事件响应器，并且当消息的**文本部分**以指定内容结尾时响应。
 
     参数:
-      msg: 指定消息结尾内容
-      rule: 事件响应规则
-      ignorecase: 是否忽略大小写
-      permission: 事件响应权限
-      handlers: 事件处理函数列表
-      temp: 是否为临时事件响应器（仅执行一次）
-      priority: 事件响应器优先级
-      block: 是否阻止事件向更低优先级传递
-      state: 默认 state
+        msg: 指定消息结尾内容
+        rule: 事件响应规则
+        ignorecase: 是否忽略大小写
+        permission: 事件响应权限
+        handlers: 事件处理函数列表
+        temp: 是否为临时事件响应器（仅执行一次）
+        priority: 事件响应器优先级
+        block: 是否阻止事件向更低优先级传递
+        state: 默认 state
     """
     return on_message(endswith(msg, ignorecase) & rule, **kwargs, _depth=_depth + 1)
 
@@ -291,14 +291,14 @@ def on_keyword(
     注册一个消息事件响应器，并且当消息纯文本部分包含关键词时响应。
 
     参数:
-      keywords: 关键词列表
-      rule: 事件响应规则
-      permission: 事件响应权限
-      handlers: 事件处理函数列表
-      temp: 是否为临时事件响应器（仅执行一次）
-      priority: 事件响应器优先级
-      block: 是否阻止事件向更低优先级传递
-      state: 默认 state
+        keywords: 关键词列表
+        rule: 事件响应规则
+        permission: 事件响应权限
+        handlers: 事件处理函数列表
+        temp: 是否为临时事件响应器（仅执行一次）
+        priority: 事件响应器优先级
+        block: 是否阻止事件向更低优先级传递
+        state: 默认 state
     """
     return on_message(keyword(*keywords) & rule, **kwargs, _depth=_depth + 1)
 
@@ -313,18 +313,18 @@ def on_command(
     """
     注册一个消息事件响应器，并且当消息以指定命令开头时响应。
 
-      命令匹配规则参考: `命令形式匹配 <rule.md#command-command>`_
+    命令匹配规则参考: `命令形式匹配 <rule.md#command-command>`_
 
     参数:
-      cmd: 指定命令内容
-      rule: 事件响应规则
-      aliases: 命令别名
-      permission: 事件响应权限
-      handlers: 事件处理函数列表
-      temp: 是否为临时事件响应器（仅执行一次）
-      priority: 事件响应器优先级
-      block: 是否阻止事件向更低优先级传递
-      state: 默认 state
+        cmd: 指定命令内容
+        rule: 事件响应规则
+        aliases: 命令别名
+        permission: 事件响应权限
+        handlers: 事件处理函数列表
+        temp: 是否为临时事件响应器（仅执行一次）
+        priority: 事件响应器优先级
+        block: 是否阻止事件向更低优先级传递
+        state: 默认 state
     """
 
     commands = set([cmd]) | (aliases or set())
@@ -345,21 +345,21 @@ def on_shell_command(
     """
     注册一个支持 `shell_like` 解析参数的命令消息事件响应器。
 
-      与普通的 `on_command` 不同的是，在添加 `parser` 参数时, 响应器会自动处理消息。
+    与普通的 `on_command` 不同的是，在添加 `parser` 参数时, 响应器会自动处理消息。
 
-      并将用户输入的原始参数列表保存在 `state["argv"]`, `parser` 处理的参数保存在 `state["args"]` 中
+    并将用户输入的原始参数列表保存在 `state["argv"]`, `parser` 处理的参数保存在 `state["args"]` 中
 
     参数:
-      cmd: 指定命令内容
-      rule: 事件响应规则
-      aliases: 命令别名
-      parser: `nonebot.rule.ArgumentParser` 对象
-      permission: 事件响应权限
-      handlers: 事件处理函数列表
-      temp: 是否为临时事件响应器（仅执行一次）
-      priority: 事件响应器优先级
-      block: 是否阻止事件向更低优先级传递
-      state: 默认 state
+        cmd: 指定命令内容
+        rule: 事件响应规则
+        aliases: 命令别名
+        parser: `nonebot.rule.ArgumentParser` 对象
+        permission: 事件响应权限
+        handlers: 事件处理函数列表
+        temp: 是否为临时事件响应器（仅执行一次）
+        priority: 事件响应器优先级
+        block: 是否阻止事件向更低优先级传递
+        state: 默认 state
     """
 
     commands = set([cmd]) | (aliases or set())
@@ -380,18 +380,18 @@ def on_regex(
     """
     注册一个消息事件响应器，并且当消息匹配正则表达式时响应。
 
-      命令匹配规则参考: `正则匹配 <rule.md#regex-regex-flags-0>`_
+    命令匹配规则参考: `正则匹配 <rule.md#regex-regex-flags-0>`_
 
     参数:
-      pattern: 正则表达式
-      flags: 正则匹配标志
-      rule: 事件响应规则
-      permission: 事件响应权限
-      handlers: 事件处理函数列表
-      temp: 是否为临时事件响应器（仅执行一次）
-      priority: 事件响应器优先级
-      block: 是否阻止事件向更低优先级传递
-      state: 默认 state
+        pattern: 正则表达式
+        flags: 正则匹配标志
+        rule: 事件响应规则
+        permission: 事件响应权限
+        handlers: 事件处理函数列表
+        temp: 是否为临时事件响应器（仅执行一次）
+        priority: 事件响应器优先级
+        block: 是否阻止事件向更低优先级传递
+        state: 默认 state
     """
     return on_message(regex(pattern, flags) & rule, **kwargs, _depth=_depth + 1)
 
@@ -402,8 +402,8 @@ class CommandGroup:
     def __init__(self, cmd: Union[str, Tuple[str, ...]], **kwargs):
         """
         参数:
-          cmd: 命令前缀
-          **kwargs`on_command` 的参数默认值，参考 `on_command <#on-command-cmd-rule-none-aliases-none-kwargs>`_
+            cmd: 命令前缀
+            **kwargs: `on_command` 的参数默认值，参考 `on_command <#on-command-cmd-rule-none-aliases-none-kwargs>`_
         """
         self.basecmd: Tuple[str, ...] = (cmd,) if isinstance(cmd, str) else cmd
         """
@@ -421,8 +421,8 @@ class CommandGroup:
         注册一个新的命令。
 
         参数:
-          cmd: 命令前缀
-          **kwargs`on_command` 的参数，将会覆盖命令组默认值
+            cmd: 命令前缀
+            **kwargs: `on_command` 的参数，将会覆盖命令组默认值
         """
         sub_cmd = (cmd,) if isinstance(cmd, str) else cmd
         cmd = self.basecmd + sub_cmd
@@ -438,8 +438,8 @@ class CommandGroup:
         注册一个新的命令。
 
         参数:
-          cmd: 命令前缀
-          **kwargs`on_shell_command` 的参数，将会覆盖命令组默认值
+            cmd: 命令前缀
+            **kwargs: `on_shell_command` 的参数，将会覆盖命令组默认值
         """
         sub_cmd = (cmd,) if isinstance(cmd, str) else cmd
         cmd = self.basecmd + sub_cmd
@@ -470,14 +470,14 @@ class MatcherGroup:
         注册一个基础事件响应器，可自定义类型。
 
         参数:
-          type: 事件响应器类型
-          rule: 事件响应规则
-          permission: 事件响应权限
-          handlers: 事件处理函数列表
-          temp: 是否为临时事件响应器（仅执行一次）
-          priority: 事件响应器优先级
-          block: 是否阻止事件向更低优先级传递
-          state: 默认 state
+            type: 事件响应器类型
+            rule: 事件响应规则
+            permission: 事件响应权限
+            handlers: 事件处理函数列表
+            temp: 是否为临时事件响应器（仅执行一次）
+            priority: 事件响应器优先级
+            block: 是否阻止事件向更低优先级传递
+            state: 默认 state
         """
         final_kwargs = self.base_kwargs.copy()
         final_kwargs.update(kwargs)
@@ -490,12 +490,12 @@ class MatcherGroup:
         注册一个元事件响应器。
 
         参数:
-          rule: 事件响应规则
-          handlers: 事件处理函数列表
-          temp: 是否为临时事件响应器（仅执行一次）
-          priority: 事件响应器优先级
-          block: 是否阻止事件向更低优先级传递
-          state: 默认 state
+            rule: 事件响应规则
+            handlers: 事件处理函数列表
+            temp: 是否为临时事件响应器（仅执行一次）
+            priority: 事件响应器优先级
+            block: 是否阻止事件向更低优先级传递
+            state: 默认 state
         """
         final_kwargs = self.base_kwargs.copy()
         final_kwargs.update(kwargs)
@@ -510,13 +510,13 @@ class MatcherGroup:
         注册一个消息事件响应器。
 
         参数:
-          rule: 事件响应规则
-          permission: 事件响应权限
-          handlers: 事件处理函数列表
-          temp: 是否为临时事件响应器（仅执行一次）
-          priority: 事件响应器优先级
-          block: 是否阻止事件向更低优先级传递
-          state: 默认 state
+            rule: 事件响应规则
+            permission: 事件响应权限
+            handlers: 事件处理函数列表
+            temp: 是否为临时事件响应器（仅执行一次）
+            priority: 事件响应器优先级
+            block: 是否阻止事件向更低优先级传递
+            state: 默认 state
         """
         final_kwargs = self.base_kwargs.copy()
         final_kwargs.update(kwargs)
@@ -530,12 +530,12 @@ class MatcherGroup:
         注册一个通知事件响应器。
 
         参数:
-          rule: 事件响应规则
-          handlers: 事件处理函数列表
-          temp: 是否为临时事件响应器（仅执行一次）
-          priority: 事件响应器优先级
-          block: 是否阻止事件向更低优先级传递
-          state: 默认 state
+            rule: 事件响应规则
+            handlers: 事件处理函数列表
+            temp: 是否为临时事件响应器（仅执行一次）
+            priority: 事件响应器优先级
+            block: 是否阻止事件向更低优先级传递
+            state: 默认 state
         """
         final_kwargs = self.base_kwargs.copy()
         final_kwargs.update(kwargs)
@@ -549,12 +549,12 @@ class MatcherGroup:
         注册一个请求事件响应器。
 
         参数:
-          rule: 事件响应规则
-          handlers: 事件处理函数列表
-          temp: 是否为临时事件响应器（仅执行一次）
-          priority: 事件响应器优先级
-          block: 是否阻止事件向更低优先级传递
-          state: 默认 state
+            rule: 事件响应规则
+            handlers: 事件处理函数列表
+            temp: 是否为临时事件响应器（仅执行一次）
+            priority: 事件响应器优先级
+            block: 是否阻止事件向更低优先级传递
+            state: 默认 state
         """
         final_kwargs = self.base_kwargs.copy()
         final_kwargs.update(kwargs)
@@ -570,15 +570,15 @@ class MatcherGroup:
         注册一个消息事件响应器，并且当消息的**文本部分**以指定内容开头时响应。
 
         参数:
-          msg: 指定消息开头内容
-          ignorecase: 是否忽略大小写
-          rule: 事件响应规则
-          permission: 事件响应权限
-          handlers: 事件处理函数列表
-          temp: 是否为临时事件响应器（仅执行一次）
-          priority: 事件响应器优先级
-          block: 是否阻止事件向更低优先级传递
-          state: 默认 state
+            msg: 指定消息开头内容
+            ignorecase: 是否忽略大小写
+            rule: 事件响应规则
+            permission: 事件响应权限
+            handlers: 事件处理函数列表
+            temp: 是否为临时事件响应器（仅执行一次）
+            priority: 事件响应器优先级
+            block: 是否阻止事件向更低优先级传递
+            state: 默认 state
         """
         final_kwargs = self.base_kwargs.copy()
         final_kwargs.update(kwargs)
@@ -592,15 +592,15 @@ class MatcherGroup:
         注册一个消息事件响应器，并且当消息的**文本部分**以指定内容结尾时响应。
 
         参数:
-          msg: 指定消息结尾内容
-          ignorecase: 是否忽略大小写
-          rule: 事件响应规则
-          permission: 事件响应权限
-          handlers: 事件处理函数列表
-          temp: 是否为临时事件响应器（仅执行一次）
-          priority: 事件响应器优先级
-          block: 是否阻止事件向更低优先级传递
-          state: 默认 state
+            msg: 指定消息结尾内容
+            ignorecase: 是否忽略大小写
+            rule: 事件响应规则
+            permission: 事件响应权限
+            handlers: 事件处理函数列表
+            temp: 是否为临时事件响应器（仅执行一次）
+            priority: 事件响应器优先级
+            block: 是否阻止事件向更低优先级传递
+            state: 默认 state
         """
         final_kwargs = self.base_kwargs.copy()
         final_kwargs.update(kwargs)
@@ -614,14 +614,14 @@ class MatcherGroup:
         注册一个消息事件响应器，并且当消息纯文本部分包含关键词时响应。
 
         参数:
-          keywords: 关键词列表
-          rule: 事件响应规则
-          permission: 事件响应权限
-          handlers: 事件处理函数列表
-          temp: 是否为临时事件响应器（仅执行一次）
-          priority: 事件响应器优先级
-          block: 是否阻止事件向更低优先级传递
-          state: 默认 state
+            keywords: 关键词列表
+            rule: 事件响应规则
+            permission: 事件响应权限
+            handlers: 事件处理函数列表
+            temp: 是否为临时事件响应器（仅执行一次）
+            priority: 事件响应器优先级
+            block: 是否阻止事件向更低优先级传递
+            state: 默认 state
         """
         final_kwargs = self.base_kwargs.copy()
         final_kwargs.update(kwargs)
@@ -642,15 +642,15 @@ class MatcherGroup:
         命令匹配规则参考: `命令形式匹配 <rule.md#command-command>`_
 
         参数:
-          cmd: 指定命令内容
-          aliases: 命令别名
-          rule: 事件响应规则
-          permission: 事件响应权限
-          handlers: 事件处理函数列表
-          temp: 是否为临时事件响应器（仅执行一次）
-          priority: 事件响应器优先级
-          block: 是否阻止事件向更低优先级传递
-          state: 默认 state
+            cmd: 指定命令内容
+            aliases: 命令别名
+            rule: 事件响应规则
+            permission: 事件响应权限
+            handlers: 事件处理函数列表
+            temp: 是否为临时事件响应器（仅执行一次）
+            priority: 事件响应器优先级
+            block: 是否阻止事件向更低优先级传递
+            state: 默认 state
         """
         final_kwargs = self.base_kwargs.copy()
         final_kwargs.update(kwargs)
@@ -674,16 +674,16 @@ class MatcherGroup:
         并将用户输入的原始参数列表保存在 `state["argv"]`, `parser` 处理的参数保存在 `state["args"]` 中
 
         参数:
-          cmd: 指定命令内容
-          aliases: 命令别名
-          parser: `nonebot.rule.ArgumentParser` 对象
-          rule: 事件响应规则
-          permission: 事件响应权限
-          handlers: 事件处理函数列表
-          temp: 是否为临时事件响应器（仅执行一次）
-          priority: 事件响应器优先级
-          block: 是否阻止事件向更低优先级传递
-          state: 默认 state
+            cmd: 指定命令内容
+            aliases: 命令别名
+            parser: `nonebot.rule.ArgumentParser` 对象
+            rule: 事件响应规则
+            permission: 事件响应权限
+            handlers: 事件处理函数列表
+            temp: 是否为临时事件响应器（仅执行一次）
+            priority: 事件响应器优先级
+            block: 是否阻止事件向更低优先级传递
+            state: 默认 state
         """
         final_kwargs = self.base_kwargs.copy()
         final_kwargs.update(kwargs)
@@ -703,15 +703,15 @@ class MatcherGroup:
         命令匹配规则参考: `正则匹配 <rule.md#regex-regex-flags-0>`_
 
         参数:
-          pattern: 正则表达式
-          flags: 正则匹配标志
-          rule: 事件响应规则
-          permission: 事件响应权限
-          handlers: 事件处理函数列表
-          temp: 是否为临时事件响应器（仅执行一次）
-          priority: 事件响应器优先级
-          block: 是否阻止事件向更低优先级传递
-          state: 默认 state
+            pattern: 正则表达式
+            flags: 正则匹配标志
+            rule: 事件响应规则
+            permission: 事件响应权限
+            handlers: 事件处理函数列表
+            temp: 是否为临时事件响应器（仅执行一次）
+            priority: 事件响应器优先级
+            block: 是否阻止事件向更低优先级传递
+            state: 默认 state
         """
         final_kwargs = self.base_kwargs.copy()
         final_kwargs.update(kwargs)
diff --git a/nonebot/plugin/plugin.py b/nonebot/plugin/plugin.py
index 82e4f806..58098e12 100644
--- a/nonebot/plugin/plugin.py
+++ b/nonebot/plugin/plugin.py
@@ -57,7 +57,7 @@ def get_plugin(name: str) -> Optional[Plugin]:
     获取当前导入的某个插件。
 
     参数:
-      name: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。
+        name: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。
     """
     return plugins.get(name)
 
diff --git a/nonebot/rule.py b/nonebot/rule.py
index 9a814636..36e19d80 100644
--- a/nonebot/rule.py
+++ b/nonebot/rule.py
@@ -114,11 +114,11 @@ class Rule:
         检查是否符合所有规则
 
         参数:
-          bot: Bot 对象
-          event: Event 对象
-          state: 当前 State
-          stack: 异步上下文栈
-          dependency_cache: 依赖缓存
+            bot: Bot 对象
+            event: Event 对象
+            state: 当前 State
+            stack: 异步上下文栈
+            dependency_cache: 依赖缓存
         """
         if not self.checkers:
             return True
@@ -210,7 +210,7 @@ def startswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Ru
     匹配消息开头
 
     参数:
-      msg: 消息开头字符串
+        msg: 消息开头字符串
     """
     if isinstance(msg, str):
         msg = (msg,)
@@ -242,7 +242,7 @@ def endswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Rule
     匹配消息结尾
 
     参数:
-      msg: 消息结尾字符串
+        msg: 消息结尾字符串
     """
     if isinstance(msg, str):
         msg = (msg,)
@@ -458,12 +458,12 @@ def regex(regex: str, flags: Union[int, re.RegexFlag] = 0) -> Rule:
     r"""
     根据正则表达式进行匹配。
 
-      可以通过 `state["_matched"]` `state["_matched_groups"]` `state["_matched_dict"]`
-      获取正则表达式匹配成功的文本。
+    可以通过 `state["_matched"]` `state["_matched_groups"]` `state["_matched_dict"]`
+    获取正则表达式匹配成功的文本。
 
     参数:
-      regex: 正则表达式
-      flags: 正则标志
+        regex: 正则表达式
+        flags: 正则标志
 
     \:\:\:tip 提示
     正则表达式匹配使用 search 而非 match，如需从头匹配请使用 `r"^xxx"` 来确保匹配开头
diff --git a/nonebot/utils.py b/nonebot/utils.py
index 8c55af14..ced56782 100644
--- a/nonebot/utils.py
+++ b/nonebot/utils.py
@@ -34,7 +34,7 @@ def escape_tag(s: str) -> str:
     用于记录带颜色日志时转义 `<tag>` 类型特殊标签
 
     参数:
-      s: 需要转义的字符串
+        s: 需要转义的字符串
     """
     return re.sub(r"</?((?:[fb]g\s)?[^<>\s]*)>", r"\\\g<0>", s)
 
@@ -86,7 +86,7 @@ def run_sync(call: Callable[P, R]) -> Callable[P, Awaitable[R]]:
     一个用于包装 sync function 为 async function 的装饰器
 
     参数:
-      call: 被装饰的同步函数
+        call: 被装饰的同步函数
     """
 
     @wraps(call)