langchain 0.0.174 → 0.0.175

package/dist/stores/message/convex.js

@@ -0,0 +1,116 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { makeFunctionReference, } from "convex/server";
+import { BaseListChatMessageHistory } from "../../schema/index.js";
+import { mapChatMessagesToStoredMessages, mapStoredMessagesToChatMessages, } from "./utils.js";
+export class ConvexChatMessageHistory extends BaseListChatMessageHistory {
+    constructor(config) {
+        super();
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "stores", "message", "convex"]
+        });
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sessionId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "table", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "index", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sessionIdField", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "messageTextFieldName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "insert", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lookup", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "deleteMany", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.ctx = config.ctx;
+        this.sessionId = config.sessionId;
+        this.table = config.table ?? "messages";
+        this.index = config.index ?? "bySessionId";
+        this.sessionIdField =
+            config.sessionIdField ?? "sessionId";
+        this.messageTextFieldName =
+            config.messageTextFieldName ?? "message";
+        this.insert =
+            config.insert ?? makeFunctionReference("langchain/db:insert");
+        this.lookup =
+            config.lookup ?? makeFunctionReference("langchain/db:lookup");
+        this.deleteMany =
+            config.deleteMany ??
+                makeFunctionReference("langchain/db:deleteMany");
+    }
+    async getMessages() {
+        const convexDocuments = await this.ctx.runQuery(this.lookup, {
+            table: this.table,
+            index: this.index,
+            keyField: this.sessionIdField,
+            key: this.sessionId,
+        });
+        return mapStoredMessagesToChatMessages(convexDocuments.map((doc) => doc[this.messageTextFieldName]));
+    }
+    async addMessage(message) {
+        const messages = mapChatMessagesToStoredMessages([message]);
+        // TODO: Remove chunking when Convex handles the concurrent requests correctly
+        const PAGE_SIZE = 16;
+        for (let i = 0; i < messages.length; i += PAGE_SIZE) {
+            await Promise.all(messages.slice(i, i + PAGE_SIZE).map((message) => this.ctx.runMutation(this.insert, {
+                table: this.table,
+                document: {
+                    [this.sessionIdField]: this.sessionId,
+                    [this.messageTextFieldName]: message,
+                },
+            })));
+        }
+    }
+    async clear() {
+        await this.ctx.runMutation(this.deleteMany, {
+            table: this.table,
+            index: this.index,
+            keyField: this.sessionIdField,
+            key: this.sessionId,
+        });
+    }
+}

package/dist/util/convex.cjs

@@ -0,0 +1,77 @@
+"use strict";
+/* eslint-disable spaced-comment */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteMany = exports.upsert = exports.lookup = exports.insert = exports.get = void 0;
+// eslint-disable-next-line import/no-extraneous-dependencies
+const server_1 = require("convex/server");
+// eslint-disable-next-line import/no-extraneous-dependencies
+const values_1 = require("convex/values");
+exports.get = (0, server_1.internalQueryGeneric)({
+    args: {
+        id: /*#__PURE__*/ values_1.v.string(),
+    },
+    handler: async (ctx, args) => {
+        const result = await ctx.db.get(args.id);
+        return result;
+    },
+});
+exports.insert = (0, server_1.internalMutationGeneric)({
+    args: {
+        table: /*#__PURE__*/ values_1.v.string(),
+        document: /*#__PURE__*/ values_1.v.any(),
+    },
+    handler: async (ctx, args) => {
+        await ctx.db.insert(args.table, args.document);
+    },
+});
+exports.lookup = (0, server_1.internalQueryGeneric)({
+    args: {
+        table: /*#__PURE__*/ values_1.v.string(),
+        index: /*#__PURE__*/ values_1.v.string(),
+        keyField: /*#__PURE__*/ values_1.v.string(),
+        key: /*#__PURE__*/ values_1.v.string(),
+    },
+    handler: async (ctx, args) => {
+        const result = await ctx.db
+            .query(args.table)
+            .withIndex(args.index, (q) => q.eq(args.keyField, args.key))
+            .collect();
+        return result;
+    },
+});
+exports.upsert = (0, server_1.internalMutationGeneric)({
+    args: {
+        table: /*#__PURE__*/ values_1.v.string(),
+        index: /*#__PURE__*/ values_1.v.string(),
+        keyField: /*#__PURE__*/ values_1.v.string(),
+        key: /*#__PURE__*/ values_1.v.string(),
+        document: /*#__PURE__*/ values_1.v.any(),
+    },
+    handler: async (ctx, args) => {
+        const existing = await ctx.db
+            .query(args.table)
+            .withIndex(args.index, (q) => q.eq(args.keyField, args.key))
+            .unique();
+        if (existing !== null) {
+            await ctx.db.replace(existing._id, args.document);
+        }
+        else {
+            await ctx.db.insert(args.table, args.document);
+        }
+    },
+});
+exports.deleteMany = (0, server_1.internalMutationGeneric)({
+    args: {
+        table: /*#__PURE__*/ values_1.v.string(),
+        index: /*#__PURE__*/ values_1.v.string(),
+        keyField: /*#__PURE__*/ values_1.v.string(),
+        key: /*#__PURE__*/ values_1.v.string(),
+    },
+    handler: async (ctx, args) => {
+        const existing = await ctx.db
+            .query(args.table)
+            .withIndex(args.index, (q) => q.eq(args.keyField, args.key))
+            .collect();
+        await Promise.all(existing.map((doc) => ctx.db.delete(doc._id)));
+    },
+});

package/dist/util/convex.d.ts

@@ -0,0 +1,26 @@
+export declare const get: import("convex/server").RegisteredQuery<"internal", {
+    id: string;
+}, Promise<any>>;
+export declare const insert: import("convex/server").RegisteredMutation<"internal", {
+    document: any;
+    table: string;
+}, Promise<void>>;
+export declare const lookup: import("convex/server").RegisteredQuery<"internal", {
+    key: string;
+    index: string;
+    table: string;
+    keyField: string;
+}, Promise<any[]>>;
+export declare const upsert: import("convex/server").RegisteredMutation<"internal", {
+    key: string;
+    index: string;
+    document: any;
+    table: string;
+    keyField: string;
+}, Promise<void>>;
+export declare const deleteMany: import("convex/server").RegisteredMutation<"internal", {
+    key: string;
+    index: string;
+    table: string;
+    keyField: string;
+}, Promise<void>>;

package/dist/util/convex.js

@@ -0,0 +1,74 @@
+/* eslint-disable spaced-comment */
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { internalQueryGeneric as internalQuery, internalMutationGeneric as internalMutation, } from "convex/server";
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { v } from "convex/values";
+export const get = /*#__PURE__*/ internalQuery({
+    args: {
+        id: /*#__PURE__*/ v.string(),
+    },
+    handler: async (ctx, args) => {
+        const result = await ctx.db.get(args.id);
+        return result;
+    },
+});
+export const insert = /*#__PURE__*/ internalMutation({
+    args: {
+        table: /*#__PURE__*/ v.string(),
+        document: /*#__PURE__*/ v.any(),
+    },
+    handler: async (ctx, args) => {
+        await ctx.db.insert(args.table, args.document);
+    },
+});
+export const lookup = /*#__PURE__*/ internalQuery({
+    args: {
+        table: /*#__PURE__*/ v.string(),
+        index: /*#__PURE__*/ v.string(),
+        keyField: /*#__PURE__*/ v.string(),
+        key: /*#__PURE__*/ v.string(),
+    },
+    handler: async (ctx, args) => {
+        const result = await ctx.db
+            .query(args.table)
+            .withIndex(args.index, (q) => q.eq(args.keyField, args.key))
+            .collect();
+        return result;
+    },
+});
+export const upsert = /*#__PURE__*/ internalMutation({
+    args: {
+        table: /*#__PURE__*/ v.string(),
+        index: /*#__PURE__*/ v.string(),
+        keyField: /*#__PURE__*/ v.string(),
+        key: /*#__PURE__*/ v.string(),
+        document: /*#__PURE__*/ v.any(),
+    },
+    handler: async (ctx, args) => {
+        const existing = await ctx.db
+            .query(args.table)
+            .withIndex(args.index, (q) => q.eq(args.keyField, args.key))
+            .unique();
+        if (existing !== null) {
+            await ctx.db.replace(existing._id, args.document);
+        }
+        else {
+            await ctx.db.insert(args.table, args.document);
+        }
+    },
+});
+export const deleteMany = /*#__PURE__*/ internalMutation({
+    args: {
+        table: /*#__PURE__*/ v.string(),
+        index: /*#__PURE__*/ v.string(),
+        keyField: /*#__PURE__*/ v.string(),
+        key: /*#__PURE__*/ v.string(),
+    },
+    handler: async (ctx, args) => {
+        const existing = await ctx.db
+            .query(args.table)
+            .withIndex(args.index, (q) => q.eq(args.keyField, args.key))
+            .collect();
+        await Promise.all(existing.map((doc) => ctx.db.delete(doc._id)));
+    },
+});

package/dist/vectorstores/convex.cjs

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConvexVectorStore = void 0;
+// eslint-disable-next-line import/no-extraneous-dependencies
+const server_1 = require("convex/server");
+const document_js_1 = require("../document.cjs");
+const base_js_1 = require("./base.cjs");
+/**
+ * Class that is a wrapper around Convex storage and vector search. It is used
+ * to insert embeddings in Convex documents with a vector search index,
+ * and perform a vector search on them.
+ *
+ * ConvexVectorStore does NOT implement maxMarginalRelevanceSearch.
+ */
+class ConvexVectorStore extends base_js_1.VectorStore {
+    _vectorstoreType() {
+        return "convex";
+    }
+    constructor(embeddings, config) {
+        super(embeddings, config);
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "table", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "index", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "textField", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "embeddingField", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "metadataField", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "insert", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "get", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.ctx = config.ctx;
+        this.table = config.table ?? "documents";
+        this.index = config.index ?? "byEmbedding";
+        this.textField = config.textField ?? "text";
+        this.embeddingField =
+            config.embeddingField ?? "embedding";
+        this.metadataField =
+            config.metadataField ?? "metadata";
+        this.insert =
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            config.insert ?? (0, server_1.makeFunctionReference)("langchain/db:insert");
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.get = config.get ?? (0, server_1.makeFunctionReference)("langchain/db:get");
+    }
+    /**
+     * Add vectors and their corresponding documents to the Convex table.
+     * @param vectors Vectors to be added.
+     * @param documents Corresponding documents to be added.
+     * @returns Promise that resolves when the vectors and documents have been added.
+     */
+    async addVectors(vectors, documents) {
+        const convexDocuments = vectors.map((embedding, idx) => ({
+            [this.textField]: documents[idx].pageContent,
+            [this.embeddingField]: embedding,
+            [this.metadataField]: documents[idx].metadata,
+        }));
+        // TODO: Remove chunking when Convex handles the concurrent requests correctly
+        const PAGE_SIZE = 16;
+        for (let i = 0; i < convexDocuments.length; i += PAGE_SIZE) {
+            await Promise.all(convexDocuments.slice(i, i + PAGE_SIZE).map((document) => this.ctx.runMutation(this.insert, {
+                table: this.table,
+                document,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            })));
+        }
+    }
+    /**
+     * Add documents to the Convex table. It first converts
+     * the documents to vectors using the embeddings and then calls the
+     * addVectors method.
+     * @param documents Documents to be added.
+     * @returns Promise that resolves when the documents have been added.
+     */
+    async addDocuments(documents) {
+        const texts = documents.map(({ pageContent }) => pageContent);
+        return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
+    }
+    /**
+     * Similarity search on the vectors stored in the
+     * Convex table. It returns a list of documents and their
+     * corresponding similarity scores.
+     * @param query Query vector for the similarity search.
+     * @param k Number of nearest neighbors to return.
+     * @param filter Optional filter to be applied.
+     * @returns Promise that resolves to a list of documents and their corresponding similarity scores.
+     */
+    async similaritySearchVectorWithScore(query, k, filter) {
+        const idsAndScores = await this.ctx.vectorSearch(this.table, this.index, {
+            vector: query,
+            limit: k,
+            filter: filter?.filter,
+        });
+        const documents = await Promise.all(idsAndScores.map(({ _id }) => 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.ctx.runQuery(this.get, { id: _id })));
+        return documents.map(({ [this.textField]: text, [this.embeddingField]: embedding, [this.metadataField]: metadata, }, idx) => [
+            new document_js_1.Document({
+                pageContent: text,
+                metadata: {
+                    ...metadata,
+                    ...(filter?.includeEmbeddings ? { embedding } : null),
+                },
+            }),
+            idsAndScores[idx]._score,
+        ]);
+    }
+    /**
+     * Static method to create an instance of ConvexVectorStore from a
+     * list of texts. It first converts the texts to vectors and then adds
+     * them to the Convex table.
+     * @param texts List of texts to be converted to vectors.
+     * @param metadatas Metadata for the texts.
+     * @param embeddings Embeddings to be used for conversion.
+     * @param dbConfig Database configuration for Convex.
+     * @returns Promise that resolves to a new instance of ConvexVectorStore.
+     */
+    static async fromTexts(texts, metadatas, embeddings, dbConfig) {
+        const docs = texts.map((text, i) => new document_js_1.Document({
+            pageContent: text,
+            metadata: Array.isArray(metadatas) ? metadatas[i] : metadatas,
+        }));
+        return ConvexVectorStore.fromDocuments(docs, embeddings, dbConfig);
+    }
+    /**
+     * Static method to create an instance of ConvexVectorStore from a
+     * list of documents. It first converts the documents to vectors and then
+     * adds them to the Convex table.
+     * @param docs List of documents to be converted to vectors.
+     * @param embeddings Embeddings to be used for conversion.
+     * @param dbConfig Database configuration for Convex.
+     * @returns Promise that resolves to a new instance of ConvexVectorStore.
+     */
+    static async fromDocuments(docs, embeddings, dbConfig) {
+        const instance = new this(embeddings, dbConfig);
+        await instance.addDocuments(docs);
+        return instance;
+    }
+}
+exports.ConvexVectorStore = ConvexVectorStore;

package/dist/vectorstores/convex.d.ts

@@ -0,0 +1,113 @@
+import { DocumentByInfo, FieldPaths, FilterExpression, FunctionReference, GenericActionCtx, GenericDataModel, GenericTableInfo, NamedTableInfo, NamedVectorIndex, TableNamesInDataModel, VectorFilterBuilder, VectorIndexNames } from "convex/server";
+import { Document } from "../document.js";
+import { Embeddings } from "../embeddings/base.js";
+import { VectorStore } from "./base.js";
+/**
+ * Type that defines the config required to initialize the
+ * ConvexVectorStore class. It includes the table name,
+ * index name, text field name, and embedding field name.
+ */
+export type ConvexVectorStoreConfig<DataModel extends GenericDataModel, TableName extends TableNamesInDataModel<DataModel>, IndexName extends VectorIndexNames<NamedTableInfo<DataModel, TableName>>, TextFieldName extends FieldPaths<NamedTableInfo<DataModel, TableName>>, EmbeddingFieldName extends FieldPaths<NamedTableInfo<DataModel, TableName>>, MetadataFieldName extends FieldPaths<NamedTableInfo<DataModel, TableName>>, InsertMutation extends FunctionReference<"mutation", "internal", {
+    table: string;
+    document: object;
+}>, GetQuery extends FunctionReference<"query", "internal", {
+    id: string;
+}, object | null>> = {
+    readonly ctx: GenericActionCtx<DataModel>;
+    readonly table?: TableName;
+    readonly index?: IndexName;
+    readonly textField?: TextFieldName;
+    readonly embeddingField?: EmbeddingFieldName;
+    readonly metadataField?: MetadataFieldName;
+    readonly insert?: InsertMutation;
+    readonly get?: GetQuery;
+};
+/**
+ * Class that is a wrapper around Convex storage and vector search. It is used
+ * to insert embeddings in Convex documents with a vector search index,
+ * and perform a vector search on them.
+ *
+ * ConvexVectorStore does NOT implement maxMarginalRelevanceSearch.
+ */
+export declare class ConvexVectorStore<DataModel extends GenericDataModel, TableName extends TableNamesInDataModel<DataModel>, IndexName extends VectorIndexNames<NamedTableInfo<DataModel, TableName>>, TextFieldName extends FieldPaths<NamedTableInfo<DataModel, TableName>>, EmbeddingFieldName extends FieldPaths<NamedTableInfo<DataModel, TableName>>, MetadataFieldName extends FieldPaths<NamedTableInfo<DataModel, TableName>>, InsertMutation extends FunctionReference<"mutation", "internal", {
+    table: string;
+    document: object;
+}>, GetQuery extends FunctionReference<"query", "internal", {
+    id: string;
+}, object | null>> extends VectorStore {
+    /**
+     * Type that defines the filter used in the
+     * similaritySearchVectorWithScore and maxMarginalRelevanceSearch methods.
+     * It includes limit, filter and a flag to include embeddings.
+     */
+    FilterType: {
+        filter?: (q: VectorFilterBuilder<DocumentByInfo<GenericTableInfo>, NamedVectorIndex<NamedTableInfo<DataModel, TableName>, IndexName>>) => FilterExpression<boolean>;
+        includeEmbeddings?: boolean;
+    };
+    private readonly ctx;
+    private readonly table;
+    private readonly index;
+    private readonly textField;
+    private readonly embeddingField;
+    private readonly metadataField;
+    private readonly insert;
+    private readonly get;
+    _vectorstoreType(): string;
+    constructor(embeddings: Embeddings, config: ConvexVectorStoreConfig<DataModel, TableName, IndexName, TextFieldName, EmbeddingFieldName, MetadataFieldName, InsertMutation, GetQuery>);
+    /**
+     * Add vectors and their corresponding documents to the Convex table.
+     * @param vectors Vectors to be added.
+     * @param documents Corresponding documents to be added.
+     * @returns Promise that resolves when the vectors and documents have been added.
+     */
+    addVectors(vectors: number[][], documents: Document[]): Promise<void>;
+    /**
+     * Add documents to the Convex table. It first converts
+     * the documents to vectors using the embeddings and then calls the
+     * addVectors method.
+     * @param documents Documents to be added.
+     * @returns Promise that resolves when the documents have been added.
+     */
+    addDocuments(documents: Document[]): Promise<void>;
+    /**
+     * Similarity search on the vectors stored in the
+     * Convex table. It returns a list of documents and their
+     * corresponding similarity scores.
+     * @param query Query vector for the similarity search.
+     * @param k Number of nearest neighbors to return.
+     * @param filter Optional filter to be applied.
+     * @returns Promise that resolves to a list of documents and their corresponding similarity scores.
+     */
+    similaritySearchVectorWithScore(query: number[], k: number, filter?: this["FilterType"]): Promise<[Document, number][]>;
+    /**
+     * Static method to create an instance of ConvexVectorStore from a
+     * list of texts. It first converts the texts to vectors and then adds
+     * them to the Convex table.
+     * @param texts List of texts to be converted to vectors.
+     * @param metadatas Metadata for the texts.
+     * @param embeddings Embeddings to be used for conversion.
+     * @param dbConfig Database configuration for Convex.
+     * @returns Promise that resolves to a new instance of ConvexVectorStore.
+     */
+    static fromTexts<DataModel extends GenericDataModel, TableName extends TableNamesInDataModel<DataModel>, IndexName extends VectorIndexNames<NamedTableInfo<DataModel, TableName>>, TextFieldName extends FieldPaths<NamedTableInfo<DataModel, TableName>>, EmbeddingFieldName extends FieldPaths<NamedTableInfo<DataModel, TableName>>, MetadataFieldName extends FieldPaths<NamedTableInfo<DataModel, TableName>>, InsertMutation extends FunctionReference<"mutation", "internal", {
+        table: string;
+        document: object;
+    }>, GetQuery extends FunctionReference<"query", "internal", {
+        id: string;
+    }, object | null>>(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig: ConvexVectorStoreConfig<DataModel, TableName, IndexName, TextFieldName, EmbeddingFieldName, MetadataFieldName, InsertMutation, GetQuery>): Promise<ConvexVectorStore<DataModel, TableName, IndexName, TextFieldName, EmbeddingFieldName, MetadataFieldName, InsertMutation, GetQuery>>;
+    /**
+     * Static method to create an instance of ConvexVectorStore from a
+     * list of documents. It first converts the documents to vectors and then
+     * adds them to the Convex table.
+     * @param docs List of documents to be converted to vectors.
+     * @param embeddings Embeddings to be used for conversion.
+     * @param dbConfig Database configuration for Convex.
+     * @returns Promise that resolves to a new instance of ConvexVectorStore.
+     */
+    static fromDocuments<DataModel extends GenericDataModel, TableName extends TableNamesInDataModel<DataModel>, IndexName extends VectorIndexNames<NamedTableInfo<DataModel, TableName>>, TextFieldName extends FieldPaths<NamedTableInfo<DataModel, TableName>>, EmbeddingFieldName extends FieldPaths<NamedTableInfo<DataModel, TableName>>, MetadataFieldName extends FieldPaths<NamedTableInfo<DataModel, TableName>>, InsertMutation extends FunctionReference<"mutation", "internal", {
+        table: string;
+        document: object;
+    }>, GetQuery extends FunctionReference<"query", "internal", {
+        id: string;
+    }, object | null>>(docs: Document[], embeddings: Embeddings, dbConfig: ConvexVectorStoreConfig<DataModel, TableName, IndexName, TextFieldName, EmbeddingFieldName, MetadataFieldName, InsertMutation, GetQuery>): Promise<ConvexVectorStore<DataModel, TableName, IndexName, TextFieldName, EmbeddingFieldName, MetadataFieldName, InsertMutation, GetQuery>>;
+}