moltbot-wecom 1.0.2 → 2.0.0

package/dist/src/config-schema.d.ts

@@ -0,0 +1,211 @@
+/**
+ * WeCom config Zod schema for validation.
+ */
+import { z } from "zod";
+export declare const WeComConfigSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    proxyUrl: z.ZodOptional<z.ZodString>;
+    proxyToken: z.ZodOptional<z.ZodString>;
+    dmPolicy: z.ZodOptional<z.ZodEnum<["pairing", "allowlist", "open", "disabled"]>>;
+    allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
+    thinkingThresholdMs: z.ZodOptional<z.ZodNumber>;
+    botNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    pingIntervalMs: z.ZodOptional<z.ZodNumber>;
+    reconnectDelayMs: z.ZodOptional<z.ZodNumber>;
+} & {
+    accounts: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        proxyUrl: z.ZodOptional<z.ZodString>;
+        proxyToken: z.ZodOptional<z.ZodString>;
+        dmPolicy: z.ZodOptional<z.ZodEnum<["pairing", "allowlist", "open", "disabled"]>>;
+        allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
+        thinkingThresholdMs: z.ZodOptional<z.ZodNumber>;
+        botNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        pingIntervalMs: z.ZodOptional<z.ZodNumber>;
+        reconnectDelayMs: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string | undefined;
+        enabled?: boolean | undefined;
+        proxyUrl?: string | undefined;
+        proxyToken?: string | undefined;
+        dmPolicy?: "pairing" | "allowlist" | "open" | "disabled" | undefined;
+        allowFrom?: (string | number)[] | undefined;
+        thinkingThresholdMs?: number | undefined;
+        botNames?: string[] | undefined;
+        pingIntervalMs?: number | undefined;
+        reconnectDelayMs?: number | undefined;
+    }, {
+        name?: string | undefined;
+        enabled?: boolean | undefined;
+        proxyUrl?: string | undefined;
+        proxyToken?: string | undefined;
+        dmPolicy?: "pairing" | "allowlist" | "open" | "disabled" | undefined;
+        allowFrom?: (string | number)[] | undefined;
+        thinkingThresholdMs?: number | undefined;
+        botNames?: string[] | undefined;
+        pingIntervalMs?: number | undefined;
+        reconnectDelayMs?: number | undefined;
+    }>, z.objectOutputType<{}, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        proxyUrl: z.ZodOptional<z.ZodString>;
+        proxyToken: z.ZodOptional<z.ZodString>;
+        dmPolicy: z.ZodOptional<z.ZodEnum<["pairing", "allowlist", "open", "disabled"]>>;
+        allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
+        thinkingThresholdMs: z.ZodOptional<z.ZodNumber>;
+        botNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        pingIntervalMs: z.ZodOptional<z.ZodNumber>;
+        reconnectDelayMs: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string | undefined;
+        enabled?: boolean | undefined;
+        proxyUrl?: string | undefined;
+        proxyToken?: string | undefined;
+        dmPolicy?: "pairing" | "allowlist" | "open" | "disabled" | undefined;
+        allowFrom?: (string | number)[] | undefined;
+        thinkingThresholdMs?: number | undefined;
+        botNames?: string[] | undefined;
+        pingIntervalMs?: number | undefined;
+        reconnectDelayMs?: number | undefined;
+    }, {
+        name?: string | undefined;
+        enabled?: boolean | undefined;
+        proxyUrl?: string | undefined;
+        proxyToken?: string | undefined;
+        dmPolicy?: "pairing" | "allowlist" | "open" | "disabled" | undefined;
+        allowFrom?: (string | number)[] | undefined;
+        thinkingThresholdMs?: number | undefined;
+        botNames?: string[] | undefined;
+        pingIntervalMs?: number | undefined;
+        reconnectDelayMs?: number | undefined;
+    }>, "strip">, z.objectInputType<{}, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        proxyUrl: z.ZodOptional<z.ZodString>;
+        proxyToken: z.ZodOptional<z.ZodString>;
+        dmPolicy: z.ZodOptional<z.ZodEnum<["pairing", "allowlist", "open", "disabled"]>>;
+        allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
+        thinkingThresholdMs: z.ZodOptional<z.ZodNumber>;
+        botNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        pingIntervalMs: z.ZodOptional<z.ZodNumber>;
+        reconnectDelayMs: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string | undefined;
+        enabled?: boolean | undefined;
+        proxyUrl?: string | undefined;
+        proxyToken?: string | undefined;
+        dmPolicy?: "pairing" | "allowlist" | "open" | "disabled" | undefined;
+        allowFrom?: (string | number)[] | undefined;
+        thinkingThresholdMs?: number | undefined;
+        botNames?: string[] | undefined;
+        pingIntervalMs?: number | undefined;
+        reconnectDelayMs?: number | undefined;
+    }, {
+        name?: string | undefined;
+        enabled?: boolean | undefined;
+        proxyUrl?: string | undefined;
+        proxyToken?: string | undefined;
+        dmPolicy?: "pairing" | "allowlist" | "open" | "disabled" | undefined;
+        allowFrom?: (string | number)[] | undefined;
+        thinkingThresholdMs?: number | undefined;
+        botNames?: string[] | undefined;
+        pingIntervalMs?: number | undefined;
+        reconnectDelayMs?: number | undefined;
+    }>, "strip">>>;
+    defaultAccount: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    defaultAccount?: string | undefined;
+    accounts?: z.objectOutputType<{}, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        proxyUrl: z.ZodOptional<z.ZodString>;
+        proxyToken: z.ZodOptional<z.ZodString>;
+        dmPolicy: z.ZodOptional<z.ZodEnum<["pairing", "allowlist", "open", "disabled"]>>;
+        allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
+        thinkingThresholdMs: z.ZodOptional<z.ZodNumber>;
+        botNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        pingIntervalMs: z.ZodOptional<z.ZodNumber>;
+        reconnectDelayMs: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string | undefined;
+        enabled?: boolean | undefined;
+        proxyUrl?: string | undefined;
+        proxyToken?: string | undefined;
+        dmPolicy?: "pairing" | "allowlist" | "open" | "disabled" | undefined;
+        allowFrom?: (string | number)[] | undefined;
+        thinkingThresholdMs?: number | undefined;
+        botNames?: string[] | undefined;
+        pingIntervalMs?: number | undefined;
+        reconnectDelayMs?: number | undefined;
+    }, {
+        name?: string | undefined;
+        enabled?: boolean | undefined;
+        proxyUrl?: string | undefined;
+        proxyToken?: string | undefined;
+        dmPolicy?: "pairing" | "allowlist" | "open" | "disabled" | undefined;
+        allowFrom?: (string | number)[] | undefined;
+        thinkingThresholdMs?: number | undefined;
+        botNames?: string[] | undefined;
+        pingIntervalMs?: number | undefined;
+        reconnectDelayMs?: number | undefined;
+    }>, "strip"> | undefined;
+    name?: string | undefined;
+    enabled?: boolean | undefined;
+    proxyUrl?: string | undefined;
+    proxyToken?: string | undefined;
+    dmPolicy?: "pairing" | "allowlist" | "open" | "disabled" | undefined;
+    allowFrom?: (string | number)[] | undefined;
+    thinkingThresholdMs?: number | undefined;
+    botNames?: string[] | undefined;
+    pingIntervalMs?: number | undefined;
+    reconnectDelayMs?: number | undefined;
+}, {
+    defaultAccount?: string | undefined;
+    accounts?: z.objectInputType<{}, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        proxyUrl: z.ZodOptional<z.ZodString>;
+        proxyToken: z.ZodOptional<z.ZodString>;
+        dmPolicy: z.ZodOptional<z.ZodEnum<["pairing", "allowlist", "open", "disabled"]>>;
+        allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
+        thinkingThresholdMs: z.ZodOptional<z.ZodNumber>;
+        botNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        pingIntervalMs: z.ZodOptional<z.ZodNumber>;
+        reconnectDelayMs: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string | undefined;
+        enabled?: boolean | undefined;
+        proxyUrl?: string | undefined;
+        proxyToken?: string | undefined;
+        dmPolicy?: "pairing" | "allowlist" | "open" | "disabled" | undefined;
+        allowFrom?: (string | number)[] | undefined;
+        thinkingThresholdMs?: number | undefined;
+        botNames?: string[] | undefined;
+        pingIntervalMs?: number | undefined;
+        reconnectDelayMs?: number | undefined;
+    }, {
+        name?: string | undefined;
+        enabled?: boolean | undefined;
+        proxyUrl?: string | undefined;
+        proxyToken?: string | undefined;
+        dmPolicy?: "pairing" | "allowlist" | "open" | "disabled" | undefined;
+        allowFrom?: (string | number)[] | undefined;
+        thinkingThresholdMs?: number | undefined;
+        botNames?: string[] | undefined;
+        pingIntervalMs?: number | undefined;
+        reconnectDelayMs?: number | undefined;
+    }>, "strip"> | undefined;
+    name?: string | undefined;
+    enabled?: boolean | undefined;
+    proxyUrl?: string | undefined;
+    proxyToken?: string | undefined;
+    dmPolicy?: "pairing" | "allowlist" | "open" | "disabled" | undefined;
+    allowFrom?: (string | number)[] | undefined;
+    thinkingThresholdMs?: number | undefined;
+    botNames?: string[] | undefined;
+    pingIntervalMs?: number | undefined;
+    reconnectDelayMs?: number | undefined;
+}>;
+//# sourceMappingURL=config-schema.d.ts.map

package/dist/src/config-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-schema.d.ts","sourceRoot":"","sources":["../../src/config-schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG5B,CAAC"}

package/dist/src/config-schema.js

@@ -0,0 +1,21 @@
+/**
+ * WeCom config Zod schema for validation.
+ */
+import { z } from "zod";
+const allowFromEntry = z.union([z.string(), z.number()]);
+const wecomAccountSchema = z.object({
+    name: z.string().optional(),
+    enabled: z.boolean().optional(),
+    proxyUrl: z.string().optional(),
+    proxyToken: z.string().optional(),
+    dmPolicy: z.enum(["pairing", "allowlist", "open", "disabled"]).optional(),
+    allowFrom: z.array(allowFromEntry).optional(),
+    thinkingThresholdMs: z.number().optional(),
+    botNames: z.array(z.string()).optional(),
+    pingIntervalMs: z.number().optional(),
+    reconnectDelayMs: z.number().optional(),
+});
+export const WeComConfigSchema = wecomAccountSchema.extend({
+    accounts: z.object({}).catchall(wecomAccountSchema).optional(),
+    defaultAccount: z.string().optional(),
+});

package/dist/src/dedup.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Message deduplication — WeCom may deliver the same event more than once.
+ */
+/** Garbage-collect expired entries and check for duplicates. */
+export declare function isDuplicate(messageId: string | undefined | null): boolean;
+/** Clear all dedup state (for testing). */
+export declare function clearDedup(): void;
+//# sourceMappingURL=dedup.d.ts.map

package/dist/src/dedup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedup.d.ts","sourceRoot":"","sources":["../../src/dedup.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,gEAAgE;AAChE,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAYzE;AAED,2CAA2C;AAC3C,wBAAgB,UAAU,IAAI,IAAI,CAEjC"}

package/dist/src/dedup.js

@@ -0,0 +1,24 @@
+/**
+ * Message deduplication — WeCom may deliver the same event more than once.
+ */
+const SEEN_TTL_MS = 10 * 60 * 1000; // 10 minutes
+const seen = new Map();
+/** Garbage-collect expired entries and check for duplicates. */
+export function isDuplicate(messageId) {
+    const now = Date.now();
+    // GC old entries
+    for (const [k, ts] of seen) {
+        if (now - ts > SEEN_TTL_MS)
+            seen.delete(k);
+    }
+    if (!messageId)
+        return false;
+    if (seen.has(messageId))
+        return true;
+    seen.set(messageId, now);
+    return false;
+}
+/** Clear all dedup state (for testing). */
+export function clearDedup() {
+    seen.clear();
+}

package/dist/src/group-filter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Smart group chat reply filter.
+ *
+ * In group chats, only respond when the message looks like a real
+ * question, request, or direct address — avoids spamming.
+ */
+/**
+ * Determine whether the bot should respond to a group message.
+ *
+ * @param text - Message text (after stripping @mention placeholders)
+ * @param mentions - Array of mention objects from the event
+ * @param botNames - Custom bot name list for address detection
+ */
+export declare function shouldRespondInGroup(text: string, mentions?: unknown[], botNames?: string[]): boolean;
+//# sourceMappingURL=group-filter.d.ts.map

package/dist/src/group-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-filter.d.ts","sourceRoot":"","sources":["../../src/group-filter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,QAAQ,GAAE,OAAO,EAAO,EACxB,QAAQ,CAAC,EAAE,MAAM,EAAE,GAClB,OAAO,CA4BT"}

package/dist/src/group-filter.js

@@ -0,0 +1,43 @@
+/**
+ * Smart group chat reply filter.
+ *
+ * In group chats, only respond when the message looks like a real
+ * question, request, or direct address — avoids spamming.
+ */
+/** Default bot name patterns for address detection. */
+const DEFAULT_BOT_NAMES = ["clawdbot", "moltbot", "bot", "助手", "智能体", "小雀"];
+/**
+ * Determine whether the bot should respond to a group message.
+ *
+ * @param text - Message text (after stripping @mention placeholders)
+ * @param mentions - Array of mention objects from the event
+ * @param botNames - Custom bot name list for address detection
+ */
+export function shouldRespondInGroup(text, mentions = [], botNames) {
+    // Always respond to @-mentions
+    if (mentions.length > 0)
+        return true;
+    const t = text.toLowerCase();
+    // Ends with question mark
+    if (/[？?]$/.test(text))
+        return true;
+    // English question words
+    if (/\b(why|how|what|when|where|who|help)\b/.test(t))
+        return true;
+    // Chinese request verbs
+    const verbs = [
+        "帮", "麻烦", "请", "能否", "可以", "解释", "看看",
+        "排查", "分析", "总结", "写", "改", "修", "查", "对比", "翻译",
+    ];
+    if (verbs.some((k) => text.includes(k)))
+        return true;
+    // Direct address by bot name
+    const names = botNames?.length ? botNames : DEFAULT_BOT_NAMES;
+    const namePattern = new RegExp(`^(${names.map(escapeRegex).join("|")})[\\s,:，：]`, "i");
+    if (namePattern.test(text))
+        return true;
+    return false;
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/src/probe.d.ts

@@ -0,0 +1,10 @@
+/**
+ * WeCom API connectivity probe.
+ */
+import type { WeComProbeResult } from "./types.js";
+/**
+ * Probe the WeCom proxy by attempting a WebSocket connection.
+ * Returns quickly to check if the proxy is reachable.
+ */
+export declare function probeWeCom(proxyUrl: string, proxyToken: string, timeoutMs?: number): Promise<WeComProbeResult>;
+//# sourceMappingURL=probe.d.ts.map

package/dist/src/probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"probe.d.ts","sourceRoot":"","sources":["../../src/probe.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;;GAGG;AACH,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,SAAS,SAAO,GACf,OAAO,CAAC,gBAAgB,CAAC,CAqE3B"}

package/dist/src/probe.js

@@ -0,0 +1,70 @@
+/**
+ * WeCom API connectivity probe.
+ */
+/**
+ * Probe the WeCom proxy by attempting a WebSocket connection.
+ * Returns quickly to check if the proxy is reachable.
+ */
+export async function probeWeCom(proxyUrl, proxyToken, timeoutMs = 5000) {
+    if (!proxyUrl?.trim()) {
+        return { ok: false, error: "Missing proxyUrl", elapsedMs: 0 };
+    }
+    const startTime = Date.now();
+    try {
+        // Dynamic import for WebSocket (works in both Node and Bun)
+        const { default: WebSocket } = await import("ws");
+        return new Promise((resolve) => {
+            const url = proxyToken
+                ? `${proxyUrl}?token=${encodeURIComponent(proxyToken)}`
+                : proxyUrl;
+            const ws = new WebSocket(url);
+            let resolved = false;
+            const timeout = setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    ws.terminate();
+                    resolve({
+                        ok: false,
+                        error: `Connection timed out after ${timeoutMs}ms`,
+                        elapsedMs: Date.now() - startTime,
+                    });
+                }
+            }, timeoutMs);
+            ws.on("open", () => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    ws.close();
+                    resolve({ ok: true, elapsedMs: Date.now() - startTime });
+                }
+            });
+            ws.on("error", (err) => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    ws.terminate();
+                    resolve({
+                        ok: false,
+                        error: err instanceof Error ? err.message : String(err),
+                        elapsedMs: Date.now() - startTime,
+                    });
+                }
+            });
+            ws.on("close", () => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    resolve({ ok: true, elapsedMs: Date.now() - startTime });
+                }
+            });
+        });
+    }
+    catch (err) {
+        const elapsedMs = Date.now() - startTime;
+        return {
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+            elapsedMs,
+        };
+    }
+}

package/dist/src/receive.d.ts

@@ -0,0 +1,26 @@
+/**
+ * WeCom WebSocket message receive handler.
+ *
+ * Connects to WeCom via a WebSocket proxy, dispatches incoming
+ * messages to Clawdbot's channel reply infrastructure.
+ */
+import type { ClawdbotConfig } from "clawdbot/plugin-sdk";
+import type { ResolvedWeComAccount } from "./types.js";
+/** Options for the WeCom provider. */
+export type WeComProviderOptions = {
+    account: ResolvedWeComAccount;
+    config: ClawdbotConfig;
+    log: {
+        info: (msg: string) => void;
+        error: (msg: string) => void;
+        debug?: (msg: string) => void;
+        warn?: (msg: string) => void;
+    };
+    abortSignal?: AbortSignal;
+    statusSink?: (patch: Record<string, unknown>) => void;
+};
+/** Start the WeCom WebSocket provider. Returns a stop function. */
+export declare function startWeComProvider(options: WeComProviderOptions): {
+    stop: () => void;
+};
+//# sourceMappingURL=receive.d.ts.map

package/dist/src/receive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"receive.d.ts","sourceRoot":"","sources":["../../src/receive.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG1D,OAAO,KAAK,EAAE,oBAAoB,EAAwB,MAAM,YAAY,CAAC;AAM7E,sCAAsC;AACtC,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,oBAAoB,CAAC;IAC9B,MAAM,EAAE,cAAc,CAAC;IACvB,GAAG,EAAE;QACH,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;QAC5B,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;QAC7B,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;QAC9B,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;KAC9B,CAAC;IACF,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;CACvD,CAAC;AAWF,mEAAmE;AACnE,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,oBAAoB,GAAG;IAAE,IAAI,EAAE,MAAM,IAAI,CAAA;CAAE,CA4JtF"}