@fraqjs/fraq 0.1.0

package/dist/index.mjs

@@ -0,0 +1,777 @@
+import mitt from "mitt";
+//#region src/protocol/client.ts
+var MilkyClientBase = class {
+	baseUrl;
+	wsBaseUrl;
+	accessToken;
+	baseHeaders;
+	constructor(baseUrl, options) {
+		this.baseUrl = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+		this.wsBaseUrl = this.baseUrl.replace(/^http/, "ws");
+		this.accessToken = options?.accessToken;
+		this.baseHeaders = { "Content-Type": "application/json" };
+		if (options?.accessToken) this.baseHeaders.Authorization = `Bearer ${options.accessToken}`;
+	}
+	async callApi(endpoint, params) {
+		const response = await fetch(`${this.baseUrl}/api/${endpoint}`, {
+			method: "POST",
+			body: JSON.stringify(params ?? {}),
+			headers: this.baseHeaders
+		});
+		if (!response.ok) throw new Error(`API call failed with status ${response.status}`);
+		const json = await response.json();
+		if (json.status === "failed") throw new Error(`API call failed with retcode ${json.retcode}: ${json.message}`);
+		return json.data;
+	}
+	async openEventWebSocket(onEvent) {
+		const ws = new WebSocket(`${this.wsBaseUrl}/event${this.accessToken ? `?access_token=${this.accessToken}` : ""}`);
+		ws.addEventListener("message", onEvent);
+		return new Promise((resolve, reject) => {
+			ws.addEventListener("open", () => resolve(ws));
+			ws.addEventListener("error", (event) => reject(/* @__PURE__ */ new Error(`WebSocket error: ${event}`)));
+		});
+	}
+};
+function createMilkyClient(...params) {
+	const base = new MilkyClientBase(...params);
+	return new Proxy(base, { get(target, endpoint) {
+		if (typeof endpoint === "string" && endpoint.includes("_")) return (params) => target.callApi(endpoint, params);
+		else return target[endpoint];
+	} });
+}
+//#endregion
+//#region src/routing/tokenizer.ts
+var Tokenizer = class {
+	segments;
+	offset = 0;
+	subOffset = void 0;
+	constructor(segments) {
+		this.segments = segments;
+	}
+	getState() {
+		return {
+			offset: this.offset,
+			subOffset: this.subOffset
+		};
+	}
+	setState(state) {
+		this.offset = state.offset;
+		this.subOffset = state.subOffset;
+	}
+	hasNext() {
+		return this.findNextPosition() !== void 0;
+	}
+	peek() {
+		const position = this.findNextPosition();
+		if (position === void 0) return;
+		const segment = this.segments[position.offset];
+		if (segment.type === "text") return this.readTextToken(segment.data.text, position.subOffset ?? 0);
+		return segment;
+	}
+	next() {
+		const position = this.findNextPosition();
+		if (position === void 0) return;
+		const segment = this.segments[position.offset];
+		if (segment.type !== "text") {
+			this.offset = position.offset + 1;
+			this.subOffset = void 0;
+			return segment;
+		}
+		const subOffset = position.subOffset ?? 0;
+		const token = this.readTextToken(segment.data.text, subOffset);
+		const tokenEnd = subOffset + token.length;
+		const nextSubOffset = this.findTextTokenStart(segment.data.text, tokenEnd);
+		if (nextSubOffset < segment.data.text.length) {
+			this.offset = position.offset;
+			this.subOffset = nextSubOffset;
+		} else {
+			this.offset = position.offset + 1;
+			this.subOffset = void 0;
+		}
+		return token;
+	}
+	isGreedyAvailable() {
+		if (this.offset !== this.segments.length - 1) return false;
+		const segment = this.segments[this.offset];
+		if (segment?.type !== "text") return false;
+		return this.findTextTokenStart(segment.data.text, this.subOffset ?? 0) < segment.data.text.length;
+	}
+	greedy() {
+		if (!this.isGreedyAvailable()) throw new Error("Greedy token is not available");
+		const segment = this.segments[this.offset];
+		if (segment.type !== "text") throw new Error("Greedy token is not available");
+		const tokenStart = this.findTextTokenStart(segment.data.text, this.subOffset ?? 0);
+		const token = segment.data.text.slice(tokenStart);
+		this.offset = this.segments.length;
+		this.subOffset = void 0;
+		return token;
+	}
+	findNextPosition() {
+		let offset = this.offset;
+		let subOffset = this.subOffset;
+		while (offset < this.segments.length) {
+			const segment = this.segments[offset];
+			if (segment.type !== "text") return {
+				offset,
+				subOffset: void 0
+			};
+			const tokenStart = this.findTextTokenStart(segment.data.text, subOffset ?? 0);
+			if (tokenStart < segment.data.text.length) return {
+				offset,
+				subOffset: tokenStart
+			};
+			offset += 1;
+			subOffset = void 0;
+		}
+	}
+	findTextTokenStart(text, from) {
+		let offset = from;
+		while (offset < text.length && text[offset] === " ") offset += 1;
+		return offset;
+	}
+	readTextToken(text, from) {
+		let offset = from;
+		while (offset < text.length && text[offset] !== " ") offset += 1;
+		return text.slice(from, offset);
+	}
+};
+//#endregion
+//#region src/routing/router.ts
+var Router = class Router {
+	entries = [];
+	groups = /* @__PURE__ */ new Map();
+	command(name, pattern, handler) {
+		const command = {
+			name,
+			pattern,
+			handler
+		};
+		this.entries.push({
+			type: "command",
+			command
+		});
+		return this;
+	}
+	rawPattern(pattern, handler) {
+		if (Object.keys(pattern).length === 0) throw new Error("Raw pattern must have at least one parameter.");
+		if (pattern[Object.keys(pattern)[0]].capturer.typeInstruction.type === "literal") throw new Error("The first parameter of a raw pattern cannot be a literal, as it would conflict with command patterns.");
+		const rawPattern = {
+			pattern,
+			handler
+		};
+		this.entries.push({
+			type: "rawPattern",
+			rawPattern
+		});
+		return this;
+	}
+	group(name) {
+		let router = this.groups.get(name);
+		if (!router) {
+			router = new Router();
+			this.groups.set(name, router);
+			this.entries.push({
+				type: "group",
+				name,
+				router
+			});
+		}
+		return router;
+	}
+	filter(predicate) {
+		const router = new Router();
+		this.entries.push({
+			type: "filter",
+			predicate,
+			router
+		});
+		return router;
+	}
+	async dispatch(session, message) {
+		const tokenizer = new Tokenizer(message.segments);
+		return await this.process(session, tokenizer);
+	}
+	async process(session, tokenizer) {
+		const initialState = tokenizer.getState();
+		for (const entry of this.entries) {
+			tokenizer.setState(initialState);
+			if (await this.processEntry(entry, session, tokenizer)) return true;
+		}
+		tokenizer.setState(initialState);
+		return false;
+	}
+	async processEntry(entry, session, tokenizer) {
+		switch (entry.type) {
+			case "command": return await this.processCommand(entry.command, session, tokenizer);
+			case "group": return await this.processGroup(entry.name, entry.router, session, tokenizer);
+			case "filter":
+				if (entry.predicate(session) !== true) return false;
+				return await entry.router.process(session, tokenizer);
+			case "rawPattern": return await this.processRawPattern(entry.rawPattern, session, tokenizer);
+		}
+	}
+	async processCommand(command, session, tokenizer) {
+		const token = tokenizer.peek();
+		if (typeof token !== "string" || token !== command.name) return false;
+		tokenizer.next();
+		const params = this.capturePattern(command.pattern, tokenizer);
+		if (params === void 0 || tokenizer.hasNext()) return false;
+		await command.handler(session, params);
+		return true;
+	}
+	async processGroup(name, router, session, tokenizer) {
+		const token = tokenizer.peek();
+		if (typeof token !== "string" || token !== name) return false;
+		tokenizer.next();
+		return await router.process(session, tokenizer);
+	}
+	async processRawPattern(rawPattern, session, tokenizer) {
+		const params = this.capturePattern(rawPattern.pattern, tokenizer);
+		if (params === void 0 || tokenizer.hasNext()) return false;
+		await rawPattern.handler(session, params);
+		return true;
+	}
+	capturePattern(pattern, tokenizer) {
+		const initialState = tokenizer.getState();
+		const params = {};
+		for (const [name, parameter] of Object.entries(pattern)) {
+			const value = parameter.capturer.capture(tokenizer);
+			if (value === void 0) {
+				tokenizer.setState(initialState);
+				return;
+			}
+			params[name] = value;
+		}
+		return params;
+	}
+};
+//#endregion
+//#region src/core/service.ts
+function getServiceName(service) {
+	return service.name || "<anonymous service>";
+}
+//#endregion
+//#region src/core/context.ts
+const INITIAL_RECONNECT_DELAY_MS = 1e3;
+const MAX_RECONNECT_DELAY_MS = 3e4;
+var Context = class Context {
+	client;
+	parent;
+	router = new Router();
+	eventBus = mitt();
+	plugins = [];
+	services = /* @__PURE__ */ new Map();
+	subContexts = [];
+	isStarted = false;
+	constructor(client, parent, filter) {
+		this.client = client;
+		this.parent = parent;
+		parent?.eventBus.on("*", (type, event) => {
+			if (filter) {
+				const predicate = filter[type];
+				if (predicate && !predicate(event)) return;
+			}
+			this.eventBus.emit(type, event);
+		});
+		this.eventBus.on("message_receive", async ({ data: message }) => {
+			try {
+				this.router.dispatch(this.createSession(message), message);
+			} catch (error) {
+				console.error("Error routing command:", error);
+			}
+		});
+	}
+	on(type, handler) {
+		this.eventBus.on(type, async (event) => {
+			try {
+				await handler(event);
+			} catch (error) {
+				console.error(`Error handling event ${type}:`, error);
+			}
+		});
+	}
+	install(plugin, ...args) {
+		this.plugins.push({
+			plugin,
+			args
+		});
+	}
+	provide(service, instance) {
+		if (this.services.has(service)) throw new Error(`Service ${getServiceName(service)} has already been provided in this context.`);
+		this.services.set(service, instance);
+	}
+	resolve(service) {
+		const instance = this.tryResolve(service);
+		if (instance === void 0) throw new Error(`Service ${getServiceName(service)} has not been provided.`);
+		return instance;
+	}
+	tryResolve(service) {
+		if (this.services.has(service)) return this.services.get(service);
+		return this.parent?.tryResolve(service);
+	}
+	isProvided(service) {
+		return this.tryResolve(service) !== void 0;
+	}
+	fork(filter) {
+		const subContext = new Context(this.client, this, filter);
+		this.subContexts.push(subContext);
+		return subContext;
+	}
+	async start() {
+		if (this.isStarted) return;
+		await this.applyPlugins();
+		for (const subContext of this.subContexts) await subContext.start();
+		this.isStarted = true;
+		if (!this.parent) this.connectEventWebSocket();
+	}
+	async applyPlugins() {
+		for (const { plugin, args } of this.sortPlugins()) {
+			const providedBeforeApply = new Set(this.services.keys());
+			await plugin.apply(this, ...args);
+			for (const service of plugin.provides ?? []) if (!this.services.has(service) || providedBeforeApply.has(service)) throw new Error(`${this.describePlugin(plugin)} declares service ${getServiceName(service)} but did not provide it.`);
+		}
+	}
+	sortPlugins() {
+		this.validateUniqueProvidedServices();
+		const pending = [...this.plugins];
+		const sorted = [];
+		const available = /* @__PURE__ */ new Set();
+		for (const service of this.collectAvailableServices()) available.add(service);
+		while (pending.length > 0) {
+			const nextIndex = pending.findIndex(({ plugin }) => this.areRequirementsAvailable(plugin, available));
+			if (nextIndex === -1) throw this.createUnresolvablePluginError(pending, available);
+			const [next] = pending.splice(nextIndex, 1);
+			sorted.push(next);
+			for (const service of next.plugin.provides ?? []) available.add(service);
+		}
+		return sorted;
+	}
+	validateUniqueProvidedServices() {
+		const providers = /* @__PURE__ */ new Map();
+		for (const { plugin } of this.plugins) for (const service of plugin.provides ?? []) {
+			const existingProvider = providers.get(service);
+			if (existingProvider) throw new Error(`Service ${getServiceName(service)} is declared by multiple plugins: ${this.describePlugin(existingProvider)} and ${this.describePlugin(plugin)}.`);
+			providers.set(service, plugin);
+		}
+	}
+	collectAvailableServices() {
+		const services = [...this.services.keys()];
+		if (this.parent) services.push(...this.parent.collectAvailableServices());
+		return services;
+	}
+	areRequirementsAvailable(plugin, available) {
+		return (plugin.requires ?? []).every((service) => available.has(service));
+	}
+	createUnresolvablePluginError(pending, available) {
+		const missingRequirements = /* @__PURE__ */ new Map();
+		const pendingProviders = /* @__PURE__ */ new Set();
+		for (const { plugin } of pending) for (const service of plugin.provides ?? []) pendingProviders.add(service);
+		for (const { plugin } of pending) for (const service of plugin.requires ?? []) if (!available.has(service)) {
+			const plugins = missingRequirements.get(service) ?? [];
+			plugins.push(plugin);
+			missingRequirements.set(service, plugins);
+		}
+		const lines = [...missingRequirements].map(([service, plugins]) => {
+			const dependents = plugins.map((plugin) => this.describePlugin(plugin)).join(", ");
+			const reason = pendingProviders.has(service) ? "blocked by a dependency cycle" : "no installed plugin provides it";
+			return `${getServiceName(service)} required by ${dependents} (${reason})`;
+		});
+		return /* @__PURE__ */ new Error(`Unable to resolve plugin service dependencies: ${lines.join("; ")}.`);
+	}
+	describePlugin(plugin) {
+		const pluginIndex = this.plugins.findIndex((installed) => installed.plugin === plugin);
+		return plugin.constructor.name && plugin.constructor.name !== "Object" ? plugin.constructor.name : `plugin #${pluginIndex + 1}`;
+	}
+	async connectEventWebSocket() {
+		let reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+		while (this.isStarted) {
+			try {
+				const ws = await this.client.openEventWebSocket((event) => this.handleWebSocketMessage(event));
+				reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+				await new Promise((resolve) => {
+					ws.addEventListener("close", () => resolve(), { once: true });
+				});
+			} catch (error) {
+				console.error("Error connecting event WebSocket:", error);
+			}
+			await this.delay(reconnectDelay);
+			reconnectDelay = Math.min(reconnectDelay * 2, MAX_RECONNECT_DELAY_MS);
+		}
+	}
+	handleWebSocketMessage(event) {
+		try {
+			if (typeof event.data !== "string") throw new Error(`Expected text frame, got ${typeof event.data}`);
+			const payload = JSON.parse(event.data);
+			this.eventBus.emit(payload.event_type, payload);
+		} catch (error) {
+			console.error("Error handling WebSocket event:", error);
+		}
+	}
+	delay(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+	createSession(message) {
+		return {
+			raw: message,
+			reply: async (segments) => {
+				try {
+					switch (message.message_scene) {
+						case "friend":
+							await this.client.send_private_message({
+								user_id: message.peer_id,
+								message: segments
+							});
+							break;
+						case "group":
+							await this.client.send_group_message({
+								group_id: message.peer_id,
+								message: segments
+							});
+							break;
+					}
+				} catch (error) {
+					console.error("Error sending reply:", error);
+				}
+			}
+		};
+	}
+	static create(options) {
+		return new Context(createMilkyClient(options.connect.baseUrl, { accessToken: options.connect.accessToken }));
+	}
+};
+//#endregion
+//#region src/core/filter.ts
+const eventKeys = [
+	"bot_offline",
+	"message_receive",
+	"message_recall",
+	"peer_pin_change",
+	"friend_request",
+	"group_join_request",
+	"group_invited_join_request",
+	"group_invitation",
+	"friend_nudge",
+	"friend_file_upload",
+	"group_admin_change",
+	"group_essence_message_change",
+	"group_member_increase",
+	"group_member_decrease",
+	"group_disband",
+	"group_name_change",
+	"group_message_reaction",
+	"group_mute",
+	"group_whole_mute",
+	"group_nudge",
+	"group_file_upload"
+];
+let filter;
+(function(_filter) {
+	function define(filter) {
+		return filter;
+	}
+	_filter.define = define;
+	function allPass() {
+		const result = {};
+		for (const key of eventKeys) result[key] = () => true;
+		return result;
+	}
+	_filter.allPass = allPass;
+	function friend(uinList) {
+		const uinSet = new Set(uinList);
+		return {
+			message_receive: ({ data }) => data.message_scene === "friend" && uinSet.has(data.peer_id),
+			message_recall: ({ data }) => data.message_scene === "friend" && uinSet.has(data.peer_id),
+			peer_pin_change: ({ data }) => data.message_scene === "friend" && uinSet.has(data.peer_id),
+			group_invitation: ({ data }) => uinSet.has(data.initiator_id),
+			friend_nudge: ({ data }) => uinSet.has(data.user_id),
+			friend_file_upload: ({ data }) => uinSet.has(data.user_id)
+		};
+	}
+	_filter.friend = friend;
+	function group(uinList) {
+		const uinSet = new Set(uinList);
+		return {
+			message_receive: ({ data }) => data.message_scene === "group" && uinSet.has(data.peer_id),
+			message_recall: ({ data }) => data.message_scene === "group" && uinSet.has(data.peer_id),
+			peer_pin_change: ({ data }) => data.message_scene === "group" && uinSet.has(data.peer_id),
+			group_join_request: ({ data }) => uinSet.has(data.group_id),
+			group_invited_join_request: ({ data }) => uinSet.has(data.group_id),
+			group_admin_change: ({ data }) => uinSet.has(data.group_id),
+			group_essence_message_change: ({ data }) => uinSet.has(data.group_id),
+			group_member_increase: ({ data }) => uinSet.has(data.group_id),
+			group_member_decrease: ({ data }) => uinSet.has(data.group_id),
+			group_name_change: ({ data }) => uinSet.has(data.group_id),
+			group_message_reaction: ({ data }) => uinSet.has(data.group_id),
+			group_mute: ({ data }) => uinSet.has(data.group_id),
+			group_whole_mute: ({ data }) => uinSet.has(data.group_id),
+			group_nudge: ({ data }) => uinSet.has(data.group_id),
+			group_file_upload: ({ data }) => uinSet.has(data.group_id)
+		};
+	}
+	_filter.group = group;
+	function admin() {
+		return { message_receive: ({ data }) => data.message_scene === "group" && data.group_member.role !== "member" };
+	}
+	_filter.admin = admin;
+	function or(...filters) {
+		const result = {};
+		for (const key of eventKeys) result[key] = (event) => {
+			for (const filter of filters) {
+				const predicate = filter[key];
+				if (predicate?.(event)) return true;
+			}
+			return false;
+		};
+		return result;
+	}
+	_filter.or = or;
+	function and(...filters) {
+		const result = {};
+		for (const key of eventKeys) result[key] = (event) => {
+			for (const filter of filters) {
+				const predicate = filter[key];
+				if (!predicate?.(event)) return false;
+			}
+			return true;
+		};
+		return result;
+	}
+	_filter.and = and;
+})(filter || (filter = {}));
+//#endregion
+//#region src/core/plugin.ts
+function definePlugin(plugin) {
+	return plugin;
+}
+//#endregion
+//#region src/protocol/segment.ts
+function msg(strings, ...values) {
+	let buffer = "";
+	const segments = [];
+	for (let i = 0; i < strings.length; i++) {
+		buffer += strings[i];
+		if (i < values.length) {
+			const value = values[i];
+			if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") buffer += value.toString();
+			else {
+				if (buffer) {
+					segments.push({
+						type: "text",
+						data: { text: buffer }
+					});
+					buffer = "";
+				}
+				segments.push(value);
+			}
+		}
+	}
+	if (buffer) segments.push({
+		type: "text",
+		data: { text: buffer }
+	});
+	return segments;
+}
+let seg;
+(function(_seg) {
+	function mention(userId) {
+		return {
+			type: "mention",
+			data: { user_id: userId }
+		};
+	}
+	_seg.mention = mention;
+	function mentionAll() {
+		return {
+			type: "mention_all",
+			data: {}
+		};
+	}
+	_seg.mentionAll = mentionAll;
+	function face(faceId, options) {
+		return {
+			type: "face",
+			data: {
+				face_id: faceId.toString(),
+				is_large: options?.isLarge ?? false
+			}
+		};
+	}
+	_seg.face = face;
+	function reply(messageSeq) {
+		return {
+			type: "reply",
+			data: { message_seq: messageSeq }
+		};
+	}
+	_seg.reply = reply;
+	function image(uri, options) {
+		return {
+			type: "image",
+			data: {
+				uri,
+				sub_type: options?.subType,
+				summary: options?.summary
+			}
+		};
+	}
+	_seg.image = image;
+	function record(uri) {
+		return {
+			type: "record",
+			data: { uri }
+		};
+	}
+	_seg.record = record;
+	function video(uri, options) {
+		return {
+			type: "video",
+			data: {
+				uri,
+				thumb_uri: options?.thumbUri
+			}
+		};
+	}
+	_seg.video = video;
+	function forward(messages, options) {
+		return {
+			type: "forward",
+			data: {
+				messages,
+				title: options?.title,
+				preview: options?.preview,
+				summary: options?.summary,
+				prompt: options?.prompt
+			}
+		};
+	}
+	_seg.forward = forward;
+})(seg || (seg = {}));
+//#endregion
+//#region src/protocol/types.ts
+const milkyVersion = "1.3";
+const milkyPackageVersion = "1.3.0-rc.1";
+//#endregion
+//#region src/routing/capturer.ts
+let capturer;
+(function(_capturer) {
+	function literal(literal) {
+		return {
+			typeInstruction: {
+				type: "literal",
+				literal
+			},
+			capture(tokenizer) {
+				const token = tokenizer.peek();
+				if (typeof token === "string" && token === literal) {
+					tokenizer.next();
+					return token;
+				}
+			}
+		};
+	}
+	_capturer.literal = literal;
+	_capturer.num = {
+		typeInstruction: { type: "number" },
+		capture(tokenizer) {
+			const token = tokenizer.peek();
+			if (typeof token === "string") {
+				const parsed = Number(token);
+				if (!Number.isNaN(parsed)) {
+					tokenizer.next();
+					return parsed;
+				}
+			}
+		}
+	};
+	_capturer.str = {
+		typeInstruction: { type: "string" },
+		capture(tokenizer) {
+			const token = tokenizer.peek();
+			if (typeof token === "string") {
+				tokenizer.next();
+				return token;
+			}
+		}
+	};
+	_capturer.greedy = {
+		typeInstruction: { type: "greedy" },
+		capture(tokenizer) {
+			if (tokenizer.isGreedyAvailable()) return tokenizer.greedy();
+		}
+	};
+	function union(...members) {
+		const literalSet = new Set(members);
+		return {
+			typeInstruction: {
+				type: "union",
+				members
+			},
+			capture(tokenizer) {
+				const token = tokenizer.peek();
+				if (typeof token === "string" && literalSet.has(token)) {
+					tokenizer.next();
+					return token;
+				}
+			}
+		};
+	}
+	_capturer.union = union;
+	function segment(type) {
+		return {
+			typeInstruction: {
+				type: "segment",
+				segmentType: type
+			},
+			capture(tokenizer) {
+				const token = tokenizer.peek();
+				if (typeof token === "object" && token !== null && token.type === type) {
+					tokenizer.next();
+					return token;
+				}
+			}
+		};
+	}
+	_capturer.segment = segment;
+})(capturer || (capturer = {}));
+//#endregion
+//#region src/routing/parameter.ts
+var Parameter = class {
+	capturer;
+	description;
+	constructor(capturer) {
+		this.capturer = capturer;
+	}
+	describe(description) {
+		this.description = description;
+		return this;
+	}
+};
+let param;
+(function(_param) {
+	function literal(literal) {
+		return new Parameter(capturer.literal(literal));
+	}
+	_param.literal = literal;
+	function num() {
+		return new Parameter(capturer.num);
+	}
+	_param.num = num;
+	function str() {
+		return new Parameter(capturer.str);
+	}
+	_param.str = str;
+	function greedy() {
+		return new Parameter(capturer.greedy);
+	}
+	_param.greedy = greedy;
+	function union(...literals) {
+		return new Parameter(capturer.union(...literals));
+	}
+	_param.union = union;
+	function segment(type) {
+		return new Parameter(capturer.segment(type));
+	}
+	_param.segment = segment;
+})(param || (param = {}));
+//#endregion
+export { Context, Parameter, Router, createMilkyClient, definePlugin, filter, milkyPackageVersion, milkyVersion, msg, param, seg };