@copilotkit/shared 0.0.0-0.0.0-max-changeset-10101010101010-20260109191632

package/dist/utils/random-id.mjs

@@ -0,0 +1,13 @@
+import {
+  dataToUUID,
+  isValidUUID,
+  randomId,
+  randomUUID
+} from "../chunk-BOKE4OKY.mjs";
+export {
+  dataToUUID,
+  isValidUUID,
+  randomId,
+  randomUUID
+};
+//# sourceMappingURL=random-id.mjs.map

package/dist/utils/random-id.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/utils/requests.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Safely read a Response/Request body with sensible defaults:
+ * - clones the response/request to avoid consuming the original response/request
+ * - Skips GET/HEAD
+ * - Tries JSON first regardless of content-type
+ * - Falls back to text and optionally parses when it "looks" like JSON
+ */
+declare function readBody<T extends Response | Request>(r: T): Promise<unknown>;
+
+export { readBody };

package/dist/utils/requests.js

@@ -0,0 +1,91 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/requests.ts
+var requests_exports = {};
+__export(requests_exports, {
+  readBody: () => readBody
+});
+module.exports = __toCommonJS(requests_exports);
+async function readBody(r) {
+  const method = "method" in r ? r.method.toUpperCase() : void 0;
+  if (method === "GET" || method === "HEAD") {
+    return void 0;
+  }
+  if (!("body" in r) || r.body == null) {
+    return void 0;
+  }
+  try {
+    return await r.clone().json();
+  } catch {
+    try {
+      const text = await r.clone().text();
+      const trimmed = text.trim();
+      if (trimmed.length === 0)
+        return text;
+      if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        try {
+          return JSON.parse(trimmed);
+        } catch {
+          return text;
+        }
+      }
+      return text;
+    } catch {
+      try {
+        const c = r.clone();
+        const stream = c.body ?? null;
+        if (!stream)
+          return void 0;
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        let out = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          if (typeof value === "string") {
+            out += value;
+          } else {
+            out += decoder.decode(value, { stream: true });
+          }
+        }
+        out += decoder.decode();
+        const trimmed = out.trim();
+        if (trimmed.length === 0)
+          return out;
+        if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+          try {
+            return JSON.parse(trimmed);
+          } catch {
+            return out;
+          }
+        }
+        return out;
+      } catch {
+        return void 0;
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readBody
+});
+//# sourceMappingURL=requests.js.map

package/dist/utils/requests.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/requests.ts"],"sourcesContent":["/**\n * Safely read a Response/Request body with sensible defaults:\n * - clones the response/request to avoid consuming the original response/request\n * - Skips GET/HEAD\n * - Tries JSON first regardless of content-type\n * - Falls back to text and optionally parses when it \"looks\" like JSON\n */\nexport async function readBody<T extends Response | Request>(r: T): Promise<unknown> {\n  // skip GET/HEAD requests (unchanged)\n  const method = \"method\" in r ? r.method.toUpperCase() : undefined;\n  if (method === \"GET\" || method === \"HEAD\") {\n    return undefined;\n  }\n\n  // no body at all → undefined (unchanged)\n  if (!(\"body\" in r) || r.body == null) {\n    return undefined;\n  }\n\n  // 1) try JSON (unchanged)\n  try {\n    return await r.clone().json();\n  } catch {\n    // 2) try text (unchanged + your whitespace/JSON-heuristic)\n    try {\n      const text = await r.clone().text();\n      const trimmed = text.trim();\n\n      if (trimmed.length === 0) return text;\n\n      if (trimmed.startsWith(\"{\") || trimmed.startsWith(\"[\")) {\n        try {\n          return JSON.parse(trimmed);\n        } catch {\n          return text;\n        }\n      }\n      return text;\n    } catch {\n      // 3) FINAL FALLBACK: manual read that accepts string or bytes\n      try {\n        const c = r.clone();\n        const stream: ReadableStream | null = c.body ?? null;\n        if (!stream) return undefined;\n\n        const reader = stream.getReader();\n        const decoder = new TextDecoder();\n        let out = \"\";\n\n        while (true) {\n          const { done, value } = await reader.read();\n          if (done) break;\n          if (typeof value === \"string\") {\n            out += value; // accept string chunks\n          } else {\n            out += decoder.decode(value, { stream: true }); // bytes\n          }\n        }\n        out += decoder.decode(); // flush\n\n        const trimmed = out.trim();\n        if (trimmed.length === 0) return out;\n\n        if (trimmed.startsWith(\"{\") || trimmed.startsWith(\"[\")) {\n          try {\n            return JSON.parse(trimmed);\n          } catch {\n            return out;\n          }\n        }\n        return out;\n      } catch {\n        return undefined; // same \"give up\" behavior you had\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,eAAsB,SAAuC,GAAwB;AAEnF,QAAM,SAAS,YAAY,IAAI,EAAE,OAAO,YAAY,IAAI;AACxD,MAAI,WAAW,SAAS,WAAW,QAAQ;AACzC,WAAO;AAAA,EACT;AAGA,MAAI,EAAE,UAAU,MAAM,EAAE,QAAQ,MAAM;AACpC,WAAO;AAAA,EACT;AAGA,MAAI;AACF,WAAO,MAAM,EAAE,MAAM,EAAE,KAAK;AAAA,EAC9B,QAAE;AAEA,QAAI;AACF,YAAM,OAAO,MAAM,EAAE,MAAM,EAAE,KAAK;AAClC,YAAM,UAAU,KAAK,KAAK;AAE1B,UAAI,QAAQ,WAAW;AAAG,eAAO;AAEjC,UAAI,QAAQ,WAAW,GAAG,KAAK,QAAQ,WAAW,GAAG,GAAG;AACtD,YAAI;AACF,iBAAO,KAAK,MAAM,OAAO;AAAA,QAC3B,QAAE;AACA,iBAAO;AAAA,QACT;AAAA,MACF;AACA,aAAO;AAAA,IACT,QAAE;AAEA,UAAI;AACF,cAAM,IAAI,EAAE,MAAM;AAClB,cAAM,SAAgC,EAAE,QAAQ;AAChD,YAAI,CAAC;AAAQ,iBAAO;AAEpB,cAAM,SAAS,OAAO,UAAU;AAChC,cAAM,UAAU,IAAI,YAAY;AAChC,YAAI,MAAM;AAEV,eAAO,MAAM;AACX,gBAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAC1C,cAAI;AAAM;AACV,cAAI,OAAO,UAAU,UAAU;AAC7B,mBAAO;AAAA,UACT,OAAO;AACL,mBAAO,QAAQ,OAAO,OAAO,EAAE,QAAQ,KAAK,CAAC;AAAA,UAC/C;AAAA,QACF;AACA,eAAO,QAAQ,OAAO;AAEtB,cAAM,UAAU,IAAI,KAAK;AACzB,YAAI,QAAQ,WAAW;AAAG,iBAAO;AAEjC,YAAI,QAAQ,WAAW,GAAG,KAAK,QAAQ,WAAW,GAAG,GAAG;AACtD,cAAI;AACF,mBAAO,KAAK,MAAM,OAAO;AAAA,UAC3B,QAAE;AACA,mBAAO;AAAA,UACT;AAAA,QACF;AACA,eAAO;AAAA,MACT,QAAE;AACA,eAAO;AAAA,MACT;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/utils/requests.mjs

@@ -0,0 +1,7 @@
+import {
+  readBody
+} from "../chunk-XEMZTHQZ.mjs";
+export {
+  readBody
+};
+//# sourceMappingURL=requests.mjs.map

package/dist/utils/requests.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/utils/types.d.ts

@@ -0,0 +1,20 @@
+type MaybePromise<T> = T | PromiseLike<T>;
+/**
+ * More specific utility for records with at least one key
+ */
+type NonEmptyRecord<T> = T extends Record<string, unknown> ? (keyof T extends never ? never : T) : never;
+/**
+ * Type representing an agent's basic information
+ */
+interface AgentDescription {
+    name: string;
+    className: string;
+    description: string;
+}
+interface RuntimeInfo {
+    version: string;
+    agents: Record<string, AgentDescription>;
+    audioFileTranscriptionEnabled: boolean;
+}
+
+export { AgentDescription, MaybePromise, NonEmptyRecord, RuntimeInfo };

package/dist/utils/types.js

@@ -0,0 +1,19 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.js.map

package/dist/utils/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/types.ts"],"sourcesContent":["export type MaybePromise<T> = T | PromiseLike<T>;\n\n/**\n * More specific utility for records with at least one key\n */\nexport type NonEmptyRecord<T> =\n  T extends Record<string, unknown> ? (keyof T extends never ? never : T) : never;\n\n/**\n * Type representing an agent's basic information\n */\nexport interface AgentDescription {\n  name: string;\n  className: string;\n  description: string;\n}\n\nexport interface RuntimeInfo {\n  version: string;\n  agents: Record<string, AgentDescription>;\n  audioFileTranscriptionEnabled: boolean;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/utils/types.mjs

@@ -0,0 +1,2 @@
+import "../chunk-XTHC46M2.mjs";
+//# sourceMappingURL=types.mjs.map

package/dist/utils/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@copilotkit/shared",
+  "private": false,
+  "homepage": "https://github.com/CopilotKit/CopilotKit",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CopilotKit/CopilotKit.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.0.0-0.0.0-max-changeset-10101010101010-20260109191632",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.4",
+    "@types/uuid": "^10.0.0",
+    "eslint": "^8.56.0",
+    "jest": "^29.6.4",
+    "ts-jest": "^29.1.1",
+    "tsup": "^6.7.0",
+    "typescript": "^5.2.3",
+    "zod-to-json-schema": "^3.23.5",
+    "eslint-config-custom": "1.4.6",
+    "tsconfig": "1.4.6"
+  },
+  "dependencies": {
+    "@segment/analytics-node": "^2.1.2",
+    "chalk": "4.1.2",
+    "graphql": "^16.8.1",
+    "uuid": "^10.0.0",
+    "zod": "^3.23.3"
+  },
+  "peerDependencies": {
+    "@ag-ui/core": "^0.0.42"
+  },
+  "keywords": [
+    "copilotkit",
+    "copilot",
+    "react",
+    "nextjs",
+    "nodejs",
+    "ai",
+    "assistant",
+    "javascript",
+    "automation",
+    "textarea"
+  ],
+  "scripts": {
+    "build": "tsup --clean",
+    "dev": "tsup --watch --no-splitting",
+    "test": "jest --passWithNoTests",
+    "check-types": "tsc --noEmit",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist && rm -rf .next",
+    "link:global": "pnpm link --global",
+    "unlink:global": "pnpm unlink --global"
+  }
+}

package/src/constants/index.ts

@@ -0,0 +1,4 @@
+export const COPILOT_CLOUD_API_URL = "https://api.cloud.copilotkit.ai";
+export const COPILOT_CLOUD_VERSION = "v1";
+export const COPILOT_CLOUD_CHAT_URL = `${COPILOT_CLOUD_API_URL}/copilotkit/${COPILOT_CLOUD_VERSION}`;
+export const COPILOT_CLOUD_PUBLIC_API_KEY_HEADER = "X-CopilotCloud-Public-Api-Key";

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from "./types";
+export * from "./utils";
+export * from "./constants";
+export * from "./telemetry";
+
+import * as packageJson from "../package.json";
+export const COPILOTKIT_VERSION = packageJson.version;

package/src/telemetry/events.ts

@@ -0,0 +1,41 @@
+export type AnalyticsEvents = {
+  "oss.runtime.instance_created": RuntimeInstanceCreatedInfo;
+  "oss.runtime.copilot_request_created": {
+    "cloud.guardrails.enabled": boolean;
+    requestType: string;
+    "cloud.api_key_provided": boolean;
+    "cloud.public_api_key"?: string;
+    "cloud.base_url"?: string;
+  };
+  "oss.runtime.server_action_executed": {};
+  "oss.runtime.remote_action_executed": RemoteActionExecutionInfo;
+  "oss.runtime.agent_execution_stream_started": { hashedLgcKey?: string };
+  "oss.runtime.agent_execution_stream_ended": AgentExecutionResponseInfo;
+  "oss.runtime.agent_execution_stream_errored": { hashedLgcKey?: string; error?: string };
+};
+
+export interface RuntimeInstanceCreatedInfo {
+  actionsAmount: number;
+  endpointTypes: string[];
+  hashedLgcKey?: string;
+  endpointsAmount: number;
+  agentsAmount?: number | null;
+  "cloud.api_key_provided": boolean;
+  "cloud.public_api_key"?: string;
+  "cloud.base_url"?: string;
+}
+
+export interface RemoteActionExecutionInfo {
+  agentExecution: boolean;
+  type: "self-hosted" | "langgraph-platform";
+  agentsAmount?: number | null;
+  hashedLgcKey?: string;
+}
+
+export interface AgentExecutionResponseInfo {
+  provider?: string;
+  model?: string;
+  langGraphHost?: string;
+  langGraphVersion?: string;
+  hashedLgcKey?: string;
+}

package/src/telemetry/index.ts

@@ -0,0 +1 @@
+export * from "./telemetry-client";

package/src/telemetry/scarf-client.ts

@@ -0,0 +1,39 @@
+import * as packageJson from "../../package.json";
+
+const SCARF_BASE_URL = `https://copilotkit.gateway.scarf.sh/${packageJson.version}`;
+
+class ScarfClient {
+  constructor() {}
+
+  async logEvent(properties: Record<string, any>): Promise<void> {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 3000);
+
+      const queryParams = new URLSearchParams();
+
+      Object.entries(properties).forEach(([key, value]) => {
+        if (value !== null && value !== undefined) {
+          queryParams.append(key, String(value));
+        }
+      });
+
+      const url = `${SCARF_BASE_URL}?${queryParams.toString()}`;
+
+      const response = await fetch(url, {
+        method: "GET",
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+    } catch {
+      // Silently fail - telemetry should not break the application
+    }
+  }
+}
+
+export default new ScarfClient();

package/src/telemetry/telemetry-client.ts

@@ -0,0 +1,142 @@
+import { Analytics } from "@segment/analytics-node";
+import { AnalyticsEvents } from "./events";
+import { flattenObject } from "./utils";
+import { v4 as uuidv4 } from "uuid";
+import scarfClient from "./scarf-client";
+
+/**
+ * Checks if telemetry is disabled via environment variables.
+ * Users can opt out by setting:
+ * - COPILOTKIT_TELEMETRY_DISABLED=true or COPILOTKIT_TELEMETRY_DISABLED=1
+ * - DO_NOT_TRACK=true or DO_NOT_TRACK=1
+ */
+export function isTelemetryDisabled(): boolean {
+  return (
+    (process.env as Record<string, string | undefined>).COPILOTKIT_TELEMETRY_DISABLED === "true" ||
+    (process.env as Record<string, string | undefined>).COPILOTKIT_TELEMETRY_DISABLED === "1" ||
+    (process.env as Record<string, string | undefined>).DO_NOT_TRACK === "true" ||
+    (process.env as Record<string, string | undefined>).DO_NOT_TRACK === "1"
+  );
+}
+
+export class TelemetryClient {
+  segment: Analytics | undefined;
+  globalProperties: Record<string, any> = {};
+  cloudConfiguration: { publicApiKey: string; baseUrl: string } | null = null;
+  packageName: string;
+  packageVersion: string;
+  private telemetryDisabled: boolean = false;
+  private sampleRate: number = 0.05;
+  private anonymousId = `anon_${uuidv4()}`;
+
+  constructor({
+    packageName,
+    packageVersion,
+    telemetryDisabled,
+    telemetryBaseUrl,
+    sampleRate,
+  }: {
+    packageName: string;
+    packageVersion: string;
+    telemetryDisabled?: boolean;
+    telemetryBaseUrl?: string;
+    sampleRate?: number;
+  }) {
+    this.packageName = packageName;
+    this.packageVersion = packageVersion;
+    this.telemetryDisabled = telemetryDisabled || isTelemetryDisabled();
+
+    if (this.telemetryDisabled) {
+      return;
+    }
+
+    this.setSampleRate(sampleRate);
+
+    // eslint-disable-next-line
+    const writeKey = process.env.COPILOTKIT_SEGMENT_WRITE_KEY || "n7XAZtQCGS2v1vvBy3LgBCv2h3Y8whja";
+
+    this.segment = new Analytics({
+      writeKey,
+    });
+
+    this.setGlobalProperties({
+      "copilotkit.package.name": packageName,
+      "copilotkit.package.version": packageVersion,
+    });
+  }
+
+  private shouldSendEvent() {
+    const randomNumber = Math.random();
+    return randomNumber < this.sampleRate;
+  }
+
+  async capture<K extends keyof AnalyticsEvents>(event: K, properties: AnalyticsEvents[K]) {
+    if (!this.shouldSendEvent() || !this.segment) {
+      return;
+    }
+
+    const flattenedProperties = flattenObject(properties);
+    const propertiesWithGlobal = {
+      ...this.globalProperties,
+      ...flattenedProperties,
+    };
+    const orderedPropertiesWithGlobal = Object.keys(propertiesWithGlobal)
+      .sort()
+      .reduce(
+        (obj, key) => {
+          obj[key] = propertiesWithGlobal[key];
+          return obj;
+        },
+        {} as Record<string, any>,
+      );
+
+    this.segment.track({
+      anonymousId: this.anonymousId,
+      event,
+      properties: { ...orderedPropertiesWithGlobal },
+    });
+
+    await scarfClient.logEvent({
+      event,
+    });
+  }
+
+  setGlobalProperties(properties: Record<string, any>) {
+    const flattenedProperties = flattenObject(properties);
+    this.globalProperties = { ...this.globalProperties, ...flattenedProperties };
+  }
+
+  setCloudConfiguration(properties: { publicApiKey: string; baseUrl: string }) {
+    this.cloudConfiguration = properties;
+
+    this.setGlobalProperties({
+      cloud: {
+        publicApiKey: properties.publicApiKey,
+        baseUrl: properties.baseUrl,
+      },
+    });
+  }
+
+  private setSampleRate(sampleRate: number | undefined) {
+    let _sampleRate: number;
+
+    _sampleRate = sampleRate ?? 0.05;
+
+    // eslint-disable-next-line
+    if (process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE) {
+      // eslint-disable-next-line
+      _sampleRate = parseFloat(process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE);
+    }
+
+    if (_sampleRate < 0 || _sampleRate > 1) {
+      throw new Error("Sample rate must be between 0 and 1");
+    }
+
+    this.sampleRate = _sampleRate;
+    this.setGlobalProperties({
+      sampleRate: this.sampleRate,
+      sampleRateAdjustmentFactor: 1 - this.sampleRate,
+      sampleWeight: 1 / this.sampleRate,
+    });
+  }
+}

package/src/telemetry/utils.ts

@@ -0,0 +1,39 @@
+import chalk from "chalk";
+
+export function flattenObject(
+  obj: Record<string, any>,
+  parentKey = "",
+  res: Record<string, any> = {},
+): Record<string, any> {
+  for (let key in obj) {
+    const propName = parentKey ? `${parentKey}.${key}` : key;
+    if (typeof obj[key] === "object" && obj[key] !== null) {
+      flattenObject(obj[key], propName, res);
+    } else {
+      res[propName] = obj[key];
+    }
+  }
+  return res;
+}
+
+export function printSecurityNotice(advisory: {
+  advisory: string | null;
+  message: string;
+  severity: "low" | "medium" | "high" | "none";
+}) {
+  const severityColor =
+    {
+      low: chalk.blue,
+      medium: chalk.yellow,
+      high: chalk.red,
+    }[advisory.severity.toLowerCase()] || chalk.white;
+
+  console.log();
+  console.log(`━━━━━━━━━━━━━━━━━━ ${chalk.bold(`CopilotKit`)} ━━━━━━━━━━━━━━━━━━`);
+  console.log();
+  console.log(`${chalk.bold(`Severity: ${severityColor(advisory.severity.toUpperCase())}`)}`);
+  console.log();
+  console.log(`${chalk.bold(advisory.message)}`);
+  console.log();
+  console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+}