langchain 0.0.168 → 0.0.170

package/dist/retrievers/time_weighted.cjs

@@ -6,7 +6,7 @@ exports.LAST_ACCESSED_AT_KEY = "last_accessed_at";
 exports.BUFFER_IDX = "buffer_idx";
 /**
  * TimeWeightedVectorStoreRetriever retrieves documents based on their time-weighted relevance.
- * ref: https://github.com/hwchase17/langchain/blob/master/langchain/retrievers/time_weighted_retriever.py
+ * ref: https://github.com/langchain-ai/langchain/blob/master/libs/langchain/langchain/retrievers/time_weighted_retriever.py
  */
 class TimeWeightedVectorStoreRetriever extends retriever_js_1.BaseRetriever {
     static lc_name() {

package/dist/retrievers/time_weighted.d.ts

@@ -19,7 +19,7 @@ export declare const LAST_ACCESSED_AT_KEY = "last_accessed_at";
 export declare const BUFFER_IDX = "buffer_idx";
 /**
  * TimeWeightedVectorStoreRetriever retrieves documents based on their time-weighted relevance.
- * ref: https://github.com/hwchase17/langchain/blob/master/langchain/retrievers/time_weighted_retriever.py
+ * ref: https://github.com/langchain-ai/langchain/blob/master/libs/langchain/langchain/retrievers/time_weighted_retriever.py
  */
 export declare class TimeWeightedVectorStoreRetriever extends BaseRetriever {
     static lc_name(): string;

package/dist/retrievers/time_weighted.js

@@ -3,7 +3,7 @@ export const LAST_ACCESSED_AT_KEY = "last_accessed_at";
 export const BUFFER_IDX = "buffer_idx";
 /**
  * TimeWeightedVectorStoreRetriever retrieves documents based on their time-weighted relevance.
- * ref: https://github.com/hwchase17/langchain/blob/master/langchain/retrievers/time_weighted_retriever.py
+ * ref: https://github.com/langchain-ai/langchain/blob/master/libs/langchain/langchain/retrievers/time_weighted_retriever.py
  */
 export class TimeWeightedVectorStoreRetriever extends BaseRetriever {
     static lc_name() {

package/dist/retrievers/zep.cjs

@@ -47,8 +47,29 @@ class ZepRetriever extends retriever_js_1.BaseRetriever {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "searchType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "mmrLambda", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "filter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.sessionId = config.sessionId;
         this.topK = config.topK;
+        this.searchType = config.searchType;
+        this.mmrLambda = config.mmrLambda;
+        this.filter = config.filter;
         this.zepClientPromise = zep_js_1.ZepClient.init(config.url, config.apiKey);
     }
     /**
@@ -59,9 +80,9 @@ class ZepRetriever extends retriever_js_1.BaseRetriever {
     searchResultToDoc(results) {
         return results
             .filter((r) => r.message)
-            .map(({ message: { content } = {}, ...metadata }, dist) => new document_js_1.Document({
+            .map(({ message: { content, metadata: messageMetadata } = {}, dist, ...rest }) => new document_js_1.Document({
             pageContent: content ?? "",
-            metadata: { score: dist, ...metadata },
+            metadata: { score: dist, ...messageMetadata, ...rest },
         }));
     }
     /**
@@ -70,7 +91,12 @@ class ZepRetriever extends retriever_js_1.BaseRetriever {
      *  @returns {Promise<Document[]>} A promise that resolves to an array of relevant Document objects.
      */
     async _getRelevantDocuments(query) {
-        const payload = { text: query, metadata: {} };
+        const payload = {
+            text: query,
+            metadata: this.filter,
+            search_type: this.searchType,
+            mmr_lambda: this.mmrLambda,
+        };
         // Wait for ZepClient to be initialized
         const zepClient = await this.zepClientPromise;
         if (!zepClient) {

package/dist/retrievers/zep.d.ts

@@ -4,12 +4,23 @@ import { Document } from "../document.js";
 /**
  * Configuration interface for the ZepRetriever class. Extends the
  * BaseRetrieverInput interface.
+ *
+ * @argument {string} sessionId - The ID of the Zep session.
+ * @argument {string} url - The URL of the Zep API.
+ * @argument {number} [topK] - The number of results to return.
+ * @argument {string} [apiKey] - The API key for the Zep API.
+ * @argument [searchType] [searchType] - The type of search to perform: "similarity" or "mmr".
+ * @argument {number} [mmrLambda] - The lambda value for the MMR search.
+ * @argument {Record<string, unknown>} [filter] - The metadata filter to apply to the search.
  */
 export interface ZepRetrieverConfig extends BaseRetrieverInput {
     sessionId: string;
     url: string;
     topK?: number;
     apiKey?: string;
+    searchType?: "similarity" | "mmr";
+    mmrLambda?: number;
+    filter?: Record<string, unknown>;
 }
 /**
  * Class for retrieving information from a Zep long-term memory store.
@@ -27,6 +38,9 @@ export declare class ZepRetriever extends BaseRetriever {
     zepClientPromise: Promise<ZepClient>;
     private sessionId;
     private topK?;
+    private searchType?;
+    private mmrLambda?;
+    private filter?;
     constructor(config: ZepRetrieverConfig);
     /**
      *  Converts an array of search results to an array of Document objects.

package/dist/retrievers/zep.js

@@ -44,8 +44,29 @@ export class ZepRetriever extends BaseRetriever {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "searchType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "mmrLambda", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "filter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.sessionId = config.sessionId;
         this.topK = config.topK;
+        this.searchType = config.searchType;
+        this.mmrLambda = config.mmrLambda;
+        this.filter = config.filter;
         this.zepClientPromise = ZepClient.init(config.url, config.apiKey);
     }
     /**
@@ -56,9 +77,9 @@ export class ZepRetriever extends BaseRetriever {
     searchResultToDoc(results) {
         return results
             .filter((r) => r.message)
-            .map(({ message: { content } = {}, ...metadata }, dist) => new Document({
+            .map(({ message: { content, metadata: messageMetadata } = {}, dist, ...rest }) => new Document({
             pageContent: content ?? "",
-            metadata: { score: dist, ...metadata },
+            metadata: { score: dist, ...messageMetadata, ...rest },
         }));
     }
     /**
@@ -67,7 +88,12 @@ export class ZepRetriever extends BaseRetriever {
      *  @returns {Promise<Document[]>} A promise that resolves to an array of relevant Document objects.
      */
     async _getRelevantDocuments(query) {
-        const payload = { text: query, metadata: {} };
+        const payload = {
+            text: query,
+            metadata: this.filter,
+            search_type: this.searchType,
+            mmr_lambda: this.mmrLambda,
+        };
         // Wait for ZepClient to be initialized
         const zepClient = await this.zepClientPromise;
         if (!zepClient) {

package/dist/schema/runnable/base.cjs

@@ -366,7 +366,7 @@ class Runnable extends serializable_js_1.Serializable {
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static isRunnable(thing) {
-        return thing.lc_runnable;
+        return thing ? thing.lc_runnable : false;
     }
 }
 exports.Runnable = Runnable;
@@ -844,6 +844,9 @@ class RunnableMap extends Runnable {
     static lc_name() {
         return "RunnableMap";
     }
+    getStepsKeys() {
+        return Object.keys(this.steps);
+    }
     constructor(fields) {
         super(fields);
         Object.defineProperty(this, "lc_namespace", {

package/dist/schema/runnable/base.d.ts

@@ -289,6 +289,7 @@ export declare class RunnableMap<RunInput> extends Runnable<RunInput, Record<str
     lc_namespace: string[];
     lc_serializable: boolean;
     protected steps: Record<string, Runnable<RunInput>>;
+    getStepsKeys(): string[];
     constructor(fields: {
         steps: Record<string, RunnableLike<RunInput>>;
     });

package/dist/schema/runnable/base.js

@@ -360,7 +360,7 @@ export class Runnable extends Serializable {
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static isRunnable(thing) {
-        return thing.lc_runnable;
+        return thing ? thing.lc_runnable : false;
     }
 }
 /**
@@ -833,6 +833,9 @@ export class RunnableMap extends Runnable {
     static lc_name() {
         return "RunnableMap";
     }
+    getStepsKeys() {
+        return Object.keys(this.steps);
+    }
     constructor(fields) {
         super(fields);
         Object.defineProperty(this, "lc_namespace", {

package/dist/schema/runnable/passthrough.cjs

@@ -1,7 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunnablePassthrough = void 0;
+exports.RunnablePassthrough = exports.RunnableAssign = void 0;
 const base_js_1 = require("./base.cjs");
+/**
+ * A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
+ */
+class RunnableAssign extends base_js_1.Runnable {
+    constructor(mapper) {
+        super();
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "schema", "runnable"]
+        });
+        Object.defineProperty(this, "mapper", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.mapper = mapper;
+    }
+    async invoke(input, options) {
+        const mapperResult = await this.mapper.invoke(input, options);
+        return {
+            ...input,
+            ...mapperResult,
+        };
+    }
+}
+exports.RunnableAssign = RunnableAssign;
 /**
  * A runnable that passes through the input.
  */
@@ -27,5 +56,8 @@ class RunnablePassthrough extends base_js_1.Runnable {
     async invoke(input, options) {
         return this._callWithConfig((input) => Promise.resolve(input), input, options);
     }
+    static assign(mapping) {
+        return new RunnableAssign(new base_js_1.RunnableMap({ steps: mapping }));
+    }
 }
 exports.RunnablePassthrough = RunnablePassthrough;

package/dist/schema/runnable/passthrough.d.ts

@@ -1,5 +1,14 @@
-import { Runnable } from "./base.js";
+import { Runnable, RunnableLike, RunnableMap } from "./base.js";
 import type { RunnableConfig } from "./config.js";
+/**
+ * A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
+ */
+export declare class RunnableAssign<RunInput extends Record<string, any> = any, RunOutput extends Record<string, any> = any, CallOptions extends RunnableConfig = RunnableConfig> extends Runnable<RunInput, RunOutput> {
+    lc_namespace: string[];
+    mapper: RunnableMap<RunInput>;
+    constructor(mapper: RunnableMap<RunInput>);
+    invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;
+}
 /**
  * A runnable that passes through the input.
  */
@@ -8,4 +17,5 @@ export declare class RunnablePassthrough<RunInput> extends Runnable<RunInput, Ru
     lc_namespace: string[];
     lc_serializable: boolean;
     invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunInput>;
+    static assign(mapping: Record<string, RunnableLike<Record<string, unknown>, any>>): RunnableAssign<Record<string, unknown>, Record<string, unknown>>;
 }

package/dist/schema/runnable/passthrough.js

@@ -1,4 +1,32 @@
-import { Runnable } from "./base.js";
+import { Runnable, RunnableMap } from "./base.js";
+/**
+ * A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
+ */
+export class RunnableAssign extends Runnable {
+    constructor(mapper) {
+        super();
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "schema", "runnable"]
+        });
+        Object.defineProperty(this, "mapper", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.mapper = mapper;
+    }
+    async invoke(input, options) {
+        const mapperResult = await this.mapper.invoke(input, options);
+        return {
+            ...input,
+            ...mapperResult,
+        };
+    }
+}
 /**
  * A runnable that passes through the input.
  */
@@ -24,4 +52,7 @@ export class RunnablePassthrough extends Runnable {
     async invoke(input, options) {
         return this._callWithConfig((input) => Promise.resolve(input), input, options);
     }
+    static assign(mapping) {
+        return new RunnableAssign(new RunnableMap({ steps: mapping }));
+    }
 }

package/dist/sql_db.cjs

@@ -3,6 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqlDatabase = void 0;
 const sql_utils_js_1 = require("./util/sql_utils.cjs");
 const serializable_js_1 = require("./load/serializable.cjs");
+/**
+ * Class that represents a SQL database in the LangChain framework.
+ *
+ * @security **Security Notice**
+ * This class generates SQL queries for the given database.
+ * The SQLDatabase class provides a getTableInfo method that can be used
+ * to get column information as well as sample data from the table.
+ * To mitigate risk of leaking sensitive data, limit permissions
+ * to read and scope to the tables that are needed.
+ * Optionally, use the includesTables or ignoreTables class parameters
+ * to limit which tables can/cannot be accessed.
+ */
 class SqlDatabase extends serializable_js_1.Serializable {
     toJSON() {
         return this.toJSONNotImplemented();

package/dist/sql_db.d.ts

@@ -2,6 +2,18 @@ import type { DataSource as DataSourceT, DataSourceOptions } from "typeorm";
 import { SerializedSqlDatabase, SqlDatabaseDataSourceParams, SqlDatabaseOptionsParams, SqlTable } from "./util/sql_utils.js";
 import { Serializable } from "./load/serializable.js";
 export type { SqlDatabaseDataSourceParams, SqlDatabaseOptionsParams };
+/**
+ * Class that represents a SQL database in the LangChain framework.
+ *
+ * @security **Security Notice**
+ * This class generates SQL queries for the given database.
+ * The SQLDatabase class provides a getTableInfo method that can be used
+ * to get column information as well as sample data from the table.
+ * To mitigate risk of leaking sensitive data, limit permissions
+ * to read and scope to the tables that are needed.
+ * Optionally, use the includesTables or ignoreTables class parameters
+ * to limit which tables can/cannot be accessed.
+ */
 export declare class SqlDatabase extends Serializable implements SqlDatabaseOptionsParams, SqlDatabaseDataSourceParams {
     lc_namespace: string[];
     toJSON(): import("./load/serializable.js").SerializedNotImplemented;

package/dist/sql_db.js

@@ -1,5 +1,17 @@
 import { generateTableInfoFromTables, getTableAndColumnsName, verifyIgnoreTablesExistInDatabase, verifyIncludeTablesExistInDatabase, verifyListTablesExistInDatabase, } from "./util/sql_utils.js";
 import { Serializable } from "./load/serializable.js";
+/**
+ * Class that represents a SQL database in the LangChain framework.
+ *
+ * @security **Security Notice**
+ * This class generates SQL queries for the given database.
+ * The SQLDatabase class provides a getTableInfo method that can be used
+ * to get column information as well as sample data from the table.
+ * To mitigate risk of leaking sensitive data, limit permissions
+ * to read and scope to the tables that are needed.
+ * Optionally, use the includesTables or ignoreTables class parameters
+ * to limit which tables can/cannot be accessed.
+ */
 export class SqlDatabase extends Serializable {
     toJSON() {
         return this.toJSONNotImplemented();

package/dist/storage/ioredis.cjs

@@ -115,7 +115,8 @@ class RedisByteStore extends storage_js_1.BaseStore {
     async *yieldKeys(prefix) {
         let pattern;
         if (prefix) {
-            pattern = this._getPrefixedKey(prefix);
+            const wildcardPrefix = prefix.endsWith("*") ? prefix : `${prefix}*`;
+            pattern = this._getPrefixedKey(wildcardPrefix);
         }
         else {
             pattern = this._getPrefixedKey("*");

package/dist/storage/ioredis.js

@@ -112,7 +112,8 @@ export class RedisByteStore extends BaseStore {
     async *yieldKeys(prefix) {
         let pattern;
         if (prefix) {
-            pattern = this._getPrefixedKey(prefix);
+            const wildcardPrefix = prefix.endsWith("*") ? prefix : `${prefix}*`;
+            pattern = this._getPrefixedKey(wildcardPrefix);
         }
         else {
             pattern = this._getPrefixedKey("*");

package/dist/storage/upstash_redis.cjs

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpstashRedisStore = void 0;
+const redis_1 = require("@upstash/redis");
+const storage_js_1 = require("../schema/storage.cjs");
+/**
+ * Class that extends the BaseStore class to interact with an Upstash Redis
+ * database. It provides methods for getting, setting, and deleting data,
+ * as well as yielding keys from the database.
+ */
+class UpstashRedisStore extends storage_js_1.BaseStore {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "storage"]
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "yieldKeysScanBatchSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1000
+        });
+        Object.defineProperty(this, "sessionTTL", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (fields.client) {
+            this.client = fields.client;
+        }
+        else if (fields.config) {
+            this.client = new redis_1.Redis(fields.config);
+        }
+        else {
+            throw new Error(`Upstash Redis store requires either a config object or a pre-configured client.`);
+        }
+        this.sessionTTL = fields.sessionTTL;
+        this.yieldKeysScanBatchSize =
+            fields.yieldKeysScanBatchSize ?? this.yieldKeysScanBatchSize;
+        this.namespace = fields.namespace;
+    }
+    _getPrefixedKey(key) {
+        if (this.namespace) {
+            const delimiter = "/";
+            return `${this.namespace}${delimiter}${key}`;
+        }
+        return key;
+    }
+    _getDeprefixedKey(key) {
+        if (this.namespace) {
+            const delimiter = "/";
+            return key.slice(this.namespace.length + delimiter.length);
+        }
+        return key;
+    }
+    /**
+     * Gets multiple keys from the Upstash Redis database.
+     * @param keys Array of keys to be retrieved.
+     * @returns An array of retrieved values.
+     */
+    async mget(keys) {
+        const encoder = new TextEncoder();
+        const prefixedKeys = keys.map(this._getPrefixedKey.bind(this));
+        const retrievedValues = await this.client.mget(...prefixedKeys);
+        return retrievedValues.map((value) => {
+            if (!value) {
+                return undefined;
+            }
+            else if (typeof value === "object") {
+                return encoder.encode(JSON.stringify(value));
+            }
+            else {
+                return encoder.encode(value);
+            }
+        });
+    }
+    /**
+     * Sets multiple keys in the Upstash Redis database.
+     * @param keyValuePairs Array of key-value pairs to be set.
+     * @returns Promise that resolves when all keys have been set.
+     */
+    async mset(keyValuePairs) {
+        const decoder = new TextDecoder();
+        const encodedKeyValuePairs = keyValuePairs.map(([key, value]) => [
+            this._getPrefixedKey(key),
+            decoder.decode(value),
+        ]);
+        const pipeline = this.client.pipeline();
+        for (const [key, value] of encodedKeyValuePairs) {
+            if (this.sessionTTL) {
+                pipeline.setex(key, this.sessionTTL, value);
+            }
+            else {
+                pipeline.set(key, value);
+            }
+        }
+        await pipeline.exec();
+    }
+    /**
+     * Deletes multiple keys from the Upstash Redis database.
+     * @param keys Array of keys to be deleted.
+     * @returns Promise that resolves when all keys have been deleted.
+     */
+    async mdelete(keys) {
+        await this.client.del(...keys.map(this._getPrefixedKey.bind(this)));
+    }
+    /**
+     * Yields keys from the Upstash Redis database.
+     * @param prefix Optional prefix to filter the keys. A wildcard (*) is always appended to the end.
+     * @returns An AsyncGenerator that yields keys from the Upstash Redis database.
+     */
+    async *yieldKeys(prefix) {
+        let pattern;
+        if (prefix) {
+            const wildcardPrefix = prefix.endsWith("*") ? prefix : `${prefix}*`;
+            pattern = `${this._getPrefixedKey(wildcardPrefix)}*`;
+        }
+        else {
+            pattern = this._getPrefixedKey("*");
+        }
+        let [cursor, batch] = await this.client.scan(0, {
+            match: pattern,
+            count: this.yieldKeysScanBatchSize,
+        });
+        for (const key of batch) {
+            yield this._getDeprefixedKey(key);
+        }
+        while (cursor !== 0) {
+            [cursor, batch] = await this.client.scan(cursor, {
+                match: pattern,
+                count: this.yieldKeysScanBatchSize,
+            });
+            for (const key of batch) {
+                yield this._getDeprefixedKey(key);
+            }
+        }
+    }
+}
+exports.UpstashRedisStore = UpstashRedisStore;

package/dist/storage/upstash_redis.d.ts

@@ -0,0 +1,59 @@
+import { Redis as UpstashRedis, type RedisConfigNodejs } from "@upstash/redis";
+import { BaseStore } from "../schema/storage.js";
+/**
+ * Type definition for the input parameters required to initialize an
+ * instance of the UpstashStoreInput class.
+ */
+export interface UpstashRedisStoreInput {
+    sessionTTL?: number;
+    config?: RedisConfigNodejs;
+    client?: UpstashRedis;
+    /**
+     * The amount of keys to retrieve per batch when yielding keys.
+     * @default 1000
+     */
+    yieldKeysScanBatchSize?: number;
+    /**
+     * The namespace to use for the keys in the database.
+     */
+    namespace?: string;
+}
+/**
+ * Class that extends the BaseStore class to interact with an Upstash Redis
+ * database. It provides methods for getting, setting, and deleting data,
+ * as well as yielding keys from the database.
+ */
+export declare class UpstashRedisStore extends BaseStore<string, Uint8Array> {
+    lc_namespace: string[];
+    protected client: UpstashRedis;
+    protected namespace?: string;
+    protected yieldKeysScanBatchSize: number;
+    private sessionTTL?;
+    constructor(fields: UpstashRedisStoreInput);
+    _getPrefixedKey(key: string): string;
+    _getDeprefixedKey(key: string): string;
+    /**
+     * Gets multiple keys from the Upstash Redis database.
+     * @param keys Array of keys to be retrieved.
+     * @returns An array of retrieved values.
+     */
+    mget(keys: string[]): Promise<(Uint8Array | undefined)[]>;
+    /**
+     * Sets multiple keys in the Upstash Redis database.
+     * @param keyValuePairs Array of key-value pairs to be set.
+     * @returns Promise that resolves when all keys have been set.
+     */
+    mset(keyValuePairs: [string, Uint8Array][]): Promise<void>;
+    /**
+     * Deletes multiple keys from the Upstash Redis database.
+     * @param keys Array of keys to be deleted.
+     * @returns Promise that resolves when all keys have been deleted.
+     */
+    mdelete(keys: string[]): Promise<void>;
+    /**
+     * Yields keys from the Upstash Redis database.
+     * @param prefix Optional prefix to filter the keys. A wildcard (*) is always appended to the end.
+     * @returns An AsyncGenerator that yields keys from the Upstash Redis database.
+     */
+    yieldKeys(prefix?: string): AsyncGenerator<string>;
+}