@aigne/afs-mattermost 1.11.0-beta.12

package/LICENSE.md

@@ -0,0 +1,26 @@
+# Proprietary License
+
+Copyright (c) 2024-2025 ArcBlock, Inc. All Rights Reserved.
+
+This software and associated documentation files (the "Software") are proprietary
+and confidential. Unauthorized copying, modification, distribution, or use of
+this Software, via any medium, is strictly prohibited.
+
+The Software is provided for internal use only within ArcBlock, Inc. and its
+authorized affiliates.
+
+## No License Granted
+
+No license, express or implied, is granted to any party for any purpose.
+All rights are reserved by ArcBlock, Inc.
+
+## Public Artifact Distribution
+
+Portions of this Software may be released publicly under separate open-source
+licenses (such as MIT License) through designated public repositories. Such
+public releases are governed by their respective licenses and do not affect
+the proprietary nature of this repository.
+
+## Contact
+
+For licensing inquiries, contact: legal@arcblock.io

package/dist/index.cjs

@@ -0,0 +1,487 @@
+let _aigne_afs_provider = require("@aigne/afs/provider");
+let _aigne_afs_messaging = require("@aigne/afs-messaging");
+
+//#region src/client.ts
+/**
+* MattermostClient — pure Mattermost REST API wrapper.
+*
+* Zero external dependencies (uses native fetch).
+* No AFS or application-specific concepts.
+* WebSocket is handled by the provider, not the client.
+*/
+const DEFAULT_API_BASE = "https://mattermost.example.com/api/v4";
+const DEFAULT_TIMEOUT = 3e4;
+var MattermostClient = class {
+	_token;
+	_apiBase;
+	_timeout;
+	constructor(options) {
+		if (!options.token) throw new Error("MattermostClient requires a token");
+		this._token = options.token;
+		this._apiBase = options.apiBase ?? DEFAULT_API_BASE;
+		this._timeout = options.timeout ?? DEFAULT_TIMEOUT;
+	}
+	async sendMessage(channelId, text) {
+		return this._call("POST", "/posts", {
+			channel_id: channelId,
+			message: text
+		});
+	}
+	async sendTyping(channelId) {
+		await this._call("POST", "/users/me/typing", { channel_id: channelId });
+	}
+	async getCurrentUser() {
+		return this._call("GET", "/users/me");
+	}
+	async _call(method, path, body) {
+		const headers = { Authorization: `Bearer ${this._token}` };
+		const init = {
+			method,
+			headers,
+			signal: AbortSignal.timeout(this._timeout)
+		};
+		if (body) {
+			headers["Content-Type"] = "application/json";
+			init.body = JSON.stringify(body);
+		}
+		const response = await fetch(`${this._apiBase}${path}`, init);
+		if (!response.ok) {
+			const desc = (await response.text().catch(() => "")).replace(this._token, "***");
+			throw new Error(`Mattermost API error ${response.status}: ${desc}`);
+		}
+		return response.json();
+	}
+};
+
+//#endregion
+//#region \0@oxc-project+runtime@0.108.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+//#region src/index.ts
+var AFSMattermost = class extends _aigne_afs_messaging.BaseMessageProvider {
+	static manifest() {
+		return {
+			name: "mattermost",
+			description: "Mattermost messaging — bidirectional via WebSocket events.\n- Self-hosted team messaging with REST + WebSocket API\n- Multi-bot support with per-bot channel monitoring\n- Path: /:bot/conversations/:channelId/messages/:msgId",
+			uriTemplate: "mattermost://{serverUrl}",
+			category: "messaging",
+			schema: {
+				type: "object",
+				properties: {
+					serverUrl: {
+						type: "string",
+						description: "Mattermost server URL"
+					},
+					token: {
+						type: "string",
+						description: "Personal access token or bot token",
+						sensitive: true
+					},
+					channels: {
+						type: "array",
+						items: { type: "string" },
+						description: "Channel IDs to monitor"
+					}
+				},
+				required: ["serverUrl", "token"]
+			},
+			tags: [
+				"mattermost",
+				"messaging",
+				"chat",
+				"self-hosted"
+			],
+			capabilityTags: [
+				"read-write",
+				"crud",
+				"search",
+				"auth:token",
+				"remote",
+				"http",
+				"on-premise",
+				"real-time"
+			],
+			security: {
+				riskLevel: "external",
+				resourceAccess: ["internet"],
+				notes: ["Connects to self-hosted Mattermost instance — requires access token"]
+			},
+			capabilities: { network: { egress: true } }
+		};
+	}
+	static treeSchema() {
+		return {
+			operations: [
+				"list",
+				"read",
+				"exec",
+				"stat",
+				"explain"
+			],
+			tree: {
+				"/": {
+					kind: "messaging:root",
+					operations: ["list", "exec"],
+					actions: [
+						"add-bot",
+						"remove-bot",
+						"start",
+						"stop",
+						"process-event"
+					]
+				},
+				"/{bot}": {
+					kind: "messaging:bot",
+					operations: ["list", "read"]
+				},
+				"/{bot}/ctl": {
+					kind: "messaging:status",
+					operations: ["read"]
+				},
+				"/{bot}/conversations": {
+					kind: "messaging:conversations",
+					operations: ["list"]
+				},
+				"/{bot}/conversations/{convId}": {
+					kind: "messaging:conversation",
+					operations: ["list"]
+				},
+				"/{bot}/conversations/{convId}/messages": {
+					kind: "messaging:messages",
+					operations: ["list", "exec"],
+					actions: ["send"]
+				},
+				"/{bot}/conversations/{convId}/messages/{msgId}": {
+					kind: "messaging:message",
+					operations: ["read"]
+				}
+			},
+			auth: {
+				type: "token",
+				env: ["MATTERMOST_TOKEN"]
+			},
+			bestFor: [
+				"self-hosted chat",
+				"team messaging",
+				"devops alerts"
+			],
+			notFor: ["file storage", "database queries"]
+		};
+	}
+	providerName = "mattermost";
+	eventPrefix = "mattermost";
+	_wsStates = /* @__PURE__ */ new Map();
+	constructor(options) {
+		let bots;
+		if (options.bots) {
+			bots = options.bots;
+			for (const bot of bots) if (!bot.token) throw new Error(`AFSMattermost bot "${bot.name}" requires a token`);
+		} else {
+			if (!options.token) throw new Error("AFSMattermost requires a token");
+			bots = [{
+				name: "default",
+				token: options.token,
+				conversations: options.channels ?? [],
+				apiBase: options.apiBase
+			}];
+		}
+		super({
+			bots,
+			bufferSize: options.bufferSize
+		});
+		for (const bot of bots) this._wsStates.set(bot.name, {
+			ws: null,
+			connected: false,
+			disposed: false,
+			seq: 1,
+			heartbeatTimer: null,
+			backoff: 1e3
+		});
+	}
+	getMessageCapabilities() {
+		return {
+			formats: {
+				send: ["text", "markdown"],
+				receive: ["text"]
+			},
+			maxMessageLength: 16383,
+			features: {
+				edit: true,
+				delete: true,
+				reply: true,
+				thread: true,
+				reaction: true,
+				inlineKeyboard: false
+			},
+			limits: { messagesPerSecond: 10 }
+		};
+	}
+	createBotClient(config) {
+		return new MattermostClient({
+			token: config.token,
+			apiBase: config.apiBase
+		});
+	}
+	async sendMessage(client, convId, text, _opts) {
+		return { messageId: (await client.sendMessage(convId, text)).id };
+	}
+	async sendTypingIndicator(client, convId) {
+		await client.sendTyping(convId);
+	}
+	normalizeMessage(raw) {
+		const msg = raw;
+		return {
+			id: msg.id ?? "0",
+			text: String(msg.message ?? ""),
+			from: this.normalizeSender({ id: msg.user_id }),
+			timestamp: msg.create_at ? Math.floor(msg.create_at / 1e3) : Math.floor(Date.now() / 1e3),
+			conversationId: String(msg.channel_id ?? ""),
+			platform: { root_id: msg.root_id }
+		};
+	}
+	normalizeSender(raw) {
+		return {
+			id: String(raw.id ?? "0"),
+			name: String(raw.username ?? raw.name ?? ""),
+			isBot: raw.is_bot
+		};
+	}
+	start(botName) {
+		const names = botName ? [botName] : [...this._wsStates.keys()];
+		for (const name of names) {
+			const state = this._wsStates.get(name);
+			if (!state || state.connected || state.disposed) continue;
+			this._connectWebSocket(name);
+		}
+	}
+	stop(botName) {
+		const names = botName ? [botName] : [...this._wsStates.keys()];
+		for (const name of names) this._disconnectWebSocket(name);
+	}
+	dispose() {
+		for (const name of this._wsStates.keys()) {
+			const state = this._wsStates.get(name);
+			state.disposed = true;
+			this._disconnectWebSocket(name);
+		}
+	}
+	async listRootActions(_ctx) {
+		return { data: [
+			this.buildEntry("/.actions/add-bot", { meta: { description: "Add a bot instance at runtime" } }),
+			this.buildEntry("/.actions/remove-bot", { meta: { description: "Remove a bot instance" } }),
+			this.buildEntry("/.actions/start", { meta: { description: "Connect to Mattermost WebSocket" } }),
+			this.buildEntry("/.actions/stop", { meta: { description: "Disconnect from WebSocket" } }),
+			this.buildEntry("/.actions/process-event", { meta: { description: "Inject a Mattermost event externally" } })
+		] };
+	}
+	async execStart(_ctx) {
+		this.start();
+		return {
+			success: true,
+			data: {
+				ok: true,
+				websocket: true
+			}
+		};
+	}
+	async execStop(_ctx) {
+		this.stop();
+		return {
+			success: true,
+			data: {
+				ok: true,
+				websocket: false
+			}
+		};
+	}
+	async execProcessEvent(_ctx, args) {
+		this._processEvent(args);
+		return {
+			success: true,
+			data: { ok: true }
+		};
+	}
+	async _connectWebSocket(botName) {
+		const state = this._wsStates.get(botName);
+		if (!state || state.disposed) return;
+		const botConfig = this._pendingBots?.find((b) => b.name === botName);
+		const token = botConfig?.token;
+		const apiBase = botConfig?.apiBase ?? "https://mattermost.example.com/api/v4";
+		if (!token) return;
+		try {
+			const wsUrl = `${apiBase.replace(/^http/, "ws").replace(/\/api\/v4$/, "")}/api/v4/websocket`;
+			const ws = new WebSocket(wsUrl);
+			state.ws = ws;
+			ws.onopen = () => {
+				state.ws?.send(JSON.stringify({
+					seq: state.seq++,
+					action: "authentication_challenge",
+					data: { token }
+				}));
+				state.connected = true;
+				state.backoff = 1e3;
+			};
+			ws.onmessage = (event) => {
+				try {
+					const payload = JSON.parse(String(event.data));
+					this._handleWSEvent(botName, payload);
+				} catch {}
+			};
+			ws.onclose = () => {
+				this._cleanupWebSocket(botName);
+				if (!state.disposed) {
+					setTimeout(() => this._connectWebSocket(botName), state.backoff);
+					state.backoff = Math.min(state.backoff * 2, 6e4);
+				}
+			};
+			ws.onerror = () => {};
+		} catch {
+			if (!state.disposed) {
+				setTimeout(() => this._connectWebSocket(botName), state.backoff);
+				state.backoff = Math.min(state.backoff * 2, 6e4);
+			}
+		}
+	}
+	_handleWSEvent(botName, payload) {
+		if (!this._wsStates.get(botName)) return;
+		if (payload.event === "posted") {
+			const postStr = payload.data.post;
+			if (!postStr) return;
+			let post;
+			try {
+				post = JSON.parse(postStr);
+			} catch {
+				return;
+			}
+			const text = String(post.message ?? "").trim();
+			if (!text) return;
+			if (post.type && post.type !== "") return;
+			const channelId = String(post.channel_id ?? payload.broadcast?.channel_id ?? "");
+			this.emitMessageReceived(botName, {
+				id: String(post.id),
+				text,
+				from: this.normalizeSender({ id: post.user_id }),
+				timestamp: post.create_at ? Math.floor(post.create_at / 1e3) : Math.floor(Date.now() / 1e3),
+				conversationId: channelId,
+				platform: { root_id: post.root_id }
+			});
+		}
+	}
+	_disconnectWebSocket(botName) {
+		const state = this._wsStates.get(botName);
+		if (!state) return;
+		if (state.heartbeatTimer) {
+			clearInterval(state.heartbeatTimer);
+			state.heartbeatTimer = null;
+		}
+		if (state.ws) {
+			state.ws.onclose = null;
+			state.ws.onmessage = null;
+			state.ws.onerror = null;
+			state.ws.close();
+			state.ws = null;
+		}
+		state.connected = false;
+	}
+	_cleanupWebSocket(botName) {
+		const state = this._wsStates.get(botName);
+		if (!state) return;
+		if (state.heartbeatTimer) {
+			clearInterval(state.heartbeatTimer);
+			state.heartbeatTimer = null;
+		}
+		state.ws = null;
+		state.connected = false;
+	}
+	/** Process an externally-provided Mattermost event. Public for testing. */
+	_processEvent(payload) {
+		const botName = payload.botName ?? this._botOrder[0] ?? "default";
+		const event = payload.event;
+		const data = payload.data ?? payload;
+		if (event === "posted" || data.message !== void 0) {
+			let post;
+			if (typeof data.post === "string") try {
+				post = JSON.parse(data.post);
+			} catch {
+				return;
+			}
+			else if (data.post && typeof data.post === "object") post = data.post;
+			else post = data;
+			const text = String(post.message ?? "").trim();
+			if (!text) return;
+			if (post.type && post.type !== "") return;
+			const channelId = String(post.channel_id ?? payload.broadcast?.channel_id ?? "");
+			this.emitMessageReceived(botName, {
+				id: String(post.id ?? Date.now()),
+				text,
+				from: this.normalizeSender({
+					id: post.user_id ?? "0",
+					username: post.username ?? ""
+				}),
+				timestamp: post.create_at ? Math.floor(post.create_at / 1e3) : Math.floor(Date.now() / 1e3),
+				conversationId: channelId,
+				platform: { root_id: post.root_id }
+			});
+		}
+	}
+	/** Add a channel to a bot. Defaults to first bot. */
+	addChannel(channelId, botName) {
+		const name = botName ?? this._botOrder[0];
+		if (!name) return;
+		const convs = this._botConversations.get(name);
+		if (!convs || convs.has(channelId)) return;
+		convs.add(channelId);
+		const buffers = this._botBuffers.get(name);
+		if (buffers && !buffers.has(channelId)) buffers.set(channelId, []);
+	}
+	/** Remove a channel from a bot. */
+	removeChannel(channelId, botName) {
+		const name = botName ?? this._botOrder[0];
+		if (!name) return;
+		const convs = this._botConversations.get(name);
+		if (convs) convs.delete(channelId);
+		const buffers = this._botBuffers.get(name);
+		if (buffers) buffers.delete(channelId);
+	}
+	/** Add a message to the ring buffer directly. Public for testing/conformance. */
+	_addToBuffer(channelId, msg) {
+		const botName = this._botOrder[0] ?? "default";
+		const convs = this._botConversations.get(botName);
+		if (convs && !convs.has(channelId)) convs.add(channelId);
+		let botBuffers = this._botBuffers.get(botName);
+		if (!botBuffers) {
+			botBuffers = /* @__PURE__ */ new Map();
+			this._botBuffers.set(botName, botBuffers);
+		}
+		let buffer = botBuffers.get(channelId);
+		if (!buffer) {
+			buffer = [];
+			botBuffers.set(channelId, buffer);
+		}
+		buffer.push({
+			id: msg.id,
+			text: msg.message,
+			from: {
+				id: msg.user_id,
+				name: msg.username ?? ""
+			},
+			timestamp: msg.create_at ? Math.floor(msg.create_at / 1e3) : Math.floor(Date.now() / 1e3),
+			conversationId: channelId,
+			platform: {}
+		});
+		while (buffer.length > this._bufferSize) buffer.shift();
+	}
+};
+__decorate([(0, _aigne_afs_provider.Actions)("/")], AFSMattermost.prototype, "listRootActions", null);
+__decorate([_aigne_afs_provider.Actions.Exec("/", "start")], AFSMattermost.prototype, "execStart", null);
+__decorate([_aigne_afs_provider.Actions.Exec("/", "stop")], AFSMattermost.prototype, "execStop", null);
+__decorate([_aigne_afs_provider.Actions.Exec("/", "process-event")], AFSMattermost.prototype, "execProcessEvent", null);
+
+//#endregion
+exports.AFSMattermost = AFSMattermost;

package/dist/index.d.cts

@@ -0,0 +1,159 @@
+import { AFSExecResult, AFSListResult, ProviderTreeSchema } from "@aigne/afs";
+import { RouteContext } from "@aigne/afs/provider";
+import { BaseMessageProvider, BotConfig, BufferedMessage, MessageCapabilities, MessageSender, SendOptions } from "@aigne/afs-messaging";
+
+//#region src/client.d.ts
+/**
+ * MattermostClient — pure Mattermost REST API wrapper.
+ *
+ * Zero external dependencies (uses native fetch).
+ * No AFS or application-specific concepts.
+ * WebSocket is handled by the provider, not the client.
+ */
+interface MattermostClientOptions {
+  token: string;
+  apiBase?: string;
+  timeout?: number;
+}
+/** Mattermost post object (subset). */
+interface MattermostPost {
+  id: string;
+  channel_id: string;
+  user_id: string;
+  message: string;
+  create_at: number;
+  update_at?: number;
+  root_id?: string;
+  type?: string;
+}
+/** Mattermost user object (subset). */
+interface MattermostUser {
+  id: string;
+  username: string;
+  email?: string;
+  first_name?: string;
+  last_name?: string;
+  nickname?: string;
+  roles?: string;
+}
+/** Mattermost WebSocket event envelope. */
+interface MattermostWSEvent {
+  event: string;
+  data: Record<string, unknown>;
+  broadcast?: {
+    channel_id?: string;
+    team_id?: string;
+    user_id?: string;
+  };
+  seq: number;
+}
+declare class MattermostClient {
+  private readonly _token;
+  private readonly _apiBase;
+  private readonly _timeout;
+  constructor(options: MattermostClientOptions);
+  sendMessage(channelId: string, text: string): Promise<MattermostPost>;
+  sendTyping(channelId: string): Promise<void>;
+  getCurrentUser(): Promise<MattermostUser>;
+  private _call;
+}
+//#endregion
+//#region src/index.d.ts
+interface AFSMattermostOptions {
+  /** Multi-bot config */
+  bots?: Array<{
+    name: string;
+    token: string;
+    conversations?: string[];
+    apiBase?: string;
+  }>;
+  /** Single-bot shorthand: token */
+  token?: string;
+  /** Single-bot shorthand: channel IDs to monitor */
+  channels?: string[];
+  apiBase?: string;
+  bufferSize?: number;
+}
+declare class AFSMattermost extends BaseMessageProvider {
+  static manifest(): {
+    name: string;
+    description: string;
+    uriTemplate: string;
+    category: string;
+    schema: {
+      type: string;
+      properties: {
+        serverUrl: {
+          type: string;
+          description: string;
+        };
+        token: {
+          type: string;
+          description: string;
+          sensitive: boolean;
+        };
+        channels: {
+          type: string;
+          items: {
+            type: string;
+          };
+          description: string;
+        };
+      };
+      required: string[];
+    };
+    tags: string[];
+    capabilityTags: string[];
+    security: {
+      riskLevel: string;
+      resourceAccess: string[];
+      notes: string[];
+    };
+    capabilities: {
+      network: {
+        egress: boolean;
+      };
+    };
+  };
+  static treeSchema(): ProviderTreeSchema;
+  readonly providerName = "mattermost";
+  readonly eventPrefix = "mattermost";
+  private readonly _wsStates;
+  constructor(options: AFSMattermostOptions);
+  getMessageCapabilities(): MessageCapabilities;
+  createBotClient(config: BotConfig): MattermostClient;
+  sendMessage(client: unknown, convId: string, text: string, _opts?: SendOptions): Promise<{
+    messageId: string;
+  }>;
+  sendTypingIndicator(client: unknown, convId: string): Promise<void>;
+  normalizeMessage(raw: Record<string, unknown>): BufferedMessage;
+  normalizeSender(raw: Record<string, unknown>): MessageSender;
+  start(botName?: string): void;
+  stop(botName?: string): void;
+  dispose(): void;
+  listRootActions(_ctx: RouteContext): Promise<AFSListResult>;
+  execStart(_ctx: RouteContext): Promise<AFSExecResult>;
+  execStop(_ctx: RouteContext): Promise<AFSExecResult>;
+  execProcessEvent(_ctx: RouteContext, args: Record<string, unknown>): Promise<AFSExecResult>;
+  private _connectWebSocket;
+  private _handleWSEvent;
+  private _disconnectWebSocket;
+  private _cleanupWebSocket;
+  /** Process an externally-provided Mattermost event. Public for testing. */
+  _processEvent(payload: Record<string, unknown>): void;
+  /** Add a channel to a bot. Defaults to first bot. */
+  addChannel(channelId: string, botName?: string): void;
+  /** Remove a channel from a bot. */
+  removeChannel(channelId: string, botName?: string): void;
+  /** Add a message to the ring buffer directly. Public for testing/conformance. */
+  _addToBuffer(channelId: string, msg: {
+    id: string;
+    message: string;
+    user_id: string;
+    username?: string;
+    create_at?: number;
+  }): void;
+}
+//#endregion
+export { AFSMattermost, AFSMattermostOptions, type MattermostClient, type MattermostPost, type MattermostUser, type MattermostWSEvent };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/client.ts","../src/index.ts"],"mappings":";;;;;;;;;;AAWA;;UAAiB,uBAAA;EACf,KAAA;EACA,OAAA;EACA,OAAA;AAAA;;UAIe,cAAA;EACf,EAAA;EACA,UAAA;EACA,OAAA;EACA,OAAA;EACA,SAAA;EACA,SAAA;EACA,OAAA;EACA,IAAA;AAAA;;UAIe,cAAA;EACf,EAAA;EACA,QAAA;EACA,KAAA;EACA,UAAA;EACA,SAAA;EACA,QAAA;EACA,KAAA;AAAA;;UAIe,iBAAA;EACf,KAAA;EACA,IAAA,EAAM,MAAA;EACN,SAAA;IACE,UAAA;IACA,OAAA;IACA,OAAA;EAAA;EAEF,GAAA;AAAA;AAAA,cAGW,gBAAA;EAAA,iBACM,MAAA;EAAA,iBACA,QAAA;EAAA,iBACA,QAAA;cAEL,OAAA,EAAS,uBAAA;EASf,WAAA,CAAY,SAAA,UAAmB,IAAA,WAAe,OAAA,CAAQ,cAAA;EAOtD,UAAA,CAAW,SAAA,WAAoB,OAAA;EAI/B,cAAA,CAAA,GAAkB,OAAA,CAAQ,cAAA;EAAA,QAMlB,KAAA;AAAA;;;UCvCC,oBAAA;EDdc;ECgB7B,IAAA,GAAO,KAAA;IACL,IAAA;IACA,KAAA;IACA,aAAA;IACA,OAAA;EAAA;EDbF;ECgBA,KAAA;EDhBK;ECkBL,QAAA;EACA,OAAA;EACA,UAAA;AAAA;AAAA,cAYW,aAAA,SAAsB,mBAAA;EAAA,OAC1B,QAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SA8CA,UAAA,CAAA,GAAc,kBAAA;EAAA,SA6BZ,YAAA;EAAA,SACA,WAAA;EAAA,iBAEQ,SAAA;cAEL,OAAA,EAAS,oBAAA;EAmCrB,sBAAA,CAAA,GAA0B,mBAAA;EAqB1B,eAAA,CAAgB,MAAA,EAAQ,SAAA,GAAY,gBAAA;EAO9B,WAAA,CACJ,MAAA,WACA,MAAA,UACA,IAAA,UACA,KAAA,GAAQ,WAAA,GACP,OAAA;IAAU,SAAA;EAAA;EAMP,mBAAA,CAAoB,MAAA,WAAiB,MAAA,WAAiB,OAAA;EAK5D,gBAAA,CAAiB,GAAA,EAAK,MAAA,oBAA0B,eAAA;EAYhD,eAAA,CAAgB,GAAA,EAAK,MAAA,oBAA0B,aAAA;EAU/C,KAAA,CAAM,OAAA;EASN,IAAA,CAAK,OAAA;EAOL,OAAA,CAAA;EAWM,eAAA,CAAgB,IAAA,EAAM,YAAA,GAAe,OAAA,CAAQ,aAAA;EAuB7C,SAAA,CAAU,IAAA,EAAM,YAAA,GAAe,OAAA,CAAQ,aAAA;EAMvC,QAAA,CAAS,IAAA,EAAM,YAAA,GAAe,OAAA,CAAQ,aAAA;EAMtC,gBAAA,CACJ,IAAA,EAAM,YAAA,EACN,IAAA,EAAM,MAAA,oBACL,OAAA,CAAQ,aAAA;EAAA,QAOG,iBAAA;EAAA,QAyDN,cAAA;EAAA,QAsCA,oBAAA;EAAA,QAiBA,iBAAA;EA1PkB;EAwQ1B,aAAA,CAAc,OAAA,EAAS,MAAA;EAnPa;EAmSpC,UAAA,CAAW,SAAA,UAAmB,OAAA;EAvR3B;EAoSH,aAAA,CAAc,SAAA,UAAmB,OAAA;EAzRX;EAmStB,YAAA,CACE,SAAA,UACA,GAAA;IACE,EAAA;IACA,OAAA;IACA,OAAA;IACA,QAAA;IACA,SAAA;EAAA;AAAA"}