alemonjs 2.1.17 → 2.1.19

package/lib/app/SinglyLinkedList.d.ts

@@ -5,6 +5,7 @@ declare class ListNode<T> {
 }
 export declare class SinglyLinkedList<T> {
     private head;
+    private tail;
     private size;
     private current;
     constructor(initialValues?: T[]);

package/lib/app/SinglyLinkedList.js

@@ -8,10 +8,12 @@ class ListNode {
 }
 class SinglyLinkedList {
     head;
+    tail;
     size;
     current;
     constructor(initialValues) {
         this.head = null;
+        this.tail = null;
         this.size = 0;
         this.current = null;
         if (initialValues) {
@@ -22,13 +24,11 @@ class SinglyLinkedList {
         const newNode = new ListNode(data);
         if (!this.head) {
             this.head = newNode;
+            this.tail = newNode;
         }
         else {
-            let current = this.head;
-            while (current.next) {
-                current = current.next;
-            }
-            current.next = newNode;
+            this.tail.next = newNode;
+            this.tail = newNode;
         }
         this.size++;
     }
@@ -42,11 +42,14 @@ class SinglyLinkedList {
         return this.current;
     }
     removeCurrent() {
-        if (!this.head) {
+        if (!this.head || !this.current) {
             return;
         }
         if (this.current === this.head) {
             this.head = this.head.next;
+            if (!this.head) {
+                this.tail = null;
+            }
             this.current = null;
             this.size--;
             return;
@@ -57,6 +60,9 @@ class SinglyLinkedList {
         }
         if (previous && this.current) {
             previous.next = this.current.next;
+            if (this.current === this.tail) {
+                this.tail = previous;
+            }
             this.current = null;
             this.size--;
         }

package/lib/app/define-platform.d.ts

@@ -1,5 +1,6 @@
 type Options = {
     main: () => any;
+    name?: string;
 };
 export declare const definePlatform: (options: Options) => () => any;
 export {};

package/lib/app/define-platform.js

@@ -1,13 +1,14 @@
 const definePlatform = (options) => {
+    const platformName = options.name || process.env.platform || 'unknown';
     const mainProcess = () => {
         ['SIGINT', 'SIGTERM', 'SIGQUIT', 'disconnect'].forEach(sig => {
             process?.on?.(sig, () => {
-                logger.info?.(`[@alemonjs/qq-bot][${sig}] 收到信号，正在关闭...`);
+                logger.info?.(`[${platformName}][${sig}] 收到信号，正在关闭...`);
                 setImmediate(() => process.exit(0));
             });
         });
         process?.on?.('exit', code => {
-            logger.info?.(`[@alemonjs/qq-bot][exit] 进程退出，code=${code}`);
+            logger.info?.(`[${platformName}][exit] 进程退出，code=${code}`);
         });
         process.on('message', msg => {
             try {

package/lib/app/define-response.d.ts

@@ -1,5 +1,2 @@
 import { DefineResponseFunc } from '../types';
-export declare const lazy: <T extends {
-    default: any;
-}>(fnc: () => Promise<T>) => (() => Promise<T["default"]>);
 export declare const defineResponse: DefineResponseFunc;

package/lib/app/define-response.js

@@ -1,7 +1,3 @@
-const lazy = (fnc) => {
-    const back = async () => (await fnc()).default;
-    return back;
-};
 const defineResponse = responses => {
     return {
         current: responses
@@ -9,4 +5,4 @@ const defineResponse = responses => {
 };
 global.defineResponse = defineResponse;
 
-export { defineResponse, lazy };
+export { defineResponse };

package/lib/app/define-router.d.ts

@@ -0,0 +1,5 @@
+import { DefineRouterFunc } from '../types';
+export declare const lazy: <T extends {
+    default: any;
+}>(fnc: () => Promise<T>) => (() => Promise<T["default"]>);
+export declare const defineRouter: DefineRouterFunc;

package/lib/app/define-router.js

@@ -0,0 +1,21 @@
+const lazy = (fnc) => {
+    let c = null;
+    const back = async () => {
+        if (c) {
+            return c;
+        }
+        const mod = await fnc();
+        console.warn('Lazy load module:', mod);
+        if (!mod || !mod.default) ;
+        c = mod.default;
+        return c;
+    };
+    return back;
+};
+const defineRouter = routes => {
+    return {
+        current: routes
+    };
+};
+
+export { defineRouter, lazy };

package/lib/app/event-processor-callHandler.js

@@ -1,4 +1,3 @@
-import { isAsyncFunction } from 'util/types';
 import 'fs';
 import 'path';
 import 'yaml';
@@ -42,20 +41,11 @@ const createCallHandler = valueEvent => {
                 return;
             }
             try {
-                if (isAsyncFunction(currents[index])) {
-                    const res = await currents[index](valueEvent, (...cns) => {
-                        isNext = true;
-                        nextEvent(...cns);
-                    });
-                    onRes(res);
-                }
-                else {
-                    const res = currents[index](valueEvent, (...cns) => {
-                        isNext = true;
-                        nextEvent(...cns);
-                    });
-                    onRes(res);
-                }
+                const res = await currents[index](valueEvent, (...cns) => {
+                    isNext = true;
+                    nextEvent(...cns);
+                });
+                onRes(res);
             }
             catch (err) {
                 showErrorModule(err);

package/lib/app/event-processor-cycleFiles.d.ts

@@ -1,2 +1,3 @@
 import { Next, Events, EventKeys, StoreResponseItem } from '../types';
+export declare const clearModuleCache: (path?: string) => void;
 export declare const createNextStep: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next, files: StoreResponseItem[], callHandler: (currents: any, nextEvent: any) => void) => Next;

package/lib/app/event-processor-cycleFiles.js

@@ -3,9 +3,26 @@ import { showErrorModule } from '../core/utils.js';
 import { EventMessageText } from '../core/variable.js';
 import { ResponseMiddleware } from './store.js';
 
+const moduleCache = new Map();
+const clearModuleCache = (path) => {
+    if (path) {
+        moduleCache.delete(path);
+    }
+    else {
+        moduleCache.clear();
+    }
+};
+const loadModule = async (filePath) => {
+    if (moduleCache.has(filePath)) {
+        return moduleCache.get(filePath);
+    }
+    const mod = await import(`file://${filePath}`);
+    moduleCache.set(filePath, mod);
+    return mod;
+};
 const callHandlerFile = async (valueEvent, select, file, nextStep, callback) => {
     try {
-        const app = await import(`file://${file.path}`);
+        const app = await loadModule(file.path);
         if (!app?.default?.current || !app?.default?.select) {
             nextStep();
             return;
@@ -88,4 +105,4 @@ const createNextStep = (valueEvent, select, next, files, callHandler) => {
     return nextStep;
 };
 
-export { createNextStep };
+export { clearModuleCache, createNextStep };

package/lib/app/event-processor-cycleRoute.js

@@ -1,10 +1,16 @@
-import { isAsyncFunction } from 'util/types';
 import { EventMessageText } from '../core/variable.js';
 import 'fs';
 import 'path';
 import 'yaml';
 import { showErrorModule } from '../core/utils.js';
 
+function isPromise(value) {
+    return value !== null && (typeof value === 'object' || typeof value === 'function') && typeof value.then === 'function';
+}
+function isAsyncFunction(fn) {
+    const AsyncFunction = (async () => { }).constructor;
+    return fn instanceof AsyncFunction;
+}
 const createRouteProcessChildren = (valueEvent, select, nextCycle, callHandler) => {
     const processChildren = (nodes, middleware, next) => {
         if (!nodes || nodes.length === 0) {
@@ -26,11 +32,26 @@ const createRouteProcessChildren = (valueEvent, select, nextCycle, callHandler)
                     return;
                 }
             }
-            if (EventMessageText.includes(select) && node.regular) {
-                const reg = new RegExp(node.regular);
-                if (!reg.test(valueEvent['MessageText'])) {
-                    void nextNode();
-                    return;
+            if (EventMessageText.includes(select)) {
+                const text = valueEvent['MessageText'] ?? '';
+                if (node.exact !== undefined) {
+                    if (text !== node.exact) {
+                        void nextNode();
+                        return;
+                    }
+                }
+                if (node.prefix !== undefined) {
+                    if (!text.startsWith(node.prefix)) {
+                        void nextNode();
+                        return;
+                    }
+                }
+                if (node.regular) {
+                    const reg = new RegExp(node.regular);
+                    if (!reg.test(text)) {
+                        void nextNode();
+                        return;
+                    }
                 }
             }
             if (!node.handler) {
@@ -45,7 +66,11 @@ const createRouteProcessChildren = (valueEvent, select, nextCycle, callHandler)
             try {
                 const currents = [];
                 for (const item of currentsAndMiddleware) {
-                    const app = isAsyncFunction(item) ? await item() : item();
+                    const app = await item();
+                    if (isPromise(app) || isAsyncFunction(app)) {
+                        currents.push(app);
+                        continue;
+                    }
                     const selects = Array.isArray(app.select) ? app.select : [app.select];
                     if (!selects.includes(select)) {
                         void nextNode();

package/lib/app/event-processor-event.js

@@ -3,13 +3,13 @@ import { createCallHandler } from './event-processor-callHandler.js';
 import { createNextStep } from './event-processor-cycleFiles.js';
 import { createRouteProcessChildren } from './event-processor-cycleRoute.js';
 
+const responseSingleton = new Response();
+const responseRouterSingleton = new ResponseRouter();
 const expendEvent = (valueEvent, select, next) => {
-    const res = new Response();
-    const StoreResponse = res.value;
+    const StoreResponse = responseSingleton.value;
     const callHandler = createCallHandler(valueEvent);
     const nextEvent = createNextStep(valueEvent, select, next, StoreResponse, callHandler);
-    const resRoute = new ResponseRouter();
-    const routes = resRoute.value;
+    const routes = responseRouterSingleton.value;
     const callRouteHandler = createCallHandler(valueEvent);
     const processChildren = createRouteProcessChildren(valueEvent, select, nextEvent, callRouteHandler);
     void processChildren(routes, [], nextEvent);

package/lib/app/event-processor-middleware.js

@@ -3,13 +3,13 @@ import { createCallHandler } from './event-processor-callHandler.js';
 import { createNextStep } from './event-processor-cycleFiles.js';
 import { createRouteProcessChildren } from './event-processor-cycleRoute.js';
 
+const middlewareSingleton = new Middleware();
+const middlewareRouterSingleton = new MiddlewareRouter();
 const expendMiddleware = (valueEvent, select, next) => {
-    const mw = new Middleware();
-    const mwFiles = mw.value;
+    const mwFiles = middlewareSingleton.value;
     const callHandler = createCallHandler(valueEvent);
     const nextMiddleware = createNextStep(valueEvent, select, next, mwFiles, callHandler);
-    const resRoute = new MiddlewareRouter();
-    const routes = resRoute.value;
+    const routes = middlewareRouterSingleton.value;
     const callRouteHandler = createCallHandler(valueEvent);
     const processChildren = createRouteProcessChildren(valueEvent, select, nextMiddleware, callRouteHandler);
     void processChildren(routes, [], nextMiddleware);

package/lib/app/event-processor.js

@@ -1,7 +1,7 @@
 import { getConfigValue } from '../core/config.js';
-import { processorRepeatedClearTimeMin, processorRepeatedClearTimeMax, processorRepeatedEventTime, processorRepeatedUserTime, processorPepeatedClearSize } from '../core/variable.js';
+import { processorRepeatedClearTimeMin, processorRepeatedClearTimeMax, processorRepeatedEventTime, processorRepeatedUserTime, processorRepeatedClearSize, processorMaxMapSize } from '../core/variable.js';
 import { expendCycle } from './event-processor-cycle.js';
-import { ProcessorEventAutoClearMap, ProcessorEventUserAudoClearMap } from './store.js';
+import { ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap } from './store.js';
 import { createHash } from '../core/utils.js';
 
 const filter = ({ Now, store, INTERVAL }, MessageId) => {
@@ -12,6 +12,15 @@ const filter = ({ Now, store, INTERVAL }, MessageId) => {
             return true;
         }
     }
+    if (store.size >= processorMaxMapSize) {
+        cleanupStore({ Now, store, INTERVAL });
+        if (store.size >= processorMaxMapSize) {
+            const firstKey = store.keys().next().value;
+            if (firstKey !== undefined) {
+                store.delete(firstKey);
+            }
+        }
+    }
     store.set(MessageId, Date.now());
 };
 const cleanupStore = ({ Now, store, INTERVAL }) => {
@@ -27,12 +36,12 @@ const cleanupStoreAll = () => {
     const EVENT_INTERVAL = value?.processor?.repeated_event_time ?? processorRepeatedEventTime;
     const USER_INTERVAL = value?.processor?.repeated_user_time ?? processorRepeatedUserTime;
     cleanupStore({ Now, INTERVAL: EVENT_INTERVAL, store: ProcessorEventAutoClearMap });
-    cleanupStore({ Now, INTERVAL: USER_INTERVAL, store: ProcessorEventUserAudoClearMap });
+    cleanupStore({ Now, INTERVAL: USER_INTERVAL, store: ProcessorEventUserAutoClearMap });
 };
 const callback = () => {
     cleanupStoreAll();
-    const length = ProcessorEventAutoClearMap.size + ProcessorEventUserAudoClearMap.size;
-    const time = length > processorPepeatedClearSize ? processorRepeatedClearTimeMin : processorRepeatedClearTimeMax;
+    const length = ProcessorEventAutoClearMap.size + ProcessorEventUserAutoClearMap.size;
+    const time = length > processorRepeatedClearSize ? processorRepeatedClearTimeMin : processorRepeatedClearTimeMax;
     setTimeout(callback, time);
 };
 setTimeout(callback, processorRepeatedClearTimeMin);
@@ -103,7 +112,7 @@ const onProcessor = (name, event, data) => {
     const USER_INTERVAL = value?.processor?.repeated_user_time ?? processorRepeatedUserTime;
     if (event['UserId']) {
         const UserId = createHash(event['UserId']);
-        if (filter({ Now, INTERVAL: USER_INTERVAL, store: ProcessorEventUserAudoClearMap }, UserId)) {
+        if (filter({ Now, INTERVAL: USER_INTERVAL, store: ProcessorEventUserAutoClearMap }, UserId)) {
             return;
         }
     }

package/lib/app/hook-use-api.d.ts

@@ -1,6 +1,6 @@
 import { DataEnums, EventKeys, Events, User } from '../types';
 import { Result } from '../core/utils';
-import { BT, MD } from './message-format';
+import { BT, Format, MD } from './message-format';
 type Options = {
     UserId?: string;
     UserKey?: string;
@@ -9,11 +9,15 @@ type Options = {
     IsBot?: boolean;
 };
 export declare const useMention: <T extends EventKeys>(event: Events[T]) => [{
-    find: (options: Options) => Promise<Result<User[]>>;
-    findOne: (options?: Options) => Promise<Result<User | null>>;
+    find: (options?: Options) => Promise<Result<User[]> & {
+        count: number;
+    }>;
+    findOne: (options?: Options) => Promise<Result<User | null> & {
+        count: number;
+    }>;
 }];
 export declare const useMessage: <T extends EventKeys>(event: Events[T]) => readonly [{
-    "__#7@#format": DataEnums[];
+    "__#8@#format": DataEnums[];
     readonly currentFormat: DataEnums[];
     addText(val: string, options?: {
         style?: "none" | "bold" | "block" | "strikethrough" | "boldItalic" | "italic";
@@ -36,12 +40,16 @@ export declare const useMessage: <T extends EventKeys>(event: Events[T]) => read
     }): any;
     addFormat(val: DataEnums[]): any;
     clear(): any;
-    send(val?: DataEnums[]): Promise<Result[]>;
+    send(params?: {
+        format: Format | DataEnums[];
+    } | DataEnums[]): Promise<Result[]>;
 }];
 export declare const useMember: <T extends EventKeys>(event: Events[T]) => readonly [{}];
 export declare const useChannel: <T extends EventKeys>(event: Events[T]) => readonly [{}];
 export declare const useSend: <T extends EventKeys>(event: Events[T]) => (...val: DataEnums[]) => Promise<Result[]>;
-export declare const useSends: <T extends EventKeys>(event: Events[T]) => readonly [(val?: DataEnums[]) => Promise<Result[]>];
+export declare const useSends: <T extends EventKeys>(event: Events[T]) => readonly [(params?: DataEnums[] | {
+    format: Format | DataEnums[];
+}) => Promise<Result[]>];
 export declare const unChildren: (name?: string) => void;
 export declare const onSelects: <T extends EventKeys[] | EventKeys>(values: T) => T;
 export declare const createSelects: <T extends EventKeys[] | EventKeys>(values: T) => T;

package/lib/app/hook-use-api.js

@@ -3,7 +3,7 @@ import { ChildrenApp } from './store.js';
 import { createResult } from '../core/utils.js';
 import { sendAction } from '../cbp/processor/actions.js';
 import { sendAPI } from '../cbp/processor/api.js';
-import { Text, Link, Image, ImageFile, ImageURL, Mention, BT, MD } from './message-format.js';
+import { Text, Link, Image, ImageFile, ImageURL, Mention, BT, MD, Format } from './message-format.js';
 
 const useMention = (event) => {
     if (!event || typeof event !== 'object') {
@@ -15,94 +15,80 @@ const useMention = (event) => {
         throw new Error('Invalid event: event must be an object');
     }
     let res = null;
+    const load = async () => {
+        if (res) {
+            return;
+        }
+        const results = await sendAction({
+            action: 'mention.get',
+            payload: { event }
+        });
+        const result = results.find(item => item.code === ResultCode.Ok);
+        if (result) {
+            res = result.data;
+        }
+    };
+    const match = (item, options) => {
+        if (options.UserId !== undefined && item.UserId !== options.UserId) {
+            return false;
+        }
+        if (options.UserKey !== undefined && item.UserKey !== options.UserKey) {
+            return false;
+        }
+        if (options.UserName !== undefined && item.UserName !== options.UserName) {
+            return false;
+        }
+        if (options.IsMaster !== undefined && item.IsMaster !== options.IsMaster) {
+            return false;
+        }
+        if (options.IsBot !== undefined && item.IsBot !== options.IsBot) {
+            return false;
+        }
+        if (options.IsBot === undefined && item.IsBot) {
+            return false;
+        }
+        return true;
+    };
     const mention = {
         find: async (options = {}) => {
             try {
-                if (!res) {
-                    const results = await sendAction({
-                        action: 'mention.get',
-                        payload: {
-                            event
-                        }
-                    });
-                    const result = results.find(item => item.code === ResultCode.Ok);
-                    if (result) {
-                        res = result.data;
-                    }
-                }
+                await load();
             }
             catch (err) {
-                return createResult(ResultCode.Fail, err?.message || 'Failed to get mention data', null);
+                const result = createResult(ResultCode.Fail, err?.message || 'Failed to get mention data', null);
+                return {
+                    ...result,
+                    count: 0
+                };
             }
             if (!Array.isArray(res)) {
-                return createResult(ResultCode.Warn, 'No mention data found', null);
+                return {
+                    ...createResult(ResultCode.Warn, 'No mention data found', null),
+                    count: 0
+                };
             }
-            const data = res.filter(item => {
-                if (options.UserId !== undefined && item.UserId !== options.UserId) {
-                    return false;
-                }
-                if (options.UserKey !== undefined && item.UserKey !== options.UserKey) {
-                    return false;
-                }
-                if (options.UserName !== undefined && item.UserName !== options.UserName) {
-                    return false;
-                }
-                if (options.IsMaster !== undefined && item.IsMaster !== options.IsMaster) {
-                    return false;
-                }
-                if (options.IsBot !== undefined && item.IsBot !== options.IsBot) {
-                    return false;
-                }
-                return true;
-            });
-            return createResult(ResultCode.Ok, 'Successfully retrieved mention data', data);
+            const data = res.filter(item => match(item, options));
+            const result = createResult(ResultCode.Ok, 'Successfully retrieved mention data', data);
+            return {
+                ...result,
+                count: data.length || 0
+            };
         },
         findOne: async (options = {}) => {
-            try {
-                if (!res) {
-                    const results = await sendAction({
-                        action: 'mention.get',
-                        payload: {
-                            event
-                        }
-                    });
-                    const result = results.find(item => item.code === ResultCode.Ok);
-                    if (result) {
-                        res = result.data;
-                    }
-                }
-            }
-            catch (err) {
-                return createResult(ResultCode.Fail, err?.message || 'Failed to get mention data', null);
-            }
-            if (!Array.isArray(res)) {
-                return createResult(ResultCode.Warn, 'No mention data found', null);
-            }
-            const data = res.find(item => {
-                if (options.UserId !== undefined && item.UserId !== options.UserId) {
-                    return false;
-                }
-                if (options.UserKey !== undefined && item.UserKey !== options.UserKey) {
-                    return false;
-                }
-                if (options.UserName !== undefined && item.UserName !== options.UserName) {
-                    return false;
-                }
-                if (options.IsMaster !== undefined && item.IsMaster !== options.IsMaster) {
-                    return false;
-                }
-                if (options.IsBot !== undefined && item.IsBot !== options.IsBot) {
-                    return false;
-                }
-                if (item.IsBot) {
-                    return false;
-                }
-                return true;
-            });
-            if (!data) {
-                return createResult(ResultCode.Warn, 'No mention data found', null);
+            const results = await mention.find(options);
+            if (results.code !== ResultCode.Ok || !results.data?.length) {
+                const result = createResult(results.code, results.message, null);
+                return {
+                    ...result,
+                    count: 0
+                };
             }
-            return createResult(ResultCode.Ok, 'Successfully retrieved mention data', data);
+            const data = results?.data[0];
+            const result = createResult(ResultCode.Ok, results.message, data);
+            return {
+                ...result,
+                count: results.data?.length || 0
+            };
         }
     };
     return [mention];
@@ -116,7 +102,13 @@ const useMessage = (event) => {
         });
         throw new Error('Invalid event: event must be an object');
     }
-    const send = async (val) => {
+    const resolveFormat = (params) => {
+        if (params.format instanceof Format) {
+            return params.format.value;
+        }
+        return params.format;
+    };
+    const sendRaw = async (val) => {
         if (!val || val.length === 0) {
             return [createResult(ResultCode.FailParams, 'Invalid val: val must be a non-empty array', null)];
         }
@@ -184,9 +176,15 @@ const useMessage = (event) => {
             this.#format = [];
             return this;
         }
-        send(val) {
-            const dataToSend = val && val.length > 0 ? val : this.#format;
-            return send(dataToSend);
+        send(params) {
+            if (!params) {
+                return sendRaw(this.#format);
+            }
+            if (Array.isArray(params)) {
+                const dataToSend = params.length > 0 ? params : this.#format;
+                return sendRaw(dataToSend);
+            }
+            return sendRaw(resolveFormat(params));
         }
     }
     return [new MessageController()];

package/lib/app/index.d.ts

@@ -4,6 +4,7 @@ export * from './define-children.js';
 export * from './define-platform.js';
 export * from './define-response.js';
 export * from './define-middleware.js';
+export * from './define-router.js';
 export * from './event-group.js';
 export * from './event-middleware';
 export * from './event-processor';

package/lib/app/index.js

@@ -1,10 +1,11 @@
-export { ChildrenApp, Core, Logger, Middleware, MiddlewareRouter, ProcessorEventAutoClearMap, ProcessorEventUserAudoClearMap, Response, ResponseMiddleware, ResponseRouter, State, StateSubscribe, SubscribeList, core, logger } from './store.js';
+export { ChildrenApp, Core, Logger, Middleware, MiddlewareRouter, ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap, Response, ResponseMiddleware, ResponseRouter, State, StateSubscribe, SubscribeList, core, logger } from './store.js';
 export { loadModels, run } from './load_modules/load.js';
 export { loadChildren, loadChildrenFile } from './load_modules/loadChild.js';
 export { defineChildren } from './define-children.js';
 export { definePlatform } from './define-platform.js';
-export { defineResponse, lazy } from './define-response.js';
+export { defineResponse } from './define-response.js';
 export { defineMiddleware } from './define-middleware.js';
+export { defineRouter, lazy } from './define-router.js';
 export { onGroup } from './event-group.js';
 export { OnMiddleware, onMiddleware } from './event-middleware.js';
 export { OnProcessor, onProcessor } from './event-processor.js';
@@ -17,4 +18,4 @@ export { createSelects, onSelects, unChildren, useChannel, useClient, useMe, use
 export { onState, unState, useState } from './hook-use-state.js';
 export { useObserver, useSubscribe } from './hook-use-subscribe.js';
 export { createDataFormat, createEventValue, format, getMessageIntent, sendToChannel, sendToUser } from './message-api.js';
-export { Ark, BT, Image, ImageFile, ImageURL, Link, MD, Mention, Text } from './message-format.js';
+export { Ark, BT, Format, Image, ImageFile, ImageURL, Link, MD, Mention, Text, createEvent } from './message-format.js';