@langchain/classic 1.0.17 → 1.0.18

package/dist/storage/file_system.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"file_system.cjs","names":["BaseStore","fields: { rootPath: string }","key: string","fs","e: any","content: Uint8Array","path","keys: string[]","values: (Uint8Array | undefined)[]","keyValuePairs: [string, Uint8Array][]","prefix?: string","rootPath: string"],"sources":["../../src/storage/file_system.ts"],"sourcesContent":["import * as fs from \"node:fs/promises\";\nimport * as path from \"node:path\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\n/**\n * File system implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in the file system.\n * @example\n * ```typescript\n * const store = await LocalFileStore.fromPath(\"./messages\");\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     new TextEncoder().encode(\n *       JSON.stringify(\n *         index % 2 === 0\n *           ? new AIMessage(\"ai stuff...\")\n *           : new HumanMessage(\"human stuff...\"),\n *       ),\n *     ),\n *   ]),\n * );\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));\n * for await (const key of store.yieldKeys(\"message:id:\")) {\n *   await store.mdelete([key]);\n * }\n * ```\n *\n * @security **Security Notice** This file store\n * can alter any text file in the provided directory and any subfolders.\n * Make sure that the path you specify when initializing the store is free\n * of other files.\n */\nexport class LocalFileStore extends BaseStore<string, Uint8Array> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  rootPath: string;\n\n  constructor(fields: { rootPath: string }) {\n    super(fields);\n    this.rootPath = fields.rootPath;\n  }\n\n  /**\n   * Read and parse the file at the given path.\n   * @param key The key to read the file for.\n   * @returns Promise that resolves to the parsed file content.\n   */\n  private async getParsedFile(key: string): Promise<Uint8Array | undefined> {\n    // Validate the key to prevent path traversal\n    if (!/^[a-zA-Z0-9_\\-:.]+$/.test(key)) {\n      throw new Error(\n        \"Invalid key. Only alphanumeric characters, underscores, hyphens, colons, and periods are allowed.\"\n      );\n    }\n    try {\n      const fileContent = await fs.readFile(this.getFullPath(key));\n      if (!fileContent) {\n        return undefined;\n      }\n      return fileContent;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (e: any) {\n      // File does not exist yet.\n      if (\"code\" in e && e.code === \"ENOENT\") {\n        return undefined;\n      }\n      throw new Error(\n        `Error reading and parsing file at path: ${\n          this.rootPath\n        }.\\nError: ${JSON.stringify(e)}`\n      );\n    }\n  }\n\n  /**\n   * Writes the given key-value pairs to the file at the given path.\n   * @param fileContent An object with the key-value pairs to be written to the file.\n   */\n  private async setFileContent(content: Uint8Array, key: string) {\n    try {\n      await fs.writeFile(this.getFullPath(key), content);\n    } catch (error) {\n      throw new Error(\n        `Error writing file at path: ${this.getFullPath(\n          key\n        )}.\\nError: ${JSON.stringify(error)}`\n      );\n    }\n  }\n\n  /**\n   * Returns the full path of the file where the value of the given key is stored.\n   * @param key the key to get the full path for\n   */\n  private getFullPath(key: string): string {\n    try {\n      const keyAsTxtFile = `${key}.txt`;\n\n      // Validate the key to prevent path traversal\n      if (!/^[a-zA-Z0-9_.\\-/]+$/.test(key)) {\n        throw new Error(`Invalid characters in key: ${key}`);\n      }\n\n      const fullPath = path.resolve(this.rootPath, keyAsTxtFile);\n      const commonPath = path.resolve(this.rootPath);\n\n      if (!fullPath.startsWith(commonPath)) {\n        throw new Error(\n          `Invalid key: ${key}. Key should be relative to the root path. ` +\n            `Root path: ${this.rootPath}, Full path: ${fullPath}`\n        );\n      }\n\n      return fullPath;\n    } catch (e) {\n      throw new Error(\n        `Error getting full path for key: ${key}.\\nError: ${String(e)}`\n      );\n    }\n  }\n\n  /**\n   * Retrieves the values associated with the given keys from the store.\n   * @param keys Keys to retrieve values for.\n   * @returns Array of values associated with the given keys.\n   */\n  async mget(keys: string[]) {\n    const values: (Uint8Array | undefined)[] = [];\n    for (const key of keys) {\n      const fileContent = await this.getParsedFile(key);\n      values.push(fileContent);\n    }\n    return values;\n  }\n\n  /**\n   * Sets the values for the given keys in the store.\n   * @param keyValuePairs Array of key-value pairs to set in the store.\n   * @returns Promise that resolves when all key-value pairs have been set.\n   */\n  async mset(keyValuePairs: [string, Uint8Array][]): Promise<void> {\n    await Promise.all(\n      keyValuePairs.map(([key, value]) => this.setFileContent(value, key))\n    );\n  }\n\n  /**\n   * Deletes the given keys and their associated values from the store.\n   * @param keys Keys to delete from the store.\n   * @returns Promise that resolves when all keys have been deleted.\n   */\n  async mdelete(keys: string[]): Promise<void> {\n    await Promise.all(keys.map((key) => fs.unlink(this.getFullPath(key))));\n  }\n\n  /**\n   * Asynchronous generator that yields keys from the store. If a prefix is\n   * provided, it only yields keys that start with the prefix.\n   * @param prefix Optional prefix to filter keys.\n   * @returns AsyncGenerator that yields keys from the store.\n   */\n  async *yieldKeys(prefix?: string): AsyncGenerator<string> {\n    const allFiles = await fs.readdir(this.rootPath);\n    const allKeys = allFiles.map((file) => file.replace(\".txt\", \"\"));\n    for (const key of allKeys) {\n      if (prefix === undefined || key.startsWith(prefix)) {\n        yield key;\n      }\n    }\n  }\n\n  /**\n   * Static method for initializing the class.\n   * Preforms a check to see if the directory exists, and if not, creates it.\n   * @param path Path to the directory.\n   * @returns Promise that resolves to an instance of the class.\n   */\n  static async fromPath(rootPath: string): Promise<LocalFileStore> {\n    try {\n      // Verifies the directory exists at the provided path, and that it is readable and writable.\n      await fs.access(rootPath, fs.constants.R_OK | fs.constants.W_OK);\n    } catch {\n      try {\n        // Directory does not exist, create it.\n        await fs.mkdir(rootPath, { recursive: true });\n      } catch (error) {\n        throw new Error(\n          `An error occurred creating directory at: ${rootPath}.\\nError: ${JSON.stringify(\n            error\n          )}`\n        );\n      }\n    }\n\n    return new this({ rootPath });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,iBAAb,cAAoCA,kCAA8B;CAChE,eAAe,CAAC,aAAa,SAAU;CAEvC;CAEA,YAAYC,QAA8B;EACxC,MAAM,OAAO;EACb,KAAK,WAAW,OAAO;CACxB;;;;;;CAOD,MAAc,cAAcC,KAA8C;AAExE,MAAI,CAAC,sBAAsB,KAAK,IAAI,CAClC,OAAM,IAAI,MACR;AAGJ,MAAI;GACF,MAAM,cAAc,MAAMC,iBAAG,SAAS,KAAK,YAAY,IAAI,CAAC;AAC5D,OAAI,CAAC,YACH,QAAO;AAET,UAAO;EAER,SAAQC,GAAQ;AAEf,OAAI,UAAU,KAAK,EAAE,SAAS,SAC5B,QAAO;AAET,SAAM,IAAI,MACR,CAAC,wCAAwC,EACvC,KAAK,SACN,UAAU,EAAE,KAAK,UAAU,EAAE,EAAE;EAEnC;CACF;;;;;CAMD,MAAc,eAAeC,SAAqBH,KAAa;AAC7D,MAAI;GACF,MAAMC,iBAAG,UAAU,KAAK,YAAY,IAAI,EAAE,QAAQ;EACnD,SAAQ,OAAO;AACd,SAAM,IAAI,MACR,CAAC,4BAA4B,EAAE,KAAK,YAClC,IACD,CAAC,UAAU,EAAE,KAAK,UAAU,MAAM,EAAE;EAExC;CACF;;;;;CAMD,AAAQ,YAAYD,KAAqB;AACvC,MAAI;GACF,MAAM,eAAe,GAAG,IAAI,IAAI,CAAC;AAGjC,OAAI,CAAC,sBAAsB,KAAK,IAAI,CAClC,OAAM,IAAI,MAAM,CAAC,2BAA2B,EAAE,KAAK;GAGrD,MAAM,WAAWI,UAAK,QAAQ,KAAK,UAAU,aAAa;GAC1D,MAAM,aAAaA,UAAK,QAAQ,KAAK,SAAS;AAE9C,OAAI,CAAC,SAAS,WAAW,WAAW,CAClC,OAAM,IAAI,MACR,CAAC,aAAa,EAAE,IAAI,sDAA2C,EAC/C,KAAK,SAAS,aAAa,EAAE,UAAU;AAI3D,UAAO;EACR,SAAQ,GAAG;AACV,SAAM,IAAI,MACR,CAAC,iCAAiC,EAAE,IAAI,UAAU,EAAE,OAAO,EAAE,EAAE;EAElE;CACF;;;;;;CAOD,MAAM,KAAKC,MAAgB;EACzB,MAAMC,SAAqC,CAAE;AAC7C,OAAK,MAAM,OAAO,MAAM;GACtB,MAAM,cAAc,MAAM,KAAK,cAAc,IAAI;GACjD,OAAO,KAAK,YAAY;EACzB;AACD,SAAO;CACR;;;;;;CAOD,MAAM,KAAKC,eAAsD;EAC/D,MAAM,QAAQ,IACZ,cAAc,IAAI,CAAC,CAAC,KAAK,MAAM,KAAK,KAAK,eAAe,OAAO,IAAI,CAAC,CACrE;CACF;;;;;;CAOD,MAAM,QAAQF,MAA+B;EAC3C,MAAM,QAAQ,IAAI,KAAK,IAAI,CAAC,QAAQJ,iBAAG,OAAO,KAAK,YAAY,IAAI,CAAC,CAAC,CAAC;CACvE;;;;;;;CAQD,OAAO,UAAUO,QAAyC;EACxD,MAAM,WAAW,MAAMP,iBAAG,QAAQ,KAAK,SAAS;EAChD,MAAM,UAAU,SAAS,IAAI,CAAC,SAAS,KAAK,QAAQ,QAAQ,GAAG,CAAC;AAChE,OAAK,MAAM,OAAO,QAChB,KAAI,WAAW,UAAa,IAAI,WAAW,OAAO,EAChD,MAAM;CAGX;;;;;;;CAQD,aAAa,SAASQ,UAA2C;AAC/D,MAAI;GAEF,MAAMR,iBAAG,OAAO,UAAUA,iBAAG,UAAU,OAAOA,iBAAG,UAAU,KAAK;EACjE,QAAO;AACN,OAAI;IAEF,MAAMA,iBAAG,MAAM,UAAU,EAAE,WAAW,KAAM,EAAC;GAC9C,SAAQ,OAAO;AACd,UAAM,IAAI,MACR,CAAC,yCAAyC,EAAE,SAAS,UAAU,EAAE,KAAK,UACpE,MACD,EAAE;GAEN;EACF;AAED,SAAO,IAAI,KAAK,EAAE,SAAU;CAC7B;AACF"}
+{"version":3,"file":"file_system.cjs","names":["BaseStore","fs","path"],"sources":["../../src/storage/file_system.ts"],"sourcesContent":["import * as fs from \"node:fs/promises\";\nimport * as path from \"node:path\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\n/**\n * File system implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in the file system.\n * @example\n * ```typescript\n * const store = await LocalFileStore.fromPath(\"./messages\");\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     new TextEncoder().encode(\n *       JSON.stringify(\n *         index % 2 === 0\n *           ? new AIMessage(\"ai stuff...\")\n *           : new HumanMessage(\"human stuff...\"),\n *       ),\n *     ),\n *   ]),\n * );\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));\n * for await (const key of store.yieldKeys(\"message:id:\")) {\n *   await store.mdelete([key]);\n * }\n * ```\n *\n * @security **Security Notice** This file store\n * can alter any text file in the provided directory and any subfolders.\n * Make sure that the path you specify when initializing the store is free\n * of other files.\n */\nexport class LocalFileStore extends BaseStore<string, Uint8Array> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  rootPath: string;\n\n  constructor(fields: { rootPath: string }) {\n    super(fields);\n    this.rootPath = fields.rootPath;\n  }\n\n  /**\n   * Read and parse the file at the given path.\n   * @param key The key to read the file for.\n   * @returns Promise that resolves to the parsed file content.\n   */\n  private async getParsedFile(key: string): Promise<Uint8Array | undefined> {\n    // Validate the key to prevent path traversal\n    if (!/^[a-zA-Z0-9_\\-:.]+$/.test(key)) {\n      throw new Error(\n        \"Invalid key. Only alphanumeric characters, underscores, hyphens, colons, and periods are allowed.\"\n      );\n    }\n    try {\n      const fileContent = await fs.readFile(this.getFullPath(key));\n      if (!fileContent) {\n        return undefined;\n      }\n      return fileContent;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (e: any) {\n      // File does not exist yet.\n      if (\"code\" in e && e.code === \"ENOENT\") {\n        return undefined;\n      }\n      throw new Error(\n        `Error reading and parsing file at path: ${\n          this.rootPath\n        }.\\nError: ${JSON.stringify(e)}`\n      );\n    }\n  }\n\n  /**\n   * Writes the given key-value pairs to the file at the given path.\n   * @param fileContent An object with the key-value pairs to be written to the file.\n   */\n  private async setFileContent(content: Uint8Array, key: string) {\n    try {\n      await fs.writeFile(this.getFullPath(key), content);\n    } catch (error) {\n      throw new Error(\n        `Error writing file at path: ${this.getFullPath(\n          key\n        )}.\\nError: ${JSON.stringify(error)}`\n      );\n    }\n  }\n\n  /**\n   * Returns the full path of the file where the value of the given key is stored.\n   * @param key the key to get the full path for\n   */\n  private getFullPath(key: string): string {\n    try {\n      const keyAsTxtFile = `${key}.txt`;\n\n      // Validate the key to prevent path traversal\n      if (!/^[a-zA-Z0-9_.\\-/]+$/.test(key)) {\n        throw new Error(`Invalid characters in key: ${key}`);\n      }\n\n      const fullPath = path.resolve(this.rootPath, keyAsTxtFile);\n      const commonPath = path.resolve(this.rootPath);\n\n      if (!fullPath.startsWith(commonPath)) {\n        throw new Error(\n          `Invalid key: ${key}. Key should be relative to the root path. ` +\n            `Root path: ${this.rootPath}, Full path: ${fullPath}`\n        );\n      }\n\n      return fullPath;\n    } catch (e) {\n      throw new Error(\n        `Error getting full path for key: ${key}.\\nError: ${String(e)}`\n      );\n    }\n  }\n\n  /**\n   * Retrieves the values associated with the given keys from the store.\n   * @param keys Keys to retrieve values for.\n   * @returns Array of values associated with the given keys.\n   */\n  async mget(keys: string[]) {\n    const values: (Uint8Array | undefined)[] = [];\n    for (const key of keys) {\n      const fileContent = await this.getParsedFile(key);\n      values.push(fileContent);\n    }\n    return values;\n  }\n\n  /**\n   * Sets the values for the given keys in the store.\n   * @param keyValuePairs Array of key-value pairs to set in the store.\n   * @returns Promise that resolves when all key-value pairs have been set.\n   */\n  async mset(keyValuePairs: [string, Uint8Array][]): Promise<void> {\n    await Promise.all(\n      keyValuePairs.map(([key, value]) => this.setFileContent(value, key))\n    );\n  }\n\n  /**\n   * Deletes the given keys and their associated values from the store.\n   * @param keys Keys to delete from the store.\n   * @returns Promise that resolves when all keys have been deleted.\n   */\n  async mdelete(keys: string[]): Promise<void> {\n    await Promise.all(keys.map((key) => fs.unlink(this.getFullPath(key))));\n  }\n\n  /**\n   * Asynchronous generator that yields keys from the store. If a prefix is\n   * provided, it only yields keys that start with the prefix.\n   * @param prefix Optional prefix to filter keys.\n   * @returns AsyncGenerator that yields keys from the store.\n   */\n  async *yieldKeys(prefix?: string): AsyncGenerator<string> {\n    const allFiles = await fs.readdir(this.rootPath);\n    const allKeys = allFiles.map((file) => file.replace(\".txt\", \"\"));\n    for (const key of allKeys) {\n      if (prefix === undefined || key.startsWith(prefix)) {\n        yield key;\n      }\n    }\n  }\n\n  /**\n   * Static method for initializing the class.\n   * Preforms a check to see if the directory exists, and if not, creates it.\n   * @param path Path to the directory.\n   * @returns Promise that resolves to an instance of the class.\n   */\n  static async fromPath(rootPath: string): Promise<LocalFileStore> {\n    try {\n      // Verifies the directory exists at the provided path, and that it is readable and writable.\n      await fs.access(rootPath, fs.constants.R_OK | fs.constants.W_OK);\n    } catch {\n      try {\n        // Directory does not exist, create it.\n        await fs.mkdir(rootPath, { recursive: true });\n      } catch (error) {\n        throw new Error(\n          `An error occurred creating directory at: ${rootPath}.\\nError: ${JSON.stringify(\n            error\n          )}`\n        );\n      }\n    }\n\n    return new this({ rootPath });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,iBAAb,cAAoCA,iCAA8B;CAChE,eAAe,CAAC,aAAa,UAAU;CAEvC;CAEA,YAAY,QAA8B;AACxC,QAAM,OAAO;AACb,OAAK,WAAW,OAAO;;;;;;;CAQzB,MAAc,cAAc,KAA8C;AAExE,MAAI,CAAC,sBAAsB,KAAK,IAAI,CAClC,OAAM,IAAI,MACR,oGACD;AAEH,MAAI;GACF,MAAM,cAAc,MAAMC,iBAAG,SAAS,KAAK,YAAY,IAAI,CAAC;AAC5D,OAAI,CAAC,YACH;AAEF,UAAO;WAEA,GAAQ;AAEf,OAAI,UAAU,KAAK,EAAE,SAAS,SAC5B;AAEF,SAAM,IAAI,MACR,2CACE,KAAK,SACN,YAAY,KAAK,UAAU,EAAE,GAC/B;;;;;;;CAQL,MAAc,eAAe,SAAqB,KAAa;AAC7D,MAAI;AACF,SAAMA,iBAAG,UAAU,KAAK,YAAY,IAAI,EAAE,QAAQ;WAC3C,OAAO;AACd,SAAM,IAAI,MACR,+BAA+B,KAAK,YAClC,IACD,CAAC,YAAY,KAAK,UAAU,MAAM,GACpC;;;;;;;CAQL,AAAQ,YAAY,KAAqB;AACvC,MAAI;GACF,MAAM,eAAe,GAAG,IAAI;AAG5B,OAAI,CAAC,sBAAsB,KAAK,IAAI,CAClC,OAAM,IAAI,MAAM,8BAA8B,MAAM;GAGtD,MAAM,WAAWC,UAAK,QAAQ,KAAK,UAAU,aAAa;GAC1D,MAAM,aAAaA,UAAK,QAAQ,KAAK,SAAS;AAE9C,OAAI,CAAC,SAAS,WAAW,WAAW,CAClC,OAAM,IAAI,MACR,gBAAgB,IAAI,wDACJ,KAAK,SAAS,eAAe,WAC9C;AAGH,UAAO;WACA,GAAG;AACV,SAAM,IAAI,MACR,oCAAoC,IAAI,YAAY,OAAO,EAAE,GAC9D;;;;;;;;CASL,MAAM,KAAK,MAAgB;EACzB,MAAM,SAAqC,EAAE;AAC7C,OAAK,MAAM,OAAO,MAAM;GACtB,MAAM,cAAc,MAAM,KAAK,cAAc,IAAI;AACjD,UAAO,KAAK,YAAY;;AAE1B,SAAO;;;;;;;CAQT,MAAM,KAAK,eAAsD;AAC/D,QAAM,QAAQ,IACZ,cAAc,KAAK,CAAC,KAAK,WAAW,KAAK,eAAe,OAAO,IAAI,CAAC,CACrE;;;;;;;CAQH,MAAM,QAAQ,MAA+B;AAC3C,QAAM,QAAQ,IAAI,KAAK,KAAK,QAAQD,iBAAG,OAAO,KAAK,YAAY,IAAI,CAAC,CAAC,CAAC;;;;;;;;CASxE,OAAO,UAAU,QAAyC;EAExD,MAAM,WADW,MAAMA,iBAAG,QAAQ,KAAK,SAAS,EACvB,KAAK,SAAS,KAAK,QAAQ,QAAQ,GAAG,CAAC;AAChE,OAAK,MAAM,OAAO,QAChB,KAAI,WAAW,UAAa,IAAI,WAAW,OAAO,CAChD,OAAM;;;;;;;;CAWZ,aAAa,SAAS,UAA2C;AAC/D,MAAI;AAEF,SAAMA,iBAAG,OAAO,UAAUA,iBAAG,UAAU,OAAOA,iBAAG,UAAU,KAAK;UAC1D;AACN,OAAI;AAEF,UAAMA,iBAAG,MAAM,UAAU,EAAE,WAAW,MAAM,CAAC;YACtC,OAAO;AACd,UAAM,IAAI,MACR,4CAA4C,SAAS,YAAY,KAAK,UACpE,MACD,GACF;;;AAIL,SAAO,IAAI,KAAK,EAAE,UAAU,CAAC"}

package/dist/storage/file_system.d.cts

@@ -1,7 +1,6 @@
 import { BaseStore } from "@langchain/core/stores";
 
 //#region src/storage/file_system.d.ts
-
 /**
  * File system implementation of the BaseStore using a dictionary. Used for
  * storing key-value pairs in the file system.

package/dist/storage/file_system.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"file_system.d.cts","names":["BaseStore","LocalFileStore","Uint8Array","ArrayBufferLike","Promise","AsyncGenerator"],"sources":["../../src/storage/file_system.d.ts"],"sourcesContent":["import { BaseStore } from \"@langchain/core/stores\";\n/**\n * File system implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in the file system.\n * @example\n * ```typescript\n * const store = await LocalFileStore.fromPath(\"./messages\");\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     new TextEncoder().encode(\n *       JSON.stringify(\n *         index % 2 === 0\n *           ? new AIMessage(\"ai stuff...\")\n *           : new HumanMessage(\"human stuff...\"),\n *       ),\n *     ),\n *   ]),\n * );\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));\n * for await (const key of store.yieldKeys(\"message:id:\")) {\n *   await store.mdelete([key]);\n * }\n * ```\n *\n * @security **Security Notice** This file store\n * can alter any text file in the provided directory and any subfolders.\n * Make sure that the path you specify when initializing the store is free\n * of other files.\n */\nexport declare class LocalFileStore extends BaseStore<string, Uint8Array> {\n    lc_namespace: string[];\n    rootPath: string;\n    constructor(fields: {\n        rootPath: string;\n    });\n    private getParsedFile;\n    private setFileContent;\n    /**\n     * Returns the full path of the file where the value of the given key is stored.\n     * @param key the key to get the full path for\n     */\n    private getFullPath;\n    /**\n     * Retrieves the values associated with the given keys from the store.\n     * @param keys Keys to retrieve values for.\n     * @returns Array of values associated with the given keys.\n     */\n    mget(keys: string[]): Promise<(Uint8Array<ArrayBufferLike> | undefined)[]>;\n    /**\n     * Sets the values for the given keys in the store.\n     * @param keyValuePairs Array of key-value pairs to set in the store.\n     * @returns Promise that resolves when all key-value pairs have been set.\n     */\n    mset(keyValuePairs: [string, Uint8Array][]): Promise<void>;\n    /**\n     * Deletes the given keys and their associated values from the store.\n     * @param keys Keys to delete from the store.\n     * @returns Promise that resolves when all keys have been deleted.\n     */\n    mdelete(keys: string[]): Promise<void>;\n    /**\n     * Asynchronous generator that yields keys from the store. If a prefix is\n     * provided, it only yields keys that start with the prefix.\n     * @param prefix Optional prefix to filter keys.\n     * @returns AsyncGenerator that yields keys from the store.\n     */\n    yieldKeys(prefix?: string): AsyncGenerator<string>;\n    /**\n     * Static method for initializing the class.\n     * Preforms a check to see if the directory exists, and if not, creates it.\n     * @param path Path to the directory.\n     * @returns Promise that resolves to an instance of the class.\n     */\n    static fromPath(rootPath: string): Promise<LocalFileStore>;\n}\n//# sourceMappingURL=file_system.d.ts.map"],"mappings":";;;;;;AA+BA;;;;;;;;;;;;AAAqD;;;;;;;;;;;;;;;;cAAhCC,cAAAA,SAAuBD,kBAAkBE;;;;;;;;;;;;;;;;;;wBAkBpCE,SAASF,WAAWC;;;;;;+BAMbD,gBAAgBE;;;;;;2BAMpBA;;;;;;;8BAOGC;;;;;;;qCAOOD,QAAQH"}
+{"version":3,"file":"file_system.d.cts","names":[],"sources":["../../src/storage/file_system.ts"],"mappings":";;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,cAAA,SAAuB,SAAA,SAAkB,UAAA;EACpD,YAAA;EAEA,QAAA;EAEA,WAAA,CAAY,MAAA;IAAU,QAAA;EAAA;EAAA,QAUR,aAAA;EAAA,QA+BA,cAAA;EAyEA;;;;EAAA,QAzDN,WAAA;EAmFK;;;;;EAnDP,IAAA,CAAK,IAAA,aAAc,OAAA,EAAA,UAAA,CAAA,eAAA;;;;;;EAcnB,IAAA,CAAK,aAAA,WAAwB,UAAA,MAAgB,OAAA;;;;;;EAW7C,OAAA,CAAQ,IAAA,aAAiB,OAAA;;;;;;;EAUxB,SAAA,CAAU,MAAA,YAAkB,cAAA;;;;;;;SAgBtB,QAAA,CAAS,QAAA,WAAmB,OAAA,CAAQ,cAAA;AAAA"}

package/dist/storage/file_system.d.ts

@@ -1,7 +1,6 @@
 import { BaseStore } from "@langchain/core/stores";
 
 //#region src/storage/file_system.d.ts
-
 /**
  * File system implementation of the BaseStore using a dictionary. Used for
  * storing key-value pairs in the file system.

package/dist/storage/file_system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file_system.d.ts","names":["BaseStore","LocalFileStore","Uint8Array","ArrayBufferLike","Promise","AsyncGenerator"],"sources":["../../src/storage/file_system.d.ts"],"sourcesContent":["import { BaseStore } from \"@langchain/core/stores\";\n/**\n * File system implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in the file system.\n * @example\n * ```typescript\n * const store = await LocalFileStore.fromPath(\"./messages\");\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     new TextEncoder().encode(\n *       JSON.stringify(\n *         index % 2 === 0\n *           ? new AIMessage(\"ai stuff...\")\n *           : new HumanMessage(\"human stuff...\"),\n *       ),\n *     ),\n *   ]),\n * );\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));\n * for await (const key of store.yieldKeys(\"message:id:\")) {\n *   await store.mdelete([key]);\n * }\n * ```\n *\n * @security **Security Notice** This file store\n * can alter any text file in the provided directory and any subfolders.\n * Make sure that the path you specify when initializing the store is free\n * of other files.\n */\nexport declare class LocalFileStore extends BaseStore<string, Uint8Array> {\n    lc_namespace: string[];\n    rootPath: string;\n    constructor(fields: {\n        rootPath: string;\n    });\n    private getParsedFile;\n    private setFileContent;\n    /**\n     * Returns the full path of the file where the value of the given key is stored.\n     * @param key the key to get the full path for\n     */\n    private getFullPath;\n    /**\n     * Retrieves the values associated with the given keys from the store.\n     * @param keys Keys to retrieve values for.\n     * @returns Array of values associated with the given keys.\n     */\n    mget(keys: string[]): Promise<(Uint8Array<ArrayBufferLike> | undefined)[]>;\n    /**\n     * Sets the values for the given keys in the store.\n     * @param keyValuePairs Array of key-value pairs to set in the store.\n     * @returns Promise that resolves when all key-value pairs have been set.\n     */\n    mset(keyValuePairs: [string, Uint8Array][]): Promise<void>;\n    /**\n     * Deletes the given keys and their associated values from the store.\n     * @param keys Keys to delete from the store.\n     * @returns Promise that resolves when all keys have been deleted.\n     */\n    mdelete(keys: string[]): Promise<void>;\n    /**\n     * Asynchronous generator that yields keys from the store. If a prefix is\n     * provided, it only yields keys that start with the prefix.\n     * @param prefix Optional prefix to filter keys.\n     * @returns AsyncGenerator that yields keys from the store.\n     */\n    yieldKeys(prefix?: string): AsyncGenerator<string>;\n    /**\n     * Static method for initializing the class.\n     * Preforms a check to see if the directory exists, and if not, creates it.\n     * @param path Path to the directory.\n     * @returns Promise that resolves to an instance of the class.\n     */\n    static fromPath(rootPath: string): Promise<LocalFileStore>;\n}\n//# sourceMappingURL=file_system.d.ts.map"],"mappings":";;;;;;AA+BA;;;;;;;;;;;;AAAqD;;;;;;;;;;;;;;;;cAAhCC,cAAAA,SAAuBD,kBAAkBE;;;;;;;;;;;;;;;;;;wBAkBpCE,SAASF,WAAWC;;;;;;+BAMbD,gBAAgBE;;;;;;2BAMpBA;;;;;;;8BAOGC;;;;;;;qCAOOD,QAAQH"}
+{"version":3,"file":"file_system.d.ts","names":[],"sources":["../../src/storage/file_system.ts"],"mappings":";;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,cAAA,SAAuB,SAAA,SAAkB,UAAA;EACpD,YAAA;EAEA,QAAA;EAEA,WAAA,CAAY,MAAA;IAAU,QAAA;EAAA;EAAA,QAUR,aAAA;EAAA,QA+BA,cAAA;EAyEA;;;;EAAA,QAzDN,WAAA;EAmFK;;;;;EAnDP,IAAA,CAAK,IAAA,aAAc,OAAA,EAAA,UAAA,CAAA,eAAA;;;;;;EAcnB,IAAA,CAAK,aAAA,WAAwB,UAAA,MAAgB,OAAA;;;;;;EAW7C,OAAA,CAAQ,IAAA,aAAiB,OAAA;;;;;;;EAUxB,SAAA,CAAU,MAAA,YAAkB,cAAA;;;;;;;SAgBtB,QAAA,CAAS,QAAA,WAAmB,OAAA,CAAQ,cAAA;AAAA"}

package/dist/storage/file_system.js

@@ -1,11 +1,10 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import * as path$1 from "node:path";
 import * as fs$1 from "node:fs/promises";
 import { BaseStore } from "@langchain/core/stores";
 
 //#region src/storage/file_system.ts
-var file_system_exports = {};
-__export(file_system_exports, { LocalFileStore: () => LocalFileStore });
+var file_system_exports = /* @__PURE__ */ __exportAll({ LocalFileStore: () => LocalFileStore });
 /**
 * File system implementation of the BaseStore using a dictionary. Used for
 * storing key-value pairs in the file system.
@@ -52,10 +51,10 @@ var LocalFileStore = class extends BaseStore {
 		if (!/^[a-zA-Z0-9_\-:.]+$/.test(key)) throw new Error("Invalid key. Only alphanumeric characters, underscores, hyphens, colons, and periods are allowed.");
 		try {
 			const fileContent = await fs$1.readFile(this.getFullPath(key));
-			if (!fileContent) return void 0;
+			if (!fileContent) return;
 			return fileContent;
 		} catch (e) {
-			if ("code" in e && e.code === "ENOENT") return void 0;
+			if ("code" in e && e.code === "ENOENT") return;
 			throw new Error(`Error reading and parsing file at path: ${this.rootPath}.\nError: ${JSON.stringify(e)}`);
 		}
 	}
@@ -122,8 +121,7 @@ var LocalFileStore = class extends BaseStore {
 	* @returns AsyncGenerator that yields keys from the store.
 	*/
 	async *yieldKeys(prefix) {
-		const allFiles = await fs$1.readdir(this.rootPath);
-		const allKeys = allFiles.map((file) => file.replace(".txt", ""));
+		const allKeys = (await fs$1.readdir(this.rootPath)).map((file) => file.replace(".txt", ""));
 		for (const key of allKeys) if (prefix === void 0 || key.startsWith(prefix)) yield key;
 	}
 	/**

package/dist/storage/file_system.js.map

@@ -1 +1 @@
-{"version":3,"file":"file_system.js","names":["fields: { rootPath: string }","key: string","fs","e: any","content: Uint8Array","path","keys: string[]","values: (Uint8Array | undefined)[]","keyValuePairs: [string, Uint8Array][]","prefix?: string","rootPath: string"],"sources":["../../src/storage/file_system.ts"],"sourcesContent":["import * as fs from \"node:fs/promises\";\nimport * as path from \"node:path\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\n/**\n * File system implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in the file system.\n * @example\n * ```typescript\n * const store = await LocalFileStore.fromPath(\"./messages\");\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     new TextEncoder().encode(\n *       JSON.stringify(\n *         index % 2 === 0\n *           ? new AIMessage(\"ai stuff...\")\n *           : new HumanMessage(\"human stuff...\"),\n *       ),\n *     ),\n *   ]),\n * );\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));\n * for await (const key of store.yieldKeys(\"message:id:\")) {\n *   await store.mdelete([key]);\n * }\n * ```\n *\n * @security **Security Notice** This file store\n * can alter any text file in the provided directory and any subfolders.\n * Make sure that the path you specify when initializing the store is free\n * of other files.\n */\nexport class LocalFileStore extends BaseStore<string, Uint8Array> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  rootPath: string;\n\n  constructor(fields: { rootPath: string }) {\n    super(fields);\n    this.rootPath = fields.rootPath;\n  }\n\n  /**\n   * Read and parse the file at the given path.\n   * @param key The key to read the file for.\n   * @returns Promise that resolves to the parsed file content.\n   */\n  private async getParsedFile(key: string): Promise<Uint8Array | undefined> {\n    // Validate the key to prevent path traversal\n    if (!/^[a-zA-Z0-9_\\-:.]+$/.test(key)) {\n      throw new Error(\n        \"Invalid key. Only alphanumeric characters, underscores, hyphens, colons, and periods are allowed.\"\n      );\n    }\n    try {\n      const fileContent = await fs.readFile(this.getFullPath(key));\n      if (!fileContent) {\n        return undefined;\n      }\n      return fileContent;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (e: any) {\n      // File does not exist yet.\n      if (\"code\" in e && e.code === \"ENOENT\") {\n        return undefined;\n      }\n      throw new Error(\n        `Error reading and parsing file at path: ${\n          this.rootPath\n        }.\\nError: ${JSON.stringify(e)}`\n      );\n    }\n  }\n\n  /**\n   * Writes the given key-value pairs to the file at the given path.\n   * @param fileContent An object with the key-value pairs to be written to the file.\n   */\n  private async setFileContent(content: Uint8Array, key: string) {\n    try {\n      await fs.writeFile(this.getFullPath(key), content);\n    } catch (error) {\n      throw new Error(\n        `Error writing file at path: ${this.getFullPath(\n          key\n        )}.\\nError: ${JSON.stringify(error)}`\n      );\n    }\n  }\n\n  /**\n   * Returns the full path of the file where the value of the given key is stored.\n   * @param key the key to get the full path for\n   */\n  private getFullPath(key: string): string {\n    try {\n      const keyAsTxtFile = `${key}.txt`;\n\n      // Validate the key to prevent path traversal\n      if (!/^[a-zA-Z0-9_.\\-/]+$/.test(key)) {\n        throw new Error(`Invalid characters in key: ${key}`);\n      }\n\n      const fullPath = path.resolve(this.rootPath, keyAsTxtFile);\n      const commonPath = path.resolve(this.rootPath);\n\n      if (!fullPath.startsWith(commonPath)) {\n        throw new Error(\n          `Invalid key: ${key}. Key should be relative to the root path. ` +\n            `Root path: ${this.rootPath}, Full path: ${fullPath}`\n        );\n      }\n\n      return fullPath;\n    } catch (e) {\n      throw new Error(\n        `Error getting full path for key: ${key}.\\nError: ${String(e)}`\n      );\n    }\n  }\n\n  /**\n   * Retrieves the values associated with the given keys from the store.\n   * @param keys Keys to retrieve values for.\n   * @returns Array of values associated with the given keys.\n   */\n  async mget(keys: string[]) {\n    const values: (Uint8Array | undefined)[] = [];\n    for (const key of keys) {\n      const fileContent = await this.getParsedFile(key);\n      values.push(fileContent);\n    }\n    return values;\n  }\n\n  /**\n   * Sets the values for the given keys in the store.\n   * @param keyValuePairs Array of key-value pairs to set in the store.\n   * @returns Promise that resolves when all key-value pairs have been set.\n   */\n  async mset(keyValuePairs: [string, Uint8Array][]): Promise<void> {\n    await Promise.all(\n      keyValuePairs.map(([key, value]) => this.setFileContent(value, key))\n    );\n  }\n\n  /**\n   * Deletes the given keys and their associated values from the store.\n   * @param keys Keys to delete from the store.\n   * @returns Promise that resolves when all keys have been deleted.\n   */\n  async mdelete(keys: string[]): Promise<void> {\n    await Promise.all(keys.map((key) => fs.unlink(this.getFullPath(key))));\n  }\n\n  /**\n   * Asynchronous generator that yields keys from the store. If a prefix is\n   * provided, it only yields keys that start with the prefix.\n   * @param prefix Optional prefix to filter keys.\n   * @returns AsyncGenerator that yields keys from the store.\n   */\n  async *yieldKeys(prefix?: string): AsyncGenerator<string> {\n    const allFiles = await fs.readdir(this.rootPath);\n    const allKeys = allFiles.map((file) => file.replace(\".txt\", \"\"));\n    for (const key of allKeys) {\n      if (prefix === undefined || key.startsWith(prefix)) {\n        yield key;\n      }\n    }\n  }\n\n  /**\n   * Static method for initializing the class.\n   * Preforms a check to see if the directory exists, and if not, creates it.\n   * @param path Path to the directory.\n   * @returns Promise that resolves to an instance of the class.\n   */\n  static async fromPath(rootPath: string): Promise<LocalFileStore> {\n    try {\n      // Verifies the directory exists at the provided path, and that it is readable and writable.\n      await fs.access(rootPath, fs.constants.R_OK | fs.constants.W_OK);\n    } catch {\n      try {\n        // Directory does not exist, create it.\n        await fs.mkdir(rootPath, { recursive: true });\n      } catch (error) {\n        throw new Error(\n          `An error occurred creating directory at: ${rootPath}.\\nError: ${JSON.stringify(\n            error\n          )}`\n        );\n      }\n    }\n\n    return new this({ rootPath });\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"file_system.js","names":["fs","path"],"sources":["../../src/storage/file_system.ts"],"sourcesContent":["import * as fs from \"node:fs/promises\";\nimport * as path from \"node:path\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\n/**\n * File system implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in the file system.\n * @example\n * ```typescript\n * const store = await LocalFileStore.fromPath(\"./messages\");\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     new TextEncoder().encode(\n *       JSON.stringify(\n *         index % 2 === 0\n *           ? new AIMessage(\"ai stuff...\")\n *           : new HumanMessage(\"human stuff...\"),\n *       ),\n *     ),\n *   ]),\n * );\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));\n * for await (const key of store.yieldKeys(\"message:id:\")) {\n *   await store.mdelete([key]);\n * }\n * ```\n *\n * @security **Security Notice** This file store\n * can alter any text file in the provided directory and any subfolders.\n * Make sure that the path you specify when initializing the store is free\n * of other files.\n */\nexport class LocalFileStore extends BaseStore<string, Uint8Array> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  rootPath: string;\n\n  constructor(fields: { rootPath: string }) {\n    super(fields);\n    this.rootPath = fields.rootPath;\n  }\n\n  /**\n   * Read and parse the file at the given path.\n   * @param key The key to read the file for.\n   * @returns Promise that resolves to the parsed file content.\n   */\n  private async getParsedFile(key: string): Promise<Uint8Array | undefined> {\n    // Validate the key to prevent path traversal\n    if (!/^[a-zA-Z0-9_\\-:.]+$/.test(key)) {\n      throw new Error(\n        \"Invalid key. Only alphanumeric characters, underscores, hyphens, colons, and periods are allowed.\"\n      );\n    }\n    try {\n      const fileContent = await fs.readFile(this.getFullPath(key));\n      if (!fileContent) {\n        return undefined;\n      }\n      return fileContent;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (e: any) {\n      // File does not exist yet.\n      if (\"code\" in e && e.code === \"ENOENT\") {\n        return undefined;\n      }\n      throw new Error(\n        `Error reading and parsing file at path: ${\n          this.rootPath\n        }.\\nError: ${JSON.stringify(e)}`\n      );\n    }\n  }\n\n  /**\n   * Writes the given key-value pairs to the file at the given path.\n   * @param fileContent An object with the key-value pairs to be written to the file.\n   */\n  private async setFileContent(content: Uint8Array, key: string) {\n    try {\n      await fs.writeFile(this.getFullPath(key), content);\n    } catch (error) {\n      throw new Error(\n        `Error writing file at path: ${this.getFullPath(\n          key\n        )}.\\nError: ${JSON.stringify(error)}`\n      );\n    }\n  }\n\n  /**\n   * Returns the full path of the file where the value of the given key is stored.\n   * @param key the key to get the full path for\n   */\n  private getFullPath(key: string): string {\n    try {\n      const keyAsTxtFile = `${key}.txt`;\n\n      // Validate the key to prevent path traversal\n      if (!/^[a-zA-Z0-9_.\\-/]+$/.test(key)) {\n        throw new Error(`Invalid characters in key: ${key}`);\n      }\n\n      const fullPath = path.resolve(this.rootPath, keyAsTxtFile);\n      const commonPath = path.resolve(this.rootPath);\n\n      if (!fullPath.startsWith(commonPath)) {\n        throw new Error(\n          `Invalid key: ${key}. Key should be relative to the root path. ` +\n            `Root path: ${this.rootPath}, Full path: ${fullPath}`\n        );\n      }\n\n      return fullPath;\n    } catch (e) {\n      throw new Error(\n        `Error getting full path for key: ${key}.\\nError: ${String(e)}`\n      );\n    }\n  }\n\n  /**\n   * Retrieves the values associated with the given keys from the store.\n   * @param keys Keys to retrieve values for.\n   * @returns Array of values associated with the given keys.\n   */\n  async mget(keys: string[]) {\n    const values: (Uint8Array | undefined)[] = [];\n    for (const key of keys) {\n      const fileContent = await this.getParsedFile(key);\n      values.push(fileContent);\n    }\n    return values;\n  }\n\n  /**\n   * Sets the values for the given keys in the store.\n   * @param keyValuePairs Array of key-value pairs to set in the store.\n   * @returns Promise that resolves when all key-value pairs have been set.\n   */\n  async mset(keyValuePairs: [string, Uint8Array][]): Promise<void> {\n    await Promise.all(\n      keyValuePairs.map(([key, value]) => this.setFileContent(value, key))\n    );\n  }\n\n  /**\n   * Deletes the given keys and their associated values from the store.\n   * @param keys Keys to delete from the store.\n   * @returns Promise that resolves when all keys have been deleted.\n   */\n  async mdelete(keys: string[]): Promise<void> {\n    await Promise.all(keys.map((key) => fs.unlink(this.getFullPath(key))));\n  }\n\n  /**\n   * Asynchronous generator that yields keys from the store. If a prefix is\n   * provided, it only yields keys that start with the prefix.\n   * @param prefix Optional prefix to filter keys.\n   * @returns AsyncGenerator that yields keys from the store.\n   */\n  async *yieldKeys(prefix?: string): AsyncGenerator<string> {\n    const allFiles = await fs.readdir(this.rootPath);\n    const allKeys = allFiles.map((file) => file.replace(\".txt\", \"\"));\n    for (const key of allKeys) {\n      if (prefix === undefined || key.startsWith(prefix)) {\n        yield key;\n      }\n    }\n  }\n\n  /**\n   * Static method for initializing the class.\n   * Preforms a check to see if the directory exists, and if not, creates it.\n   * @param path Path to the directory.\n   * @returns Promise that resolves to an instance of the class.\n   */\n  static async fromPath(rootPath: string): Promise<LocalFileStore> {\n    try {\n      // Verifies the directory exists at the provided path, and that it is readable and writable.\n      await fs.access(rootPath, fs.constants.R_OK | fs.constants.W_OK);\n    } catch {\n      try {\n        // Directory does not exist, create it.\n        await fs.mkdir(rootPath, { recursive: true });\n      } catch (error) {\n        throw new Error(\n          `An error occurred creating directory at: ${rootPath}.\\nError: ${JSON.stringify(\n            error\n          )}`\n        );\n      }\n    }\n\n    return new this({ rootPath });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,iBAAb,cAAoC,UAA8B;CAChE,eAAe,CAAC,aAAa,UAAU;CAEvC;CAEA,YAAY,QAA8B;AACxC,QAAM,OAAO;AACb,OAAK,WAAW,OAAO;;;;;;;CAQzB,MAAc,cAAc,KAA8C;AAExE,MAAI,CAAC,sBAAsB,KAAK,IAAI,CAClC,OAAM,IAAI,MACR,oGACD;AAEH,MAAI;GACF,MAAM,cAAc,MAAMA,KAAG,SAAS,KAAK,YAAY,IAAI,CAAC;AAC5D,OAAI,CAAC,YACH;AAEF,UAAO;WAEA,GAAQ;AAEf,OAAI,UAAU,KAAK,EAAE,SAAS,SAC5B;AAEF,SAAM,IAAI,MACR,2CACE,KAAK,SACN,YAAY,KAAK,UAAU,EAAE,GAC/B;;;;;;;CAQL,MAAc,eAAe,SAAqB,KAAa;AAC7D,MAAI;AACF,SAAMA,KAAG,UAAU,KAAK,YAAY,IAAI,EAAE,QAAQ;WAC3C,OAAO;AACd,SAAM,IAAI,MACR,+BAA+B,KAAK,YAClC,IACD,CAAC,YAAY,KAAK,UAAU,MAAM,GACpC;;;;;;;CAQL,AAAQ,YAAY,KAAqB;AACvC,MAAI;GACF,MAAM,eAAe,GAAG,IAAI;AAG5B,OAAI,CAAC,sBAAsB,KAAK,IAAI,CAClC,OAAM,IAAI,MAAM,8BAA8B,MAAM;GAGtD,MAAM,WAAWC,OAAK,QAAQ,KAAK,UAAU,aAAa;GAC1D,MAAM,aAAaA,OAAK,QAAQ,KAAK,SAAS;AAE9C,OAAI,CAAC,SAAS,WAAW,WAAW,CAClC,OAAM,IAAI,MACR,gBAAgB,IAAI,wDACJ,KAAK,SAAS,eAAe,WAC9C;AAGH,UAAO;WACA,GAAG;AACV,SAAM,IAAI,MACR,oCAAoC,IAAI,YAAY,OAAO,EAAE,GAC9D;;;;;;;;CASL,MAAM,KAAK,MAAgB;EACzB,MAAM,SAAqC,EAAE;AAC7C,OAAK,MAAM,OAAO,MAAM;GACtB,MAAM,cAAc,MAAM,KAAK,cAAc,IAAI;AACjD,UAAO,KAAK,YAAY;;AAE1B,SAAO;;;;;;;CAQT,MAAM,KAAK,eAAsD;AAC/D,QAAM,QAAQ,IACZ,cAAc,KAAK,CAAC,KAAK,WAAW,KAAK,eAAe,OAAO,IAAI,CAAC,CACrE;;;;;;;CAQH,MAAM,QAAQ,MAA+B;AAC3C,QAAM,QAAQ,IAAI,KAAK,KAAK,QAAQD,KAAG,OAAO,KAAK,YAAY,IAAI,CAAC,CAAC,CAAC;;;;;;;;CASxE,OAAO,UAAU,QAAyC;EAExD,MAAM,WADW,MAAMA,KAAG,QAAQ,KAAK,SAAS,EACvB,KAAK,SAAS,KAAK,QAAQ,QAAQ,GAAG,CAAC;AAChE,OAAK,MAAM,OAAO,QAChB,KAAI,WAAW,UAAa,IAAI,WAAW,OAAO,CAChD,OAAM;;;;;;;;CAWZ,aAAa,SAAS,UAA2C;AAC/D,MAAI;AAEF,SAAMA,KAAG,OAAO,UAAUA,KAAG,UAAU,OAAOA,KAAG,UAAU,KAAK;UAC1D;AACN,OAAI;AAEF,UAAMA,KAAG,MAAM,UAAU,EAAE,WAAW,MAAM,CAAC;YACtC,OAAO;AACd,UAAM,IAAI,MACR,4CAA4C,SAAS,YAAY,KAAK,UACpE,MACD,GACF;;;AAIL,SAAO,IAAI,KAAK,EAAE,UAAU,CAAC"}

package/dist/storage/in_memory.cjs

@@ -1,15 +1,15 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const __langchain_core_stores = require_rolldown_runtime.__toESM(require("@langchain/core/stores"));
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let _langchain_core_stores = require("@langchain/core/stores");
 
 //#region src/storage/in_memory.ts
-var in_memory_exports = {};
-require_rolldown_runtime.__export(in_memory_exports, { InMemoryStore: () => __langchain_core_stores.InMemoryStore });
+var in_memory_exports = /* @__PURE__ */ require_runtime.__exportAll({ InMemoryStore: () => _langchain_core_stores.InMemoryStore });
 
 //#endregion
 Object.defineProperty(exports, 'InMemoryStore', {
   enumerable: true,
   get: function () {
-    return __langchain_core_stores.InMemoryStore;
+    return _langchain_core_stores.InMemoryStore;
   }
 });
 Object.defineProperty(exports, 'in_memory_exports', {

package/dist/storage/in_memory.js

@@ -1,9 +1,8 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import { InMemoryStore } from "@langchain/core/stores";
 
 //#region src/storage/in_memory.ts
-var in_memory_exports = {};
-__export(in_memory_exports, { InMemoryStore: () => InMemoryStore });
+var in_memory_exports = /* @__PURE__ */ __exportAll({ InMemoryStore: () => InMemoryStore });
 
 //#endregion
 export { InMemoryStore, in_memory_exports };

package/dist/stores/doc/base.cjs

@@ -1,8 +1,8 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
 
 //#region src/stores/doc/base.ts
-var base_exports = {};
-require_rolldown_runtime.__export(base_exports, { Docstore: () => Docstore });
+var base_exports = /* @__PURE__ */ require_runtime.__exportAll({ Docstore: () => Docstore });
 /**
 * Abstract class for a document store. All document stores should extend
 * this class.

package/dist/stores/doc/base.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"base.cjs","names":[],"sources":["../../../src/stores/doc/base.ts"],"sourcesContent":["import { type Document } from \"@langchain/core/documents\";\n\n/**\n * Abstract class for a document store. All document stores should extend\n * this class.\n */\nexport abstract class Docstore {\n  abstract search(search: string): Promise<Document>;\n\n  abstract add(texts: Record<string, Document>): Promise<void>;\n}\n"],"mappings":";;;;;;;;;AAMA,IAAsB,WAAtB,MAA+B,CAI9B"}
+{"version":3,"file":"base.cjs","names":[],"sources":["../../../src/stores/doc/base.ts"],"sourcesContent":["import { type Document } from \"@langchain/core/documents\";\n\n/**\n * Abstract class for a document store. All document stores should extend\n * this class.\n */\nexport abstract class Docstore {\n  abstract search(search: string): Promise<Document>;\n\n  abstract add(texts: Record<string, Document>): Promise<void>;\n}\n"],"mappings":";;;;;;;;;AAMA,IAAsB,WAAtB,MAA+B"}

package/dist/stores/doc/base.d.cts

@@ -1,7 +1,6 @@
 import { Document } from "@langchain/core/documents";
 
 //#region src/stores/doc/base.d.ts
-
 /**
  * Abstract class for a document store. All document stores should extend
  * this class.

package/dist/stores/doc/base.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.cts","names":["Document","Docstore","Promise","Record"],"sources":["../../../src/stores/doc/base.d.ts"],"sourcesContent":["import { type Document } from \"@langchain/core/documents\";\n/**\n * Abstract class for a document store. All document stores should extend\n * this class.\n */\nexport declare abstract class Docstore {\n    abstract search(search: string): Promise<Document>;\n    abstract add(texts: Record<string, Document>): Promise<void>;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;AAKA;;AACqCE,uBADPD,QAAAA,CACOC;EACEF,SAAAA,MAAAA,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,EADFE,OACEF,CADMA,QACNA,CAAAA;EAAfG,SAAAA,GAAAA,CAAAA,KAAAA,EAAAA,MAAAA,CAAAA,MAAAA,EAAeH,QAAfG,CAAAA,CAAAA,EAA2BD,OAA3BC,CAAAA,IAAAA,CAAAA"}
+{"version":3,"file":"base.d.cts","names":[],"sources":["../../../src/stores/doc/base.ts"],"mappings":";;;;;AAMA;;uBAAsB,QAAA;EAAA,SACX,MAAA,CAAO,MAAA,WAAiB,OAAA,CAAQ,QAAA;EAAA,SAEhC,GAAA,CAAI,KAAA,EAAO,MAAA,SAAe,QAAA,IAAY,OAAA;AAAA"}

package/dist/stores/doc/base.d.ts

@@ -1,7 +1,6 @@
 import { Document } from "@langchain/core/documents";
 
 //#region src/stores/doc/base.d.ts
-
 /**
  * Abstract class for a document store. All document stores should extend
  * this class.

package/dist/stores/doc/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","names":["Document","Docstore","Promise","Record"],"sources":["../../../src/stores/doc/base.d.ts"],"sourcesContent":["import { type Document } from \"@langchain/core/documents\";\n/**\n * Abstract class for a document store. All document stores should extend\n * this class.\n */\nexport declare abstract class Docstore {\n    abstract search(search: string): Promise<Document>;\n    abstract add(texts: Record<string, Document>): Promise<void>;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;AAKA;;AACqCE,uBADPD,QAAAA,CACOC;EACEF,SAAAA,MAAAA,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,EADFE,OACEF,CADMA,QACNA,CAAAA;EAAfG,SAAAA,GAAAA,CAAAA,KAAAA,EAAAA,MAAAA,CAAAA,MAAAA,EAAeH,QAAfG,CAAAA,CAAAA,EAA2BD,OAA3BC,CAAAA,IAAAA,CAAAA"}
+{"version":3,"file":"base.d.ts","names":[],"sources":["../../../src/stores/doc/base.ts"],"mappings":";;;;;AAMA;;uBAAsB,QAAA;EAAA,SACX,MAAA,CAAO,MAAA,WAAiB,OAAA,CAAQ,QAAA;EAAA,SAEhC,GAAA,CAAI,KAAA,EAAO,MAAA,SAAe,QAAA,IAAY,OAAA;AAAA"}

package/dist/stores/doc/base.js

@@ -1,8 +1,7 @@
-import { __export } from "../../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
 
 //#region src/stores/doc/base.ts
-var base_exports = {};
-__export(base_exports, { Docstore: () => Docstore });
+var base_exports = /* @__PURE__ */ __exportAll({ Docstore: () => Docstore });
 /**
 * Abstract class for a document store. All document stores should extend
 * this class.

package/dist/stores/doc/base.js.map

@@ -1 +1 @@
-{"version":3,"file":"base.js","names":[],"sources":["../../../src/stores/doc/base.ts"],"sourcesContent":["import { type Document } from \"@langchain/core/documents\";\n\n/**\n * Abstract class for a document store. All document stores should extend\n * this class.\n */\nexport abstract class Docstore {\n  abstract search(search: string): Promise<Document>;\n\n  abstract add(texts: Record<string, Document>): Promise<void>;\n}\n"],"mappings":";;;;;;;;;AAMA,IAAsB,WAAtB,MAA+B,CAI9B"}
+{"version":3,"file":"base.js","names":[],"sources":["../../../src/stores/doc/base.ts"],"sourcesContent":["import { type Document } from \"@langchain/core/documents\";\n\n/**\n * Abstract class for a document store. All document stores should extend\n * this class.\n */\nexport abstract class Docstore {\n  abstract search(search: string): Promise<Document>;\n\n  abstract add(texts: Record<string, Document>): Promise<void>;\n}\n"],"mappings":";;;;;;;;AAMA,IAAsB,WAAtB,MAA+B"}

package/dist/stores/doc/in_memory.cjs

@@ -1,9 +1,9 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
 const require_stores_doc_base = require('./base.cjs');
 
 //#region src/stores/doc/in_memory.ts
-var in_memory_exports = {};
-require_rolldown_runtime.__export(in_memory_exports, {
+var in_memory_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	InMemoryDocstore: () => InMemoryDocstore,
 	SynchronousInMemoryDocstore: () => SynchronousInMemoryDocstore
 });

package/dist/stores/doc/in_memory.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"in_memory.cjs","names":["Docstore","docs?: Map<string, Document>","search: string","texts: Record<string, Document>","keys: string[]","keyValuePairs: [string, Document][]","_keys: string[]","_prefix?: string"],"sources":["../../../src/stores/doc/in_memory.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStoreInterface } from \"@langchain/core/stores\";\nimport { Docstore } from \"./base.js\";\n\n/**\n * Class for storing and retrieving documents in memory asynchronously.\n * Extends the Docstore class.\n */\nexport class InMemoryDocstore\n  extends Docstore\n  implements BaseStoreInterface<string, Document>\n{\n  _docs: Map<string, Document>;\n\n  constructor(docs?: Map<string, Document>) {\n    super();\n    this._docs = docs ?? new Map();\n  }\n\n  /**\n   * Searches for a document in the store based on its ID.\n   * @param search The ID of the document to search for.\n   * @returns The document with the given ID.\n   */\n  async search(search: string): Promise<Document> {\n    const result = this._docs.get(search);\n    if (!result) {\n      throw new Error(`ID ${search} not found.`);\n    } else {\n      return result;\n    }\n  }\n\n  /**\n   * Adds new documents to the store.\n   * @param texts An object where the keys are document IDs and the values are the documents themselves.\n   * @returns Void\n   */\n  async add(texts: Record<string, Document>): Promise<void> {\n    const keys = [...this._docs.keys()];\n    const overlapping = Object.keys(texts).filter((x) => keys.includes(x));\n\n    if (overlapping.length > 0) {\n      throw new Error(`Tried to add ids that already exist: ${overlapping}`);\n    }\n\n    for (const [key, value] of Object.entries(texts)) {\n      this._docs.set(key, value);\n    }\n  }\n\n  async mget(keys: string[]): Promise<Document[]> {\n    return Promise.all(keys.map((key) => this.search(key)));\n  }\n\n  async mset(keyValuePairs: [string, Document][]): Promise<void> {\n    await Promise.all(\n      keyValuePairs.map(([key, value]) => this.add({ [key]: value }))\n    );\n  }\n\n  async mdelete(_keys: string[]): Promise<void> {\n    throw new Error(\"Not implemented.\");\n  }\n\n  // eslint-disable-next-line require-yield\n  async *yieldKeys(_prefix?: string): AsyncGenerator<string> {\n    throw new Error(\"Not implemented\");\n  }\n}\n\n/**\n * Class for storing and retrieving documents in memory synchronously.\n */\nexport class SynchronousInMemoryDocstore {\n  _docs: Map<string, Document>;\n\n  constructor(docs?: Map<string, Document>) {\n    this._docs = docs ?? new Map();\n  }\n\n  /**\n   * Searches for a document in the store based on its ID.\n   * @param search The ID of the document to search for.\n   * @returns The document with the given ID.\n   */\n  search(search: string): Document {\n    const result = this._docs.get(search);\n    if (!result) {\n      throw new Error(`ID ${search} not found.`);\n    } else {\n      return result;\n    }\n  }\n\n  /**\n   * Adds new documents to the store.\n   * @param texts An object where the keys are document IDs and the values are the documents themselves.\n   * @returns Void\n   */\n  add(texts: Record<string, Document>): void {\n    const keys = [...this._docs.keys()];\n    const overlapping = Object.keys(texts).filter((x) => keys.includes(x));\n\n    if (overlapping.length > 0) {\n      throw new Error(`Tried to add ids that already exist: ${overlapping}`);\n    }\n\n    for (const [key, value] of Object.entries(texts)) {\n      this._docs.set(key, value);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAQA,IAAa,mBAAb,cACUA,iCAEV;CACE;CAEA,YAAYC,MAA8B;EACxC,OAAO;EACP,KAAK,QAAQ,wBAAQ,IAAI;CAC1B;;;;;;CAOD,MAAM,OAAOC,QAAmC;EAC9C,MAAM,SAAS,KAAK,MAAM,IAAI,OAAO;AACrC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,CAAC,GAAG,EAAE,OAAO,WAAW,CAAC;MAEzC,QAAO;CAEV;;;;;;CAOD,MAAM,IAAIC,OAAgD;EACxD,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,MAAM,AAAC;EACnC,MAAM,cAAc,OAAO,KAAK,MAAM,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;AAEtE,MAAI,YAAY,SAAS,EACvB,OAAM,IAAI,MAAM,CAAC,qCAAqC,EAAE,aAAa;AAGvE,OAAK,MAAM,CAAC,KAAK,MAAM,IAAI,OAAO,QAAQ,MAAM,EAC9C,KAAK,MAAM,IAAI,KAAK,MAAM;CAE7B;CAED,MAAM,KAAKC,MAAqC;AAC9C,SAAO,QAAQ,IAAI,KAAK,IAAI,CAAC,QAAQ,KAAK,OAAO,IAAI,CAAC,CAAC;CACxD;CAED,MAAM,KAAKC,eAAoD;EAC7D,MAAM,QAAQ,IACZ,cAAc,IAAI,CAAC,CAAC,KAAK,MAAM,KAAK,KAAK,IAAI,GAAG,MAAM,MAAO,EAAC,CAAC,CAChE;CACF;CAED,MAAM,QAAQC,OAAgC;AAC5C,QAAM,IAAI,MAAM;CACjB;CAGD,OAAO,UAAUC,SAA0C;AACzD,QAAM,IAAI,MAAM;CACjB;AACF;;;;AAKD,IAAa,8BAAb,MAAyC;CACvC;CAEA,YAAYN,MAA8B;EACxC,KAAK,QAAQ,wBAAQ,IAAI;CAC1B;;;;;;CAOD,OAAOC,QAA0B;EAC/B,MAAM,SAAS,KAAK,MAAM,IAAI,OAAO;AACrC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,CAAC,GAAG,EAAE,OAAO,WAAW,CAAC;MAEzC,QAAO;CAEV;;;;;;CAOD,IAAIC,OAAuC;EACzC,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,MAAM,AAAC;EACnC,MAAM,cAAc,OAAO,KAAK,MAAM,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;AAEtE,MAAI,YAAY,SAAS,EACvB,OAAM,IAAI,MAAM,CAAC,qCAAqC,EAAE,aAAa;AAGvE,OAAK,MAAM,CAAC,KAAK,MAAM,IAAI,OAAO,QAAQ,MAAM,EAC9C,KAAK,MAAM,IAAI,KAAK,MAAM;CAE7B;AACF"}
+{"version":3,"file":"in_memory.cjs","names":["Docstore"],"sources":["../../../src/stores/doc/in_memory.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStoreInterface } from \"@langchain/core/stores\";\nimport { Docstore } from \"./base.js\";\n\n/**\n * Class for storing and retrieving documents in memory asynchronously.\n * Extends the Docstore class.\n */\nexport class InMemoryDocstore\n  extends Docstore\n  implements BaseStoreInterface<string, Document>\n{\n  _docs: Map<string, Document>;\n\n  constructor(docs?: Map<string, Document>) {\n    super();\n    this._docs = docs ?? new Map();\n  }\n\n  /**\n   * Searches for a document in the store based on its ID.\n   * @param search The ID of the document to search for.\n   * @returns The document with the given ID.\n   */\n  async search(search: string): Promise<Document> {\n    const result = this._docs.get(search);\n    if (!result) {\n      throw new Error(`ID ${search} not found.`);\n    } else {\n      return result;\n    }\n  }\n\n  /**\n   * Adds new documents to the store.\n   * @param texts An object where the keys are document IDs and the values are the documents themselves.\n   * @returns Void\n   */\n  async add(texts: Record<string, Document>): Promise<void> {\n    const keys = [...this._docs.keys()];\n    const overlapping = Object.keys(texts).filter((x) => keys.includes(x));\n\n    if (overlapping.length > 0) {\n      throw new Error(`Tried to add ids that already exist: ${overlapping}`);\n    }\n\n    for (const [key, value] of Object.entries(texts)) {\n      this._docs.set(key, value);\n    }\n  }\n\n  async mget(keys: string[]): Promise<Document[]> {\n    return Promise.all(keys.map((key) => this.search(key)));\n  }\n\n  async mset(keyValuePairs: [string, Document][]): Promise<void> {\n    await Promise.all(\n      keyValuePairs.map(([key, value]) => this.add({ [key]: value }))\n    );\n  }\n\n  async mdelete(_keys: string[]): Promise<void> {\n    throw new Error(\"Not implemented.\");\n  }\n\n  // eslint-disable-next-line require-yield\n  async *yieldKeys(_prefix?: string): AsyncGenerator<string> {\n    throw new Error(\"Not implemented\");\n  }\n}\n\n/**\n * Class for storing and retrieving documents in memory synchronously.\n */\nexport class SynchronousInMemoryDocstore {\n  _docs: Map<string, Document>;\n\n  constructor(docs?: Map<string, Document>) {\n    this._docs = docs ?? new Map();\n  }\n\n  /**\n   * Searches for a document in the store based on its ID.\n   * @param search The ID of the document to search for.\n   * @returns The document with the given ID.\n   */\n  search(search: string): Document {\n    const result = this._docs.get(search);\n    if (!result) {\n      throw new Error(`ID ${search} not found.`);\n    } else {\n      return result;\n    }\n  }\n\n  /**\n   * Adds new documents to the store.\n   * @param texts An object where the keys are document IDs and the values are the documents themselves.\n   * @returns Void\n   */\n  add(texts: Record<string, Document>): void {\n    const keys = [...this._docs.keys()];\n    const overlapping = Object.keys(texts).filter((x) => keys.includes(x));\n\n    if (overlapping.length > 0) {\n      throw new Error(`Tried to add ids that already exist: ${overlapping}`);\n    }\n\n    for (const [key, value] of Object.entries(texts)) {\n      this._docs.set(key, value);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAQA,IAAa,mBAAb,cACUA,iCAEV;CACE;CAEA,YAAY,MAA8B;AACxC,SAAO;AACP,OAAK,QAAQ,wBAAQ,IAAI,KAAK;;;;;;;CAQhC,MAAM,OAAO,QAAmC;EAC9C,MAAM,SAAS,KAAK,MAAM,IAAI,OAAO;AACrC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,MAAM,OAAO,aAAa;MAE1C,QAAO;;;;;;;CASX,MAAM,IAAI,OAAgD;EACxD,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,MAAM,CAAC;EACnC,MAAM,cAAc,OAAO,KAAK,MAAM,CAAC,QAAQ,MAAM,KAAK,SAAS,EAAE,CAAC;AAEtE,MAAI,YAAY,SAAS,EACvB,OAAM,IAAI,MAAM,wCAAwC,cAAc;AAGxE,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,CAC9C,MAAK,MAAM,IAAI,KAAK,MAAM;;CAI9B,MAAM,KAAK,MAAqC;AAC9C,SAAO,QAAQ,IAAI,KAAK,KAAK,QAAQ,KAAK,OAAO,IAAI,CAAC,CAAC;;CAGzD,MAAM,KAAK,eAAoD;AAC7D,QAAM,QAAQ,IACZ,cAAc,KAAK,CAAC,KAAK,WAAW,KAAK,IAAI,GAAG,MAAM,OAAO,CAAC,CAAC,CAChE;;CAGH,MAAM,QAAQ,OAAgC;AAC5C,QAAM,IAAI,MAAM,mBAAmB;;CAIrC,OAAO,UAAU,SAA0C;AACzD,QAAM,IAAI,MAAM,kBAAkB;;;;;;AAOtC,IAAa,8BAAb,MAAyC;CACvC;CAEA,YAAY,MAA8B;AACxC,OAAK,QAAQ,wBAAQ,IAAI,KAAK;;;;;;;CAQhC,OAAO,QAA0B;EAC/B,MAAM,SAAS,KAAK,MAAM,IAAI,OAAO;AACrC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,MAAM,OAAO,aAAa;MAE1C,QAAO;;;;;;;CASX,IAAI,OAAuC;EACzC,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,MAAM,CAAC;EACnC,MAAM,cAAc,OAAO,KAAK,MAAM,CAAC,QAAQ,MAAM,KAAK,SAAS,EAAE,CAAC;AAEtE,MAAI,YAAY,SAAS,EACvB,OAAM,IAAI,MAAM,wCAAwC,cAAc;AAGxE,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,CAC9C,MAAK,MAAM,IAAI,KAAK,MAAM"}

package/dist/stores/doc/in_memory.d.cts

@@ -3,7 +3,6 @@ import { Document } from "@langchain/core/documents";
 import { BaseStoreInterface } from "@langchain/core/stores";
 
 //#region src/stores/doc/in_memory.d.ts
-
 /**
  * Class for storing and retrieving documents in memory asynchronously.
  * Extends the Docstore class.

package/dist/stores/doc/in_memory.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"in_memory.d.cts","names":["Document","BaseStoreInterface","Docstore","InMemoryDocstore","Map","Promise","Record","AsyncGenerator","SynchronousInMemoryDocstore"],"sources":["../../../src/stores/doc/in_memory.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStoreInterface } from \"@langchain/core/stores\";\nimport { Docstore } from \"./base.js\";\n/**\n * Class for storing and retrieving documents in memory asynchronously.\n * Extends the Docstore class.\n */\nexport declare class InMemoryDocstore extends Docstore implements BaseStoreInterface<string, Document> {\n    _docs: Map<string, Document>;\n    constructor(docs?: Map<string, Document>);\n    /**\n     * Searches for a document in the store based on its ID.\n     * @param search The ID of the document to search for.\n     * @returns The document with the given ID.\n     */\n    search(search: string): Promise<Document>;\n    /**\n     * Adds new documents to the store.\n     * @param texts An object where the keys are document IDs and the values are the documents themselves.\n     * @returns Void\n     */\n    add(texts: Record<string, Document>): Promise<void>;\n    mget(keys: string[]): Promise<Document[]>;\n    mset(keyValuePairs: [string, Document][]): Promise<void>;\n    mdelete(_keys: string[]): Promise<void>;\n    yieldKeys(_prefix?: string): AsyncGenerator<string>;\n}\n/**\n * Class for storing and retrieving documents in memory synchronously.\n */\nexport declare class SynchronousInMemoryDocstore {\n    _docs: Map<string, Document>;\n    constructor(docs?: Map<string, Document>);\n    /**\n     * Searches for a document in the store based on its ID.\n     * @param search The ID of the document to search for.\n     * @returns The document with the given ID.\n     */\n    search(search: string): Document;\n    /**\n     * Adds new documents to the store.\n     * @param texts An object where the keys are document IDs and the values are the documents themselves.\n     * @returns Void\n     */\n    add(texts: Record<string, Document>): void;\n}\n//# sourceMappingURL=in_memory.d.ts.map"],"mappings":";;;;;;;;AAOA;;AACuBA,cADFG,gBAAAA,SAAyBD,QAAAA,YAAoBD,kBAC3CD,CAAAA,MAAAA,EADsEA,QACtEA,CAAAA,CAAAA;EAAZI,KAAAA,EAAAA,GAAAA,CAAAA,MAAAA,EAAYJ,QAAZI,CAAAA;EACwBJ,WAAAA,CAAAA,IAAAA,CAAAA,EAAZI,GAAYJ,CAAAA,MAAAA,EAAAA,QAAAA,CAAAA;EAAZI;;;;;EAYmBC,MAAAA,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,EANdA,OAMcA,CANNL,QAMMK,CAAAA;EACRL;;;;;EAGDO,GAAAA,CAAAA,KAAAA,EAJlBD,MAIkBC,CAAAA,MAAAA,EAJHP,QAIGO,CAAAA,CAAAA,EAJSF,OAITE,CAAAA,IAAAA,CAAAA;EAlBaL,IAAAA,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EAepBG,OAfoBH,CAeZF,QAfYE,EAAAA,CAAAA;EAAoBD,IAAAA,CAAAA,aAAAA,EAAAA,CAAAA,MAAAA,EAgBjCD,QAhBiCC,CAAAA,EAAAA,CAAAA,EAgBnBI,OAhBmBJ,CAAAA,IAAAA,CAAAA;EAAkB,OAAA,CAAA,KAAA,EAAA,MAAA,EAAA,CAAA,EAiBtDI,OAjBsD,CAAA,IAAA,CAAA;EAuB/DG,SAAAA,CAAAA,OAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EALYD,cAKe,CAAA,MAAA,CAAA;;;;;AAQpBP,cARPQ,2BAAAA,CAQOR;EAMEA,KAAAA,EAbnBI,GAamBJ,CAAAA,MAAAA,EAbPA,QAaOA,CAAAA;EAAfM,WAAAA,CAAAA,IAAAA,CAAAA,EAZQF,GAYRE,CAAAA,MAAAA,EAZoBN,QAYpBM,CAAAA;EAAM;;;;;0BANON;;;;;;aAMbM,eAAeN"}
+{"version":3,"file":"in_memory.d.cts","names":[],"sources":["../../../src/stores/doc/in_memory.ts"],"mappings":";;;;;;;AAQA;;cAAa,gBAAA,SACH,QAAA,YACG,kBAAA,SAA2B,QAAA;EAEtC,KAAA,EAAO,GAAA,SAAY,QAAA;EAEnB,WAAA,CAAY,IAAA,GAAO,GAAA,SAAY,QAAA;EAFxB;;;;;EAYD,MAAA,CAAO,MAAA,WAAiB,OAAA,CAAQ,QAAA;EAcrB;;;;;EAAX,GAAA,CAAI,KAAA,EAAO,MAAA,SAAe,QAAA,IAAY,OAAA;EAatC,IAAA,CAAK,IAAA,aAAiB,OAAA,CAAQ,QAAA;EAI9B,IAAA,CAAK,aAAA,WAAwB,QAAA,MAAc,OAAA;EAM3C,OAAA,CAAQ,KAAA,aAAkB,OAAA;EAKzB,SAAA,CAAU,OAAA,YAAmB,cAAA;AAAA;;;;cAQzB,2BAAA;EACX,KAAA,EAAO,GAAA,SAAY,QAAA;EAEnB,WAAA,CAAY,IAAA,GAAO,GAAA,SAAY,QAAA;EAjEZ;;;;;EA0EnB,MAAA,CAAO,MAAA,WAAiB,QAAA;EA9DX;;;;;EA4Eb,GAAA,CAAI,KAAA,EAAO,MAAA,SAAe,QAAA;AAAA"}

package/dist/stores/doc/in_memory.d.ts

@@ -3,7 +3,6 @@ import { Document } from "@langchain/core/documents";
 import { BaseStoreInterface } from "@langchain/core/stores";
 
 //#region src/stores/doc/in_memory.d.ts
-
 /**
  * Class for storing and retrieving documents in memory asynchronously.
  * Extends the Docstore class.

package/dist/stores/doc/in_memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in_memory.d.ts","names":["Document","BaseStoreInterface","Docstore","InMemoryDocstore","Map","Promise","Record","AsyncGenerator","SynchronousInMemoryDocstore"],"sources":["../../../src/stores/doc/in_memory.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStoreInterface } from \"@langchain/core/stores\";\nimport { Docstore } from \"./base.js\";\n/**\n * Class for storing and retrieving documents in memory asynchronously.\n * Extends the Docstore class.\n */\nexport declare class InMemoryDocstore extends Docstore implements BaseStoreInterface<string, Document> {\n    _docs: Map<string, Document>;\n    constructor(docs?: Map<string, Document>);\n    /**\n     * Searches for a document in the store based on its ID.\n     * @param search The ID of the document to search for.\n     * @returns The document with the given ID.\n     */\n    search(search: string): Promise<Document>;\n    /**\n     * Adds new documents to the store.\n     * @param texts An object where the keys are document IDs and the values are the documents themselves.\n     * @returns Void\n     */\n    add(texts: Record<string, Document>): Promise<void>;\n    mget(keys: string[]): Promise<Document[]>;\n    mset(keyValuePairs: [string, Document][]): Promise<void>;\n    mdelete(_keys: string[]): Promise<void>;\n    yieldKeys(_prefix?: string): AsyncGenerator<string>;\n}\n/**\n * Class for storing and retrieving documents in memory synchronously.\n */\nexport declare class SynchronousInMemoryDocstore {\n    _docs: Map<string, Document>;\n    constructor(docs?: Map<string, Document>);\n    /**\n     * Searches for a document in the store based on its ID.\n     * @param search The ID of the document to search for.\n     * @returns The document with the given ID.\n     */\n    search(search: string): Document;\n    /**\n     * Adds new documents to the store.\n     * @param texts An object where the keys are document IDs and the values are the documents themselves.\n     * @returns Void\n     */\n    add(texts: Record<string, Document>): void;\n}\n//# sourceMappingURL=in_memory.d.ts.map"],"mappings":";;;;;;;;AAOA;;AACuBA,cADFG,gBAAAA,SAAyBD,QAAAA,YAAoBD,kBAC3CD,CAAAA,MAAAA,EADsEA,QACtEA,CAAAA,CAAAA;EAAZI,KAAAA,EAAAA,GAAAA,CAAAA,MAAAA,EAAYJ,QAAZI,CAAAA;EACwBJ,WAAAA,CAAAA,IAAAA,CAAAA,EAAZI,GAAYJ,CAAAA,MAAAA,EAAAA,QAAAA,CAAAA;EAAZI;;;;;EAYmBC,MAAAA,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,EANdA,OAMcA,CANNL,QAMMK,CAAAA;EACRL;;;;;EAGDO,GAAAA,CAAAA,KAAAA,EAJlBD,MAIkBC,CAAAA,MAAAA,EAJHP,QAIGO,CAAAA,CAAAA,EAJSF,OAITE,CAAAA,IAAAA,CAAAA;EAlBaL,IAAAA,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EAepBG,OAfoBH,CAeZF,QAfYE,EAAAA,CAAAA;EAAoBD,IAAAA,CAAAA,aAAAA,EAAAA,CAAAA,MAAAA,EAgBjCD,QAhBiCC,CAAAA,EAAAA,CAAAA,EAgBnBI,OAhBmBJ,CAAAA,IAAAA,CAAAA;EAAkB,OAAA,CAAA,KAAA,EAAA,MAAA,EAAA,CAAA,EAiBtDI,OAjBsD,CAAA,IAAA,CAAA;EAuB/DG,SAAAA,CAAAA,OAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EALYD,cAKe,CAAA,MAAA,CAAA;;;;;AAQpBP,cARPQ,2BAAAA,CAQOR;EAMEA,KAAAA,EAbnBI,GAamBJ,CAAAA,MAAAA,EAbPA,QAaOA,CAAAA;EAAfM,WAAAA,CAAAA,IAAAA,CAAAA,EAZQF,GAYRE,CAAAA,MAAAA,EAZoBN,QAYpBM,CAAAA;EAAM;;;;;0BANON;;;;;;aAMbM,eAAeN"}
+{"version":3,"file":"in_memory.d.ts","names":[],"sources":["../../../src/stores/doc/in_memory.ts"],"mappings":";;;;;;;AAQA;;cAAa,gBAAA,SACH,QAAA,YACG,kBAAA,SAA2B,QAAA;EAEtC,KAAA,EAAO,GAAA,SAAY,QAAA;EAEnB,WAAA,CAAY,IAAA,GAAO,GAAA,SAAY,QAAA;EAFxB;;;;;EAYD,MAAA,CAAO,MAAA,WAAiB,OAAA,CAAQ,QAAA;EAcrB;;;;;EAAX,GAAA,CAAI,KAAA,EAAO,MAAA,SAAe,QAAA,IAAY,OAAA;EAatC,IAAA,CAAK,IAAA,aAAiB,OAAA,CAAQ,QAAA;EAI9B,IAAA,CAAK,aAAA,WAAwB,QAAA,MAAc,OAAA;EAM3C,OAAA,CAAQ,KAAA,aAAkB,OAAA;EAKzB,SAAA,CAAU,OAAA,YAAmB,cAAA;AAAA;;;;cAQzB,2BAAA;EACX,KAAA,EAAO,GAAA,SAAY,QAAA;EAEnB,WAAA,CAAY,IAAA,GAAO,GAAA,SAAY,QAAA;EAjEZ;;;;;EA0EnB,MAAA,CAAO,MAAA,WAAiB,QAAA;EA9DX;;;;;EA4Eb,GAAA,CAAI,KAAA,EAAO,MAAA,SAAe,QAAA;AAAA"}

package/dist/stores/doc/in_memory.js

@@ -1,9 +1,8 @@
-import { __export } from "../../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
 import { Docstore } from "./base.js";
 
 //#region src/stores/doc/in_memory.ts
-var in_memory_exports = {};
-__export(in_memory_exports, {
+var in_memory_exports = /* @__PURE__ */ __exportAll({
 	InMemoryDocstore: () => InMemoryDocstore,
 	SynchronousInMemoryDocstore: () => SynchronousInMemoryDocstore
 });

package/dist/stores/doc/in_memory.js.map

@@ -1 +1 @@
-{"version":3,"file":"in_memory.js","names":["docs?: Map<string, Document>","search: string","texts: Record<string, Document>","keys: string[]","keyValuePairs: [string, Document][]","_keys: string[]","_prefix?: string"],"sources":["../../../src/stores/doc/in_memory.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStoreInterface } from \"@langchain/core/stores\";\nimport { Docstore } from \"./base.js\";\n\n/**\n * Class for storing and retrieving documents in memory asynchronously.\n * Extends the Docstore class.\n */\nexport class InMemoryDocstore\n  extends Docstore\n  implements BaseStoreInterface<string, Document>\n{\n  _docs: Map<string, Document>;\n\n  constructor(docs?: Map<string, Document>) {\n    super();\n    this._docs = docs ?? new Map();\n  }\n\n  /**\n   * Searches for a document in the store based on its ID.\n   * @param search The ID of the document to search for.\n   * @returns The document with the given ID.\n   */\n  async search(search: string): Promise<Document> {\n    const result = this._docs.get(search);\n    if (!result) {\n      throw new Error(`ID ${search} not found.`);\n    } else {\n      return result;\n    }\n  }\n\n  /**\n   * Adds new documents to the store.\n   * @param texts An object where the keys are document IDs and the values are the documents themselves.\n   * @returns Void\n   */\n  async add(texts: Record<string, Document>): Promise<void> {\n    const keys = [...this._docs.keys()];\n    const overlapping = Object.keys(texts).filter((x) => keys.includes(x));\n\n    if (overlapping.length > 0) {\n      throw new Error(`Tried to add ids that already exist: ${overlapping}`);\n    }\n\n    for (const [key, value] of Object.entries(texts)) {\n      this._docs.set(key, value);\n    }\n  }\n\n  async mget(keys: string[]): Promise<Document[]> {\n    return Promise.all(keys.map((key) => this.search(key)));\n  }\n\n  async mset(keyValuePairs: [string, Document][]): Promise<void> {\n    await Promise.all(\n      keyValuePairs.map(([key, value]) => this.add({ [key]: value }))\n    );\n  }\n\n  async mdelete(_keys: string[]): Promise<void> {\n    throw new Error(\"Not implemented.\");\n  }\n\n  // eslint-disable-next-line require-yield\n  async *yieldKeys(_prefix?: string): AsyncGenerator<string> {\n    throw new Error(\"Not implemented\");\n  }\n}\n\n/**\n * Class for storing and retrieving documents in memory synchronously.\n */\nexport class SynchronousInMemoryDocstore {\n  _docs: Map<string, Document>;\n\n  constructor(docs?: Map<string, Document>) {\n    this._docs = docs ?? new Map();\n  }\n\n  /**\n   * Searches for a document in the store based on its ID.\n   * @param search The ID of the document to search for.\n   * @returns The document with the given ID.\n   */\n  search(search: string): Document {\n    const result = this._docs.get(search);\n    if (!result) {\n      throw new Error(`ID ${search} not found.`);\n    } else {\n      return result;\n    }\n  }\n\n  /**\n   * Adds new documents to the store.\n   * @param texts An object where the keys are document IDs and the values are the documents themselves.\n   * @returns Void\n   */\n  add(texts: Record<string, Document>): void {\n    const keys = [...this._docs.keys()];\n    const overlapping = Object.keys(texts).filter((x) => keys.includes(x));\n\n    if (overlapping.length > 0) {\n      throw new Error(`Tried to add ids that already exist: ${overlapping}`);\n    }\n\n    for (const [key, value] of Object.entries(texts)) {\n      this._docs.set(key, value);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAQA,IAAa,mBAAb,cACU,SAEV;CACE;CAEA,YAAYA,MAA8B;EACxC,OAAO;EACP,KAAK,QAAQ,wBAAQ,IAAI;CAC1B;;;;;;CAOD,MAAM,OAAOC,QAAmC;EAC9C,MAAM,SAAS,KAAK,MAAM,IAAI,OAAO;AACrC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,CAAC,GAAG,EAAE,OAAO,WAAW,CAAC;MAEzC,QAAO;CAEV;;;;;;CAOD,MAAM,IAAIC,OAAgD;EACxD,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,MAAM,AAAC;EACnC,MAAM,cAAc,OAAO,KAAK,MAAM,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;AAEtE,MAAI,YAAY,SAAS,EACvB,OAAM,IAAI,MAAM,CAAC,qCAAqC,EAAE,aAAa;AAGvE,OAAK,MAAM,CAAC,KAAK,MAAM,IAAI,OAAO,QAAQ,MAAM,EAC9C,KAAK,MAAM,IAAI,KAAK,MAAM;CAE7B;CAED,MAAM,KAAKC,MAAqC;AAC9C,SAAO,QAAQ,IAAI,KAAK,IAAI,CAAC,QAAQ,KAAK,OAAO,IAAI,CAAC,CAAC;CACxD;CAED,MAAM,KAAKC,eAAoD;EAC7D,MAAM,QAAQ,IACZ,cAAc,IAAI,CAAC,CAAC,KAAK,MAAM,KAAK,KAAK,IAAI,GAAG,MAAM,MAAO,EAAC,CAAC,CAChE;CACF;CAED,MAAM,QAAQC,OAAgC;AAC5C,QAAM,IAAI,MAAM;CACjB;CAGD,OAAO,UAAUC,SAA0C;AACzD,QAAM,IAAI,MAAM;CACjB;AACF;;;;AAKD,IAAa,8BAAb,MAAyC;CACvC;CAEA,YAAYN,MAA8B;EACxC,KAAK,QAAQ,wBAAQ,IAAI;CAC1B;;;;;;CAOD,OAAOC,QAA0B;EAC/B,MAAM,SAAS,KAAK,MAAM,IAAI,OAAO;AACrC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,CAAC,GAAG,EAAE,OAAO,WAAW,CAAC;MAEzC,QAAO;CAEV;;;;;;CAOD,IAAIC,OAAuC;EACzC,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,MAAM,AAAC;EACnC,MAAM,cAAc,OAAO,KAAK,MAAM,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;AAEtE,MAAI,YAAY,SAAS,EACvB,OAAM,IAAI,MAAM,CAAC,qCAAqC,EAAE,aAAa;AAGvE,OAAK,MAAM,CAAC,KAAK,MAAM,IAAI,OAAO,QAAQ,MAAM,EAC9C,KAAK,MAAM,IAAI,KAAK,MAAM;CAE7B;AACF"}
+{"version":3,"file":"in_memory.js","names":[],"sources":["../../../src/stores/doc/in_memory.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStoreInterface } from \"@langchain/core/stores\";\nimport { Docstore } from \"./base.js\";\n\n/**\n * Class for storing and retrieving documents in memory asynchronously.\n * Extends the Docstore class.\n */\nexport class InMemoryDocstore\n  extends Docstore\n  implements BaseStoreInterface<string, Document>\n{\n  _docs: Map<string, Document>;\n\n  constructor(docs?: Map<string, Document>) {\n    super();\n    this._docs = docs ?? new Map();\n  }\n\n  /**\n   * Searches for a document in the store based on its ID.\n   * @param search The ID of the document to search for.\n   * @returns The document with the given ID.\n   */\n  async search(search: string): Promise<Document> {\n    const result = this._docs.get(search);\n    if (!result) {\n      throw new Error(`ID ${search} not found.`);\n    } else {\n      return result;\n    }\n  }\n\n  /**\n   * Adds new documents to the store.\n   * @param texts An object where the keys are document IDs and the values are the documents themselves.\n   * @returns Void\n   */\n  async add(texts: Record<string, Document>): Promise<void> {\n    const keys = [...this._docs.keys()];\n    const overlapping = Object.keys(texts).filter((x) => keys.includes(x));\n\n    if (overlapping.length > 0) {\n      throw new Error(`Tried to add ids that already exist: ${overlapping}`);\n    }\n\n    for (const [key, value] of Object.entries(texts)) {\n      this._docs.set(key, value);\n    }\n  }\n\n  async mget(keys: string[]): Promise<Document[]> {\n    return Promise.all(keys.map((key) => this.search(key)));\n  }\n\n  async mset(keyValuePairs: [string, Document][]): Promise<void> {\n    await Promise.all(\n      keyValuePairs.map(([key, value]) => this.add({ [key]: value }))\n    );\n  }\n\n  async mdelete(_keys: string[]): Promise<void> {\n    throw new Error(\"Not implemented.\");\n  }\n\n  // eslint-disable-next-line require-yield\n  async *yieldKeys(_prefix?: string): AsyncGenerator<string> {\n    throw new Error(\"Not implemented\");\n  }\n}\n\n/**\n * Class for storing and retrieving documents in memory synchronously.\n */\nexport class SynchronousInMemoryDocstore {\n  _docs: Map<string, Document>;\n\n  constructor(docs?: Map<string, Document>) {\n    this._docs = docs ?? new Map();\n  }\n\n  /**\n   * Searches for a document in the store based on its ID.\n   * @param search The ID of the document to search for.\n   * @returns The document with the given ID.\n   */\n  search(search: string): Document {\n    const result = this._docs.get(search);\n    if (!result) {\n      throw new Error(`ID ${search} not found.`);\n    } else {\n      return result;\n    }\n  }\n\n  /**\n   * Adds new documents to the store.\n   * @param texts An object where the keys are document IDs and the values are the documents themselves.\n   * @returns Void\n   */\n  add(texts: Record<string, Document>): void {\n    const keys = [...this._docs.keys()];\n    const overlapping = Object.keys(texts).filter((x) => keys.includes(x));\n\n    if (overlapping.length > 0) {\n      throw new Error(`Tried to add ids that already exist: ${overlapping}`);\n    }\n\n    for (const [key, value] of Object.entries(texts)) {\n      this._docs.set(key, value);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAQA,IAAa,mBAAb,cACU,SAEV;CACE;CAEA,YAAY,MAA8B;AACxC,SAAO;AACP,OAAK,QAAQ,wBAAQ,IAAI,KAAK;;;;;;;CAQhC,MAAM,OAAO,QAAmC;EAC9C,MAAM,SAAS,KAAK,MAAM,IAAI,OAAO;AACrC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,MAAM,OAAO,aAAa;MAE1C,QAAO;;;;;;;CASX,MAAM,IAAI,OAAgD;EACxD,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,MAAM,CAAC;EACnC,MAAM,cAAc,OAAO,KAAK,MAAM,CAAC,QAAQ,MAAM,KAAK,SAAS,EAAE,CAAC;AAEtE,MAAI,YAAY,SAAS,EACvB,OAAM,IAAI,MAAM,wCAAwC,cAAc;AAGxE,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,CAC9C,MAAK,MAAM,IAAI,KAAK,MAAM;;CAI9B,MAAM,KAAK,MAAqC;AAC9C,SAAO,QAAQ,IAAI,KAAK,KAAK,QAAQ,KAAK,OAAO,IAAI,CAAC,CAAC;;CAGzD,MAAM,KAAK,eAAoD;AAC7D,QAAM,QAAQ,IACZ,cAAc,KAAK,CAAC,KAAK,WAAW,KAAK,IAAI,GAAG,MAAM,OAAO,CAAC,CAAC,CAChE;;CAGH,MAAM,QAAQ,OAAgC;AAC5C,QAAM,IAAI,MAAM,mBAAmB;;CAIrC,OAAO,UAAU,SAA0C;AACzD,QAAM,IAAI,MAAM,kBAAkB;;;;;;AAOtC,IAAa,8BAAb,MAAyC;CACvC;CAEA,YAAY,MAA8B;AACxC,OAAK,QAAQ,wBAAQ,IAAI,KAAK;;;;;;;CAQhC,OAAO,QAA0B;EAC/B,MAAM,SAAS,KAAK,MAAM,IAAI,OAAO;AACrC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,MAAM,OAAO,aAAa;MAE1C,QAAO;;;;;;;CASX,IAAI,OAAuC;EACzC,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,MAAM,CAAC;EACnC,MAAM,cAAc,OAAO,KAAK,MAAM,CAAC,QAAQ,MAAM,KAAK,SAAS,EAAE,CAAC;AAEtE,MAAI,YAAY,SAAS,EACvB,OAAM,IAAI,MAAM,wCAAwC,cAAc;AAGxE,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,CAC9C,MAAK,MAAM,IAAI,KAAK,MAAM"}

package/dist/stores/file/base.cjs

@@ -1,12 +1,12 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
-const __langchain_core_load_serializable = require_rolldown_runtime.__toESM(require("@langchain/core/load/serializable"));
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
+let _langchain_core_load_serializable = require("@langchain/core/load/serializable");
 
 //#region src/stores/file/base.ts
 /**
 * Base class for all file stores. All file stores should extend this
 * class.
 */
-var BaseFileStore = class extends __langchain_core_load_serializable.Serializable {};
+var BaseFileStore = class extends _langchain_core_load_serializable.Serializable {};
 
 //#endregion
 exports.BaseFileStore = BaseFileStore;

package/dist/stores/file/base.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"base.cjs","names":["Serializable"],"sources":["../../../src/stores/file/base.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\n\n/**\n * Base class for all file stores. All file stores should extend this\n * class.\n */\nexport abstract class BaseFileStore extends Serializable {\n  abstract readFile(path: string): Promise<string>;\n\n  abstract writeFile(path: string, contents: string): Promise<void>;\n}\n"],"mappings":";;;;;;;;AAMA,IAAsB,gBAAtB,cAA4CA,gDAAa,CAIxD"}
+{"version":3,"file":"base.cjs","names":["Serializable"],"sources":["../../../src/stores/file/base.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\n\n/**\n * Base class for all file stores. All file stores should extend this\n * class.\n */\nexport abstract class BaseFileStore extends Serializable {\n  abstract readFile(path: string): Promise<string>;\n\n  abstract writeFile(path: string, contents: string): Promise<void>;\n}\n"],"mappings":";;;;;;;;AAMA,IAAsB,gBAAtB,cAA4CA,+CAAa"}

package/dist/stores/file/base.d.cts

@@ -1,7 +1,6 @@
 import { Serializable } from "@langchain/core/load/serializable";
 
 //#region src/stores/file/base.d.ts
-
 /**
  * Base class for all file stores. All file stores should extend this
  * class.

package/dist/stores/file/base.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.cts","names":["Serializable","BaseFileStore","Promise"],"sources":["../../../src/stores/file/base.d.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\n/**\n * Base class for all file stores. All file stores should extend this\n * class.\n */\nexport declare abstract class BaseFileStore extends Serializable {\n    abstract readFile(path: string): Promise<string>;\n    abstract writeFile(path: string, contents: string): Promise<void>;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;AAKA;;AAEwDE,uBAF1BD,aAAAA,SAAsBD,YAAAA,CAEIE;EAFJF,SAAAA,QAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EACfE,OADeF,CAAAA,MAAAA,CAAAA;EAAY,SAAA,SAAA,CAAA,IAAA,EAAA,MAAA,EAAA,QAAA,EAAA,MAAA,CAAA,EAERE,OAFQ,CAAA,IAAA,CAAA"}
+{"version":3,"file":"base.d.cts","names":[],"sources":["../../../src/stores/file/base.ts"],"mappings":";;;;;AAMA;;uBAAsB,aAAA,SAAsB,YAAA;EAAA,SACjC,QAAA,CAAS,IAAA,WAAe,OAAA;EAAA,SAExB,SAAA,CAAU,IAAA,UAAc,QAAA,WAAmB,OAAA;AAAA"}

package/dist/stores/file/base.d.ts

@@ -1,7 +1,6 @@
 import { Serializable } from "@langchain/core/load/serializable";
 
 //#region src/stores/file/base.d.ts
-
 /**
  * Base class for all file stores. All file stores should extend this
  * class.

package/dist/stores/file/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","names":["Serializable","BaseFileStore","Promise"],"sources":["../../../src/stores/file/base.d.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\n/**\n * Base class for all file stores. All file stores should extend this\n * class.\n */\nexport declare abstract class BaseFileStore extends Serializable {\n    abstract readFile(path: string): Promise<string>;\n    abstract writeFile(path: string, contents: string): Promise<void>;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;AAKA;;AAEwDE,uBAF1BD,aAAAA,SAAsBD,YAAAA,CAEIE;EAFJF,SAAAA,QAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EACfE,OADeF,CAAAA,MAAAA,CAAAA;EAAY,SAAA,SAAA,CAAA,IAAA,EAAA,MAAA,EAAA,QAAA,EAAA,MAAA,CAAA,EAERE,OAFQ,CAAA,IAAA,CAAA"}
+{"version":3,"file":"base.d.ts","names":[],"sources":["../../../src/stores/file/base.ts"],"mappings":";;;;;AAMA;;uBAAsB,aAAA,SAAsB,YAAA;EAAA,SACjC,QAAA,CAAS,IAAA,WAAe,OAAA;EAAA,SAExB,SAAA,CAAU,IAAA,UAAc,QAAA,WAAmB,OAAA;AAAA"}

package/dist/stores/file/base.js.map

@@ -1 +1 @@
-{"version":3,"file":"base.js","names":[],"sources":["../../../src/stores/file/base.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\n\n/**\n * Base class for all file stores. All file stores should extend this\n * class.\n */\nexport abstract class BaseFileStore extends Serializable {\n  abstract readFile(path: string): Promise<string>;\n\n  abstract writeFile(path: string, contents: string): Promise<void>;\n}\n"],"mappings":";;;;;;;AAMA,IAAsB,gBAAtB,cAA4C,aAAa,CAIxD"}
+{"version":3,"file":"base.js","names":[],"sources":["../../../src/stores/file/base.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\n\n/**\n * Base class for all file stores. All file stores should extend this\n * class.\n */\nexport abstract class BaseFileStore extends Serializable {\n  abstract readFile(path: string): Promise<string>;\n\n  abstract writeFile(path: string, contents: string): Promise<void>;\n}\n"],"mappings":";;;;;;;AAMA,IAAsB,gBAAtB,cAA4C,aAAa"}

package/dist/stores/file/in_memory.cjs

@@ -1,9 +1,9 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
 const require_base = require('./base.cjs');
 
 //#region src/stores/file/in_memory.ts
-var in_memory_exports = {};
-require_rolldown_runtime.__export(in_memory_exports, { InMemoryFileStore: () => InMemoryFileStore });
+var in_memory_exports = /* @__PURE__ */ require_runtime.__exportAll({ InMemoryFileStore: () => InMemoryFileStore });
 /**
 * Class that provides an in-memory file storage system. It extends the
 * BaseFileStore class and implements its readFile and writeFile methods.

package/dist/stores/file/in_memory.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"in_memory.cjs","names":["BaseFileStore","path: string","contents: string"],"sources":["../../../src/stores/file/in_memory.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n\n/**\n * Class that provides an in-memory file storage system. It extends the\n * BaseFileStore class and implements its readFile and writeFile methods.\n * This class is typically used in scenarios where temporary, in-memory\n * file storage is needed, such as during testing or for caching files in\n * memory for quick access.\n */\nexport class InMemoryFileStore extends BaseFileStore {\n  lc_namespace = [\"langchain\", \"stores\", \"file\", \"in_memory\"];\n\n  private files: Map<string, string> = new Map();\n\n  /**\n   * Retrieves the contents of a file given its path. If the file does not\n   * exist, it throws an error.\n   * @param path The path of the file to read.\n   * @returns The contents of the file as a string.\n   */\n  async readFile(path: string): Promise<string> {\n    const contents = this.files.get(path);\n    if (contents === undefined) {\n      throw new Error(`File not found: ${path}`);\n    }\n    return contents;\n  }\n\n  /**\n   * Writes contents to a file at a given path. If the file already exists,\n   * it overwrites the existing contents.\n   * @param path The path of the file to write.\n   * @param contents The contents to write to the file.\n   * @returns Void\n   */\n  async writeFile(path: string, contents: string): Promise<void> {\n    this.files.set(path, contents);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AASA,IAAa,oBAAb,cAAuCA,2BAAc;CACnD,eAAe;EAAC;EAAa;EAAU;EAAQ;CAAY;CAE3D,AAAQ,wBAA6B,IAAI;;;;;;;CAQzC,MAAM,SAASC,MAA+B;EAC5C,MAAM,WAAW,KAAK,MAAM,IAAI,KAAK;AACrC,MAAI,aAAa,OACf,OAAM,IAAI,MAAM,CAAC,gBAAgB,EAAE,MAAM;AAE3C,SAAO;CACR;;;;;;;;CASD,MAAM,UAAUA,MAAcC,UAAiC;EAC7D,KAAK,MAAM,IAAI,MAAM,SAAS;CAC/B;AACF"}
+{"version":3,"file":"in_memory.cjs","names":["BaseFileStore"],"sources":["../../../src/stores/file/in_memory.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n\n/**\n * Class that provides an in-memory file storage system. It extends the\n * BaseFileStore class and implements its readFile and writeFile methods.\n * This class is typically used in scenarios where temporary, in-memory\n * file storage is needed, such as during testing or for caching files in\n * memory for quick access.\n */\nexport class InMemoryFileStore extends BaseFileStore {\n  lc_namespace = [\"langchain\", \"stores\", \"file\", \"in_memory\"];\n\n  private files: Map<string, string> = new Map();\n\n  /**\n   * Retrieves the contents of a file given its path. If the file does not\n   * exist, it throws an error.\n   * @param path The path of the file to read.\n   * @returns The contents of the file as a string.\n   */\n  async readFile(path: string): Promise<string> {\n    const contents = this.files.get(path);\n    if (contents === undefined) {\n      throw new Error(`File not found: ${path}`);\n    }\n    return contents;\n  }\n\n  /**\n   * Writes contents to a file at a given path. If the file already exists,\n   * it overwrites the existing contents.\n   * @param path The path of the file to write.\n   * @param contents The contents to write to the file.\n   * @returns Void\n   */\n  async writeFile(path: string, contents: string): Promise<void> {\n    this.files.set(path, contents);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AASA,IAAa,oBAAb,cAAuCA,2BAAc;CACnD,eAAe;EAAC;EAAa;EAAU;EAAQ;EAAY;CAE3D,AAAQ,wBAA6B,IAAI,KAAK;;;;;;;CAQ9C,MAAM,SAAS,MAA+B;EAC5C,MAAM,WAAW,KAAK,MAAM,IAAI,KAAK;AACrC,MAAI,aAAa,OACf,OAAM,IAAI,MAAM,mBAAmB,OAAO;AAE5C,SAAO;;;;;;;;;CAUT,MAAM,UAAU,MAAc,UAAiC;AAC7D,OAAK,MAAM,IAAI,MAAM,SAAS"}

package/dist/stores/file/in_memory.d.cts

@@ -1,7 +1,6 @@
 import { BaseFileStore } from "./base.cjs";
 
 //#region src/stores/file/in_memory.d.ts
-
 /**
  * Class that provides an in-memory file storage system. It extends the
  * BaseFileStore class and implements its readFile and writeFile methods.

package/dist/stores/file/in_memory.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"in_memory.d.cts","names":["BaseFileStore","InMemoryFileStore","Promise"],"sources":["../../../src/stores/file/in_memory.d.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n/**\n * Class that provides an in-memory file storage system. It extends the\n * BaseFileStore class and implements its readFile and writeFile methods.\n * This class is typically used in scenarios where temporary, in-memory\n * file storage is needed, such as during testing or for caching files in\n * memory for quick access.\n */\nexport declare class InMemoryFileStore extends BaseFileStore {\n    lc_namespace: string[];\n    private files;\n    /**\n     * Retrieves the contents of a file given its path. If the file does not\n     * exist, it throws an error.\n     * @param path The path of the file to read.\n     * @returns The contents of the file as a string.\n     */\n    readFile(path: string): Promise<string>;\n    /**\n     * Writes contents to a file at a given path. If the file already exists,\n     * it overwrites the existing contents.\n     * @param path The path of the file to write.\n     * @param contents The contents to write to the file.\n     * @returns Void\n     */\n    writeFile(path: string, contents: string): Promise<void>;\n}\n//# sourceMappingURL=in_memory.d.ts.map"],"mappings":";;;;;;AAQA;;;;AAA4D;cAAvCC,iBAAAA,SAA0BD,aAAAA;;;;;;;;;0BASnBE;;;;;;;;6CAQmBA"}
+{"version":3,"file":"in_memory.d.cts","names":[],"sources":["../../../src/stores/file/in_memory.ts"],"mappings":";;;;;AASA;;;;;cAAa,iBAAA,SAA0B,aAAA;EACrC,YAAA;EAAA,QAEQ,KAAA;EAH6B;;;;;;EAW/B,QAAA,CAAS,IAAA,WAAe,OAAA;EAed;;;;;;;EAAV,SAAA,CAAU,IAAA,UAAc,QAAA,WAAmB,OAAA;AAAA"}

package/dist/stores/file/in_memory.d.ts

@@ -1,7 +1,6 @@
 import { BaseFileStore } from "./base.js";
 
 //#region src/stores/file/in_memory.d.ts
-
 /**
  * Class that provides an in-memory file storage system. It extends the
  * BaseFileStore class and implements its readFile and writeFile methods.

package/dist/stores/file/in_memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in_memory.d.ts","names":["BaseFileStore","InMemoryFileStore","Promise"],"sources":["../../../src/stores/file/in_memory.d.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n/**\n * Class that provides an in-memory file storage system. It extends the\n * BaseFileStore class and implements its readFile and writeFile methods.\n * This class is typically used in scenarios where temporary, in-memory\n * file storage is needed, such as during testing or for caching files in\n * memory for quick access.\n */\nexport declare class InMemoryFileStore extends BaseFileStore {\n    lc_namespace: string[];\n    private files;\n    /**\n     * Retrieves the contents of a file given its path. If the file does not\n     * exist, it throws an error.\n     * @param path The path of the file to read.\n     * @returns The contents of the file as a string.\n     */\n    readFile(path: string): Promise<string>;\n    /**\n     * Writes contents to a file at a given path. If the file already exists,\n     * it overwrites the existing contents.\n     * @param path The path of the file to write.\n     * @param contents The contents to write to the file.\n     * @returns Void\n     */\n    writeFile(path: string, contents: string): Promise<void>;\n}\n//# sourceMappingURL=in_memory.d.ts.map"],"mappings":";;;;;;AAQA;;;;AAA4D;cAAvCC,iBAAAA,SAA0BD,aAAAA;;;;;;;;;0BASnBE;;;;;;;;6CAQmBA"}
+{"version":3,"file":"in_memory.d.ts","names":[],"sources":["../../../src/stores/file/in_memory.ts"],"mappings":";;;;;AASA;;;;;cAAa,iBAAA,SAA0B,aAAA;EACrC,YAAA;EAAA,QAEQ,KAAA;EAH6B;;;;;;EAW/B,QAAA,CAAS,IAAA,WAAe,OAAA;EAed;;;;;;;EAAV,SAAA,CAAU,IAAA,UAAc,QAAA,WAAmB,OAAA;AAAA"}

package/dist/stores/file/in_memory.js

@@ -1,9 +1,8 @@
-import { __export } from "../../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
 import { BaseFileStore } from "./base.js";
 
 //#region src/stores/file/in_memory.ts
-var in_memory_exports = {};
-__export(in_memory_exports, { InMemoryFileStore: () => InMemoryFileStore });
+var in_memory_exports = /* @__PURE__ */ __exportAll({ InMemoryFileStore: () => InMemoryFileStore });
 /**
 * Class that provides an in-memory file storage system. It extends the
 * BaseFileStore class and implements its readFile and writeFile methods.

package/dist/stores/file/in_memory.js.map

@@ -1 +1 @@
-{"version":3,"file":"in_memory.js","names":["path: string","contents: string"],"sources":["../../../src/stores/file/in_memory.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n\n/**\n * Class that provides an in-memory file storage system. It extends the\n * BaseFileStore class and implements its readFile and writeFile methods.\n * This class is typically used in scenarios where temporary, in-memory\n * file storage is needed, such as during testing or for caching files in\n * memory for quick access.\n */\nexport class InMemoryFileStore extends BaseFileStore {\n  lc_namespace = [\"langchain\", \"stores\", \"file\", \"in_memory\"];\n\n  private files: Map<string, string> = new Map();\n\n  /**\n   * Retrieves the contents of a file given its path. If the file does not\n   * exist, it throws an error.\n   * @param path The path of the file to read.\n   * @returns The contents of the file as a string.\n   */\n  async readFile(path: string): Promise<string> {\n    const contents = this.files.get(path);\n    if (contents === undefined) {\n      throw new Error(`File not found: ${path}`);\n    }\n    return contents;\n  }\n\n  /**\n   * Writes contents to a file at a given path. If the file already exists,\n   * it overwrites the existing contents.\n   * @param path The path of the file to write.\n   * @param contents The contents to write to the file.\n   * @returns Void\n   */\n  async writeFile(path: string, contents: string): Promise<void> {\n    this.files.set(path, contents);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AASA,IAAa,oBAAb,cAAuC,cAAc;CACnD,eAAe;EAAC;EAAa;EAAU;EAAQ;CAAY;CAE3D,AAAQ,wBAA6B,IAAI;;;;;;;CAQzC,MAAM,SAASA,MAA+B;EAC5C,MAAM,WAAW,KAAK,MAAM,IAAI,KAAK;AACrC,MAAI,aAAa,OACf,OAAM,IAAI,MAAM,CAAC,gBAAgB,EAAE,MAAM;AAE3C,SAAO;CACR;;;;;;;;CASD,MAAM,UAAUA,MAAcC,UAAiC;EAC7D,KAAK,MAAM,IAAI,MAAM,SAAS;CAC/B;AACF"}
+{"version":3,"file":"in_memory.js","names":[],"sources":["../../../src/stores/file/in_memory.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n\n/**\n * Class that provides an in-memory file storage system. It extends the\n * BaseFileStore class and implements its readFile and writeFile methods.\n * This class is typically used in scenarios where temporary, in-memory\n * file storage is needed, such as during testing or for caching files in\n * memory for quick access.\n */\nexport class InMemoryFileStore extends BaseFileStore {\n  lc_namespace = [\"langchain\", \"stores\", \"file\", \"in_memory\"];\n\n  private files: Map<string, string> = new Map();\n\n  /**\n   * Retrieves the contents of a file given its path. If the file does not\n   * exist, it throws an error.\n   * @param path The path of the file to read.\n   * @returns The contents of the file as a string.\n   */\n  async readFile(path: string): Promise<string> {\n    const contents = this.files.get(path);\n    if (contents === undefined) {\n      throw new Error(`File not found: ${path}`);\n    }\n    return contents;\n  }\n\n  /**\n   * Writes contents to a file at a given path. If the file already exists,\n   * it overwrites the existing contents.\n   * @param path The path of the file to write.\n   * @param contents The contents to write to the file.\n   * @returns Void\n   */\n  async writeFile(path: string, contents: string): Promise<void> {\n    this.files.set(path, contents);\n  }\n}\n"],"mappings":";;;;;;;;;;;;AASA,IAAa,oBAAb,cAAuC,cAAc;CACnD,eAAe;EAAC;EAAa;EAAU;EAAQ;EAAY;CAE3D,AAAQ,wBAA6B,IAAI,KAAK;;;;;;;CAQ9C,MAAM,SAAS,MAA+B;EAC5C,MAAM,WAAW,KAAK,MAAM,IAAI,KAAK;AACrC,MAAI,aAAa,OACf,OAAM,IAAI,MAAM,mBAAmB,OAAO;AAE5C,SAAO;;;;;;;;;CAUT,MAAM,UAAU,MAAc,UAAiC;AAC7D,OAAK,MAAM,IAAI,MAAM,SAAS"}