@aigne/afs-matrix 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,457 @@
+let _aigne_afs_provider = require("@aigne/afs/provider");
+let _aigne_afs_messaging = require("@aigne/afs-messaging");
+
+//#region src/client.ts
+/**
+* MatrixClient — pure Matrix Client-Server API wrapper.
+*
+* Zero external dependencies (uses native fetch).
+* No AFS or application-specific concepts.
+*/
+const DEFAULT_TIMEOUT = 3e4;
+let _txnCounter = 0;
+var MatrixClient = class {
+	_accessToken;
+	_homeserver;
+	_timeout;
+	constructor(options) {
+		if (!options.accessToken) throw new Error("MatrixClient requires an accessToken");
+		if (!options.homeserver) throw new Error("MatrixClient requires a homeserver");
+		this._accessToken = options.accessToken;
+		this._homeserver = options.homeserver.replace(/\/+$/, "");
+		this._timeout = options.timeout ?? DEFAULT_TIMEOUT;
+	}
+	async sendMessage(roomId, text) {
+		const txnId = `m${Date.now()}.${_txnCounter++}`;
+		return this._call("PUT", `/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`, {
+			msgtype: "m.text",
+			body: text
+		});
+	}
+	async sendTyping(roomId, userId, timeout = 1e4) {
+		await this._call("PUT", `/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/typing/${encodeURIComponent(userId)}`, {
+			typing: true,
+			timeout
+		});
+	}
+	async sync(since, timeout) {
+		const params = new URLSearchParams();
+		if (since) params.set("since", since);
+		if (timeout !== void 0) params.set("timeout", String(timeout));
+		return this._call("GET", `/_matrix/client/v3/sync?${params.toString()}`);
+	}
+	async whoami() {
+		return this._call("GET", "/_matrix/client/v3/account/whoami");
+	}
+	async _call(method, path, body) {
+		const headers = { Authorization: `Bearer ${this._accessToken}` };
+		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._homeserver}${path}`, init);
+		if (!response.ok) {
+			const desc = (await response.text().catch(() => "")).replace(this._accessToken, "***");
+			throw new Error(`Matrix 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 AFSMatrix = class extends _aigne_afs_messaging.BaseMessageProvider {
+	static manifest() {
+		return {
+			name: "matrix",
+			description: "Matrix messaging — decentralized, federated chat protocol.\n- Sync long-poll for real-time message reception\n- Multi-bot support with per-bot room monitoring\n- Path: /:bot/conversations/:roomId/messages/:eventId",
+			uriTemplate: "matrix://{homeserver}",
+			category: "messaging",
+			schema: {
+				type: "object",
+				properties: {
+					homeserver: {
+						type: "string",
+						description: "Matrix homeserver URL"
+					},
+					accessToken: {
+						type: "string",
+						description: "Matrix access token",
+						sensitive: true
+					},
+					rooms: {
+						type: "array",
+						items: { type: "string" },
+						description: "Room IDs to monitor"
+					}
+				},
+				required: ["homeserver", "accessToken"]
+			},
+			tags: [
+				"matrix",
+				"messaging",
+				"chat",
+				"decentralized",
+				"federated"
+			],
+			capabilityTags: [
+				"read-write",
+				"crud",
+				"search",
+				"auth:token",
+				"remote",
+				"http",
+				"real-time"
+			],
+			security: {
+				riskLevel: "external",
+				resourceAccess: ["internet"],
+				notes: ["Connects to Matrix homeserver — 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: ["MATRIX_ACCESS_TOKEN"]
+			},
+			bestFor: [
+				"decentralized chat",
+				"federated messaging",
+				"privacy-focused comms"
+			],
+			notFor: ["file storage", "database queries"]
+		};
+	}
+	providerName = "matrix";
+	eventPrefix = "matrix";
+	_syncStates = /* @__PURE__ */ new Map();
+	_userIds = /* @__PURE__ */ new Map();
+	constructor(options) {
+		let bots;
+		if (options.bots) {
+			bots = options.bots.map((b) => ({
+				name: b.name,
+				accessToken: b.token,
+				homeserver: b.homeserver,
+				conversations: b.conversations
+			}));
+			for (const bot of options.bots) {
+				if (!bot.token) throw new Error(`AFSMatrix bot "${bot.name}" requires a token`);
+				if (!bot.homeserver) throw new Error(`AFSMatrix bot "${bot.name}" requires a homeserver`);
+			}
+		} else {
+			if (!options.accessToken) throw new Error("AFSMatrix requires an accessToken");
+			if (!options.homeserver) throw new Error("AFSMatrix requires a homeserver");
+			bots = [{
+				name: "default",
+				accessToken: options.accessToken,
+				homeserver: options.homeserver,
+				conversations: options.rooms ?? []
+			}];
+		}
+		super({
+			bots,
+			bufferSize: options.bufferSize
+		});
+		for (const bot of bots) this._syncStates.set(bot.name, {
+			syncing: false,
+			disposed: false,
+			abort: null,
+			backoff: 1e3,
+			nextBatch: null
+		});
+	}
+	getMessageCapabilities() {
+		return {
+			formats: {
+				send: ["text", "markdown"],
+				receive: ["text"]
+			},
+			maxMessageLength: 65536,
+			features: {
+				edit: true,
+				delete: false,
+				reply: true,
+				thread: true,
+				reaction: true,
+				inlineKeyboard: false
+			},
+			limits: { messagesPerSecond: 10 }
+		};
+	}
+	createBotClient(config) {
+		return new MatrixClient({
+			accessToken: config.accessToken,
+			homeserver: config.homeserver
+		});
+	}
+	async sendMessage(client, convId, text, _opts) {
+		return { messageId: (await client.sendMessage(convId, text)).event_id };
+	}
+	async sendTypingIndicator(client, convId) {
+		const mc = client;
+		const botName = [...this._botClients.entries()].find(([, c]) => c === client)?.[0] ?? "";
+		let userId = this._userIds.get(botName);
+		if (!userId) {
+			userId = (await mc.whoami()).user_id;
+			this._userIds.set(botName, userId);
+		}
+		await mc.sendTyping(convId, userId);
+	}
+	normalizeMessage(raw) {
+		const evt = raw;
+		return {
+			id: String(evt.event_id ?? "0"),
+			text: String(evt.content?.body ?? ""),
+			from: this.normalizeSender({ sender: evt.sender }),
+			timestamp: evt.origin_server_ts ? Math.floor(evt.origin_server_ts / 1e3) : Math.floor(Date.now() / 1e3),
+			conversationId: String(evt.room_id ?? ""),
+			platform: { event_id: evt.event_id }
+		};
+	}
+	normalizeSender(raw) {
+		const sender = String(raw.sender ?? raw.id ?? "");
+		return {
+			id: sender,
+			name: sender.match(/^@([^:]+):/)?.[1] ?? sender
+		};
+	}
+	start(botName) {
+		const names = botName ? [botName] : [...this._syncStates.keys()];
+		for (const name of names) {
+			const state = this._syncStates.get(name);
+			if (!state || state.syncing || state.disposed) continue;
+			state.syncing = true;
+			this._syncLoop(name);
+		}
+	}
+	stop(botName) {
+		const names = botName ? [botName] : [...this._syncStates.keys()];
+		for (const name of names) {
+			const state = this._syncStates.get(name);
+			if (!state) continue;
+			state.syncing = false;
+			if (state.abort) {
+				state.abort.abort();
+				state.abort = null;
+			}
+		}
+	}
+	dispose() {
+		for (const [, state] of this._syncStates) {
+			state.syncing = false;
+			state.disposed = true;
+			if (state.abort) {
+				state.abort.abort();
+				state.abort = null;
+			}
+		}
+	}
+	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: "Start sync loop for updates" } }),
+			this.buildEntry("/.actions/stop", { meta: { description: "Stop sync loop" } }),
+			this.buildEntry("/.actions/process-event", { meta: { description: "Inject a Matrix event externally" } })
+		] };
+	}
+	async execStart(_ctx) {
+		this.start();
+		return {
+			success: true,
+			data: {
+				ok: true,
+				syncing: true
+			}
+		};
+	}
+	async execStop(_ctx) {
+		this.stop();
+		return {
+			success: true,
+			data: {
+				ok: true,
+				syncing: false
+			}
+		};
+	}
+	async execProcessEvent(_ctx, args) {
+		this._processEvent(args);
+		return {
+			success: true,
+			data: { ok: true }
+		};
+	}
+	async _syncLoop(botName) {
+		const state = this._syncStates.get(botName);
+		const client = this._getClient(botName);
+		if (!state || !client) return;
+		while (state.syncing && !state.disposed) try {
+			state.abort = new AbortController();
+			const response = await client.sync(state.nextBatch ?? void 0, 3e4);
+			state.nextBatch = response.next_batch;
+			if (response.rooms?.join) for (const [roomId, room] of Object.entries(response.rooms.join)) {
+				const events = room.timeline?.events ?? [];
+				for (const evt of events) if (evt.type === "m.room.message" && evt.content?.msgtype === "m.text") {
+					const text = String(evt.content.body ?? "").trim();
+					if (!text) continue;
+					this.emitMessageReceived(botName, {
+						id: String(evt.event_id),
+						text,
+						from: this.normalizeSender({ sender: evt.sender }),
+						timestamp: evt.origin_server_ts ? Math.floor(evt.origin_server_ts / 1e3) : Math.floor(Date.now() / 1e3),
+						conversationId: roomId,
+						platform: { event_id: evt.event_id }
+					});
+				}
+			}
+			state.backoff = 1e3;
+		} catch (err) {
+			if (state.disposed) break;
+			const msg = err instanceof Error ? err.message : "";
+			if (/API error (401|403)/.test(msg)) {
+				state.syncing = false;
+				break;
+			}
+			await new Promise((r) => setTimeout(r, state.backoff));
+			state.backoff = Math.min(state.backoff * 2, 6e4);
+		}
+	}
+	/** Process an externally-provided Matrix event. Public for testing. */
+	_processEvent(payload) {
+		const botName = payload.botName ?? this._botOrder[0] ?? "default";
+		const evt = payload;
+		const eventId = String(evt.event_id ?? evt.id ?? Date.now());
+		const sender = String(evt.sender ?? "");
+		const body = String(evt.content?.body ?? evt.body ?? "").trim();
+		const roomId = String(evt.room_id ?? evt.roomId ?? "");
+		const originServerTs = evt.origin_server_ts ?? evt.timestamp;
+		if (!body) return;
+		this.emitMessageReceived(botName, {
+			id: eventId,
+			text: body,
+			from: this.normalizeSender({ sender }),
+			timestamp: originServerTs ? Math.floor(Number(originServerTs) / 1e3) : Math.floor(Date.now() / 1e3),
+			conversationId: roomId,
+			platform: { event_id: eventId }
+		});
+	}
+	/** Add a room to a bot. Defaults to first bot. */
+	addRoom(roomId, botName) {
+		const name = botName ?? this._botOrder[0];
+		if (!name) return;
+		const convs = this._botConversations.get(name);
+		if (!convs || convs.has(roomId)) return;
+		convs.add(roomId);
+		const buffers = this._botBuffers.get(name);
+		if (buffers && !buffers.has(roomId)) buffers.set(roomId, []);
+	}
+	/** Remove a room from a bot. */
+	removeRoom(roomId, botName) {
+		const name = botName ?? this._botOrder[0];
+		if (!name) return;
+		const convs = this._botConversations.get(name);
+		if (convs) convs.delete(roomId);
+		const buffers = this._botBuffers.get(name);
+		if (buffers) buffers.delete(roomId);
+	}
+	/** Add a message to the ring buffer directly. Public for testing/conformance. */
+	_addToBuffer(roomId, msg) {
+		const botName = this._botOrder[0] ?? "default";
+		const convs = this._botConversations.get(botName);
+		if (convs && !convs.has(roomId)) convs.add(roomId);
+		let botBuffers = this._botBuffers.get(botName);
+		if (!botBuffers) {
+			botBuffers = /* @__PURE__ */ new Map();
+			this._botBuffers.set(botName, botBuffers);
+		}
+		let buffer = botBuffers.get(roomId);
+		if (!buffer) {
+			buffer = [];
+			botBuffers.set(roomId, buffer);
+		}
+		const senderName = msg.sender.match(/^@([^:]+):/)?.[1] ?? msg.sender;
+		buffer.push({
+			id: msg.event_id,
+			text: msg.body,
+			from: {
+				id: msg.sender,
+				name: senderName
+			},
+			timestamp: msg.origin_server_ts ? Math.floor(msg.origin_server_ts / 1e3) : Math.floor(Date.now() / 1e3),
+			conversationId: roomId,
+			platform: { event_id: msg.event_id }
+		});
+		while (buffer.length > this._bufferSize) buffer.shift();
+	}
+};
+__decorate([(0, _aigne_afs_provider.Actions)("/")], AFSMatrix.prototype, "listRootActions", null);
+__decorate([_aigne_afs_provider.Actions.Exec("/", "start")], AFSMatrix.prototype, "execStart", null);
+__decorate([_aigne_afs_provider.Actions.Exec("/", "stop")], AFSMatrix.prototype, "execStop", null);
+__decorate([_aigne_afs_provider.Actions.Exec("/", "process-event")], AFSMatrix.prototype, "execProcessEvent", null);
+
+//#endregion
+exports.AFSMatrix = AFSMatrix;

package/dist/index.d.cts

@@ -0,0 +1,156 @@
+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
+/**
+ * MatrixClient — pure Matrix Client-Server API wrapper.
+ *
+ * Zero external dependencies (uses native fetch).
+ * No AFS or application-specific concepts.
+ */
+interface MatrixClientOptions {
+  accessToken: string;
+  homeserver: string;
+  timeout?: number;
+}
+/** Matrix room message event (subset). */
+interface MatrixEvent {
+  event_id: string;
+  type: string;
+  sender: string;
+  content: {
+    msgtype?: string;
+    body?: string;
+    [key: string]: unknown;
+  };
+  origin_server_ts: number;
+  room_id?: string;
+}
+/** Matrix sync response (subset). */
+interface MatrixSyncResponse {
+  next_batch: string;
+  rooms?: {
+    join?: Record<string, {
+      timeline?: {
+        events?: MatrixEvent[];
+      };
+    }>;
+  };
+}
+/** Matrix whoami response. */
+interface MatrixWhoamiResponse {
+  user_id: string;
+  device_id?: string;
+}
+declare class MatrixClient {
+  private readonly _accessToken;
+  private readonly _homeserver;
+  private readonly _timeout;
+  constructor(options: MatrixClientOptions);
+  sendMessage(roomId: string, text: string): Promise<{
+    event_id: string;
+  }>;
+  sendTyping(roomId: string, userId: string, timeout?: number): Promise<void>;
+  sync(since?: string, timeout?: number): Promise<MatrixSyncResponse>;
+  whoami(): Promise<MatrixWhoamiResponse>;
+  private _call;
+}
+//#endregion
+//#region src/index.d.ts
+interface AFSMatrixOptions {
+  /** Multi-bot config */
+  bots?: Array<{
+    name: string;
+    token: string;
+    homeserver: string;
+    conversations?: string[];
+  }>;
+  /** Single-bot shorthand: access token */
+  accessToken?: string;
+  /** Single-bot shorthand: homeserver URL */
+  homeserver?: string;
+  /** Single-bot shorthand: room IDs to monitor */
+  rooms?: string[];
+  bufferSize?: number;
+}
+declare class AFSMatrix extends BaseMessageProvider {
+  static manifest(): {
+    name: string;
+    description: string;
+    uriTemplate: string;
+    category: string;
+    schema: {
+      type: string;
+      properties: {
+        homeserver: {
+          type: string;
+          description: string;
+        };
+        accessToken: {
+          type: string;
+          description: string;
+          sensitive: boolean;
+        };
+        rooms: {
+          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 = "matrix";
+  readonly eventPrefix = "matrix";
+  private readonly _syncStates;
+  private readonly _userIds;
+  constructor(options: AFSMatrixOptions);
+  getMessageCapabilities(): MessageCapabilities;
+  createBotClient(config: BotConfig): MatrixClient;
+  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 _syncLoop;
+  /** Process an externally-provided Matrix event. Public for testing. */
+  _processEvent(payload: Record<string, unknown>): void;
+  /** Add a room to a bot. Defaults to first bot. */
+  addRoom(roomId: string, botName?: string): void;
+  /** Remove a room from a bot. */
+  removeRoom(roomId: string, botName?: string): void;
+  /** Add a message to the ring buffer directly. Public for testing/conformance. */
+  _addToBuffer(roomId: string, msg: {
+    event_id: string;
+    sender: string;
+    body: string;
+    origin_server_ts?: number;
+  }): void;
+}
+//#endregion
+export { AFSMatrix, AFSMatrixOptions, type MatrixClient, type MatrixEvent, type MatrixSyncResponse, type MatrixWhoamiResponse };
+//# 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":";;;;;;;;;;AASA;UAAiB,mBAAA;EACf,WAAA;EACA,UAAA;EACA,OAAA;AAAA;;UAIe,WAAA;EACf,QAAA;EACA,IAAA;EACA,MAAA;EACA,OAAA;IACE,OAAA;IACA,IAAA;IAAA,CACC,GAAA;EAAA;EAEH,gBAAA;EACA,OAAA;AAAA;;UAIe,kBAAA;EACf,UAAA;EACA,KAAA;IACE,IAAA,GAAO,MAAA;MAGH,QAAA;QACE,MAAA,GAAS,WAAA;MAAA;IAAA;EAAA;AAAA;;UAQF,oBAAA;EACf,OAAA;EACA,SAAA;AAAA;AAAA,cAKW,YAAA;EAAA,iBACM,YAAA;EAAA,iBACA,WAAA;EAAA,iBACA,QAAA;cAEL,OAAA,EAAS,mBAAA;EAUf,WAAA,CAAY,MAAA,UAAgB,IAAA,WAAe,OAAA;IAAU,QAAA;EAAA;EASrD,UAAA,CAAW,MAAA,UAAgB,MAAA,UAAgB,OAAA,YAAkB,OAAA;EAQ7D,IAAA,CAAK,KAAA,WAAgB,OAAA,YAAmB,OAAA,CAAQ,kBAAA;EAOhD,MAAA,CAAA,GAAU,OAAA,CAAQ,oBAAA;EAAA,QAMV,KAAA;AAAA;;;UC1DC,gBAAA;EDbf;ECeA,IAAA,GAAO,KAAA;IACL,IAAA;IACA,KAAA;IACA,UAAA;IACA,aAAA;EAAA;EDdF;ECiBA,WAAA;EDfE;ECiBF,UAAA;EDdM;ECgBN,KAAA;EACA,UAAA;AAAA;AAAA,cAWW,SAAA,SAAkB,mBAAA;EAAA,OACtB,QAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SA6BA,UAAA,CAAA,GAAc,kBAAA;EAAA,SA6BZ,YAAA;EAAA,SACA,WAAA;EAAA,iBAEQ,WAAA;EAAA,iBACA,QAAA;cAEL,OAAA,EAAS,gBAAA;EAyCrB,sBAAA,CAAA,GAA0B,mBAAA;EAqB1B,eAAA,CAAgB,MAAA,EAAQ,SAAA,GAAY,YAAA;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;EAa5D,gBAAA,CAAiB,GAAA,EAAK,MAAA,oBAA0B,eAAA;EAchD,eAAA,CAAgB,GAAA,EAAK,MAAA,oBAA0B,aAAA;EAa/C,KAAA,CAAM,OAAA;EAUN,IAAA,CAAK,OAAA;EAaL,OAAA,CAAA;EAcM,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,SAAA;EAtRJ;EA+UV,aAAA,CAAc,OAAA,EAAS,MAAA;EApUF;EAgWrB,OAAA,CAAQ,MAAA,UAAgB,OAAA;EAlUH;EA+UrB,UAAA,CAAW,MAAA,UAAgB,OAAA;EAnQD;EA6Q1B,YAAA,CACE,MAAA,UACA,GAAA;IACE,QAAA;IACA,MAAA;IACA,IAAA;IACA,gBAAA;EAAA;AAAA"}