@yanhaidao/wecom 2.2.7 → 2.3.2

package/src/config/accounts.ts

@@ -5,66 +5,79 @@
 import type { OpenClawConfig } from "openclaw/plugin-sdk";
 import type {
     WecomConfig,
+    WecomAccountConfig,
     WecomBotConfig,
     WecomAgentConfig,
     WecomNetworkConfig,
+    ResolvedWecomAccount,
     ResolvedBotAccount,
     ResolvedAgentAccount,
     ResolvedMode,
     ResolvedWecomAccounts,
 } from "../types/index.js";
 
-const DEFAULT_ACCOUNT_ID = "default";
+export const DEFAULT_ACCOUNT_ID = "default";
+
+export type WecomAccountConflict = {
+    type: "duplicate_bot_token" | "duplicate_bot_aibotid" | "duplicate_agent_id";
+    accountId: string;
+    ownerAccountId: string;
+    message: string;
+};
 
 /**
  * 检测配置中启用的模式
  */
 export function detectMode(config: WecomConfig | undefined): ResolvedMode {
-    if (!config) return { bot: false, agent: false };
+    if (!config || config.enabled === false) return "disabled";
 
-    const botConfigured = Boolean(
-        config.bot?.token && config.bot?.encodingAESKey
-    );
-    const agentConfigured = Boolean(
-        config.agent?.corpId && config.agent?.corpSecret && config.agent?.agentId &&
-        config.agent?.token && config.agent?.encodingAESKey
-    );
+    const accounts = config.accounts;
+    if (accounts && typeof accounts === "object") {
+        const enabledEntries = Object.values(accounts).filter(
+            (entry) => entry && entry.enabled !== false,
+        );
+        if (enabledEntries.length > 0) return "matrix";
+    }
 
-    return { bot: botConfigured, agent: agentConfigured };
+    return "legacy";
 }
 
 /**
  * 解析 Bot 模式账号
  */
-function resolveBotAccount(config: WecomBotConfig): ResolvedBotAccount {
+function resolveBotAccount(accountId: string, config: WecomBotConfig, network?: WecomNetworkConfig): ResolvedBotAccount {
     return {
-        accountId: DEFAULT_ACCOUNT_ID,
+        accountId,
         enabled: true,
         configured: Boolean(config.token && config.encodingAESKey),
         token: config.token,
         encodingAESKey: config.encodingAESKey,
         receiveId: config.receiveId?.trim() ?? "",
         config,
+        network,
     };
 }
 
 /**
  * 解析 Agent 模式账号
  */
-function resolveAgentAccount(config: WecomAgentConfig, network?: WecomNetworkConfig): ResolvedAgentAccount {
+function resolveAgentAccount(accountId: string, config: WecomAgentConfig, network?: WecomNetworkConfig): ResolvedAgentAccount {
     const agentIdRaw = config.agentId;
-    const agentId = typeof agentIdRaw === "number" ? agentIdRaw : Number(agentIdRaw);
+    const agentId = agentIdRaw == null
+        ? undefined
+        : (typeof agentIdRaw === "number" ? agentIdRaw : Number(agentIdRaw));
+    const normalizedAgentId = Number.isFinite(agentId) ? agentId : undefined;
 
     return {
-        accountId: DEFAULT_ACCOUNT_ID,
+        accountId,
         enabled: true,
         configured: Boolean(
-            config.corpId && config.corpSecret && agentId &&
+            config.corpId && config.corpSecret &&
             config.token && config.encodingAESKey
         ),
         corpId: config.corpId,
         corpSecret: config.corpSecret,
-        agentId,
+        agentId: normalizedAgentId,
         token: config.token,
         encodingAESKey: config.encodingAESKey,
         config,
@@ -72,6 +85,218 @@ function resolveAgentAccount(config: WecomAgentConfig, network?: WecomNetworkCon
     };
 }
 
+function toResolvedAccount(params: {
+    accountId: string;
+    enabled: boolean;
+    name?: string;
+    config: WecomAccountConfig;
+    network?: WecomNetworkConfig;
+}): ResolvedWecomAccount {
+    const bot = params.config.bot
+        ? resolveBotAccount(params.accountId, params.config.bot, params.network)
+        : undefined;
+    const agent = params.config.agent
+        ? resolveAgentAccount(params.accountId, params.config.agent, params.network)
+        : undefined;
+    const configured = Boolean(bot?.configured || agent?.configured);
+    return {
+        accountId: params.accountId,
+        name: params.name,
+        enabled: params.enabled,
+        configured,
+        config: params.config,
+        bot,
+        agent,
+    };
+}
+
+function resolveMatrixAccounts(wecom: WecomConfig): Record<string, ResolvedWecomAccount> {
+    const accounts = wecom.accounts;
+    if (!accounts || typeof accounts !== "object") return {};
+
+    const resolved: Record<string, ResolvedWecomAccount> = {};
+    for (const [rawId, entry] of Object.entries(accounts)) {
+        const accountId = rawId.trim();
+        if (!accountId || !entry) continue;
+        const enabled = wecom.enabled !== false && entry.enabled !== false;
+        const config: WecomAccountConfig = {
+            enabled: entry.enabled,
+            name: entry.name,
+            bot: entry.bot,
+            agent: entry.agent,
+        };
+        resolved[accountId] = toResolvedAccount({
+            accountId,
+            enabled,
+            name: entry.name,
+            config,
+            network: wecom.network,
+        });
+    }
+    return resolved;
+}
+
+function resolveLegacyAccounts(wecom: WecomConfig): Record<string, ResolvedWecomAccount> {
+    const config: WecomAccountConfig = {
+        bot: wecom.bot,
+        agent: wecom.agent,
+    };
+    const account = toResolvedAccount({
+        accountId: DEFAULT_ACCOUNT_ID,
+        enabled: wecom.enabled !== false,
+        config,
+        network: wecom.network,
+    });
+    return { [DEFAULT_ACCOUNT_ID]: account };
+}
+
+function normalizeDuplicateKey(value: string): string {
+    return value.trim().toLowerCase();
+}
+
+function formatBotTokenConflict(params: { accountId: string; ownerAccountId: string }): WecomAccountConflict {
+    return {
+        type: "duplicate_bot_token",
+        accountId: params.accountId,
+        ownerAccountId: params.ownerAccountId,
+        message:
+            `Duplicate WeCom bot token: account "${params.accountId}" shares a token with account "${params.ownerAccountId}". ` +
+            "Keep one owner account per bot token.",
+    };
+}
+
+function formatBotAibotidConflict(params: { accountId: string; ownerAccountId: string }): WecomAccountConflict {
+    return {
+        type: "duplicate_bot_aibotid",
+        accountId: params.accountId,
+        ownerAccountId: params.ownerAccountId,
+        message:
+            `Duplicate WeCom bot aibotid: account "${params.accountId}" shares aibotid with account "${params.ownerAccountId}". ` +
+            "Keep one owner account per aibotid.",
+    };
+}
+
+function formatAgentIdConflict(params: { accountId: string; ownerAccountId: string; corpId: string; agentId: number }): WecomAccountConflict {
+    return {
+        type: "duplicate_agent_id",
+        accountId: params.accountId,
+        ownerAccountId: params.ownerAccountId,
+        message:
+            `Duplicate WeCom agent identity: account "${params.accountId}" shares corpId/agentId (${params.corpId}/${params.agentId}) with account "${params.ownerAccountId}". ` +
+            "Keep one owner account per corpId/agentId pair.",
+    };
+}
+
+function collectWecomAccountConflicts(cfg: OpenClawConfig): Map<string, WecomAccountConflict> {
+    const resolved = resolveWecomAccounts(cfg);
+    const conflicts = new Map<string, WecomAccountConflict>();
+    const botTokenOwners = new Map<string, string>();
+    const botAibotidOwners = new Map<string, string>();
+    const agentOwners = new Map<string, string>();
+
+    const accountIds = Object.keys(resolved.accounts).sort((a, b) => a.localeCompare(b));
+    for (const accountId of accountIds) {
+        const account = resolved.accounts[accountId];
+        if (!account || account.enabled === false) {
+            continue;
+        }
+        const bot = account.bot;
+        const agent = account.agent;
+
+        const botToken = bot?.token?.trim();
+        if (botToken) {
+            const key = normalizeDuplicateKey(botToken);
+            const owner = botTokenOwners.get(key);
+            if (owner && owner !== accountId) {
+                conflicts.set(accountId, formatBotTokenConflict({ accountId, ownerAccountId: owner }));
+            } else {
+                botTokenOwners.set(key, accountId);
+            }
+        }
+
+        const botAibotid = bot?.config.aibotid?.trim();
+        if (botAibotid) {
+            const key = normalizeDuplicateKey(botAibotid);
+            const owner = botAibotidOwners.get(key);
+            if (owner && owner !== accountId) {
+                conflicts.set(accountId, formatBotAibotidConflict({ accountId, ownerAccountId: owner }));
+            } else {
+                botAibotidOwners.set(key, accountId);
+            }
+        }
+
+        const corpId = agent?.corpId?.trim();
+        const agentId = agent?.agentId;
+        if (corpId && typeof agentId === "number" && Number.isFinite(agentId)) {
+            const key = `${normalizeDuplicateKey(corpId)}:${agentId}`;
+            const owner = agentOwners.get(key);
+            if (owner && owner !== accountId) {
+                conflicts.set(accountId, formatAgentIdConflict({ accountId, ownerAccountId: owner, corpId, agentId }));
+            } else {
+                agentOwners.set(key, accountId);
+            }
+        }
+    }
+
+    return conflicts;
+}
+
+export function resolveWecomAccountConflict(params: {
+    cfg: OpenClawConfig;
+    accountId: string;
+}): WecomAccountConflict | undefined {
+    return collectWecomAccountConflicts(params.cfg).get(params.accountId);
+}
+
+export function listWecomAccountIds(cfg: OpenClawConfig): string[] {
+    const wecom = cfg.channels?.wecom as WecomConfig | undefined;
+    const mode = detectMode(wecom);
+    if (mode === "matrix" && wecom?.accounts) {
+        const ids = Object.keys(wecom.accounts)
+            .map((id) => id.trim())
+            .filter(Boolean)
+            .sort((a, b) => a.localeCompare(b));
+        if (ids.length > 0) return ids;
+    }
+    return [DEFAULT_ACCOUNT_ID];
+}
+
+export function resolveDefaultWecomAccountId(cfg: OpenClawConfig): string {
+    const wecom = cfg.channels?.wecom as WecomConfig | undefined;
+    const ids = listWecomAccountIds(cfg);
+    const preferred = wecom?.defaultAccount?.trim();
+    if (preferred && ids.includes(preferred)) return preferred;
+    return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+
+export function resolveWecomAccount(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+}): ResolvedWecomAccount {
+    const resolved = resolveWecomAccounts(params.cfg);
+    const fallbackId = resolved.defaultAccountId;
+    const requestedId = params.accountId?.trim();
+    if (requestedId) {
+        return (
+            resolved.accounts[requestedId] ??
+            toResolvedAccount({
+                accountId: requestedId,
+                enabled: false,
+                config: {},
+            })
+        );
+    }
+    return (
+        resolved.accounts[fallbackId] ??
+        resolved.accounts[DEFAULT_ACCOUNT_ID] ??
+        toResolvedAccount({
+            accountId: fallbackId,
+            enabled: false,
+            config: {},
+        })
+    );
+}
+
 /**
  * 解析 WeCom 账号 (双模式)
  */
@@ -79,14 +304,24 @@ export function resolveWecomAccounts(cfg: OpenClawConfig): ResolvedWecomAccounts
     const wecom = cfg.channels?.wecom as WecomConfig | undefined;
 
     if (!wecom || wecom.enabled === false) {
-        return {};
+        return {
+            mode: "disabled",
+            defaultAccountId: DEFAULT_ACCOUNT_ID,
+            accounts: {},
+        };
     }
 
     const mode = detectMode(wecom);
+    const accounts = mode === "matrix" ? resolveMatrixAccounts(wecom) : resolveLegacyAccounts(wecom);
+    const defaultAccountId = resolveDefaultWecomAccountId(cfg);
+    const defaultAccount = accounts[defaultAccountId] ?? accounts[DEFAULT_ACCOUNT_ID];
 
     return {
-        bot: mode.bot && wecom.bot ? { ...resolveBotAccount(wecom.bot), network: wecom.network } : undefined,
-        agent: mode.agent && wecom.agent ? resolveAgentAccount(wecom.agent, wecom.network) : undefined,
+        mode,
+        defaultAccountId,
+        accounts,
+        bot: defaultAccount?.bot,
+        agent: defaultAccount?.agent,
     };
 }
 
@@ -94,6 +329,6 @@ export function resolveWecomAccounts(cfg: OpenClawConfig): ResolvedWecomAccounts
  * 检查是否有任何模式启用
  */
 export function isWecomEnabled(cfg: OpenClawConfig): boolean {
-    const accounts = resolveWecomAccounts(cfg);
-    return Boolean(accounts.bot?.configured || accounts.agent?.configured);
+    const resolved = resolveWecomAccounts(cfg);
+    return Object.values(resolved.accounts).some((account) => account.configured && account.enabled);
 }

package/src/config/index.ts

@@ -4,9 +4,15 @@
 
 export { WecomConfigSchema, type WecomConfigInput } from "./schema.js";
 export {
+    DEFAULT_ACCOUNT_ID,
     detectMode,
+    listWecomAccountIds,
+    resolveDefaultWecomAccountId,
+    resolveWecomAccount,
+    resolveWecomAccountConflict,
     resolveWecomAccounts,
     isWecomEnabled,
 } from "./accounts.js";
 export { resolveWecomEgressProxyUrl, resolveWecomEgressProxyUrlFromNetwork } from "./network.js";
 export { DEFAULT_WECOM_MEDIA_MAX_BYTES, resolveWecomMediaMaxBytes } from "./media.js";
+export { resolveWecomFailClosedOnDefaultRoute, shouldRejectWecomDefaultRoute } from "./routing.js";

package/src/config/network.ts

@@ -3,11 +3,15 @@ import type { OpenClawConfig } from "openclaw/plugin-sdk";
 import type { WecomConfig, WecomNetworkConfig } from "../types/index.js";
 
 export function resolveWecomEgressProxyUrlFromNetwork(network?: WecomNetworkConfig): string | undefined {
-  const env = (process.env.OPENCLAW_WECOM_EGRESS_PROXY_URL ?? process.env.WECOM_EGRESS_PROXY_URL ?? "").trim();
-  if (env) return env;
-
-  const fromCfg = network?.egressProxyUrl?.trim() ?? "";
-  return fromCfg || undefined;
+  const proxyUrl = network?.egressProxyUrl ??
+    process.env.OPENCLAW_WECOM_EGRESS_PROXY_URL ??
+    process.env.WECOM_EGRESS_PROXY_URL ??
+    process.env.HTTPS_PROXY ??
+    process.env.ALL_PROXY ??
+    process.env.HTTP_PROXY ??
+    "";
+    
+  return proxyUrl.trim() || undefined;
 }
 
 export function resolveWecomEgressProxyUrl(cfg: OpenClawConfig): string | undefined {

package/src/config/routing.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+
+import { resolveWecomFailClosedOnDefaultRoute, shouldRejectWecomDefaultRoute } from "./routing.js";
+
+describe("resolveWecomFailClosedOnDefaultRoute", () => {
+    it("defaults to true in matrix mode", () => {
+        const cfg: OpenClawConfig = {
+            channels: {
+                wecom: {
+                    enabled: true,
+                    accounts: {
+                        a: { enabled: true, bot: { token: "t1", encodingAESKey: "k1" } },
+                    },
+                },
+            },
+        } as OpenClawConfig;
+        expect(resolveWecomFailClosedOnDefaultRoute(cfg)).toBe(true);
+    });
+
+    it("defaults to false in legacy mode", () => {
+        const cfg: OpenClawConfig = {
+            channels: {
+                wecom: {
+                    enabled: true,
+                    bot: { token: "t1", encodingAESKey: "k1" },
+                },
+            },
+        } as OpenClawConfig;
+        expect(resolveWecomFailClosedOnDefaultRoute(cfg)).toBe(false);
+    });
+
+    it("respects explicit override", () => {
+        const cfg: OpenClawConfig = {
+            channels: {
+                wecom: {
+                    enabled: true,
+                    bot: { token: "t1", encodingAESKey: "k1" },
+                    routing: { failClosedOnDefaultRoute: true },
+                },
+            },
+        } as OpenClawConfig;
+        expect(resolveWecomFailClosedOnDefaultRoute(cfg)).toBe(true);
+    });
+});
+
+describe("shouldRejectWecomDefaultRoute", () => {
+    const matrixCfg = {
+        channels: {
+            wecom: {
+                enabled: true,
+                accounts: {
+                    a: { enabled: true, bot: { token: "t1", encodingAESKey: "k1" } },
+                },
+            },
+        },
+    } as OpenClawConfig;
+
+    it("rejects default route in matrix mode when dynamic agent is disabled", () => {
+        expect(
+            shouldRejectWecomDefaultRoute({
+                cfg: matrixCfg,
+                matchedBy: "default",
+                useDynamicAgent: false,
+            }),
+        ).toBe(true);
+    });
+
+    it("does not reject when route already matched a binding", () => {
+        expect(
+            shouldRejectWecomDefaultRoute({
+                cfg: matrixCfg,
+                matchedBy: "binding.account",
+                useDynamicAgent: false,
+            }),
+        ).toBe(false);
+    });
+
+    it("does not reject when dynamic agent routing is enabled", () => {
+        expect(
+            shouldRejectWecomDefaultRoute({
+                cfg: matrixCfg,
+                matchedBy: "default",
+                useDynamicAgent: true,
+            }),
+        ).toBe(false);
+    });
+});

package/src/config/routing.ts

@@ -0,0 +1,26 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+
+import type { WecomConfig } from "../types/index.js";
+import { detectMode } from "./accounts.js";
+
+/**
+ * 默认策略：
+ * - matrix（多账号）: 开启 fail-closed，防止未绑定账号回退到 main
+ * - legacy（单账号兼容）: 维持历史行为，不强制拦截
+ */
+export function resolveWecomFailClosedOnDefaultRoute(cfg: OpenClawConfig): boolean {
+    const wecom = cfg.channels?.wecom as WecomConfig | undefined;
+    const explicit = wecom?.routing?.failClosedOnDefaultRoute;
+    if (typeof explicit === "boolean") return explicit;
+    return detectMode(wecom) === "matrix";
+}
+
+export function shouldRejectWecomDefaultRoute(params: {
+    cfg: OpenClawConfig;
+    matchedBy: string;
+    useDynamicAgent: boolean;
+}): boolean {
+    if (params.matchedBy !== "default") return false;
+    if (params.useDynamicAgent) return false;
+    return resolveWecomFailClosedOnDefaultRoute(params.cfg);
+}

package/src/config/schema.ts

@@ -4,6 +4,14 @@
 
 import { z } from "zod";
 
+function bindToJsonSchema<T extends z.ZodTypeAny>(schema: T): T {
+    const anySchema = schema as unknown as { toJSONSchema?: (...args: any[]) => unknown };
+    if (typeof anySchema.toJSONSchema === "function") {
+        anySchema.toJSONSchema = anySchema.toJSONSchema.bind(schema) as any;
+    }
+    return schema;
+}
+
 /**
  * **dmSchema (单聊配置)**
  * 
@@ -50,6 +58,16 @@ const networkSchema = z.object({
     egressProxyUrl: z.string().optional(),
 }).optional();
 
+/**
+ * **routingSchema (路由策略配置)**
+ *
+ * 控制未命中 bindings 时的回退行为。
+ * @property failClosedOnDefaultRoute - true=拒绝 default 回退，false=允许回退默认 agent
+ */
+const routingSchema = z.object({
+    failClosedOnDefaultRoute: z.boolean().optional(),
+}).optional();
+
 /**
  * **botSchema (Bot 模式配置)**
  * 
@@ -62,8 +80,10 @@ const networkSchema = z.object({
  * @property dm - 单聊策略覆盖配置
  */
 const botSchema = z.object({
+    aibotid: z.string().optional(),
     token: z.string(),
     encodingAESKey: z.string(),
+    botIds: z.array(z.string()).optional(),
     receiveId: z.string().optional(),
     streamPlaceholderContent: z.string().optional(),
     welcomeText: z.string().optional(),
@@ -76,7 +96,7 @@ const botSchema = z.object({
  * 用于配置企业微信自建应用 (Agent)。
  * @property corpId - 企业 ID (CorpID)
  * @property corpSecret - 应用 Secret
- * @property agentId - 应用 AgentId (数字)
+ * @property agentId - 应用 AgentId (数字，可选)
  * @property token - 回调配置 Token
  * @property encodingAESKey - 回调配置 EncodingAESKey
  * @property welcomeText - (可选) 欢迎语
@@ -85,7 +105,7 @@ const botSchema = z.object({
 const agentSchema = z.object({
     corpId: z.string(),
     corpSecret: z.string(),
-    agentId: z.union([z.string(), z.number()]),
+    agentId: z.union([z.string(), z.number()]).optional(),
     token: z.string(),
     encodingAESKey: z.string(),
     welcomeText: z.string().optional(),
@@ -108,14 +128,25 @@ const dynamicAgentsSchema = z.object({
     adminUsers: z.array(z.string()).optional(),
 }).optional();
 
+/** Matrix 账号条目 */
+const accountSchema = z.object({
+    enabled: z.boolean().optional(),
+    name: z.string().optional(),
+    bot: botSchema,
+    agent: agentSchema,
+});
+
 /** 顶层 WeCom 配置 Schema */
-export const WecomConfigSchema = z.object({
+export const WecomConfigSchema = bindToJsonSchema(z.object({
     enabled: z.boolean().optional(),
     bot: botSchema,
     agent: agentSchema,
+    accounts: z.record(z.string(), accountSchema).optional(),
+    defaultAccount: z.string().optional(),
     media: mediaSchema,
     network: networkSchema,
+    routing: routingSchema,
     dynamicAgents: dynamicAgentsSchema,
-});
+}));
 
 export type WecomConfigInput = z.infer<typeof WecomConfigSchema>;

package/src/config-schema.ts

@@ -1,41 +1,5 @@
-import { z } from "zod";
-
-const allowFromEntry = z.union([z.string(), z.number()]);
-
-const dmSchema = z
-  .object({
-    enabled: z.boolean().optional(),
-    policy: z.enum(["pairing", "allowlist", "open", "disabled"]).optional(),
-    allowFrom: z.array(allowFromEntry).optional(),
-  })
-  .optional();
-
-export const WecomConfigSchema = z.object({
-  name: z.string().optional(),
-  enabled: z.boolean().optional(),
-
-  webhookPath: z.string().optional(),
-  token: z.string().optional(),
-  encodingAESKey: z.string().optional(),
-  receiveId: z.string().optional(),
-
-  streamPlaceholderContent: z.string().optional(),
-  debounceMs: z.number().optional(),
-
-  welcomeText: z.string().optional(),
-  dm: dmSchema,
-
-  defaultAccount: z.string().optional(),
-  accounts: z.object({}).catchall(z.object({
-    name: z.string().optional(),
-    enabled: z.boolean().optional(),
-    webhookPath: z.string().optional(),
-    token: z.string().optional(),
-    encodingAESKey: z.string().optional(),
-    receiveId: z.string().optional(),
-    streamPlaceholderContent: z.string().optional(),
-    debounceMs: z.number().optional(),
-    welcomeText: z.string().optional(),
-    dm: dmSchema,
-  })).optional(),
-});
+/**
+ * Backward-compatible schema export.
+ * Canonical schema lives in `src/config/schema.ts`.
+ */
+export { WecomConfigSchema, type WecomConfigInput } from "./config/schema.js";

package/src/dynamic-agent.account-scope.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+
+import { generateAgentId } from "./dynamic-agent.js";
+
+describe("generateAgentId account scoping", () => {
+  it("generates different ids for same peer across accounts", () => {
+    const a = generateAgentId("dm", "zhangsan", "acct-a");
+    const b = generateAgentId("dm", "zhangsan", "acct-b");
+    expect(a).toBe("wecom-acct-a-dm-zhangsan");
+    expect(b).toBe("wecom-acct-b-dm-zhangsan");
+    expect(a).not.toBe(b);
+  });
+
+  it("falls back to default account scope when accountId is omitted", () => {
+    expect(generateAgentId("group", "wr123456")).toBe("wecom-default-group-wr123456");
+  });
+});