@aigne/afs-lark 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,468 @@
+let _aigne_afs_provider = require("@aigne/afs/provider");
+let _aigne_afs_messaging = require("@aigne/afs-messaging");
+
+//#region src/client.ts
+/**
+* LarkClient — pure Lark (Feishu) API wrapper.
+*
+* Two modes:
+* - Webhook: outbound-only, POST to Incoming Webhook URL
+* - Bot: bidirectional, send via App Bot API with tenant_access_token
+*
+* Zero external dependencies (uses native fetch).
+* No AFS or application-specific concepts.
+*/
+const DEFAULT_API_BASE = "https://open.feishu.cn/open-apis";
+const DEFAULT_TIMEOUT = 3e4;
+/** 5-minute buffer before token expiry to trigger refresh */
+const TOKEN_REFRESH_BUFFER_MS = 3e5;
+var LarkClient = class LarkClient {
+	mode;
+	_webhookUrl;
+	_appId;
+	_appSecret;
+	_apiBase;
+	_timeout;
+	_tenantAccessToken = null;
+	_tokenExpiresAt = 0;
+	constructor(opts) {
+		this.mode = opts.mode;
+		this._webhookUrl = opts.webhookUrl ?? null;
+		this._appId = opts.appId ?? null;
+		this._appSecret = opts.appSecret ?? null;
+		this._apiBase = opts.apiBase ?? DEFAULT_API_BASE;
+		this._timeout = opts.timeout ?? DEFAULT_TIMEOUT;
+	}
+	static webhook(url, options) {
+		if (!url) throw new Error("LarkClient.webhook requires a webhook URL");
+		let parsed;
+		try {
+			parsed = new URL(url);
+		} catch {
+			throw new Error("LarkClient.webhook: invalid webhook URL");
+		}
+		const isLocal = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+		if (parsed.protocol !== "https:" && !isLocal) throw new Error("LarkClient.webhook: webhook URL must use HTTPS (or localhost for testing)");
+		return new LarkClient({
+			mode: "webhook",
+			webhookUrl: url,
+			timeout: options?.timeout
+		});
+	}
+	static bot(options) {
+		if (!options.appId) throw new Error("LarkClient.bot requires an appId");
+		if (!options.appSecret) throw new Error("LarkClient.bot requires an appSecret");
+		return new LarkClient({
+			mode: "bot",
+			appId: options.appId,
+			appSecret: options.appSecret,
+			apiBase: options.apiBase,
+			timeout: options.timeout
+		});
+	}
+	async sendWebhook(text) {
+		if (!this._webhookUrl) throw new Error("sendWebhook requires webhook mode");
+		const payload = {
+			msg_type: "text",
+			content: { text }
+		};
+		const response = await fetch(this._webhookUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(payload),
+			signal: AbortSignal.timeout(this._timeout)
+		});
+		if (!response.ok) {
+			const desc = await response.text().catch(() => "");
+			throw new Error(`Lark webhook error ${response.status}: ${desc}`);
+		}
+	}
+	async sendMessage(chatId, text, options) {
+		await this._ensureToken();
+		const body = {
+			receive_id: chatId,
+			content: JSON.stringify({ text }),
+			msg_type: "text"
+		};
+		if (options?.replyTo) body.reply_in_thread = true;
+		const response = await fetch(`${this._apiBase}/im/v1/messages?receive_id_type=chat_id`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${this._tenantAccessToken}`
+			},
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(this._timeout)
+		});
+		if (!response.ok) {
+			const desc = await response.text().catch(() => "");
+			const safeDesc = this._appSecret ? desc.replace(this._appSecret, "***") : desc;
+			throw new Error(`Lark API error ${response.status}: ${safeDesc}`);
+		}
+		const data = await response.json();
+		if (data.code !== 0) throw new Error(`Lark API error: ${data.msg} (code ${data.code})`);
+		return { messageId: data.data?.message_id ?? "" };
+	}
+	static parseEvent(payload) {
+		if (!payload) return null;
+		if (payload.type === "url_verification" && payload.challenge) return {
+			type: "url_verification",
+			challenge: payload.challenge
+		};
+		const header = payload.header ?? payload.schema;
+		const event = payload.event;
+		if (!event) return null;
+		if ((header?.event_type ?? payload.event_type) !== "im.message.receive_v1") return null;
+		const message = event.message;
+		if (!message) return null;
+		const messageId = message.message_id ?? "";
+		const chatId = message.chat_id ?? "";
+		const messageType = message.message_type ?? "text";
+		let content = "";
+		try {
+			content = JSON.parse(message.content ?? "{}").text ?? "";
+		} catch {
+			content = String(message.content ?? "");
+		}
+		const sender = event.sender ?? {};
+		const senderId = sender.sender_id?.open_id ?? sender.sender_id?.user_id ?? "";
+		const senderType = sender.sender_type ?? "user";
+		if (!content.trim() || !senderId) return null;
+		return {
+			type: "message",
+			messageId,
+			chatId,
+			messageType,
+			content: content.trim(),
+			senderId,
+			senderType
+		};
+	}
+	/** Ensure we have a valid tenant access token, refreshing if needed. */
+	async _ensureToken() {
+		if (this._tenantAccessToken && Date.now() < this._tokenExpiresAt - TOKEN_REFRESH_BUFFER_MS) return;
+		if (!this._appId || !this._appSecret) throw new Error("Token refresh requires bot mode (appId + appSecret)");
+		const response = await fetch(`${this._apiBase}/auth/v3/tenant_access_token/internal`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				app_id: this._appId,
+				app_secret: this._appSecret
+			}),
+			signal: AbortSignal.timeout(this._timeout)
+		});
+		if (!response.ok) {
+			const desc = await response.text().catch(() => "");
+			throw new Error(`Lark token refresh error ${response.status}: ${desc}`);
+		}
+		const data = await response.json();
+		if (data.code !== 0 || !data.tenant_access_token) throw new Error(`Lark token refresh failed: ${data.msg} (code ${data.code})`);
+		this._tenantAccessToken = data.tenant_access_token;
+		this._tokenExpiresAt = Date.now() + (data.expire ?? 7200) * 1e3;
+	}
+	static escapeMarkdown(text) {
+		return text.replace(/([*_~`|\\])/g, "\\$1");
+	}
+};
+
+//#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 AFSLark = class extends _aigne_afs_messaging.BaseMessageProvider {
+	static manifest() {
+		return {
+			name: "lark",
+			description: "Lark/Feishu (飞书) messaging — webhook or bot API with auto token refresh.\n- Webhook mode for simple outbound notifications\n- Bot mode with app credentials for bidirectional messaging\n- Path: /:bot/conversations/:chatId/messages/:msgId",
+			uriTemplate: "lark://{appId}",
+			category: "messaging",
+			schema: {
+				type: "object",
+				properties: {
+					appId: {
+						type: "string",
+						description: "Lark App ID"
+					},
+					appSecret: {
+						type: "string",
+						description: "Lark App Secret",
+						sensitive: true
+					},
+					webhook: {
+						type: "string",
+						description: "Webhook URL for outbound-only mode",
+						sensitive: true
+					},
+					chatIds: {
+						type: "array",
+						items: { type: "string" },
+						description: "Chat IDs to monitor"
+					}
+				}
+			},
+			tags: [
+				"lark",
+				"feishu",
+				"messaging",
+				"chat",
+				"enterprise"
+			],
+			capabilityTags: [
+				"read-write",
+				"crud",
+				"search",
+				"auth:token",
+				"remote",
+				"http",
+				"real-time",
+				"rate-limited"
+			],
+			security: {
+				riskLevel: "external",
+				resourceAccess: ["internet"],
+				notes: ["Connects to Lark/Feishu API — requires app credentials or webhook URL"]
+			},
+			capabilities: { network: {
+				egress: true,
+				allowedDomains: ["open.feishu.cn", "open.larksuite.com"]
+			} }
+		};
+	}
+	static treeSchema() {
+		return {
+			operations: [
+				"list",
+				"read",
+				"exec",
+				"stat",
+				"explain"
+			],
+			tree: {
+				"/": {
+					kind: "messaging:root",
+					operations: ["list", "exec"],
+					actions: [
+						"add-bot",
+						"remove-bot",
+						"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: "custom",
+				env: ["LARK_APP_ID", "LARK_APP_SECRET"]
+			},
+			bestFor: [
+				"enterprise messaging",
+				"workflow alerts",
+				"team collaboration"
+			],
+			notFor: ["file storage", "database queries"]
+		};
+	}
+	providerName = "lark";
+	eventPrefix = "lark";
+	constructor(options) {
+		let bots;
+		if (options.bots) bots = options.bots.map((b) => ({
+			...b,
+			conversations: b.chatIds
+		}));
+		else {
+			if (!options.appId && !options.webhook) throw new Error("AFSLark requires either appId+appSecret or webhook");
+			bots = [{
+				name: "default",
+				appId: options.appId,
+				appSecret: options.appSecret,
+				webhook: options.webhook,
+				conversations: options.chatIds ?? [],
+				apiBase: options.apiBase
+			}];
+		}
+		super({
+			bots,
+			bufferSize: options.bufferSize
+		});
+	}
+	getMessageCapabilities() {
+		return {
+			formats: {
+				send: ["text", "markdown"],
+				receive: ["text"]
+			},
+			maxMessageLength: 4096,
+			features: {
+				edit: false,
+				delete: false,
+				reply: true,
+				thread: true,
+				reaction: true,
+				inlineKeyboard: true
+			},
+			limits: { messagesPerSecond: 5 }
+		};
+	}
+	createBotClient(config) {
+		const appId = config.appId;
+		const appSecret = config.appSecret;
+		const webhook = config.webhook;
+		const apiBase = config.apiBase;
+		if (appId && appSecret) return LarkClient.bot({
+			appId,
+			appSecret,
+			apiBase
+		});
+		if (webhook) return LarkClient.webhook(webhook);
+		throw new Error(`Lark bot "${config.name}" requires appId+appSecret or webhook`);
+	}
+	async sendMessage(client, convId, text, _opts) {
+		const lc = client;
+		if (lc.mode === "bot") return lc.sendMessage(convId, text);
+		await lc.sendWebhook(text);
+		return { messageId: String(Date.now()) };
+	}
+	async sendTypingIndicator(_client, _convId) {}
+	normalizeMessage(raw) {
+		const msg = raw;
+		let text = "";
+		if (typeof msg.content === "string") try {
+			text = JSON.parse(msg.content).text ?? "";
+		} catch {
+			text = msg.content;
+		}
+		else text = String(msg.content ?? msg.text ?? "");
+		return {
+			id: String(msg.message_id ?? msg.messageId ?? "0"),
+			text,
+			from: this.normalizeSender(msg.sender ?? {}),
+			timestamp: Math.floor(Date.now() / 1e3),
+			conversationId: String(msg.chat_id ?? msg.chatId ?? ""),
+			platform: { message_type: msg.message_type ?? msg.messageType }
+		};
+	}
+	normalizeSender(raw) {
+		const senderId = raw.sender_id;
+		return {
+			id: String(senderId?.open_id ?? raw.open_id ?? raw.id ?? "0"),
+			name: String(raw.name ?? raw.sender_type ?? ""),
+			isBot: raw.sender_type === "app" ? true : void 0
+		};
+	}
+	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/process-event", { meta: { description: "Process an incoming Lark event callback payload" } })
+		] };
+	}
+	async execProcessEvent(_ctx, args) {
+		return {
+			success: true,
+			data: this._processEvent(args) ?? { ok: true }
+		};
+	}
+	/** Process a Lark event callback payload. Returns challenge response for url_verification. */
+	_processEvent(payload) {
+		const parsed = LarkClient.parseEvent(payload);
+		if (!parsed) return { ok: true };
+		if (parsed.type === "url_verification") return { challenge: parsed.challenge };
+		if (parsed.senderType === "app") return { ok: true };
+		const botName = this._botOrder[0] ?? "default";
+		this.emitMessageReceived(botName, {
+			id: parsed.messageId,
+			text: parsed.content,
+			from: {
+				id: parsed.senderId,
+				name: parsed.senderType
+			},
+			timestamp: Math.floor(Date.now() / 1e3),
+			conversationId: parsed.chatId,
+			platform: { message_type: parsed.messageType }
+		});
+		return { ok: true };
+	}
+	/** Add a chat to a bot. Defaults to first bot. */
+	addChat(chatId, botName) {
+		const name = botName ?? this._botOrder[0];
+		if (!name) return;
+		const convs = this._botConversations.get(name);
+		if (!convs || convs.has(chatId)) return;
+		convs.add(chatId);
+		const buffers = this._botBuffers.get(name);
+		if (buffers && !buffers.has(chatId)) buffers.set(chatId, []);
+	}
+	/** Remove a chat from a bot. */
+	removeChat(chatId, botName) {
+		const name = botName ?? this._botOrder[0];
+		if (!name) return;
+		const convs = this._botConversations.get(name);
+		if (convs) convs.delete(chatId);
+		const buffers = this._botBuffers.get(name);
+		if (buffers) buffers.delete(chatId);
+	}
+	/** Add a message to the ring buffer directly. Public for testing/conformance. */
+	_addToBuffer(chatId, msg) {
+		const botName = this._botOrder[0] ?? "default";
+		const convs = this._botConversations.get(botName);
+		if (convs && !convs.has(chatId)) convs.add(chatId);
+		let botBuffers = this._botBuffers.get(botName);
+		if (!botBuffers) {
+			botBuffers = /* @__PURE__ */ new Map();
+			this._botBuffers.set(botName, botBuffers);
+		}
+		let buffer = botBuffers.get(chatId);
+		if (!buffer) {
+			buffer = [];
+			botBuffers.set(chatId, buffer);
+		}
+		buffer.push({
+			id: msg.messageId,
+			text: msg.content,
+			from: {
+				id: msg.senderId,
+				name: msg.senderName ?? msg.senderId
+			},
+			timestamp: Math.floor(Date.now() / 1e3),
+			conversationId: chatId,
+			platform: {}
+		});
+		while (buffer.length > this._bufferSize) buffer.shift();
+	}
+};
+__decorate([(0, _aigne_afs_provider.Actions)("/")], AFSLark.prototype, "listRootActions", null);
+__decorate([_aigne_afs_provider.Actions.Exec("/", "process-event")], AFSLark.prototype, "execProcessEvent", null);
+
+//#endregion
+exports.AFSLark = AFSLark;

package/dist/index.d.cts

@@ -0,0 +1,166 @@
+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
+/**
+ * LarkClient — pure Lark (Feishu) API wrapper.
+ *
+ * Two modes:
+ * - Webhook: outbound-only, POST to Incoming Webhook URL
+ * - Bot: bidirectional, send via App Bot API with tenant_access_token
+ *
+ * Zero external dependencies (uses native fetch).
+ * No AFS or application-specific concepts.
+ */
+interface LarkBotOptions {
+  appId: string;
+  appSecret: string;
+  apiBase?: string;
+  timeout?: number;
+}
+interface SendMessageOptions {
+  /** Reply to a specific message */
+  replyTo?: string;
+}
+/** Parsed Lark event callback. */
+type LarkParsedEvent = {
+  type: "url_verification";
+  challenge: string;
+} | {
+  type: "message";
+  messageId: string;
+  chatId: string;
+  messageType: string;
+  content: string;
+  senderId: string;
+  senderType: string;
+} | null;
+declare class LarkClient {
+  readonly mode: "webhook" | "bot";
+  private readonly _webhookUrl;
+  private readonly _appId;
+  private readonly _appSecret;
+  private readonly _apiBase;
+  private readonly _timeout;
+  private _tenantAccessToken;
+  private _tokenExpiresAt;
+  private constructor();
+  static webhook(url: string, options?: {
+    timeout?: number;
+  }): LarkClient;
+  static bot(options: LarkBotOptions): LarkClient;
+  sendWebhook(text: string): Promise<void>;
+  sendMessage(chatId: string, text: string, options?: SendMessageOptions): Promise<{
+    messageId: string;
+  }>;
+  static parseEvent(payload: any): LarkParsedEvent;
+  /** Ensure we have a valid tenant access token, refreshing if needed. */
+  private _ensureToken;
+  static escapeMarkdown(text: string): string;
+}
+//#endregion
+//#region src/index.d.ts
+interface AFSLarkOptions {
+  /** Multi-bot config */
+  bots?: Array<{
+    name: string;
+    appId?: string;
+    appSecret?: string;
+    webhook?: string;
+    chatIds?: string[];
+    apiBase?: string;
+  }>;
+  /** Single-bot shorthand: webhook URL (outbound only) */
+  webhook?: string;
+  /** Single-bot shorthand: app ID */
+  appId?: string;
+  /** Single-bot shorthand: app secret */
+  appSecret?: string;
+  /** Single-bot shorthand: chat IDs to monitor */
+  chatIds?: string[];
+  apiBase?: string;
+  bufferSize?: number;
+}
+declare class AFSLark extends BaseMessageProvider {
+  static manifest(): {
+    name: string;
+    description: string;
+    uriTemplate: string;
+    category: string;
+    schema: {
+      type: string;
+      properties: {
+        appId: {
+          type: string;
+          description: string;
+        };
+        appSecret: {
+          type: string;
+          description: string;
+          sensitive: boolean;
+        };
+        webhook: {
+          type: string;
+          description: string;
+          sensitive: boolean;
+        };
+        chatIds: {
+          type: string;
+          items: {
+            type: string;
+          };
+          description: string;
+        };
+      };
+    };
+    tags: string[];
+    capabilityTags: string[];
+    security: {
+      riskLevel: string;
+      resourceAccess: string[];
+      notes: string[];
+    };
+    capabilities: {
+      network: {
+        egress: boolean;
+        allowedDomains: string[];
+      };
+    };
+  };
+  static treeSchema(): ProviderTreeSchema;
+  readonly providerName = "lark";
+  readonly eventPrefix = "lark";
+  constructor(options: AFSLarkOptions);
+  getMessageCapabilities(): MessageCapabilities;
+  createBotClient(config: BotConfig): LarkClient;
+  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;
+  listRootActions(_ctx: RouteContext): Promise<AFSListResult>;
+  execProcessEvent(_ctx: RouteContext, args: Record<string, unknown>): Promise<AFSExecResult>;
+  /** Process a Lark event callback payload. Returns challenge response for url_verification. */
+  _processEvent(payload: any): {
+    ok: true;
+  } | {
+    challenge: string;
+  };
+  /** Add a chat to a bot. Defaults to first bot. */
+  addChat(chatId: string, botName?: string): void;
+  /** Remove a chat from a bot. */
+  removeChat(chatId: string, botName?: string): void;
+  /** Add a message to the ring buffer directly. Public for testing/conformance. */
+  _addToBuffer(chatId: string, msg: {
+    messageId: string;
+    content: string;
+    chatId?: string;
+    senderId: string;
+    senderName?: string;
+  }): void;
+}
+//#endregion
+export { AFSLark, AFSLarkOptions, type LarkClient, type LarkParsedEvent };
+//# 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":";;;;;;;;;;AAiBA;;;;;UAAiB,cAAA;EACf,KAAA;EACA,SAAA;EACA,OAAA;EACA,OAAA;AAAA;AAAA,UAGe,kBAAA;;EAEf,OAAA;AAAA;AAIF;AAAA,KAAY,eAAA;EACN,IAAA;EAA0B,SAAA;AAAA;EAE1B,IAAA;EACA,SAAA;EACA,MAAA;EACA,WAAA;EACA,OAAA;EACA,QAAA;EACA,UAAA;AAAA;AAAA,cAIO,UAAA;EAAA,SACF,IAAA;EAAA,iBACQ,WAAA;EAAA,iBACA,MAAA;EAAA,iBACA,UAAA;EAAA,iBACA,QAAA;EAAA,iBACA,QAAA;EAAA,QAET,kBAAA;EAAA,QACA,eAAA;EAAA,QAED,WAAA,CAAA;EAAA,OAkBA,OAAA,CAAQ,GAAA,UAAa,OAAA;IAAY,OAAA;EAAA,IAAqB,UAAA;EAAA,OAsBtD,GAAA,CAAI,OAAA,EAAS,cAAA,GAAiB,UAAA;EAc/B,WAAA,CAAY,IAAA,WAAe,OAAA;EAuB3B,WAAA,CACJ,MAAA,UACA,IAAA,UACA,OAAA,GAAU,kBAAA,GACT,OAAA;IAAU,SAAA;EAAA;EAAA,OA6CN,UAAA,CAAW,OAAA,QAAe,eAAA;EAnIhB;EAAA,QAuLH,YAAA;EAAA,OA0CP,cAAA,CAAe,IAAA;AAAA;;;UC9OP,cAAA;EDDX;ECGJ,IAAA,GAAO,KAAA;IACL,IAAA;IACA,KAAA;IACA,SAAA;IACA,OAAA;IACA,OAAA;IACA,OAAA;EAAA;;EAGF,OAAA;ED+CoB;EC7CpB,KAAA;ED2DiC;ECzDjC,SAAA;EDoFG;EClFH,OAAA;EACA,OAAA;EACA,UAAA;AAAA;AAAA,cAGW,OAAA,SAAgB,mBAAA;EAAA,OACpB,QAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SA0CA,UAAA,CAAA,GAAc,kBAAA;EAAA,SA6BZ,YAAA;EAAA,SACA,WAAA;cAEG,OAAA,EAAS,cAAA;EA4BrB,sBAAA,CAAA,GAA0B,mBAAA;EAqB1B,eAAA,CAAgB,MAAA,EAAQ,SAAA,GAAY,UAAA;EAe9B,WAAA,CACJ,MAAA,WACA,MAAA,UACA,IAAA,UACA,KAAA,GAAQ,WAAA,GACP,OAAA;IAAU,SAAA;EAAA;EAYP,mBAAA,CAAoB,OAAA,WAAkB,OAAA,WAAkB,OAAA;EAE9D,gBAAA,CAAiB,GAAA,EAAK,MAAA,oBAA0B,eAAA;EA0BhD,eAAA,CAAgB,GAAA,EAAK,MAAA,oBAA0B,aAAA;EAYzC,eAAA,CAAgB,IAAA,EAAM,YAAA,GAAe,OAAA,CAAQ,aAAA;EAiB7C,gBAAA,CACJ,IAAA,EAAM,YAAA,EACN,IAAA,EAAM,MAAA,oBACL,OAAA,CAAQ,aAAA;;EAQX,aAAA,CAAc,OAAA;IAAiB,EAAA;EAAA;IAAe,SAAA;EAAA;EAjFpC;EA8GV,OAAA,CAAQ,MAAA,UAAgB,OAAA;EAjGsC;EA8G9D,UAAA,CAAW,MAAA,UAAgB,OAAA;EA5GqB;EAsHhD,YAAA,CACE,MAAA,UACA,GAAA;IACE,SAAA;IACA,OAAA;IACA,MAAA;IACA,QAAA;IACA,UAAA;EAAA;AAAA"}