@mrlingxd/koishi-plugin-adapter-onebot 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-present Shigma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/bot/base.d.ts

@@ -0,0 +1,36 @@
+import { Bot, Context, Schema, Universal } from "koishi";
+import * as OneBot from "../utils";
+import { OneBotMessageEncoder } from "./message";
+export declare class BaseBot<C extends Context = Context, T extends BaseBot.Config = BaseBot.Config> extends Bot<C, T> {
+    static MessageEncoder: typeof OneBotMessageEncoder;
+    static inject: string[];
+    parent?: BaseBot;
+    internal: OneBot.Internal;
+    createDirectChannel(userId: string): Promise<{
+        id: string;
+        type: Universal.Channel.Type;
+    }>;
+    getMessage(channelId: string, messageId: string): Promise<Universal.Message>;
+    deleteMessage(channelId: string, messageId: string): Promise<void>;
+    getLogin(): Promise<Universal.Login>;
+    getUser(userId: string): Promise<Universal.User>;
+    getFriendList(): Promise<{
+        data: Universal.User[];
+    }>;
+    handleFriendRequest(messageId: string, approve: boolean, comment?: string): Promise<void>;
+    handleGuildRequest(messageId: string, approve: boolean, comment?: string): Promise<void>;
+    handleGuildMemberRequest(messageId: string, approve: boolean, comment?: string): Promise<void>;
+    deleteFriend(userId: string): Promise<void>;
+    getMessageList(channelId: string, before?: string, direction?: Universal.Direction): Promise<{
+        data: Universal.Message[];
+    }>;
+}
+export declare namespace BaseBot {
+    interface Config {
+        advanced?: AdvancedConfig;
+    }
+    interface AdvancedConfig {
+        splitMixedContent?: boolean;
+    }
+    const AdvancedConfig: Schema<AdvancedConfig>;
+}

package/lib/bot/base.js

@@ -0,0 +1,66 @@
+import { Bot, Schema } from "koishi";
+import * as OneBot from "../utils";
+import { OneBotMessageEncoder, PRIVATE_PFX } from "./message";
+export class BaseBot extends Bot {
+    static MessageEncoder = OneBotMessageEncoder;
+    static inject = ["http"];
+    parent;
+    internal;
+    async createDirectChannel(userId) {
+        return { id: `${PRIVATE_PFX}${userId}`, type: 1 /* Universal.Channel.Type.DIRECT */ };
+    }
+    async getMessage(channelId, messageId) {
+        const data = await this.internal.getMsg(messageId);
+        return await OneBot.adaptMessage(this, data);
+    }
+    async deleteMessage(channelId, messageId) {
+        await this.internal.deleteMsg(messageId);
+    }
+    async getLogin() {
+        const data = await this.internal.getLoginInfo();
+        this.user = OneBot.decodeUser(data);
+        return this.toJSON();
+    }
+    async getUser(userId) {
+        const data = await this.internal.getStrangerInfo(userId);
+        return OneBot.decodeUser(data);
+    }
+    async getFriendList() {
+        const data = await this.internal.getFriendList();
+        return { data: data.map(OneBot.decodeUser) };
+    }
+    async handleFriendRequest(messageId, approve, comment) {
+        await this.internal.setFriendAddRequest(messageId, approve, comment);
+    }
+    async handleGuildRequest(messageId, approve, comment) {
+        await this.internal.setGroupAddRequest(messageId, "invite", approve, comment);
+    }
+    async handleGuildMemberRequest(messageId, approve, comment) {
+        await this.internal.setGroupAddRequest(messageId, "add", approve, comment);
+    }
+    async deleteFriend(userId) {
+        await this.internal.deleteFriend(userId);
+    }
+    async getMessageList(channelId, before, direction = "before") {
+        if (direction !== "before")
+            throw new Error("Unsupported direction.");
+        // include `before` message
+        let list;
+        if (before) {
+            const msg = await this.internal.getMsg(before);
+            if (msg?.message_seq) {
+                list = (await this.internal.getGroupMsgHistory(Number(channelId), msg.message_seq)).messages;
+            }
+        }
+        else {
+            list = (await this.internal.getGroupMsgHistory(Number(channelId))).messages;
+        }
+        // 从旧到新
+        return { data: await Promise.all(list.map((item) => OneBot.adaptMessage(this, item))) };
+    }
+}
+(function (BaseBot) {
+    BaseBot.AdvancedConfig = Schema.object({
+        splitMixedContent: Schema.boolean().description("是否自动在混合内容间插入空格。").default(true)
+    }).description("高级设置");
+})(BaseBot || (BaseBot = {}));

package/lib/bot/cqcode.d.ts

@@ -0,0 +1,13 @@
+import { Dict, h } from "koishi";
+export declare function CQCode(type: string, attrs: Dict<string>): string;
+export interface CQCode {
+    type: string;
+    data: Dict<string>;
+    capture?: RegExpExecArray;
+}
+export declare namespace CQCode {
+    function escape(source: any, inline?: boolean): string;
+    function unescape(source: string): string;
+    function from(source: string): CQCode;
+    function parse(source: string | CQCode[]): h[];
+}

package/lib/bot/cqcode.js

@@ -0,0 +1,60 @@
+import { h } from "koishi";
+export function CQCode(type, attrs) {
+    if (type === "text")
+        return attrs.content;
+    let output = "[CQ:" + type;
+    for (const key in attrs) {
+        if (attrs[key])
+            output += `,${key}=${h.escape(attrs[key], true)}`;
+    }
+    return output + "]";
+}
+(function (CQCode) {
+    const ESCAPE_MAP = { "&": "&", "[": "[", "]": "]" };
+    const UNESCAPE_MAP = Object.fromEntries(Object.entries(ESCAPE_MAP).map(([k, v]) => [v, k]));
+    function escape(source, inline = false) {
+        let result = String(source).replace(/[&[\]]/g, (m) => ESCAPE_MAP[m]);
+        if (inline) {
+            result = result.replace(/,/g, ",");
+            result = result.replace(/(\ud83c[\udf00-\udfff])|(\ud83d[\udc00-\ude4f\ude80-\udeff])|[\u2600-\u2B55]/g, " ");
+        }
+        return result;
+    }
+    CQCode.escape = escape;
+    function unescape(source) {
+        return String(source).replace(/[|]|,|&/g, (m) => UNESCAPE_MAP[m] ?? m);
+    }
+    CQCode.unescape = unescape;
+    const pattern = /\[CQ:(\w+)((,\w+=[^,\]]*)*)\]/;
+    function from(source) {
+        const capture = pattern.exec(source);
+        if (!capture)
+            return null;
+        const [, type, attrs] = capture;
+        const data = Object.fromEntries((attrs?.slice(1).split(",") || []).map((str) => {
+            const index = str.indexOf("=");
+            return [str.slice(0, index), unescape(str.slice(index + 1))];
+        }));
+        return { type, data, capture };
+    }
+    CQCode.from = from;
+    function parse(source) {
+        if (typeof source !== "string") {
+            return source.map(({ type, data }) => h(type === "text" ? "text" : type, type === "text" ? { content: data.text } : data));
+        }
+        const elements = [];
+        let result;
+        while ((result = from(source))) {
+            const { type, data, capture } = result;
+            if (capture.index) {
+                elements.push(h("text", { content: unescape(source.slice(0, capture.index)) }));
+            }
+            elements.push(h(type, data));
+            source = source.slice(capture.index + capture[0].length);
+        }
+        if (source)
+            elements.push(h("text", { content: unescape(source) }));
+        return elements;
+    }
+    CQCode.parse = parse;
+})(CQCode || (CQCode = {}));

package/lib/bot/index.d.ts

@@ -0,0 +1,42 @@
+import { Context, Schema, Session } from "koishi";
+import { HttpServer } from "../http";
+import { WsClient, WsServer } from "../ws";
+import { BaseBot } from "./base";
+import { QQGuildBot } from "./qqguild";
+export * from "./base";
+export * from "./cqcode";
+export * from "./message";
+export * from "./qqguild";
+export declare class OneBotBot<C extends Context, T extends OneBotBot.Config = OneBotBot.Config> extends BaseBot<C, T> {
+    guildBot: QQGuildBot<C>;
+    constructor(ctx: C, config: T);
+    stop(): Promise<void>;
+    initialize(): Promise<void>;
+    setupGuildService(): Promise<void>;
+    getChannel(channelId: string): Promise<import("@satorijs/protocol").Channel>;
+    getGuild(guildId: string): Promise<import("@satorijs/protocol").Guild>;
+    getGuildList(): Promise<{
+        data: import("@satorijs/protocol").Guild[];
+    }>;
+    getChannelList(guildId: string): Promise<{
+        data: import("@satorijs/protocol").Channel[];
+    }>;
+    getGuildMember(guildId: string, userId: string): Promise<import("@satorijs/protocol").GuildMember>;
+    getGuildMemberList(guildId: string): Promise<{
+        data: import("@satorijs/protocol").GuildMember[];
+    }>;
+    kickGuildMember(guildId: string, userId: string, permanent?: boolean): Promise<void>;
+    muteGuildMember(guildId: string, userId: string, duration: number): Promise<void>;
+    muteChannel(channelId: string, guildId?: string, enable?: boolean): Promise<void>;
+    checkPermission(name: string, session: Partial<Session>): Promise<boolean>;
+}
+export declare namespace OneBotBot {
+    interface BaseConfig extends BaseBot.Config {
+        selfId: string;
+        password?: string;
+        token?: string;
+    }
+    const BaseConfig: Schema<BaseConfig>;
+    type Config = BaseConfig & (HttpServer.Options | WsServer.Options | WsClient.Options);
+    const Config: Schema<Config>;
+}

package/lib/bot/index.js

@@ -0,0 +1,108 @@
+import { noop, Schema } from "koishi";
+import { HttpServer } from "../http";
+import * as OneBot from "../utils";
+import { WsClient, WsServer } from "../ws";
+import { BaseBot } from "./base";
+import { QQGuildBot } from "./qqguild";
+export * from "./base";
+export * from "./cqcode";
+export * from "./message";
+export * from "./qqguild";
+export class OneBotBot extends BaseBot {
+    guildBot;
+    constructor(ctx, config) {
+        super(ctx, config, "onebot");
+        this.selfId = config.selfId;
+        this.internal = new OneBot.Internal(this);
+        this.user.avatar = `http://q.qlogo.cn/headimg_dl?dst_uin=${config.selfId}&spec=640`;
+        if (config.protocol === "http") {
+            ctx.plugin(HttpServer, this);
+        }
+        else if (config.protocol === "ws") {
+            ctx.plugin(WsClient, this);
+        }
+        else if (config.protocol === "ws-reverse") {
+            ctx.plugin(WsServer, this);
+        }
+    }
+    async stop() {
+        if (this.guildBot) {
+            // QQGuild stub bot should also be removed
+            delete this.ctx.bots[this.guildBot.sid];
+        }
+        await super.stop();
+    }
+    async initialize() {
+        await Promise.all([this.getLogin(), this.setupGuildService().catch(noop)]).then(() => this.online(), (error) => this.offline(error));
+    }
+    async setupGuildService() {
+        const profile = await this.internal.getGuildServiceProfile();
+        // guild service is not supported in this account
+        if (!profile?.tiny_id || profile.tiny_id === "0")
+            return;
+        this.ctx.plugin(QQGuildBot, {
+            profile,
+            parent: this,
+            advanced: this.config.advanced
+        });
+    }
+    async getChannel(channelId) {
+        const data = await this.internal.getGroupInfo(channelId);
+        return OneBot.adaptChannel(data);
+    }
+    async getGuild(guildId) {
+        const data = await this.internal.getGroupInfo(guildId);
+        return OneBot.adaptGuild(data);
+    }
+    async getGuildList() {
+        const data = await this.internal.getGroupList();
+        return { data: data.map(OneBot.adaptGuild) };
+    }
+    async getChannelList(guildId) {
+        return { data: [await this.getChannel(guildId)] };
+    }
+    async getGuildMember(guildId, userId) {
+        const data = await this.internal.getGroupMemberInfo(guildId, userId);
+        return OneBot.decodeGuildMember(data);
+    }
+    async getGuildMemberList(guildId) {
+        const data = await this.internal.getGroupMemberList(guildId);
+        return { data: data.map(OneBot.decodeGuildMember) };
+    }
+    async kickGuildMember(guildId, userId, permanent) {
+        return this.internal.setGroupKick(guildId, userId, permanent);
+    }
+    async muteGuildMember(guildId, userId, duration) {
+        return this.internal.setGroupBan(guildId, userId, Math.round(duration / 1000));
+    }
+    async muteChannel(channelId, guildId, enable) {
+        return this.internal.setGroupWholeBan(channelId, enable);
+    }
+    async checkPermission(name, session) {
+        if (name === "onebot.group.admin") {
+            return session.author?.roles?.[0] === "admin";
+        }
+        else if (name === "onebot.group.owner") {
+            return session.author?.roles?.[0] === "owner";
+        }
+        return super.checkPermission(name, session);
+    }
+}
+(function (OneBotBot) {
+    OneBotBot.BaseConfig = Schema.object({
+        selfId: Schema.string().description("机器人的账号。").required(),
+        token: Schema.string()
+            .role("secret")
+            .description("发送信息时用于验证的字段，应与 OneBot 配置文件中的 `access_token` 保持一致。"),
+        protocol: process.env.KOISHI_ENV === "browser"
+            ? Schema.const("ws").default("ws")
+            : Schema.union(["http", "ws", "ws-reverse"]).description("选择要使用的协议。").default("ws-reverse")
+    });
+    OneBotBot.Config = Schema.intersect([
+        OneBotBot.BaseConfig,
+        Schema.union([HttpServer.Options, WsClient.Options, WsServer.Options]),
+        Schema.object({
+            advanced: BaseBot.AdvancedConfig
+        })
+    ]);
+})(OneBotBot || (OneBotBot = {}));

package/lib/bot/message.d.ts

@@ -0,0 +1,25 @@
+import { Context, h, MessageEncoder, Universal } from "koishi";
+import { BaseBot } from "./base";
+import { CQCode } from "./cqcode";
+export interface Author extends Universal.User {
+    time?: string | number;
+    messageId?: string;
+}
+declare class State {
+    type: "message" | "forward" | "reply";
+    author: Partial<Author>;
+    children: CQCode[];
+    constructor(type: "message" | "forward" | "reply");
+}
+export declare const PRIVATE_PFX = "private:";
+export declare class OneBotMessageEncoder<C extends Context = Context> extends MessageEncoder<C, BaseBot<C>> {
+    stack: State[];
+    children: CQCode[];
+    prepare(): Promise<void>;
+    forward(): Promise<void>;
+    flush(): Promise<void>;
+    private sendFile;
+    private text;
+    visit(element: h): Promise<void>;
+}
+export {};

package/lib/bot/message.js

@@ -0,0 +1,281 @@
+import { MessageEncoder, pick } from "koishi";
+import { fileURLToPath } from "node:url";
+class State {
+    type;
+    author = {};
+    children = [];
+    constructor(type) {
+        this.type = type;
+    }
+}
+export const PRIVATE_PFX = "private:";
+export class OneBotMessageEncoder extends MessageEncoder {
+    stack = [new State("message")];
+    children = [];
+    async prepare() {
+        super.prepare();
+        const { event: { channel } } = this.session;
+        if (!channel.type) {
+            channel.type = channel.id.startsWith(PRIVATE_PFX)
+                ? 1 /* Universal.Channel.Type.DIRECT */
+                : 0 /* Universal.Channel.Type.TEXT */;
+        }
+        if (!this.session.isDirect) {
+            this.session.guildId ??= this.channelId;
+        }
+    }
+    async forward() {
+        if (!this.stack[0].children.length)
+            return;
+        const session = this.bot.session();
+        session.content = "";
+        session.messageId =
+            this.session.event.channel.type === 1 /* Universal.Channel.Type.DIRECT */
+                ? "" +
+                    (await this.bot.internal.sendPrivateForwardMsg(this.channelId.slice(PRIVATE_PFX.length), this.stack[0].children))
+                : "" + (await this.bot.internal.sendGroupForwardMsg(this.channelId, this.stack[0].children));
+        session.userId = this.bot.selfId;
+        session.channelId = this.session.channelId;
+        session.guildId = this.session.guildId;
+        session.isDirect = this.session.isDirect;
+        session.app.emit(session, "send", session);
+        this.results.push(session.event.message);
+    }
+    async flush() {
+        // trim start
+        while (true) {
+            const first = this.children[0];
+            if (first?.type !== "text")
+                break;
+            first.data.text = first.data.text.trimStart();
+            if (first.data.text)
+                break;
+            this.children.shift();
+        }
+        // trim end
+        while (true) {
+            const last = this.children[this.children.length - 1];
+            if (last?.type !== "text")
+                break;
+            last.data.text = last.data.text.trimEnd();
+            if (last.data.text)
+                break;
+            this.children.pop();
+        }
+        // flush
+        const { type, author } = this.stack[0];
+        if (!this.children.length && !author.messageId)
+            return;
+        if (type === "forward") {
+            if (author.messageId) {
+                this.stack[1].children.push({
+                    type: "node",
+                    data: {
+                        id: author.messageId
+                    }
+                });
+            }
+            else {
+                this.stack[1].children.push({
+                    type: "node",
+                    data: {
+                        name: author.name || this.bot.user.name,
+                        uin: author.id || this.bot.userId,
+                        content: String(this.children),
+                        time: `${Math.floor((+author.time || Date.now()) / 1000)}`
+                    }
+                });
+            }
+            this.children = [];
+            return;
+        }
+        const session = this.bot.session();
+        session.content = "";
+        session.messageId = this.bot.parent
+            ? "" + (await this.bot.internal.sendGuildChannelMsg(this.session.guildId, this.channelId, this.children))
+            : this.session.event.channel.type === 1 /* Universal.Channel.Type.DIRECT */
+                ? "" + (await this.bot.internal.sendPrivateMsg(this.channelId.slice(PRIVATE_PFX.length), this.children))
+                : "" + (await this.bot.internal.sendGroupMsg(this.channelId, this.children));
+        session.userId = this.bot.selfId;
+        session.channelId = this.session.channelId;
+        session.guildId = this.session.guildId;
+        session.isDirect = this.session.isDirect;
+        session.app.emit(session, "send", session);
+        this.results.push(session.event.message);
+        this.children = [];
+    }
+    async sendFile(attrs) {
+        const src = attrs.src || attrs.url;
+        const name = attrs.title || (await this.bot.ctx.http.file(src)).filename;
+        // 本地文件路径
+        const file = src.startsWith("file:") ? fileURLToPath(src) : await this.bot.internal.downloadFile(src);
+        if (this.session.event.channel.type === 1 /* Universal.Channel.Type.DIRECT */) {
+            await this.bot.internal.uploadPrivateFile(this.channelId.slice(PRIVATE_PFX.length), file, name);
+        }
+        else {
+            await this.bot.internal.uploadGroupFile(this.channelId, file, name);
+        }
+        const session = this.bot.session();
+        // 相关 API 没有返回 message_id
+        session.messageId = "";
+        session.content = "";
+        session.userId = this.bot.selfId;
+        session.channelId = this.session.channelId;
+        session.guildId = this.session.guildId;
+        session.isDirect = this.session.isDirect;
+        session.app.emit(session, "send", session);
+        this.results.push(session.event.message);
+    }
+    text(text) {
+        this.children.push({ type: "text", data: { text } });
+    }
+    async visit(element) {
+        let { type, attrs, children } = element;
+        if (type === "text") {
+            this.text(attrs.content);
+        }
+        else if (type === "br") {
+            this.text("\n");
+        }
+        else if (type === "p") {
+            const prev = this.children[this.children.length - 1];
+            if (prev?.type === "text") {
+                if (!prev.data.text.endsWith("\n")) {
+                    prev.data.text += "\n";
+                }
+            }
+            else {
+                this.text("\n");
+            }
+            await this.render(children);
+            this.text("\n");
+        }
+        else if (type === "at") {
+            if (attrs.type === "all") {
+                this.children.push({ type: "at", data: { qq: "all" } });
+            }
+            else {
+                this.children.push({ type: "at", data: { qq: attrs.id, name: attrs.name } });
+            }
+        }
+        else if (type === "sharp") {
+            if (attrs.id)
+                this.text(attrs.id);
+        }
+        else if (type === "face") {
+            if (attrs.platform && attrs.platform !== this.bot.platform) {
+                await this.render(children);
+            }
+            else {
+                this.children.push({ type: "face", data: { id: attrs.id } });
+            }
+        }
+        else if (type === "a") {
+            await this.render(children);
+            // https://github.com/koishijs/koishi-plugin-adapter-onebot/issues/23
+            if (attrs.href)
+                this.text(`（${attrs.href}）`);
+        }
+        else if (["video", "audio", "image", "img"].includes(type)) {
+            if (type === "video" || type === "audio")
+                await this.flush();
+            if (type === "audio")
+                type = "record";
+            if (type === "img")
+                type = "image";
+            attrs = { ...attrs };
+            attrs.file = attrs.src || attrs.url;
+            delete attrs.src;
+            delete attrs.url;
+            if (attrs.cache) {
+                attrs.cache = 1;
+            }
+            else {
+                attrs.cache = 0;
+            }
+            // https://github.com/koishijs/koishi-plugin-adapter-onebot/issues/30
+            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
+            const cap = /^data:([\w/.+-]+);base64,/.exec(attrs.file);
+            if (cap)
+                attrs.file = "base64://" + attrs.file.slice(cap[0].length);
+            this.children.push({ type, data: attrs });
+        }
+        else if (type === "file") {
+            await this.flush();
+            await this.sendFile(attrs);
+        }
+        else if (type === "onebot:music") {
+            await this.flush();
+            this.children.push({ type: "music", data: attrs });
+        }
+        else if (type === "onebot:tts") {
+            await this.flush();
+            this.children.push({ type: "tts", data: attrs });
+        }
+        else if (type === "onebot:poke") {
+            await this.flush();
+            this.children.push({ type: "poke", data: attrs });
+        }
+        else if (type === "onebot:gift") {
+            await this.flush();
+            this.children.push({ type: "gift", data: attrs });
+        }
+        else if (type === "onebot:share") {
+            await this.flush();
+            this.children.push({ type: "share", data: attrs });
+        }
+        else if (type === "onebot:json") {
+            await this.flush();
+            this.children.push({ type: "json", data: attrs });
+        }
+        else if (type === "onebot:xml") {
+            await this.flush();
+            this.children.push({ type: "xml", data: attrs });
+        }
+        else if (type === "onebot:cardimage") {
+            await this.flush();
+            this.children.push({ type: "cardimage", data: attrs });
+        }
+        else if (type === "author") {
+            Object.assign(this.stack[0].author, attrs);
+        }
+        else if (type === "figure" && !this.bot.parent) {
+            await this.flush();
+            this.stack.unshift(new State("forward"));
+            await this.render(children);
+            await this.flush();
+            this.stack.shift();
+            await this.forward();
+        }
+        else if (type === "figure") {
+            await this.render(children);
+            await this.flush();
+        }
+        else if (type === "quote") {
+            await this.flush();
+            this.children.push({ type: "reply", data: attrs });
+        }
+        else if (type === "message") {
+            await this.flush();
+            // qqguild does not support forward messages
+            if ("forward" in attrs && !this.bot.parent) {
+                this.stack.unshift(new State("forward"));
+                await this.render(children);
+                await this.flush();
+                this.stack.shift();
+                await this.forward();
+            }
+            else if ("id" in attrs) {
+                this.stack[0].author.messageId = attrs.id.toString();
+            }
+            else {
+                Object.assign(this.stack[0].author, pick(attrs, ["userId", "username", "nickname", "time"]));
+                await this.render(children);
+                await this.flush();
+            }
+        }
+        else {
+            await this.render(children);
+        }
+    }
+}