@langchain/classic 1.0.17 → 1.0.18-dev-1771365493298

package/dist/document_loaders/fs/json.cjs

@@ -1,10 +1,11 @@
-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_document_loaders_fs_text = require('./text.cjs');
-const jsonpointer = require_rolldown_runtime.__toESM(require("jsonpointer"));
+let jsonpointer = require("jsonpointer");
+jsonpointer = require_runtime.__toESM(jsonpointer);
 
 //#region src/document_loaders/fs/json.ts
-var json_exports = {};
-require_rolldown_runtime.__export(json_exports, {
+var json_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	JSONLinesLoader: () => JSONLinesLoader,
 	JSONLoader: () => JSONLoader
 });
@@ -53,8 +54,7 @@ var JSONLoader = class extends require_document_loaders_fs_text.TextLoader {
 		if (typeof json === "object") {
 			if (extractAllStrings) return this.extractArrayStringsFromObject(Object.values(json), pointers, true);
 			const targetedEntries = this.getTargetedEntries(json, pointers);
-			const thisLevelEntries = Object.values(json);
-			const notTargetedEntries = thisLevelEntries.filter((entry) => !targetedEntries.includes(entry));
+			const notTargetedEntries = Object.values(json).filter((entry) => !targetedEntries.includes(entry));
 			let extractedStrings = [];
 			if (targetedEntries.length > 0) {
 				for (const oneEntry of targetedEntries) extractedStrings = extractedStrings.concat(this.extractArrayStringsFromObject(oneEntry, pointers, true, true));
@@ -103,8 +103,7 @@ var JSONLinesLoader = class extends require_document_loaders_fs_text.TextLoader
 	* @returns A promise that resolves to an array of strings.
 	*/
 	async parse(raw) {
-		const lines = raw.split("\n");
-		const jsons = lines.map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+		const jsons = raw.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
 		const pointer = jsonpointer.default.compile(this.pointer);
 		return jsons.map((json) => {
 			const data = pointer.get(json);

package/dist/document_loaders/fs/json.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"json.cjs","names":["TextLoader","filePathOrBlob: string | Blob","pointers: string | string[]","raw: string","json: any","pointers: jsonpointer[]","extractedString: string[]","entry: object","extractedStrings: string[]","json: object","pointer: string"],"sources":["../../../src/document_loaders/fs/json.ts"],"sourcesContent":["import jsonpointer from \"jsonpointer\";\nimport { TextLoader } from \"./text.js\";\n\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON files. It has a constructor that\n * takes a `filePathOrBlob` parameter representing the path to the JSON\n * file or a `Blob` object, and an optional `pointers` parameter that\n * specifies the JSON pointers to extract.\n */\nexport class JSONLoader extends TextLoader {\n  public pointers: string[];\n\n  constructor(filePathOrBlob: string | Blob, pointers: string | string[] = []) {\n    super(filePathOrBlob);\n    this.pointers = Array.isArray(pointers) ? pointers : [pointers];\n  }\n\n  /**\n   * Method that takes a `raw` string as a parameter and returns a promise\n   * that resolves to an array of strings. It parses the raw JSON string and\n   * extracts the values based on the specified JSON pointers. If no JSON\n   * pointers are specified, it extracts all the strings from the JSON\n   * object.\n   * @param raw The raw JSON string to parse.\n   * @returns A promise that resolves to an array of strings.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    const json = JSON.parse(raw.trim());\n    // If there is no pointers specified we extract all strings we found\n    const extractAllStrings = !(this.pointers.length > 0);\n    const compiledPointers = this.pointers.map((pointer) =>\n      jsonpointer.compile(pointer)\n    );\n\n    return this.extractArrayStringsFromObject(\n      json,\n      compiledPointers,\n      extractAllStrings\n    );\n  }\n\n  /**\n   * If JSON pointers are specified, return all strings below any of them\n   * and exclude all other nodes expect if they match a JSON pointer (to allow to extract strings from different levels)\n   *\n   * If no JSON pointer is specified then return all string in the object\n   */\n  private extractArrayStringsFromObject(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    json: any,\n    pointers: jsonpointer[],\n    extractAllStrings = false,\n    keyHasBeenFound = false\n  ): string[] {\n    if (!json) {\n      return [];\n    }\n\n    if (typeof json === \"string\" && extractAllStrings) {\n      return [json];\n    }\n\n    if (Array.isArray(json) && extractAllStrings) {\n      let extractedString: string[] = [];\n      for (const element of json) {\n        extractedString = extractedString.concat(\n          this.extractArrayStringsFromObject(element, pointers, true)\n        );\n      }\n\n      return extractedString;\n    }\n\n    if (typeof json === \"object\") {\n      if (extractAllStrings) {\n        return this.extractArrayStringsFromObject(\n          Object.values(json),\n          pointers,\n          true\n        );\n      }\n\n      const targetedEntries = this.getTargetedEntries(json, pointers);\n      const thisLevelEntries = Object.values(json) as object[];\n      const notTargetedEntries = thisLevelEntries.filter(\n        (entry: object) => !targetedEntries.includes(entry)\n      );\n\n      let extractedStrings: string[] = [];\n      // If we found a targeted entry, we extract all strings from it\n      if (targetedEntries.length > 0) {\n        for (const oneEntry of targetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(oneEntry, pointers, true, true)\n          );\n        }\n\n        for (const oneEntry of notTargetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(oneEntry, pointers, false, true)\n          );\n        }\n      } else if (extractAllStrings || !keyHasBeenFound) {\n        for (const oneEntry of notTargetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(\n              oneEntry,\n              pointers,\n              extractAllStrings\n            )\n          );\n        }\n      }\n\n      return extractedStrings;\n    }\n\n    return [];\n  }\n\n  /**\n   * Method that takes a `json` object and an array of `pointers` as\n   * parameters and returns an array of targeted entries. It iterates over\n   * the JSON pointers and uses the `jsonpointer.get()` function to get the\n   * targeted entries from the JSON object.\n   * @param json The JSON object to get targeted entries from.\n   * @param pointers The JSON pointers to get targeted entries.\n   * @returns An array of targeted entries.\n   */\n  private getTargetedEntries(json: object, pointers: jsonpointer[]): object[] {\n    const targetEntries = [];\n    for (const pointer of pointers) {\n      const targetedEntry = pointer.get(json);\n      if (targetedEntry) {\n        targetEntries.push(targetedEntry);\n      }\n    }\n\n    return targetEntries;\n  }\n}\n\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON Lines files. It has a constructor\n * that takes a `filePathOrBlob` parameter representing the path to the\n * JSON Lines file or a `Blob` object, and a `pointer` parameter that\n * specifies the JSON pointer to extract.\n */\nexport class JSONLinesLoader extends TextLoader {\n  constructor(\n    filePathOrBlob: string | Blob,\n    public pointer: string\n  ) {\n    super(filePathOrBlob);\n  }\n\n  /**\n   * Method that takes a `raw` string as a parameter and returns a promise\n   * that resolves to an array of strings. It parses the raw JSON Lines\n   * string, splits it into lines, parses each line as JSON, and extracts\n   * the values based on the specified JSON pointer.\n   * @param raw The raw JSON Lines string to parse.\n   * @returns A promise that resolves to an array of strings.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    const lines = raw.split(\"\\n\");\n    const jsons = lines\n      .map((line) => line.trim())\n      .filter(Boolean)\n      .map((line) => JSON.parse(line));\n    const pointer = jsonpointer.compile(this.pointer);\n    return jsons.map((json) => {\n      const data = pointer.get(json);\n      if (typeof data === \"string\") {\n        return data;\n      }\n      if (!data) {\n        return \"\";\n      }\n      if (typeof data === \"object\") {\n        return JSON.stringify(data);\n      }\n      return \"\";\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAUA,IAAa,aAAb,cAAgCA,4CAAW;CACzC,AAAO;CAEP,YAAYC,gBAA+BC,WAA8B,CAAE,GAAE;EAC3E,MAAM,eAAe;EACrB,KAAK,WAAW,MAAM,QAAQ,SAAS,GAAG,WAAW,CAAC,QAAS;CAChE;;;;;;;;;;CAWD,MAAgB,MAAMC,KAAgC;EACpD,MAAM,OAAO,KAAK,MAAM,IAAI,MAAM,CAAC;EAEnC,MAAM,oBAAoB,EAAE,KAAK,SAAS,SAAS;EACnD,MAAM,mBAAmB,KAAK,SAAS,IAAI,CAAC,YAC1C,oBAAY,QAAQ,QAAQ,CAC7B;AAED,SAAO,KAAK,8BACV,MACA,kBACA,kBACD;CACF;;;;;;;CAQD,AAAQ,8BAENC,MACAC,UACA,oBAAoB,OACpB,kBAAkB,OACR;AACV,MAAI,CAAC,KACH,QAAO,CAAE;AAGX,MAAI,OAAO,SAAS,YAAY,kBAC9B,QAAO,CAAC,IAAK;AAGf,MAAI,MAAM,QAAQ,KAAK,IAAI,mBAAmB;GAC5C,IAAIC,kBAA4B,CAAE;AAClC,QAAK,MAAM,WAAW,MACpB,kBAAkB,gBAAgB,OAChC,KAAK,8BAA8B,SAAS,UAAU,KAAK,CAC5D;AAGH,UAAO;EACR;AAED,MAAI,OAAO,SAAS,UAAU;AAC5B,OAAI,kBACF,QAAO,KAAK,8BACV,OAAO,OAAO,KAAK,EACnB,UACA,KACD;GAGH,MAAM,kBAAkB,KAAK,mBAAmB,MAAM,SAAS;GAC/D,MAAM,mBAAmB,OAAO,OAAO,KAAK;GAC5C,MAAM,qBAAqB,iBAAiB,OAC1C,CAACC,UAAkB,CAAC,gBAAgB,SAAS,MAAM,CACpD;GAED,IAAIC,mBAA6B,CAAE;AAEnC,OAAI,gBAAgB,SAAS,GAAG;AAC9B,SAAK,MAAM,YAAY,iBACrB,mBAAmB,iBAAiB,OAClC,KAAK,8BAA8B,UAAU,UAAU,MAAM,KAAK,CACnE;AAGH,SAAK,MAAM,YAAY,oBACrB,mBAAmB,iBAAiB,OAClC,KAAK,8BAA8B,UAAU,UAAU,OAAO,KAAK,CACpE;GAEJ,WAAU,qBAAqB,CAAC,gBAC/B,MAAK,MAAM,YAAY,oBACrB,mBAAmB,iBAAiB,OAClC,KAAK,8BACH,UACA,UACA,kBACD,CACF;AAIL,UAAO;EACR;AAED,SAAO,CAAE;CACV;;;;;;;;;;CAWD,AAAQ,mBAAmBC,MAAcJ,UAAmC;EAC1E,MAAM,gBAAgB,CAAE;AACxB,OAAK,MAAM,WAAW,UAAU;GAC9B,MAAM,gBAAgB,QAAQ,IAAI,KAAK;AACvC,OAAI,eACF,cAAc,KAAK,cAAc;EAEpC;AAED,SAAO;CACR;AACF;;;;;;;;AASD,IAAa,kBAAb,cAAqCL,4CAAW;CAC9C,YACEC,gBACOS,SACP;EACA,MAAM,eAAe;EAFd;CAGR;;;;;;;;;CAUD,MAAgB,MAAMP,KAAgC;EACpD,MAAM,QAAQ,IAAI,MAAM,KAAK;EAC7B,MAAM,QAAQ,MACX,IAAI,CAAC,SAAS,KAAK,MAAM,CAAC,CAC1B,OAAO,QAAQ,CACf,IAAI,CAAC,SAAS,KAAK,MAAM,KAAK,CAAC;EAClC,MAAM,UAAU,oBAAY,QAAQ,KAAK,QAAQ;AACjD,SAAO,MAAM,IAAI,CAAC,SAAS;GACzB,MAAM,OAAO,QAAQ,IAAI,KAAK;AAC9B,OAAI,OAAO,SAAS,SAClB,QAAO;AAET,OAAI,CAAC,KACH,QAAO;AAET,OAAI,OAAO,SAAS,SAClB,QAAO,KAAK,UAAU,KAAK;AAE7B,UAAO;EACR,EAAC;CACH;AACF"}
+{"version":3,"file":"json.cjs","names":["TextLoader"],"sources":["../../../src/document_loaders/fs/json.ts"],"sourcesContent":["import jsonpointer from \"jsonpointer\";\nimport { TextLoader } from \"./text.js\";\n\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON files. It has a constructor that\n * takes a `filePathOrBlob` parameter representing the path to the JSON\n * file or a `Blob` object, and an optional `pointers` parameter that\n * specifies the JSON pointers to extract.\n */\nexport class JSONLoader extends TextLoader {\n  public pointers: string[];\n\n  constructor(filePathOrBlob: string | Blob, pointers: string | string[] = []) {\n    super(filePathOrBlob);\n    this.pointers = Array.isArray(pointers) ? pointers : [pointers];\n  }\n\n  /**\n   * Method that takes a `raw` string as a parameter and returns a promise\n   * that resolves to an array of strings. It parses the raw JSON string and\n   * extracts the values based on the specified JSON pointers. If no JSON\n   * pointers are specified, it extracts all the strings from the JSON\n   * object.\n   * @param raw The raw JSON string to parse.\n   * @returns A promise that resolves to an array of strings.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    const json = JSON.parse(raw.trim());\n    // If there is no pointers specified we extract all strings we found\n    const extractAllStrings = !(this.pointers.length > 0);\n    const compiledPointers = this.pointers.map((pointer) =>\n      jsonpointer.compile(pointer)\n    );\n\n    return this.extractArrayStringsFromObject(\n      json,\n      compiledPointers,\n      extractAllStrings\n    );\n  }\n\n  /**\n   * If JSON pointers are specified, return all strings below any of them\n   * and exclude all other nodes expect if they match a JSON pointer (to allow to extract strings from different levels)\n   *\n   * If no JSON pointer is specified then return all string in the object\n   */\n  private extractArrayStringsFromObject(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    json: any,\n    pointers: jsonpointer[],\n    extractAllStrings = false,\n    keyHasBeenFound = false\n  ): string[] {\n    if (!json) {\n      return [];\n    }\n\n    if (typeof json === \"string\" && extractAllStrings) {\n      return [json];\n    }\n\n    if (Array.isArray(json) && extractAllStrings) {\n      let extractedString: string[] = [];\n      for (const element of json) {\n        extractedString = extractedString.concat(\n          this.extractArrayStringsFromObject(element, pointers, true)\n        );\n      }\n\n      return extractedString;\n    }\n\n    if (typeof json === \"object\") {\n      if (extractAllStrings) {\n        return this.extractArrayStringsFromObject(\n          Object.values(json),\n          pointers,\n          true\n        );\n      }\n\n      const targetedEntries = this.getTargetedEntries(json, pointers);\n      const thisLevelEntries = Object.values(json) as object[];\n      const notTargetedEntries = thisLevelEntries.filter(\n        (entry: object) => !targetedEntries.includes(entry)\n      );\n\n      let extractedStrings: string[] = [];\n      // If we found a targeted entry, we extract all strings from it\n      if (targetedEntries.length > 0) {\n        for (const oneEntry of targetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(oneEntry, pointers, true, true)\n          );\n        }\n\n        for (const oneEntry of notTargetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(oneEntry, pointers, false, true)\n          );\n        }\n      } else if (extractAllStrings || !keyHasBeenFound) {\n        for (const oneEntry of notTargetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(\n              oneEntry,\n              pointers,\n              extractAllStrings\n            )\n          );\n        }\n      }\n\n      return extractedStrings;\n    }\n\n    return [];\n  }\n\n  /**\n   * Method that takes a `json` object and an array of `pointers` as\n   * parameters and returns an array of targeted entries. It iterates over\n   * the JSON pointers and uses the `jsonpointer.get()` function to get the\n   * targeted entries from the JSON object.\n   * @param json The JSON object to get targeted entries from.\n   * @param pointers The JSON pointers to get targeted entries.\n   * @returns An array of targeted entries.\n   */\n  private getTargetedEntries(json: object, pointers: jsonpointer[]): object[] {\n    const targetEntries = [];\n    for (const pointer of pointers) {\n      const targetedEntry = pointer.get(json);\n      if (targetedEntry) {\n        targetEntries.push(targetedEntry);\n      }\n    }\n\n    return targetEntries;\n  }\n}\n\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON Lines files. It has a constructor\n * that takes a `filePathOrBlob` parameter representing the path to the\n * JSON Lines file or a `Blob` object, and a `pointer` parameter that\n * specifies the JSON pointer to extract.\n */\nexport class JSONLinesLoader extends TextLoader {\n  constructor(\n    filePathOrBlob: string | Blob,\n    public pointer: string\n  ) {\n    super(filePathOrBlob);\n  }\n\n  /**\n   * Method that takes a `raw` string as a parameter and returns a promise\n   * that resolves to an array of strings. It parses the raw JSON Lines\n   * string, splits it into lines, parses each line as JSON, and extracts\n   * the values based on the specified JSON pointer.\n   * @param raw The raw JSON Lines string to parse.\n   * @returns A promise that resolves to an array of strings.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    const lines = raw.split(\"\\n\");\n    const jsons = lines\n      .map((line) => line.trim())\n      .filter(Boolean)\n      .map((line) => JSON.parse(line));\n    const pointer = jsonpointer.compile(this.pointer);\n    return jsons.map((json) => {\n      const data = pointer.get(json);\n      if (typeof data === \"string\") {\n        return data;\n      }\n      if (!data) {\n        return \"\";\n      }\n      if (typeof data === \"object\") {\n        return JSON.stringify(data);\n      }\n      return \"\";\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAUA,IAAa,aAAb,cAAgCA,4CAAW;CACzC,AAAO;CAEP,YAAY,gBAA+B,WAA8B,EAAE,EAAE;AAC3E,QAAM,eAAe;AACrB,OAAK,WAAW,MAAM,QAAQ,SAAS,GAAG,WAAW,CAAC,SAAS;;;;;;;;;;;CAYjE,MAAgB,MAAM,KAAgC;EACpD,MAAM,OAAO,KAAK,MAAM,IAAI,MAAM,CAAC;EAEnC,MAAM,oBAAoB,EAAE,KAAK,SAAS,SAAS;EACnD,MAAM,mBAAmB,KAAK,SAAS,KAAK,YAC1C,oBAAY,QAAQ,QAAQ,CAC7B;AAED,SAAO,KAAK,8BACV,MACA,kBACA,kBACD;;;;;;;;CASH,AAAQ,8BAEN,MACA,UACA,oBAAoB,OACpB,kBAAkB,OACR;AACV,MAAI,CAAC,KACH,QAAO,EAAE;AAGX,MAAI,OAAO,SAAS,YAAY,kBAC9B,QAAO,CAAC,KAAK;AAGf,MAAI,MAAM,QAAQ,KAAK,IAAI,mBAAmB;GAC5C,IAAI,kBAA4B,EAAE;AAClC,QAAK,MAAM,WAAW,KACpB,mBAAkB,gBAAgB,OAChC,KAAK,8BAA8B,SAAS,UAAU,KAAK,CAC5D;AAGH,UAAO;;AAGT,MAAI,OAAO,SAAS,UAAU;AAC5B,OAAI,kBACF,QAAO,KAAK,8BACV,OAAO,OAAO,KAAK,EACnB,UACA,KACD;GAGH,MAAM,kBAAkB,KAAK,mBAAmB,MAAM,SAAS;GAE/D,MAAM,qBADmB,OAAO,OAAO,KAAK,CACA,QACzC,UAAkB,CAAC,gBAAgB,SAAS,MAAM,CACpD;GAED,IAAI,mBAA6B,EAAE;AAEnC,OAAI,gBAAgB,SAAS,GAAG;AAC9B,SAAK,MAAM,YAAY,gBACrB,oBAAmB,iBAAiB,OAClC,KAAK,8BAA8B,UAAU,UAAU,MAAM,KAAK,CACnE;AAGH,SAAK,MAAM,YAAY,mBACrB,oBAAmB,iBAAiB,OAClC,KAAK,8BAA8B,UAAU,UAAU,OAAO,KAAK,CACpE;cAEM,qBAAqB,CAAC,gBAC/B,MAAK,MAAM,YAAY,mBACrB,oBAAmB,iBAAiB,OAClC,KAAK,8BACH,UACA,UACA,kBACD,CACF;AAIL,UAAO;;AAGT,SAAO,EAAE;;;;;;;;;;;CAYX,AAAQ,mBAAmB,MAAc,UAAmC;EAC1E,MAAM,gBAAgB,EAAE;AACxB,OAAK,MAAM,WAAW,UAAU;GAC9B,MAAM,gBAAgB,QAAQ,IAAI,KAAK;AACvC,OAAI,cACF,eAAc,KAAK,cAAc;;AAIrC,SAAO;;;;;;;;;;AAWX,IAAa,kBAAb,cAAqCA,4CAAW;CAC9C,YACE,gBACA,AAAO,SACP;AACA,QAAM,eAAe;EAFd;;;;;;;;;;CAaT,MAAgB,MAAM,KAAgC;EAEpD,MAAM,QADQ,IAAI,MAAM,KAAK,CAE1B,KAAK,SAAS,KAAK,MAAM,CAAC,CAC1B,OAAO,QAAQ,CACf,KAAK,SAAS,KAAK,MAAM,KAAK,CAAC;EAClC,MAAM,UAAU,oBAAY,QAAQ,KAAK,QAAQ;AACjD,SAAO,MAAM,KAAK,SAAS;GACzB,MAAM,OAAO,QAAQ,IAAI,KAAK;AAC9B,OAAI,OAAO,SAAS,SAClB,QAAO;AAET,OAAI,CAAC,KACH,QAAO;AAET,OAAI,OAAO,SAAS,SAClB,QAAO,KAAK,UAAU,KAAK;AAE7B,UAAO;IACP"}

package/dist/document_loaders/fs/json.d.cts

@@ -1,7 +1,6 @@
 import { TextLoader } from "./text.cjs";
 
 //#region src/document_loaders/fs/json.d.ts
-
 /**
  * Class that extends the `TextLoader` class. It represents a document
  * loader that loads documents from JSON files. It has a constructor that

package/dist/document_loaders/fs/json.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"json.d.cts","names":["TextLoader","JSONLoader","Blob","Promise","JSONLinesLoader"],"sources":["../../../src/document_loaders/fs/json.d.ts"],"sourcesContent":["import { TextLoader } from \"./text.js\";\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON files. It has a constructor that\n * takes a `filePathOrBlob` parameter representing the path to the JSON\n * file or a `Blob` object, and an optional `pointers` parameter that\n * specifies the JSON pointers to extract.\n */\nexport declare class JSONLoader extends TextLoader {\n    pointers: string[];\n    constructor(filePathOrBlob: string | Blob, pointers?: string | string[]);\n    /**\n     * Method that takes a `raw` string as a parameter and returns a promise\n     * that resolves to an array of strings. It parses the raw JSON string and\n     * extracts the values based on the specified JSON pointers. If no JSON\n     * pointers are specified, it extracts all the strings from the JSON\n     * object.\n     * @param raw The raw JSON string to parse.\n     * @returns A promise that resolves to an array of strings.\n     */\n    protected parse(raw: string): Promise<string[]>;\n    /**\n     * If JSON pointers are specified, return all strings below any of them\n     * and exclude all other nodes expect if they match a JSON pointer (to allow to extract strings from different levels)\n     *\n     * If no JSON pointer is specified then return all string in the object\n     */\n    private extractArrayStringsFromObject;\n    /**\n     * Method that takes a `json` object and an array of `pointers` as\n     * parameters and returns an array of targeted entries. It iterates over\n     * the JSON pointers and uses the `jsonpointer.get()` function to get the\n     * targeted entries from the JSON object.\n     * @param json The JSON object to get targeted entries from.\n     * @param pointers The JSON pointers to get targeted entries.\n     * @returns An array of targeted entries.\n     */\n    private getTargetedEntries;\n}\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON Lines files. It has a constructor\n * that takes a `filePathOrBlob` parameter representing the path to the\n * JSON Lines file or a `Blob` object, and a `pointer` parameter that\n * specifies the JSON pointer to extract.\n */\nexport declare class JSONLinesLoader extends TextLoader {\n    pointer: string;\n    constructor(filePathOrBlob: string | Blob, pointer: string);\n    /**\n     * Method that takes a `raw` string as a parameter and returns a promise\n     * that resolves to an array of strings. It parses the raw JSON Lines\n     * string, splits it into lines, parses each line as JSON, and extracts\n     * the values based on the specified JSON pointer.\n     * @param raw The raw JSON Lines string to parse.\n     * @returns A promise that resolves to an array of strings.\n     */\n    protected parse(raw: string): Promise<string[]>;\n}\n//# sourceMappingURL=json.d.ts.map"],"mappings":";;;;;;AAQA;;;;AAAkD;AAsC7BI,cAtCAH,UAAAA,SAAmBD,UAAAA,CAsCJ;EAEKE,QAAAA,EAAAA,MAAAA,EAAAA;EASPC,WAAAA,CAAAA,cAAAA,EAAAA,MAAAA,GA/COD,IA+CPC,EAAAA,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,MAAAA,EAAAA;EAXWH;AAAU;;;;;;;;gCA1BrBG;;;;;;;;;;;;;;;;;;;;;;;;;;cA0BbC,eAAAA,SAAwBJ,UAAAA;;uCAEJE;;;;;;;;;gCASPC"}
+{"version":3,"file":"json.d.cts","names":[],"sources":["../../../src/document_loaders/fs/json.ts"],"mappings":";;;;;AAUA;;;;;cAAa,UAAA,SAAmB,UAAA;EACvB,QAAA;EAEP,WAAA,CAAY,cAAA,WAAyB,IAAA,EAAM,QAAA;EAHb;;;;;;;;;EAAA,UAiBd,KAAA,CAAM,GAAA,WAAc,OAAA;EAuG5B;;;AAoBV;;;EApBU,QAlFA,6BAAA;EAsH4B;;;;;;;;;EAAA,QApC5B,kBAAA;AAAA;;;;;;;;cAoBG,eAAA,SAAwB,UAAA;EAG1B,OAAA;EAFT,WAAA,CACE,cAAA,WAAyB,IAAA,EAClB,OAAA;;;;;;;;;YAaO,KAAA,CAAM,GAAA,WAAc,OAAA;AAAA"}

package/dist/document_loaders/fs/json.d.ts

@@ -1,7 +1,6 @@
 import { TextLoader } from "./text.js";
 
 //#region src/document_loaders/fs/json.d.ts
-
 /**
  * Class that extends the `TextLoader` class. It represents a document
  * loader that loads documents from JSON files. It has a constructor that

package/dist/document_loaders/fs/json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json.d.ts","names":["TextLoader","JSONLoader","Blob","Promise","JSONLinesLoader"],"sources":["../../../src/document_loaders/fs/json.d.ts"],"sourcesContent":["import { TextLoader } from \"./text.js\";\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON files. It has a constructor that\n * takes a `filePathOrBlob` parameter representing the path to the JSON\n * file or a `Blob` object, and an optional `pointers` parameter that\n * specifies the JSON pointers to extract.\n */\nexport declare class JSONLoader extends TextLoader {\n    pointers: string[];\n    constructor(filePathOrBlob: string | Blob, pointers?: string | string[]);\n    /**\n     * Method that takes a `raw` string as a parameter and returns a promise\n     * that resolves to an array of strings. It parses the raw JSON string and\n     * extracts the values based on the specified JSON pointers. If no JSON\n     * pointers are specified, it extracts all the strings from the JSON\n     * object.\n     * @param raw The raw JSON string to parse.\n     * @returns A promise that resolves to an array of strings.\n     */\n    protected parse(raw: string): Promise<string[]>;\n    /**\n     * If JSON pointers are specified, return all strings below any of them\n     * and exclude all other nodes expect if they match a JSON pointer (to allow to extract strings from different levels)\n     *\n     * If no JSON pointer is specified then return all string in the object\n     */\n    private extractArrayStringsFromObject;\n    /**\n     * Method that takes a `json` object and an array of `pointers` as\n     * parameters and returns an array of targeted entries. It iterates over\n     * the JSON pointers and uses the `jsonpointer.get()` function to get the\n     * targeted entries from the JSON object.\n     * @param json The JSON object to get targeted entries from.\n     * @param pointers The JSON pointers to get targeted entries.\n     * @returns An array of targeted entries.\n     */\n    private getTargetedEntries;\n}\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON Lines files. It has a constructor\n * that takes a `filePathOrBlob` parameter representing the path to the\n * JSON Lines file or a `Blob` object, and a `pointer` parameter that\n * specifies the JSON pointer to extract.\n */\nexport declare class JSONLinesLoader extends TextLoader {\n    pointer: string;\n    constructor(filePathOrBlob: string | Blob, pointer: string);\n    /**\n     * Method that takes a `raw` string as a parameter and returns a promise\n     * that resolves to an array of strings. It parses the raw JSON Lines\n     * string, splits it into lines, parses each line as JSON, and extracts\n     * the values based on the specified JSON pointer.\n     * @param raw The raw JSON Lines string to parse.\n     * @returns A promise that resolves to an array of strings.\n     */\n    protected parse(raw: string): Promise<string[]>;\n}\n//# sourceMappingURL=json.d.ts.map"],"mappings":";;;;;;AAQA;;;;AAAkD;AAsC7BI,cAtCAH,UAAAA,SAAmBD,UAAAA,CAsCJ;EAEKE,QAAAA,EAAAA,MAAAA,EAAAA;EASPC,WAAAA,CAAAA,cAAAA,EAAAA,MAAAA,GA/COD,IA+CPC,EAAAA,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,MAAAA,EAAAA;EAXWH;AAAU;;;;;;;;gCA1BrBG;;;;;;;;;;;;;;;;;;;;;;;;;;cA0BbC,eAAAA,SAAwBJ,UAAAA;;uCAEJE;;;;;;;;;gCASPC"}
+{"version":3,"file":"json.d.ts","names":[],"sources":["../../../src/document_loaders/fs/json.ts"],"mappings":";;;;;AAUA;;;;;cAAa,UAAA,SAAmB,UAAA;EACvB,QAAA;EAEP,WAAA,CAAY,cAAA,WAAyB,IAAA,EAAM,QAAA;EAHb;;;;;;;;;EAAA,UAiBd,KAAA,CAAM,GAAA,WAAc,OAAA;EAuG5B;;;AAoBV;;;EApBU,QAlFA,6BAAA;EAsH4B;;;;;;;;;EAAA,QApC5B,kBAAA;AAAA;;;;;;;;cAoBG,eAAA,SAAwB,UAAA;EAG1B,OAAA;EAFT,WAAA,CACE,cAAA,WAAyB,IAAA,EAClB,OAAA;;;;;;;;;YAaO,KAAA,CAAM,GAAA,WAAc,OAAA;AAAA"}

package/dist/document_loaders/fs/json.js

@@ -1,10 +1,9 @@
-import { __export } from "../../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
 import { TextLoader } from "./text.js";
 import jsonpointer from "jsonpointer";
 
 //#region src/document_loaders/fs/json.ts
-var json_exports = {};
-__export(json_exports, {
+var json_exports = /* @__PURE__ */ __exportAll({
 	JSONLinesLoader: () => JSONLinesLoader,
 	JSONLoader: () => JSONLoader
 });
@@ -53,8 +52,7 @@ var JSONLoader = class extends TextLoader {
 		if (typeof json === "object") {
 			if (extractAllStrings) return this.extractArrayStringsFromObject(Object.values(json), pointers, true);
 			const targetedEntries = this.getTargetedEntries(json, pointers);
-			const thisLevelEntries = Object.values(json);
-			const notTargetedEntries = thisLevelEntries.filter((entry) => !targetedEntries.includes(entry));
+			const notTargetedEntries = Object.values(json).filter((entry) => !targetedEntries.includes(entry));
 			let extractedStrings = [];
 			if (targetedEntries.length > 0) {
 				for (const oneEntry of targetedEntries) extractedStrings = extractedStrings.concat(this.extractArrayStringsFromObject(oneEntry, pointers, true, true));
@@ -103,8 +101,7 @@ var JSONLinesLoader = class extends TextLoader {
 	* @returns A promise that resolves to an array of strings.
 	*/
 	async parse(raw) {
-		const lines = raw.split("\n");
-		const jsons = lines.map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+		const jsons = raw.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
 		const pointer = jsonpointer.compile(this.pointer);
 		return jsons.map((json) => {
 			const data = pointer.get(json);

package/dist/document_loaders/fs/json.js.map

@@ -1 +1 @@
-{"version":3,"file":"json.js","names":["filePathOrBlob: string | Blob","pointers: string | string[]","raw: string","json: any","pointers: jsonpointer[]","extractedString: string[]","entry: object","extractedStrings: string[]","json: object","pointer: string"],"sources":["../../../src/document_loaders/fs/json.ts"],"sourcesContent":["import jsonpointer from \"jsonpointer\";\nimport { TextLoader } from \"./text.js\";\n\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON files. It has a constructor that\n * takes a `filePathOrBlob` parameter representing the path to the JSON\n * file or a `Blob` object, and an optional `pointers` parameter that\n * specifies the JSON pointers to extract.\n */\nexport class JSONLoader extends TextLoader {\n  public pointers: string[];\n\n  constructor(filePathOrBlob: string | Blob, pointers: string | string[] = []) {\n    super(filePathOrBlob);\n    this.pointers = Array.isArray(pointers) ? pointers : [pointers];\n  }\n\n  /**\n   * Method that takes a `raw` string as a parameter and returns a promise\n   * that resolves to an array of strings. It parses the raw JSON string and\n   * extracts the values based on the specified JSON pointers. If no JSON\n   * pointers are specified, it extracts all the strings from the JSON\n   * object.\n   * @param raw The raw JSON string to parse.\n   * @returns A promise that resolves to an array of strings.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    const json = JSON.parse(raw.trim());\n    // If there is no pointers specified we extract all strings we found\n    const extractAllStrings = !(this.pointers.length > 0);\n    const compiledPointers = this.pointers.map((pointer) =>\n      jsonpointer.compile(pointer)\n    );\n\n    return this.extractArrayStringsFromObject(\n      json,\n      compiledPointers,\n      extractAllStrings\n    );\n  }\n\n  /**\n   * If JSON pointers are specified, return all strings below any of them\n   * and exclude all other nodes expect if they match a JSON pointer (to allow to extract strings from different levels)\n   *\n   * If no JSON pointer is specified then return all string in the object\n   */\n  private extractArrayStringsFromObject(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    json: any,\n    pointers: jsonpointer[],\n    extractAllStrings = false,\n    keyHasBeenFound = false\n  ): string[] {\n    if (!json) {\n      return [];\n    }\n\n    if (typeof json === \"string\" && extractAllStrings) {\n      return [json];\n    }\n\n    if (Array.isArray(json) && extractAllStrings) {\n      let extractedString: string[] = [];\n      for (const element of json) {\n        extractedString = extractedString.concat(\n          this.extractArrayStringsFromObject(element, pointers, true)\n        );\n      }\n\n      return extractedString;\n    }\n\n    if (typeof json === \"object\") {\n      if (extractAllStrings) {\n        return this.extractArrayStringsFromObject(\n          Object.values(json),\n          pointers,\n          true\n        );\n      }\n\n      const targetedEntries = this.getTargetedEntries(json, pointers);\n      const thisLevelEntries = Object.values(json) as object[];\n      const notTargetedEntries = thisLevelEntries.filter(\n        (entry: object) => !targetedEntries.includes(entry)\n      );\n\n      let extractedStrings: string[] = [];\n      // If we found a targeted entry, we extract all strings from it\n      if (targetedEntries.length > 0) {\n        for (const oneEntry of targetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(oneEntry, pointers, true, true)\n          );\n        }\n\n        for (const oneEntry of notTargetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(oneEntry, pointers, false, true)\n          );\n        }\n      } else if (extractAllStrings || !keyHasBeenFound) {\n        for (const oneEntry of notTargetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(\n              oneEntry,\n              pointers,\n              extractAllStrings\n            )\n          );\n        }\n      }\n\n      return extractedStrings;\n    }\n\n    return [];\n  }\n\n  /**\n   * Method that takes a `json` object and an array of `pointers` as\n   * parameters and returns an array of targeted entries. It iterates over\n   * the JSON pointers and uses the `jsonpointer.get()` function to get the\n   * targeted entries from the JSON object.\n   * @param json The JSON object to get targeted entries from.\n   * @param pointers The JSON pointers to get targeted entries.\n   * @returns An array of targeted entries.\n   */\n  private getTargetedEntries(json: object, pointers: jsonpointer[]): object[] {\n    const targetEntries = [];\n    for (const pointer of pointers) {\n      const targetedEntry = pointer.get(json);\n      if (targetedEntry) {\n        targetEntries.push(targetedEntry);\n      }\n    }\n\n    return targetEntries;\n  }\n}\n\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON Lines files. It has a constructor\n * that takes a `filePathOrBlob` parameter representing the path to the\n * JSON Lines file or a `Blob` object, and a `pointer` parameter that\n * specifies the JSON pointer to extract.\n */\nexport class JSONLinesLoader extends TextLoader {\n  constructor(\n    filePathOrBlob: string | Blob,\n    public pointer: string\n  ) {\n    super(filePathOrBlob);\n  }\n\n  /**\n   * Method that takes a `raw` string as a parameter and returns a promise\n   * that resolves to an array of strings. It parses the raw JSON Lines\n   * string, splits it into lines, parses each line as JSON, and extracts\n   * the values based on the specified JSON pointer.\n   * @param raw The raw JSON Lines string to parse.\n   * @returns A promise that resolves to an array of strings.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    const lines = raw.split(\"\\n\");\n    const jsons = lines\n      .map((line) => line.trim())\n      .filter(Boolean)\n      .map((line) => JSON.parse(line));\n    const pointer = jsonpointer.compile(this.pointer);\n    return jsons.map((json) => {\n      const data = pointer.get(json);\n      if (typeof data === \"string\") {\n        return data;\n      }\n      if (!data) {\n        return \"\";\n      }\n      if (typeof data === \"object\") {\n        return JSON.stringify(data);\n      }\n      return \"\";\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAUA,IAAa,aAAb,cAAgC,WAAW;CACzC,AAAO;CAEP,YAAYA,gBAA+BC,WAA8B,CAAE,GAAE;EAC3E,MAAM,eAAe;EACrB,KAAK,WAAW,MAAM,QAAQ,SAAS,GAAG,WAAW,CAAC,QAAS;CAChE;;;;;;;;;;CAWD,MAAgB,MAAMC,KAAgC;EACpD,MAAM,OAAO,KAAK,MAAM,IAAI,MAAM,CAAC;EAEnC,MAAM,oBAAoB,EAAE,KAAK,SAAS,SAAS;EACnD,MAAM,mBAAmB,KAAK,SAAS,IAAI,CAAC,YAC1C,YAAY,QAAQ,QAAQ,CAC7B;AAED,SAAO,KAAK,8BACV,MACA,kBACA,kBACD;CACF;;;;;;;CAQD,AAAQ,8BAENC,MACAC,UACA,oBAAoB,OACpB,kBAAkB,OACR;AACV,MAAI,CAAC,KACH,QAAO,CAAE;AAGX,MAAI,OAAO,SAAS,YAAY,kBAC9B,QAAO,CAAC,IAAK;AAGf,MAAI,MAAM,QAAQ,KAAK,IAAI,mBAAmB;GAC5C,IAAIC,kBAA4B,CAAE;AAClC,QAAK,MAAM,WAAW,MACpB,kBAAkB,gBAAgB,OAChC,KAAK,8BAA8B,SAAS,UAAU,KAAK,CAC5D;AAGH,UAAO;EACR;AAED,MAAI,OAAO,SAAS,UAAU;AAC5B,OAAI,kBACF,QAAO,KAAK,8BACV,OAAO,OAAO,KAAK,EACnB,UACA,KACD;GAGH,MAAM,kBAAkB,KAAK,mBAAmB,MAAM,SAAS;GAC/D,MAAM,mBAAmB,OAAO,OAAO,KAAK;GAC5C,MAAM,qBAAqB,iBAAiB,OAC1C,CAACC,UAAkB,CAAC,gBAAgB,SAAS,MAAM,CACpD;GAED,IAAIC,mBAA6B,CAAE;AAEnC,OAAI,gBAAgB,SAAS,GAAG;AAC9B,SAAK,MAAM,YAAY,iBACrB,mBAAmB,iBAAiB,OAClC,KAAK,8BAA8B,UAAU,UAAU,MAAM,KAAK,CACnE;AAGH,SAAK,MAAM,YAAY,oBACrB,mBAAmB,iBAAiB,OAClC,KAAK,8BAA8B,UAAU,UAAU,OAAO,KAAK,CACpE;GAEJ,WAAU,qBAAqB,CAAC,gBAC/B,MAAK,MAAM,YAAY,oBACrB,mBAAmB,iBAAiB,OAClC,KAAK,8BACH,UACA,UACA,kBACD,CACF;AAIL,UAAO;EACR;AAED,SAAO,CAAE;CACV;;;;;;;;;;CAWD,AAAQ,mBAAmBC,MAAcJ,UAAmC;EAC1E,MAAM,gBAAgB,CAAE;AACxB,OAAK,MAAM,WAAW,UAAU;GAC9B,MAAM,gBAAgB,QAAQ,IAAI,KAAK;AACvC,OAAI,eACF,cAAc,KAAK,cAAc;EAEpC;AAED,SAAO;CACR;AACF;;;;;;;;AASD,IAAa,kBAAb,cAAqC,WAAW;CAC9C,YACEJ,gBACOS,SACP;EACA,MAAM,eAAe;EAFd;CAGR;;;;;;;;;CAUD,MAAgB,MAAMP,KAAgC;EACpD,MAAM,QAAQ,IAAI,MAAM,KAAK;EAC7B,MAAM,QAAQ,MACX,IAAI,CAAC,SAAS,KAAK,MAAM,CAAC,CAC1B,OAAO,QAAQ,CACf,IAAI,CAAC,SAAS,KAAK,MAAM,KAAK,CAAC;EAClC,MAAM,UAAU,YAAY,QAAQ,KAAK,QAAQ;AACjD,SAAO,MAAM,IAAI,CAAC,SAAS;GACzB,MAAM,OAAO,QAAQ,IAAI,KAAK;AAC9B,OAAI,OAAO,SAAS,SAClB,QAAO;AAET,OAAI,CAAC,KACH,QAAO;AAET,OAAI,OAAO,SAAS,SAClB,QAAO,KAAK,UAAU,KAAK;AAE7B,UAAO;EACR,EAAC;CACH;AACF"}
+{"version":3,"file":"json.js","names":[],"sources":["../../../src/document_loaders/fs/json.ts"],"sourcesContent":["import jsonpointer from \"jsonpointer\";\nimport { TextLoader } from \"./text.js\";\n\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON files. It has a constructor that\n * takes a `filePathOrBlob` parameter representing the path to the JSON\n * file or a `Blob` object, and an optional `pointers` parameter that\n * specifies the JSON pointers to extract.\n */\nexport class JSONLoader extends TextLoader {\n  public pointers: string[];\n\n  constructor(filePathOrBlob: string | Blob, pointers: string | string[] = []) {\n    super(filePathOrBlob);\n    this.pointers = Array.isArray(pointers) ? pointers : [pointers];\n  }\n\n  /**\n   * Method that takes a `raw` string as a parameter and returns a promise\n   * that resolves to an array of strings. It parses the raw JSON string and\n   * extracts the values based on the specified JSON pointers. If no JSON\n   * pointers are specified, it extracts all the strings from the JSON\n   * object.\n   * @param raw The raw JSON string to parse.\n   * @returns A promise that resolves to an array of strings.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    const json = JSON.parse(raw.trim());\n    // If there is no pointers specified we extract all strings we found\n    const extractAllStrings = !(this.pointers.length > 0);\n    const compiledPointers = this.pointers.map((pointer) =>\n      jsonpointer.compile(pointer)\n    );\n\n    return this.extractArrayStringsFromObject(\n      json,\n      compiledPointers,\n      extractAllStrings\n    );\n  }\n\n  /**\n   * If JSON pointers are specified, return all strings below any of them\n   * and exclude all other nodes expect if they match a JSON pointer (to allow to extract strings from different levels)\n   *\n   * If no JSON pointer is specified then return all string in the object\n   */\n  private extractArrayStringsFromObject(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    json: any,\n    pointers: jsonpointer[],\n    extractAllStrings = false,\n    keyHasBeenFound = false\n  ): string[] {\n    if (!json) {\n      return [];\n    }\n\n    if (typeof json === \"string\" && extractAllStrings) {\n      return [json];\n    }\n\n    if (Array.isArray(json) && extractAllStrings) {\n      let extractedString: string[] = [];\n      for (const element of json) {\n        extractedString = extractedString.concat(\n          this.extractArrayStringsFromObject(element, pointers, true)\n        );\n      }\n\n      return extractedString;\n    }\n\n    if (typeof json === \"object\") {\n      if (extractAllStrings) {\n        return this.extractArrayStringsFromObject(\n          Object.values(json),\n          pointers,\n          true\n        );\n      }\n\n      const targetedEntries = this.getTargetedEntries(json, pointers);\n      const thisLevelEntries = Object.values(json) as object[];\n      const notTargetedEntries = thisLevelEntries.filter(\n        (entry: object) => !targetedEntries.includes(entry)\n      );\n\n      let extractedStrings: string[] = [];\n      // If we found a targeted entry, we extract all strings from it\n      if (targetedEntries.length > 0) {\n        for (const oneEntry of targetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(oneEntry, pointers, true, true)\n          );\n        }\n\n        for (const oneEntry of notTargetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(oneEntry, pointers, false, true)\n          );\n        }\n      } else if (extractAllStrings || !keyHasBeenFound) {\n        for (const oneEntry of notTargetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(\n              oneEntry,\n              pointers,\n              extractAllStrings\n            )\n          );\n        }\n      }\n\n      return extractedStrings;\n    }\n\n    return [];\n  }\n\n  /**\n   * Method that takes a `json` object and an array of `pointers` as\n   * parameters and returns an array of targeted entries. It iterates over\n   * the JSON pointers and uses the `jsonpointer.get()` function to get the\n   * targeted entries from the JSON object.\n   * @param json The JSON object to get targeted entries from.\n   * @param pointers The JSON pointers to get targeted entries.\n   * @returns An array of targeted entries.\n   */\n  private getTargetedEntries(json: object, pointers: jsonpointer[]): object[] {\n    const targetEntries = [];\n    for (const pointer of pointers) {\n      const targetedEntry = pointer.get(json);\n      if (targetedEntry) {\n        targetEntries.push(targetedEntry);\n      }\n    }\n\n    return targetEntries;\n  }\n}\n\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON Lines files. It has a constructor\n * that takes a `filePathOrBlob` parameter representing the path to the\n * JSON Lines file or a `Blob` object, and a `pointer` parameter that\n * specifies the JSON pointer to extract.\n */\nexport class JSONLinesLoader extends TextLoader {\n  constructor(\n    filePathOrBlob: string | Blob,\n    public pointer: string\n  ) {\n    super(filePathOrBlob);\n  }\n\n  /**\n   * Method that takes a `raw` string as a parameter and returns a promise\n   * that resolves to an array of strings. It parses the raw JSON Lines\n   * string, splits it into lines, parses each line as JSON, and extracts\n   * the values based on the specified JSON pointer.\n   * @param raw The raw JSON Lines string to parse.\n   * @returns A promise that resolves to an array of strings.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    const lines = raw.split(\"\\n\");\n    const jsons = lines\n      .map((line) => line.trim())\n      .filter(Boolean)\n      .map((line) => JSON.parse(line));\n    const pointer = jsonpointer.compile(this.pointer);\n    return jsons.map((json) => {\n      const data = pointer.get(json);\n      if (typeof data === \"string\") {\n        return data;\n      }\n      if (!data) {\n        return \"\";\n      }\n      if (typeof data === \"object\") {\n        return JSON.stringify(data);\n      }\n      return \"\";\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAUA,IAAa,aAAb,cAAgC,WAAW;CACzC,AAAO;CAEP,YAAY,gBAA+B,WAA8B,EAAE,EAAE;AAC3E,QAAM,eAAe;AACrB,OAAK,WAAW,MAAM,QAAQ,SAAS,GAAG,WAAW,CAAC,SAAS;;;;;;;;;;;CAYjE,MAAgB,MAAM,KAAgC;EACpD,MAAM,OAAO,KAAK,MAAM,IAAI,MAAM,CAAC;EAEnC,MAAM,oBAAoB,EAAE,KAAK,SAAS,SAAS;EACnD,MAAM,mBAAmB,KAAK,SAAS,KAAK,YAC1C,YAAY,QAAQ,QAAQ,CAC7B;AAED,SAAO,KAAK,8BACV,MACA,kBACA,kBACD;;;;;;;;CASH,AAAQ,8BAEN,MACA,UACA,oBAAoB,OACpB,kBAAkB,OACR;AACV,MAAI,CAAC,KACH,QAAO,EAAE;AAGX,MAAI,OAAO,SAAS,YAAY,kBAC9B,QAAO,CAAC,KAAK;AAGf,MAAI,MAAM,QAAQ,KAAK,IAAI,mBAAmB;GAC5C,IAAI,kBAA4B,EAAE;AAClC,QAAK,MAAM,WAAW,KACpB,mBAAkB,gBAAgB,OAChC,KAAK,8BAA8B,SAAS,UAAU,KAAK,CAC5D;AAGH,UAAO;;AAGT,MAAI,OAAO,SAAS,UAAU;AAC5B,OAAI,kBACF,QAAO,KAAK,8BACV,OAAO,OAAO,KAAK,EACnB,UACA,KACD;GAGH,MAAM,kBAAkB,KAAK,mBAAmB,MAAM,SAAS;GAE/D,MAAM,qBADmB,OAAO,OAAO,KAAK,CACA,QACzC,UAAkB,CAAC,gBAAgB,SAAS,MAAM,CACpD;GAED,IAAI,mBAA6B,EAAE;AAEnC,OAAI,gBAAgB,SAAS,GAAG;AAC9B,SAAK,MAAM,YAAY,gBACrB,oBAAmB,iBAAiB,OAClC,KAAK,8BAA8B,UAAU,UAAU,MAAM,KAAK,CACnE;AAGH,SAAK,MAAM,YAAY,mBACrB,oBAAmB,iBAAiB,OAClC,KAAK,8BAA8B,UAAU,UAAU,OAAO,KAAK,CACpE;cAEM,qBAAqB,CAAC,gBAC/B,MAAK,MAAM,YAAY,mBACrB,oBAAmB,iBAAiB,OAClC,KAAK,8BACH,UACA,UACA,kBACD,CACF;AAIL,UAAO;;AAGT,SAAO,EAAE;;;;;;;;;;;CAYX,AAAQ,mBAAmB,MAAc,UAAmC;EAC1E,MAAM,gBAAgB,EAAE;AACxB,OAAK,MAAM,WAAW,UAAU;GAC9B,MAAM,gBAAgB,QAAQ,IAAI,KAAK;AACvC,OAAI,cACF,eAAc,KAAK,cAAc;;AAIrC,SAAO;;;;;;;;;;AAWX,IAAa,kBAAb,cAAqC,WAAW;CAC9C,YACE,gBACA,AAAO,SACP;AACA,QAAM,eAAe;EAFd;;;;;;;;;;CAaT,MAAgB,MAAM,KAAgC;EAEpD,MAAM,QADQ,IAAI,MAAM,KAAK,CAE1B,KAAK,SAAS,KAAK,MAAM,CAAC,CAC1B,OAAO,QAAQ,CACf,KAAK,SAAS,KAAK,MAAM,KAAK,CAAC;EAClC,MAAM,UAAU,YAAY,QAAQ,KAAK,QAAQ;AACjD,SAAO,MAAM,KAAK,SAAS;GACzB,MAAM,OAAO,QAAQ,IAAI,KAAK;AAC9B,OAAI,OAAO,SAAS,SAClB,QAAO;AAET,OAAI,CAAC,KACH,QAAO;AAET,OAAI,OAAO,SAAS,SAClB,QAAO,KAAK,UAAU,KAAK;AAE7B,UAAO;IACP"}

package/dist/document_loaders/fs/multi_file.cjs

@@ -1,12 +1,12 @@
-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_document_loaders_fs_directory = require('./directory.cjs');
-const node_path = require_rolldown_runtime.__toESM(require("node:path"));
-const node_fs_promises = require_rolldown_runtime.__toESM(require("node:fs/promises"));
-const __langchain_core_document_loaders_base = require_rolldown_runtime.__toESM(require("@langchain/core/document_loaders/base"));
+let node_path = require("node:path");
+let node_fs_promises = require("node:fs/promises");
+let _langchain_core_document_loaders_base = require("@langchain/core/document_loaders/base");
 
 //#region src/document_loaders/fs/multi_file.ts
-var multi_file_exports = {};
-require_rolldown_runtime.__export(multi_file_exports, { MultiFileLoader: () => MultiFileLoader });
+var multi_file_exports = /* @__PURE__ */ require_runtime.__exportAll({ MultiFileLoader: () => MultiFileLoader });
 /**
 * A document loader that loads documents from multiple files. It extends the
 * `BaseDocumentLoader` class and implements the `load()` method.
@@ -25,7 +25,7 @@ require_rolldown_runtime.__export(multi_file_exports, { MultiFileLoader: () => M
 *
 * ```
 */
-var MultiFileLoader = class extends __langchain_core_document_loaders_base.BaseDocumentLoader {
+var MultiFileLoader = class extends _langchain_core_document_loaders_base.BaseDocumentLoader {
 	constructor(filePaths, loaders, unknown = require_document_loaders_fs_directory.UnknownHandling.Warn) {
 		super();
 		this.filePaths = filePaths;
@@ -49,8 +49,7 @@ var MultiFileLoader = class extends __langchain_core_document_loaders_base.BaseD
 		const documents = [];
 		for (const filePath of this.filePaths) {
 			const fullPath = (0, node_path.resolve)(filePath);
-			const fileStat = await (0, node_fs_promises.stat)(fullPath);
-			if (fileStat.isDirectory()) {
+			if ((await (0, node_fs_promises.stat)(fullPath)).isDirectory()) {
 				console.warn(`Ignoring directory: ${fullPath}`);
 				continue;
 			}

package/dist/document_loaders/fs/multi_file.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"multi_file.cjs","names":["BaseDocumentLoader","filePaths: string[]","loaders: LoadersMapping","unknown: UnknownHandling","UnknownHandling","documents: Document[]"],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"sourcesContent":["import { extname, resolve } from \"node:path\";\nimport { stat } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport { type LoadersMapping, UnknownHandling } from \"./directory.js\";\n\n/**\n * A document loader that loads documents from multiple files. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const multiFileLoader = new MultiFileLoader(\n *   [\"path/to/file1.pdf\", \"path/to/file2.txt\"],\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await multiFileLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport class MultiFileLoader extends BaseDocumentLoader {\n  constructor(\n    public filePaths: string[],\n    public loaders: LoadersMapping,\n    public unknown: UnknownHandling = UnknownHandling.Warn\n  ) {\n    super();\n\n    if (Object.keys(loaders).length === 0) {\n      throw new Error(\"Must provide at least one loader\");\n    }\n    for (const extension in loaders) {\n      if (Object.hasOwn(loaders, extension)) {\n        if (extension[0] !== \".\") {\n          throw new Error(`Extension must start with a dot: ${extension}`);\n        }\n      }\n    }\n  }\n\n  /**\n   * Loads the documents from the provided file paths. It checks if the file\n   * is a directory and ignores it. If a file is a file, it checks if there\n   * is a corresponding loader function for the file extension in the `loaders`\n   * mapping. If there is, it loads the documents. If there is no\n   * corresponding loader function and `unknown` is set to `Warn`, it logs a\n   * warning message. If `unknown` is set to `Error`, it throws an error.\n   * @returns A promise that resolves to an array of loaded documents.\n   */\n  public async load(): Promise<Document[]> {\n    const documents: Document[] = [];\n\n    for (const filePath of this.filePaths) {\n      const fullPath = resolve(filePath);\n      const fileStat = await stat(fullPath);\n\n      if (fileStat.isDirectory()) {\n        console.warn(`Ignoring directory: ${fullPath}`);\n        continue;\n      }\n\n      const loaderFactory = this.loaders[extname(fullPath)];\n      if (loaderFactory) {\n        const loader = loaderFactory(fullPath);\n        documents.push(...(await loader.load()));\n      } else {\n        switch (this.unknown) {\n          case UnknownHandling.Ignore:\n            break;\n          case UnknownHandling.Warn:\n            console.warn(`Unknown file type: ${fullPath}`);\n            break;\n          case UnknownHandling.Error:\n            throw new Error(`Unknown file type: ${fullPath}`);\n          default:\n            throw new Error(`Unknown unknown handling: ${this.unknown}`);\n        }\n      }\n    }\n\n    return documents;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,kBAAb,cAAqCA,0DAAmB;CACtD,YACSC,WACAC,SACAC,UAA2BC,sDAAgB,MAClD;EACA,OAAO;EAJA;EACA;EACA;AAIP,MAAI,OAAO,KAAK,QAAQ,CAAC,WAAW,EAClC,OAAM,IAAI,MAAM;AAElB,OAAK,MAAM,aAAa,QACtB,KAAI,OAAO,OAAO,SAAS,UAAU,EACnC;OAAI,UAAU,OAAO,IACnB,OAAM,IAAI,MAAM,CAAC,iCAAiC,EAAE,WAAW;EAChE;CAGN;;;;;;;;;;CAWD,MAAa,OAA4B;EACvC,MAAMC,YAAwB,CAAE;AAEhC,OAAK,MAAM,YAAY,KAAK,WAAW;GACrC,MAAM,kCAAmB,SAAS;GAClC,MAAM,WAAW,iCAAW,SAAS;AAErC,OAAI,SAAS,aAAa,EAAE;IAC1B,QAAQ,KAAK,CAAC,oBAAoB,EAAE,UAAU,CAAC;AAC/C;GACD;GAED,MAAM,gBAAgB,KAAK,+BAAgB,SAAS;AACpD,OAAI,eAAe;IACjB,MAAM,SAAS,cAAc,SAAS;IACtC,UAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;GACzC,MACC,SAAQ,KAAK,SAAb;IACE,KAAKD,sDAAgB,OACnB;IACF,KAAKA,sDAAgB;KACnB,QAAQ,KAAK,CAAC,mBAAmB,EAAE,UAAU,CAAC;AAC9C;IACF,KAAKA,sDAAgB,MACnB,OAAM,IAAI,MAAM,CAAC,mBAAmB,EAAE,UAAU;IAClD,QACE,OAAM,IAAI,MAAM,CAAC,0BAA0B,EAAE,KAAK,SAAS;GAC9D;EAEJ;AAED,SAAO;CACR;AACF"}
+{"version":3,"file":"multi_file.cjs","names":["BaseDocumentLoader","UnknownHandling"],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"sourcesContent":["import { extname, resolve } from \"node:path\";\nimport { stat } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport { type LoadersMapping, UnknownHandling } from \"./directory.js\";\n\n/**\n * A document loader that loads documents from multiple files. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const multiFileLoader = new MultiFileLoader(\n *   [\"path/to/file1.pdf\", \"path/to/file2.txt\"],\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await multiFileLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport class MultiFileLoader extends BaseDocumentLoader {\n  constructor(\n    public filePaths: string[],\n    public loaders: LoadersMapping,\n    public unknown: UnknownHandling = UnknownHandling.Warn\n  ) {\n    super();\n\n    if (Object.keys(loaders).length === 0) {\n      throw new Error(\"Must provide at least one loader\");\n    }\n    for (const extension in loaders) {\n      if (Object.hasOwn(loaders, extension)) {\n        if (extension[0] !== \".\") {\n          throw new Error(`Extension must start with a dot: ${extension}`);\n        }\n      }\n    }\n  }\n\n  /**\n   * Loads the documents from the provided file paths. It checks if the file\n   * is a directory and ignores it. If a file is a file, it checks if there\n   * is a corresponding loader function for the file extension in the `loaders`\n   * mapping. If there is, it loads the documents. If there is no\n   * corresponding loader function and `unknown` is set to `Warn`, it logs a\n   * warning message. If `unknown` is set to `Error`, it throws an error.\n   * @returns A promise that resolves to an array of loaded documents.\n   */\n  public async load(): Promise<Document[]> {\n    const documents: Document[] = [];\n\n    for (const filePath of this.filePaths) {\n      const fullPath = resolve(filePath);\n      const fileStat = await stat(fullPath);\n\n      if (fileStat.isDirectory()) {\n        console.warn(`Ignoring directory: ${fullPath}`);\n        continue;\n      }\n\n      const loaderFactory = this.loaders[extname(fullPath)];\n      if (loaderFactory) {\n        const loader = loaderFactory(fullPath);\n        documents.push(...(await loader.load()));\n      } else {\n        switch (this.unknown) {\n          case UnknownHandling.Ignore:\n            break;\n          case UnknownHandling.Warn:\n            console.warn(`Unknown file type: ${fullPath}`);\n            break;\n          case UnknownHandling.Error:\n            throw new Error(`Unknown file type: ${fullPath}`);\n          default:\n            throw new Error(`Unknown unknown handling: ${this.unknown}`);\n        }\n      }\n    }\n\n    return documents;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,kBAAb,cAAqCA,yDAAmB;CACtD,YACE,AAAO,WACP,AAAO,SACP,AAAO,UAA2BC,sDAAgB,MAClD;AACA,SAAO;EAJA;EACA;EACA;AAIP,MAAI,OAAO,KAAK,QAAQ,CAAC,WAAW,EAClC,OAAM,IAAI,MAAM,mCAAmC;AAErD,OAAK,MAAM,aAAa,QACtB,KAAI,OAAO,OAAO,SAAS,UAAU,EACnC;OAAI,UAAU,OAAO,IACnB,OAAM,IAAI,MAAM,oCAAoC,YAAY;;;;;;;;;;;;CAexE,MAAa,OAA4B;EACvC,MAAM,YAAwB,EAAE;AAEhC,OAAK,MAAM,YAAY,KAAK,WAAW;GACrC,MAAM,kCAAmB,SAAS;AAGlC,QAFiB,iCAAW,SAAS,EAExB,aAAa,EAAE;AAC1B,YAAQ,KAAK,uBAAuB,WAAW;AAC/C;;GAGF,MAAM,gBAAgB,KAAK,+BAAgB,SAAS;AACpD,OAAI,eAAe;IACjB,MAAM,SAAS,cAAc,SAAS;AACtC,cAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;SAExC,SAAQ,KAAK,SAAb;IACE,KAAKA,sDAAgB,OACnB;IACF,KAAKA,sDAAgB;AACnB,aAAQ,KAAK,sBAAsB,WAAW;AAC9C;IACF,KAAKA,sDAAgB,MACnB,OAAM,IAAI,MAAM,sBAAsB,WAAW;IACnD,QACE,OAAM,IAAI,MAAM,6BAA6B,KAAK,UAAU;;;AAKpE,SAAO"}

package/dist/document_loaders/fs/multi_file.d.cts

@@ -3,7 +3,6 @@ import { Document } from "@langchain/core/documents";
 import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
 
 //#region src/document_loaders/fs/multi_file.d.ts
-
 /**
  * A document loader that loads documents from multiple files. It extends the
  * `BaseDocumentLoader` class and implements the `load()` method.

package/dist/document_loaders/fs/multi_file.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"multi_file.d.cts","names":["Document","BaseDocumentLoader","LoadersMapping","UnknownHandling","MultiFileLoader","Promise"],"sources":["../../../src/document_loaders/fs/multi_file.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport { type LoadersMapping, UnknownHandling } from \"./directory.js\";\n/**\n * A document loader that loads documents from multiple files. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const multiFileLoader = new MultiFileLoader(\n *   [\"path/to/file1.pdf\", \"path/to/file2.txt\"],\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await multiFileLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport declare class MultiFileLoader extends BaseDocumentLoader {\n    filePaths: string[];\n    loaders: LoadersMapping;\n    unknown: UnknownHandling;\n    constructor(filePaths: string[], loaders: LoadersMapping, unknown?: UnknownHandling);\n    /**\n     * Loads the documents from the provided file paths. It checks if the file\n     * is a directory and ignores it. If a file is a file, it checks if there\n     * is a corresponding loader function for the file extension in the `loaders`\n     * mapping. If there is, it loads the documents. If there is no\n     * corresponding loader function and `unknown` is set to `Warn`, it logs a\n     * warning message. If `unknown` is set to `Error`, it throws an error.\n     * @returns A promise that resolves to an array of loaded documents.\n     */\n    load(): Promise<Document[]>;\n}\n//# sourceMappingURL=multi_file.d.ts.map"],"mappings":";;;;;;;;AAqBA;;;;;;;;AAA+D;;;;;;;;cAA1CI,eAAAA,SAAwBH,kBAAAA;;WAEhCC;WACAC;4CACiCD,0BAA0BC;;;;;;;;;;UAU5DE,QAAQL"}
+{"version":3,"file":"multi_file.d.cts","names":[],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"mappings":";;;;;;;AAwBA;;;;;;;;;;;;;;;;cAAa,eAAA,SAAwB,kBAAA;EAE1B,SAAA;EACA,OAAA,EAAS,cAAA;EACT,OAAA,EAAS,eAAA;EAHlB,WAAA,CACS,SAAA,YACA,OAAA,EAAS,cAAA,EACT,OAAA,GAAS,eAAA;EADT;;;;;;;;;EA0BI,IAAA,CAAA,GAAQ,OAAA,CAAQ,QAAA;AAAA"}

package/dist/document_loaders/fs/multi_file.d.ts

@@ -3,7 +3,6 @@ import { Document } from "@langchain/core/documents";
 import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
 
 //#region src/document_loaders/fs/multi_file.d.ts
-
 /**
  * A document loader that loads documents from multiple files. It extends the
  * `BaseDocumentLoader` class and implements the `load()` method.

package/dist/document_loaders/fs/multi_file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multi_file.d.ts","names":["Document","BaseDocumentLoader","LoadersMapping","UnknownHandling","MultiFileLoader","Promise"],"sources":["../../../src/document_loaders/fs/multi_file.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport { type LoadersMapping, UnknownHandling } from \"./directory.js\";\n/**\n * A document loader that loads documents from multiple files. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const multiFileLoader = new MultiFileLoader(\n *   [\"path/to/file1.pdf\", \"path/to/file2.txt\"],\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await multiFileLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport declare class MultiFileLoader extends BaseDocumentLoader {\n    filePaths: string[];\n    loaders: LoadersMapping;\n    unknown: UnknownHandling;\n    constructor(filePaths: string[], loaders: LoadersMapping, unknown?: UnknownHandling);\n    /**\n     * Loads the documents from the provided file paths. It checks if the file\n     * is a directory and ignores it. If a file is a file, it checks if there\n     * is a corresponding loader function for the file extension in the `loaders`\n     * mapping. If there is, it loads the documents. If there is no\n     * corresponding loader function and `unknown` is set to `Warn`, it logs a\n     * warning message. If `unknown` is set to `Error`, it throws an error.\n     * @returns A promise that resolves to an array of loaded documents.\n     */\n    load(): Promise<Document[]>;\n}\n//# sourceMappingURL=multi_file.d.ts.map"],"mappings":";;;;;;;;AAqBA;;;;;;;;AAA+D;;;;;;;;cAA1CI,eAAAA,SAAwBH,kBAAAA;;WAEhCC;WACAC;4CACiCD,0BAA0BC;;;;;;;;;;UAU5DE,QAAQL"}
+{"version":3,"file":"multi_file.d.ts","names":[],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"mappings":";;;;;;;AAwBA;;;;;;;;;;;;;;;;cAAa,eAAA,SAAwB,kBAAA;EAE1B,SAAA;EACA,OAAA,EAAS,cAAA;EACT,OAAA,EAAS,eAAA;EAHlB,WAAA,CACS,SAAA,YACA,OAAA,EAAS,cAAA,EACT,OAAA,GAAS,eAAA;EADT;;;;;;;;;EA0BI,IAAA,CAAA,GAAQ,OAAA,CAAQ,QAAA;AAAA"}

package/dist/document_loaders/fs/multi_file.js

@@ -1,12 +1,11 @@
-import { __export } from "../../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
 import { UnknownHandling } from "./directory.js";
 import { extname, resolve } from "node:path";
 import { stat } from "node:fs/promises";
 import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
 
 //#region src/document_loaders/fs/multi_file.ts
-var multi_file_exports = {};
-__export(multi_file_exports, { MultiFileLoader: () => MultiFileLoader });
+var multi_file_exports = /* @__PURE__ */ __exportAll({ MultiFileLoader: () => MultiFileLoader });
 /**
 * A document loader that loads documents from multiple files. It extends the
 * `BaseDocumentLoader` class and implements the `load()` method.
@@ -49,8 +48,7 @@ var MultiFileLoader = class extends BaseDocumentLoader {
 		const documents = [];
 		for (const filePath of this.filePaths) {
 			const fullPath = resolve(filePath);
-			const fileStat = await stat(fullPath);
-			if (fileStat.isDirectory()) {
+			if ((await stat(fullPath)).isDirectory()) {
 				console.warn(`Ignoring directory: ${fullPath}`);
 				continue;
 			}

package/dist/document_loaders/fs/multi_file.js.map

@@ -1 +1 @@
-{"version":3,"file":"multi_file.js","names":["filePaths: string[]","loaders: LoadersMapping","unknown: UnknownHandling","documents: Document[]"],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"sourcesContent":["import { extname, resolve } from \"node:path\";\nimport { stat } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport { type LoadersMapping, UnknownHandling } from \"./directory.js\";\n\n/**\n * A document loader that loads documents from multiple files. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const multiFileLoader = new MultiFileLoader(\n *   [\"path/to/file1.pdf\", \"path/to/file2.txt\"],\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await multiFileLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport class MultiFileLoader extends BaseDocumentLoader {\n  constructor(\n    public filePaths: string[],\n    public loaders: LoadersMapping,\n    public unknown: UnknownHandling = UnknownHandling.Warn\n  ) {\n    super();\n\n    if (Object.keys(loaders).length === 0) {\n      throw new Error(\"Must provide at least one loader\");\n    }\n    for (const extension in loaders) {\n      if (Object.hasOwn(loaders, extension)) {\n        if (extension[0] !== \".\") {\n          throw new Error(`Extension must start with a dot: ${extension}`);\n        }\n      }\n    }\n  }\n\n  /**\n   * Loads the documents from the provided file paths. It checks if the file\n   * is a directory and ignores it. If a file is a file, it checks if there\n   * is a corresponding loader function for the file extension in the `loaders`\n   * mapping. If there is, it loads the documents. If there is no\n   * corresponding loader function and `unknown` is set to `Warn`, it logs a\n   * warning message. If `unknown` is set to `Error`, it throws an error.\n   * @returns A promise that resolves to an array of loaded documents.\n   */\n  public async load(): Promise<Document[]> {\n    const documents: Document[] = [];\n\n    for (const filePath of this.filePaths) {\n      const fullPath = resolve(filePath);\n      const fileStat = await stat(fullPath);\n\n      if (fileStat.isDirectory()) {\n        console.warn(`Ignoring directory: ${fullPath}`);\n        continue;\n      }\n\n      const loaderFactory = this.loaders[extname(fullPath)];\n      if (loaderFactory) {\n        const loader = loaderFactory(fullPath);\n        documents.push(...(await loader.load()));\n      } else {\n        switch (this.unknown) {\n          case UnknownHandling.Ignore:\n            break;\n          case UnknownHandling.Warn:\n            console.warn(`Unknown file type: ${fullPath}`);\n            break;\n          case UnknownHandling.Error:\n            throw new Error(`Unknown file type: ${fullPath}`);\n          default:\n            throw new Error(`Unknown unknown handling: ${this.unknown}`);\n        }\n      }\n    }\n\n    return documents;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,kBAAb,cAAqC,mBAAmB;CACtD,YACSA,WACAC,SACAC,UAA2B,gBAAgB,MAClD;EACA,OAAO;EAJA;EACA;EACA;AAIP,MAAI,OAAO,KAAK,QAAQ,CAAC,WAAW,EAClC,OAAM,IAAI,MAAM;AAElB,OAAK,MAAM,aAAa,QACtB,KAAI,OAAO,OAAO,SAAS,UAAU,EACnC;OAAI,UAAU,OAAO,IACnB,OAAM,IAAI,MAAM,CAAC,iCAAiC,EAAE,WAAW;EAChE;CAGN;;;;;;;;;;CAWD,MAAa,OAA4B;EACvC,MAAMC,YAAwB,CAAE;AAEhC,OAAK,MAAM,YAAY,KAAK,WAAW;GACrC,MAAM,WAAW,QAAQ,SAAS;GAClC,MAAM,WAAW,MAAM,KAAK,SAAS;AAErC,OAAI,SAAS,aAAa,EAAE;IAC1B,QAAQ,KAAK,CAAC,oBAAoB,EAAE,UAAU,CAAC;AAC/C;GACD;GAED,MAAM,gBAAgB,KAAK,QAAQ,QAAQ,SAAS;AACpD,OAAI,eAAe;IACjB,MAAM,SAAS,cAAc,SAAS;IACtC,UAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;GACzC,MACC,SAAQ,KAAK,SAAb;IACE,KAAK,gBAAgB,OACnB;IACF,KAAK,gBAAgB;KACnB,QAAQ,KAAK,CAAC,mBAAmB,EAAE,UAAU,CAAC;AAC9C;IACF,KAAK,gBAAgB,MACnB,OAAM,IAAI,MAAM,CAAC,mBAAmB,EAAE,UAAU;IAClD,QACE,OAAM,IAAI,MAAM,CAAC,0BAA0B,EAAE,KAAK,SAAS;GAC9D;EAEJ;AAED,SAAO;CACR;AACF"}
+{"version":3,"file":"multi_file.js","names":[],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"sourcesContent":["import { extname, resolve } from \"node:path\";\nimport { stat } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport { type LoadersMapping, UnknownHandling } from \"./directory.js\";\n\n/**\n * A document loader that loads documents from multiple files. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const multiFileLoader = new MultiFileLoader(\n *   [\"path/to/file1.pdf\", \"path/to/file2.txt\"],\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await multiFileLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport class MultiFileLoader extends BaseDocumentLoader {\n  constructor(\n    public filePaths: string[],\n    public loaders: LoadersMapping,\n    public unknown: UnknownHandling = UnknownHandling.Warn\n  ) {\n    super();\n\n    if (Object.keys(loaders).length === 0) {\n      throw new Error(\"Must provide at least one loader\");\n    }\n    for (const extension in loaders) {\n      if (Object.hasOwn(loaders, extension)) {\n        if (extension[0] !== \".\") {\n          throw new Error(`Extension must start with a dot: ${extension}`);\n        }\n      }\n    }\n  }\n\n  /**\n   * Loads the documents from the provided file paths. It checks if the file\n   * is a directory and ignores it. If a file is a file, it checks if there\n   * is a corresponding loader function for the file extension in the `loaders`\n   * mapping. If there is, it loads the documents. If there is no\n   * corresponding loader function and `unknown` is set to `Warn`, it logs a\n   * warning message. If `unknown` is set to `Error`, it throws an error.\n   * @returns A promise that resolves to an array of loaded documents.\n   */\n  public async load(): Promise<Document[]> {\n    const documents: Document[] = [];\n\n    for (const filePath of this.filePaths) {\n      const fullPath = resolve(filePath);\n      const fileStat = await stat(fullPath);\n\n      if (fileStat.isDirectory()) {\n        console.warn(`Ignoring directory: ${fullPath}`);\n        continue;\n      }\n\n      const loaderFactory = this.loaders[extname(fullPath)];\n      if (loaderFactory) {\n        const loader = loaderFactory(fullPath);\n        documents.push(...(await loader.load()));\n      } else {\n        switch (this.unknown) {\n          case UnknownHandling.Ignore:\n            break;\n          case UnknownHandling.Warn:\n            console.warn(`Unknown file type: ${fullPath}`);\n            break;\n          case UnknownHandling.Error:\n            throw new Error(`Unknown file type: ${fullPath}`);\n          default:\n            throw new Error(`Unknown unknown handling: ${this.unknown}`);\n        }\n      }\n    }\n\n    return documents;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,kBAAb,cAAqC,mBAAmB;CACtD,YACE,AAAO,WACP,AAAO,SACP,AAAO,UAA2B,gBAAgB,MAClD;AACA,SAAO;EAJA;EACA;EACA;AAIP,MAAI,OAAO,KAAK,QAAQ,CAAC,WAAW,EAClC,OAAM,IAAI,MAAM,mCAAmC;AAErD,OAAK,MAAM,aAAa,QACtB,KAAI,OAAO,OAAO,SAAS,UAAU,EACnC;OAAI,UAAU,OAAO,IACnB,OAAM,IAAI,MAAM,oCAAoC,YAAY;;;;;;;;;;;;CAexE,MAAa,OAA4B;EACvC,MAAM,YAAwB,EAAE;AAEhC,OAAK,MAAM,YAAY,KAAK,WAAW;GACrC,MAAM,WAAW,QAAQ,SAAS;AAGlC,QAFiB,MAAM,KAAK,SAAS,EAExB,aAAa,EAAE;AAC1B,YAAQ,KAAK,uBAAuB,WAAW;AAC/C;;GAGF,MAAM,gBAAgB,KAAK,QAAQ,QAAQ,SAAS;AACpD,OAAI,eAAe;IACjB,MAAM,SAAS,cAAc,SAAS;AACtC,cAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;SAExC,SAAQ,KAAK,SAAb;IACE,KAAK,gBAAgB,OACnB;IACF,KAAK,gBAAgB;AACnB,aAAQ,KAAK,sBAAsB,WAAW;AAC9C;IACF,KAAK,gBAAgB,MACnB,OAAM,IAAI,MAAM,sBAAsB,WAAW;IACnD,QACE,OAAM,IAAI,MAAM,6BAA6B,KAAK,UAAU;;;AAKpE,SAAO"}

package/dist/document_loaders/fs/text.cjs

@@ -1,11 +1,11 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
-const __langchain_core_documents = require_rolldown_runtime.__toESM(require("@langchain/core/documents"));
-const __langchain_core_utils_env = require_rolldown_runtime.__toESM(require("@langchain/core/utils/env"));
-const __langchain_core_document_loaders_base = require_rolldown_runtime.__toESM(require("@langchain/core/document_loaders/base"));
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
+let _langchain_core_utils_env = require("@langchain/core/utils/env");
+let _langchain_core_documents = require("@langchain/core/documents");
+let _langchain_core_document_loaders_base = require("@langchain/core/document_loaders/base");
 
 //#region src/document_loaders/fs/text.ts
-var text_exports = {};
-require_rolldown_runtime.__export(text_exports, { TextLoader: () => TextLoader });
+var text_exports = /* @__PURE__ */ require_runtime.__exportAll({ TextLoader: () => TextLoader });
 /**
 * A class that extends the `BaseDocumentLoader` class. It represents a
 * document loader that loads documents from a text file. The `load()`
@@ -19,7 +19,7 @@ require_rolldown_runtime.__export(text_exports, { TextLoader: () => TextLoader }
 * const docs = await loader.load();
 * ```
 */
-var TextLoader = class TextLoader extends __langchain_core_document_loaders_base.BaseDocumentLoader {
+var TextLoader = class TextLoader extends _langchain_core_document_loaders_base.BaseDocumentLoader {
 	constructor(filePathOrBlob) {
 		super();
 		this.filePathOrBlob = filePathOrBlob;
@@ -63,7 +63,7 @@ var TextLoader = class TextLoader extends __langchain_core_document_loaders_base
 		parsed.forEach((pageContent, i) => {
 			if (typeof pageContent !== "string") throw new Error(`Expected string, at position ${i} got ${typeof pageContent}`);
 		});
-		return parsed.map((pageContent, i) => new __langchain_core_documents.Document({
+		return parsed.map((pageContent, i) => new _langchain_core_documents.Document({
 			pageContent,
 			metadata: parsed.length === 1 ? metadata : {
 				...metadata,
@@ -85,7 +85,7 @@ var TextLoader = class TextLoader extends __langchain_core_document_loaders_base
 			return { readFile };
 		} catch (e) {
 			console.error(e);
-			throw new Error(`Failed to load fs/promises. TextLoader available only on environment 'node'. It appears you are running environment '${(0, __langchain_core_utils_env.getEnv)()}'. See https://<link to docs> for alternatives.`);
+			throw new Error(`Failed to load fs/promises. TextLoader available only on environment 'node'. It appears you are running environment '${(0, _langchain_core_utils_env.getEnv)()}'. See https://<link to docs> for alternatives.`);
 		}
 	}
 };

package/dist/document_loaders/fs/text.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"text.cjs","names":["BaseDocumentLoader","filePathOrBlob: string | Blob","raw: string","text: string","metadata: Record<string, string>","Document"],"sources":["../../../src/document_loaders/fs/text.ts"],"sourcesContent":["import type { readFile as ReadFileT } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { getEnv } from \"@langchain/core/utils/env\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\n\n/**\n * A class that extends the `BaseDocumentLoader` class. It represents a\n * document loader that loads documents from a text file. The `load()`\n * method is implemented to read the text from the file or blob, parse it\n * using the `parse()` method, and create a `Document` instance for each\n * parsed page. The metadata includes the source of the text (file path or\n * blob) and, if there are multiple pages, the line number of each page.\n * @example\n * ```typescript\n * const loader = new TextLoader(\"src/document_loaders/example_data/example.txt\");\n * const docs = await loader.load();\n * ```\n */\nexport class TextLoader extends BaseDocumentLoader {\n  constructor(public filePathOrBlob: string | Blob) {\n    super();\n  }\n\n  /**\n   * A protected method that takes a `raw` string as a parameter and returns\n   * a promise that resolves to an array containing the raw text as a single\n   * element.\n   * @param raw The raw text to be parsed.\n   * @returns A promise that resolves to an array containing the raw text as a single element.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    return [raw];\n  }\n\n  /**\n   * A method that loads the text file or blob and returns a promise that\n   * resolves to an array of `Document` instances. It reads the text from\n   * the file or blob using the `readFile` function from the\n   * `node:fs/promises` module or the `text()` method of the blob. It then\n   * parses the text using the `parse()` method and creates a `Document`\n   * instance for each parsed page. The metadata includes the source of the\n   * text (file path or blob) and, if there are multiple pages, the line\n   * number of each page.\n   * @returns A promise that resolves to an array of `Document` instances.\n   */\n  public async load(): Promise<Document[]> {\n    let text: string;\n    let metadata: Record<string, string>;\n    if (typeof this.filePathOrBlob === \"string\") {\n      const { readFile } = await TextLoader.imports();\n      text = await readFile(this.filePathOrBlob, \"utf8\");\n      metadata = { source: this.filePathOrBlob };\n    } else {\n      text = await this.filePathOrBlob.text();\n      metadata = { source: \"blob\", blobType: this.filePathOrBlob.type };\n    }\n    const parsed = await this.parse(text);\n    parsed.forEach((pageContent, i) => {\n      if (typeof pageContent !== \"string\") {\n        throw new Error(\n          `Expected string, at position ${i} got ${typeof pageContent}`\n        );\n      }\n    });\n    return parsed.map(\n      (pageContent, i) =>\n        new Document({\n          pageContent,\n          metadata:\n            parsed.length === 1\n              ? metadata\n              : {\n                  ...metadata,\n                  line: i + 1,\n                },\n        })\n    );\n  }\n\n  /**\n   * A static method that imports the `readFile` function from the\n   * `node:fs/promises` module. It is used to dynamically import the\n   * function when needed. If the import fails, it throws an error\n   * indicating that the `fs/promises` module is not available in the\n   * current environment.\n   * @returns A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.\n   */\n  static async imports(): Promise<{\n    readFile: typeof ReadFileT;\n  }> {\n    try {\n      const { readFile } = await import(\"node:fs/promises\");\n      return { readFile };\n    } catch (e) {\n      console.error(e);\n      throw new Error(\n        `Failed to load fs/promises. TextLoader available only on environment 'node'. It appears you are running environment '${getEnv()}'. See https://<link to docs> for alternatives.`\n      );\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAkBA,IAAa,aAAb,MAAa,mBAAmBA,0DAAmB;CACjD,YAAmBC,gBAA+B;EAChD,OAAO;EADU;CAElB;;;;;;;;CASD,MAAgB,MAAMC,KAAgC;AACpD,SAAO,CAAC,GAAI;CACb;;;;;;;;;;;;CAaD,MAAa,OAA4B;EACvC,IAAIC;EACJ,IAAIC;AACJ,MAAI,OAAO,KAAK,mBAAmB,UAAU;GAC3C,MAAM,EAAE,UAAU,GAAG,MAAM,WAAW,SAAS;GAC/C,OAAO,MAAM,SAAS,KAAK,gBAAgB,OAAO;GAClD,WAAW,EAAE,QAAQ,KAAK,eAAgB;EAC3C,OAAM;GACL,OAAO,MAAM,KAAK,eAAe,MAAM;GACvC,WAAW;IAAE,QAAQ;IAAQ,UAAU,KAAK,eAAe;GAAM;EAClE;EACD,MAAM,SAAS,MAAM,KAAK,MAAM,KAAK;EACrC,OAAO,QAAQ,CAAC,aAAa,MAAM;AACjC,OAAI,OAAO,gBAAgB,SACzB,OAAM,IAAI,MACR,CAAC,6BAA6B,EAAE,EAAE,KAAK,EAAE,OAAO,aAAa;EAGlE,EAAC;AACF,SAAO,OAAO,IACZ,CAAC,aAAa,MACZ,IAAIC,oCAAS;GACX;GACA,UACE,OAAO,WAAW,IACd,WACA;IACE,GAAG;IACH,MAAM,IAAI;GACX;EACR,GACJ;CACF;;;;;;;;;CAUD,aAAa,UAEV;AACD,MAAI;GACF,MAAM,EAAE,UAAU,GAAG,MAAM,OAAO;AAClC,UAAO,EAAE,SAAU;EACpB,SAAQ,GAAG;GACV,QAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR,CAAC,qHAAqH,0CAAU,CAAC,+CAA+C,CAAC;EAEpL;CACF;AACF"}
+{"version":3,"file":"text.cjs","names":["BaseDocumentLoader","Document"],"sources":["../../../src/document_loaders/fs/text.ts"],"sourcesContent":["import type { readFile as ReadFileT } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { getEnv } from \"@langchain/core/utils/env\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\n\n/**\n * A class that extends the `BaseDocumentLoader` class. It represents a\n * document loader that loads documents from a text file. The `load()`\n * method is implemented to read the text from the file or blob, parse it\n * using the `parse()` method, and create a `Document` instance for each\n * parsed page. The metadata includes the source of the text (file path or\n * blob) and, if there are multiple pages, the line number of each page.\n * @example\n * ```typescript\n * const loader = new TextLoader(\"src/document_loaders/example_data/example.txt\");\n * const docs = await loader.load();\n * ```\n */\nexport class TextLoader extends BaseDocumentLoader {\n  constructor(public filePathOrBlob: string | Blob) {\n    super();\n  }\n\n  /**\n   * A protected method that takes a `raw` string as a parameter and returns\n   * a promise that resolves to an array containing the raw text as a single\n   * element.\n   * @param raw The raw text to be parsed.\n   * @returns A promise that resolves to an array containing the raw text as a single element.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    return [raw];\n  }\n\n  /**\n   * A method that loads the text file or blob and returns a promise that\n   * resolves to an array of `Document` instances. It reads the text from\n   * the file or blob using the `readFile` function from the\n   * `node:fs/promises` module or the `text()` method of the blob. It then\n   * parses the text using the `parse()` method and creates a `Document`\n   * instance for each parsed page. The metadata includes the source of the\n   * text (file path or blob) and, if there are multiple pages, the line\n   * number of each page.\n   * @returns A promise that resolves to an array of `Document` instances.\n   */\n  public async load(): Promise<Document[]> {\n    let text: string;\n    let metadata: Record<string, string>;\n    if (typeof this.filePathOrBlob === \"string\") {\n      const { readFile } = await TextLoader.imports();\n      text = await readFile(this.filePathOrBlob, \"utf8\");\n      metadata = { source: this.filePathOrBlob };\n    } else {\n      text = await this.filePathOrBlob.text();\n      metadata = { source: \"blob\", blobType: this.filePathOrBlob.type };\n    }\n    const parsed = await this.parse(text);\n    parsed.forEach((pageContent, i) => {\n      if (typeof pageContent !== \"string\") {\n        throw new Error(\n          `Expected string, at position ${i} got ${typeof pageContent}`\n        );\n      }\n    });\n    return parsed.map(\n      (pageContent, i) =>\n        new Document({\n          pageContent,\n          metadata:\n            parsed.length === 1\n              ? metadata\n              : {\n                  ...metadata,\n                  line: i + 1,\n                },\n        })\n    );\n  }\n\n  /**\n   * A static method that imports the `readFile` function from the\n   * `node:fs/promises` module. It is used to dynamically import the\n   * function when needed. If the import fails, it throws an error\n   * indicating that the `fs/promises` module is not available in the\n   * current environment.\n   * @returns A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.\n   */\n  static async imports(): Promise<{\n    readFile: typeof ReadFileT;\n  }> {\n    try {\n      const { readFile } = await import(\"node:fs/promises\");\n      return { readFile };\n    } catch (e) {\n      console.error(e);\n      throw new Error(\n        `Failed to load fs/promises. TextLoader available only on environment 'node'. It appears you are running environment '${getEnv()}'. See https://<link to docs> for alternatives.`\n      );\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAkBA,IAAa,aAAb,MAAa,mBAAmBA,yDAAmB;CACjD,YAAY,AAAO,gBAA+B;AAChD,SAAO;EADU;;;;;;;;;CAWnB,MAAgB,MAAM,KAAgC;AACpD,SAAO,CAAC,IAAI;;;;;;;;;;;;;CAcd,MAAa,OAA4B;EACvC,IAAI;EACJ,IAAI;AACJ,MAAI,OAAO,KAAK,mBAAmB,UAAU;GAC3C,MAAM,EAAE,aAAa,MAAM,WAAW,SAAS;AAC/C,UAAO,MAAM,SAAS,KAAK,gBAAgB,OAAO;AAClD,cAAW,EAAE,QAAQ,KAAK,gBAAgB;SACrC;AACL,UAAO,MAAM,KAAK,eAAe,MAAM;AACvC,cAAW;IAAE,QAAQ;IAAQ,UAAU,KAAK,eAAe;IAAM;;EAEnE,MAAM,SAAS,MAAM,KAAK,MAAM,KAAK;AACrC,SAAO,SAAS,aAAa,MAAM;AACjC,OAAI,OAAO,gBAAgB,SACzB,OAAM,IAAI,MACR,gCAAgC,EAAE,OAAO,OAAO,cACjD;IAEH;AACF,SAAO,OAAO,KACX,aAAa,MACZ,IAAIC,mCAAS;GACX;GACA,UACE,OAAO,WAAW,IACd,WACA;IACE,GAAG;IACH,MAAM,IAAI;IACX;GACR,CAAC,CACL;;;;;;;;;;CAWH,aAAa,UAEV;AACD,MAAI;GACF,MAAM,EAAE,aAAa,MAAM,OAAO;AAClC,UAAO,EAAE,UAAU;WACZ,GAAG;AACV,WAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR,+JAAgI,CAAC,iDAClI"}

package/dist/document_loaders/fs/text.d.cts

@@ -3,7 +3,6 @@ import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
 import { readFile } from "node:fs/promises";
 
 //#region src/document_loaders/fs/text.d.ts
-
 /**
  * A class that extends the `BaseDocumentLoader` class. It represents a
  * document loader that loads documents from a text file. The `load()`

package/dist/document_loaders/fs/text.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"text.d.cts","names":["readFile","ReadFileT","Document","BaseDocumentLoader","TextLoader","Blob","Promise"],"sources":["../../../src/document_loaders/fs/text.d.ts"],"sourcesContent":["import type { readFile as ReadFileT } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\n/**\n * A class that extends the `BaseDocumentLoader` class. It represents a\n * document loader that loads documents from a text file. The `load()`\n * method is implemented to read the text from the file or blob, parse it\n * using the `parse()` method, and create a `Document` instance for each\n * parsed page. The metadata includes the source of the text (file path or\n * blob) and, if there are multiple pages, the line number of each page.\n * @example\n * ```typescript\n * const loader = new TextLoader(\"src/document_loaders/example_data/example.txt\");\n * const docs = await loader.load();\n * ```\n */\nexport declare class TextLoader extends BaseDocumentLoader {\n    filePathOrBlob: string | Blob;\n    constructor(filePathOrBlob: string | Blob);\n    /**\n     * A protected method that takes a `raw` string as a parameter and returns\n     * a promise that resolves to an array containing the raw text as a single\n     * element.\n     * @param raw The raw text to be parsed.\n     * @returns A promise that resolves to an array containing the raw text as a single element.\n     */\n    protected parse(raw: string): Promise<string[]>;\n    /**\n     * A method that loads the text file or blob and returns a promise that\n     * resolves to an array of `Document` instances. It reads the text from\n     * the file or blob using the `readFile` function from the\n     * `node:fs/promises` module or the `text()` method of the blob. It then\n     * parses the text using the `parse()` method and creates a `Document`\n     * instance for each parsed page. The metadata includes the source of the\n     * text (file path or blob) and, if there are multiple pages, the line\n     * number of each page.\n     * @returns A promise that resolves to an array of `Document` instances.\n     */\n    load(): Promise<Document[]>;\n    /**\n     * A static method that imports the `readFile` function from the\n     * `node:fs/promises` module. It is used to dynamically import the\n     * function when needed. If the import fails, it throws an error\n     * indicating that the `fs/promises` module is not available in the\n     * current environment.\n     * @returns A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.\n     */\n    static imports(): Promise<{\n        readFile: typeof ReadFileT;\n    }>;\n}\n//# sourceMappingURL=text.d.ts.map"],"mappings":";;;;;;;;AAgBA;;;;;;;;;AAA0D;;cAArCI,UAAAA,SAAmBD,kBAAAA;2BACXE;uCACYA;;;;;;;;gCAQPC;;;;;;;;;;;;UAYtBA,QAAQJ;;;;;;;;;oBASEI;qBACGL"}
+{"version":3,"file":"text.d.cts","names":[],"sources":["../../../src/document_loaders/fs/text.ts"],"mappings":";;;;;;;AAkBA;;;;;;;;;;;cAAa,UAAA,SAAmB,kBAAA;EACX,cAAA,WAAyB,IAAA;EAA5C,WAAA,CAAmB,cAAA,WAAyB,IAAA;EAAzB;;;;;;;EAAA,UAWH,KAAA,CAAM,GAAA,WAAc,OAAA;EAevB;;;;;;;;;;;EAAA,IAAA,CAAA,GAAQ,OAAA,CAAQ,QAAA;;;;;;;;;SA0ChB,OAAA,CAAA,GAAW,OAAA;IACtB,QAAA,SAAiB,QAAA;EAAA;AAAA"}

package/dist/document_loaders/fs/text.d.ts

@@ -1,9 +1,8 @@
-import { Document } from "@langchain/core/documents";
 import { readFile } from "node:fs/promises";
+import { Document } from "@langchain/core/documents";
 import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
 
 //#region src/document_loaders/fs/text.d.ts
-
 /**
  * A class that extends the `BaseDocumentLoader` class. It represents a
  * document loader that loads documents from a text file. The `load()`

package/dist/document_loaders/fs/text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text.d.ts","names":["readFile","ReadFileT","Document","BaseDocumentLoader","TextLoader","Blob","Promise"],"sources":["../../../src/document_loaders/fs/text.d.ts"],"sourcesContent":["import type { readFile as ReadFileT } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\n/**\n * A class that extends the `BaseDocumentLoader` class. It represents a\n * document loader that loads documents from a text file. The `load()`\n * method is implemented to read the text from the file or blob, parse it\n * using the `parse()` method, and create a `Document` instance for each\n * parsed page. The metadata includes the source of the text (file path or\n * blob) and, if there are multiple pages, the line number of each page.\n * @example\n * ```typescript\n * const loader = new TextLoader(\"src/document_loaders/example_data/example.txt\");\n * const docs = await loader.load();\n * ```\n */\nexport declare class TextLoader extends BaseDocumentLoader {\n    filePathOrBlob: string | Blob;\n    constructor(filePathOrBlob: string | Blob);\n    /**\n     * A protected method that takes a `raw` string as a parameter and returns\n     * a promise that resolves to an array containing the raw text as a single\n     * element.\n     * @param raw The raw text to be parsed.\n     * @returns A promise that resolves to an array containing the raw text as a single element.\n     */\n    protected parse(raw: string): Promise<string[]>;\n    /**\n     * A method that loads the text file or blob and returns a promise that\n     * resolves to an array of `Document` instances. It reads the text from\n     * the file or blob using the `readFile` function from the\n     * `node:fs/promises` module or the `text()` method of the blob. It then\n     * parses the text using the `parse()` method and creates a `Document`\n     * instance for each parsed page. The metadata includes the source of the\n     * text (file path or blob) and, if there are multiple pages, the line\n     * number of each page.\n     * @returns A promise that resolves to an array of `Document` instances.\n     */\n    load(): Promise<Document[]>;\n    /**\n     * A static method that imports the `readFile` function from the\n     * `node:fs/promises` module. It is used to dynamically import the\n     * function when needed. If the import fails, it throws an error\n     * indicating that the `fs/promises` module is not available in the\n     * current environment.\n     * @returns A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.\n     */\n    static imports(): Promise<{\n        readFile: typeof ReadFileT;\n    }>;\n}\n//# sourceMappingURL=text.d.ts.map"],"mappings":";;;;;;;;AAgBA;;;;;;;;;AAA0D;;cAArCI,UAAAA,SAAmBD,kBAAAA;2BACXE;uCACYA;;;;;;;;gCAQPC;;;;;;;;;;;;UAYtBA,QAAQJ;;;;;;;;;oBASEI;qBACGL"}
+{"version":3,"file":"text.d.ts","names":[],"sources":["../../../src/document_loaders/fs/text.ts"],"mappings":";;;;;;;AAkBA;;;;;;;;;;;cAAa,UAAA,SAAmB,kBAAA;EACX,cAAA,WAAyB,IAAA;EAA5C,WAAA,CAAmB,cAAA,WAAyB,IAAA;EAAzB;;;;;;;EAAA,UAWH,KAAA,CAAM,GAAA,WAAc,OAAA;EAevB;;;;;;;;;;;EAAA,IAAA,CAAA,GAAQ,OAAA,CAAQ,QAAA;;;;;;;;;SA0ChB,OAAA,CAAA,GAAW,OAAA;IACtB,QAAA,SAAiB,QAAA;EAAA;AAAA"}

package/dist/document_loaders/fs/text.js

@@ -1,11 +1,10 @@
-import { __export } from "../../_virtual/rolldown_runtime.js";
-import { Document } from "@langchain/core/documents";
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
 import { getEnv } from "@langchain/core/utils/env";
+import { Document } from "@langchain/core/documents";
 import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
 
 //#region src/document_loaders/fs/text.ts
-var text_exports = {};
-__export(text_exports, { TextLoader: () => TextLoader });
+var text_exports = /* @__PURE__ */ __exportAll({ TextLoader: () => TextLoader });
 /**
 * A class that extends the `BaseDocumentLoader` class. It represents a
 * document loader that loads documents from a text file. The `load()`

package/dist/document_loaders/fs/text.js.map

@@ -1 +1 @@
-{"version":3,"file":"text.js","names":["filePathOrBlob: string | Blob","raw: string","text: string","metadata: Record<string, string>"],"sources":["../../../src/document_loaders/fs/text.ts"],"sourcesContent":["import type { readFile as ReadFileT } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { getEnv } from \"@langchain/core/utils/env\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\n\n/**\n * A class that extends the `BaseDocumentLoader` class. It represents a\n * document loader that loads documents from a text file. The `load()`\n * method is implemented to read the text from the file or blob, parse it\n * using the `parse()` method, and create a `Document` instance for each\n * parsed page. The metadata includes the source of the text (file path or\n * blob) and, if there are multiple pages, the line number of each page.\n * @example\n * ```typescript\n * const loader = new TextLoader(\"src/document_loaders/example_data/example.txt\");\n * const docs = await loader.load();\n * ```\n */\nexport class TextLoader extends BaseDocumentLoader {\n  constructor(public filePathOrBlob: string | Blob) {\n    super();\n  }\n\n  /**\n   * A protected method that takes a `raw` string as a parameter and returns\n   * a promise that resolves to an array containing the raw text as a single\n   * element.\n   * @param raw The raw text to be parsed.\n   * @returns A promise that resolves to an array containing the raw text as a single element.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    return [raw];\n  }\n\n  /**\n   * A method that loads the text file or blob and returns a promise that\n   * resolves to an array of `Document` instances. It reads the text from\n   * the file or blob using the `readFile` function from the\n   * `node:fs/promises` module or the `text()` method of the blob. It then\n   * parses the text using the `parse()` method and creates a `Document`\n   * instance for each parsed page. The metadata includes the source of the\n   * text (file path or blob) and, if there are multiple pages, the line\n   * number of each page.\n   * @returns A promise that resolves to an array of `Document` instances.\n   */\n  public async load(): Promise<Document[]> {\n    let text: string;\n    let metadata: Record<string, string>;\n    if (typeof this.filePathOrBlob === \"string\") {\n      const { readFile } = await TextLoader.imports();\n      text = await readFile(this.filePathOrBlob, \"utf8\");\n      metadata = { source: this.filePathOrBlob };\n    } else {\n      text = await this.filePathOrBlob.text();\n      metadata = { source: \"blob\", blobType: this.filePathOrBlob.type };\n    }\n    const parsed = await this.parse(text);\n    parsed.forEach((pageContent, i) => {\n      if (typeof pageContent !== \"string\") {\n        throw new Error(\n          `Expected string, at position ${i} got ${typeof pageContent}`\n        );\n      }\n    });\n    return parsed.map(\n      (pageContent, i) =>\n        new Document({\n          pageContent,\n          metadata:\n            parsed.length === 1\n              ? metadata\n              : {\n                  ...metadata,\n                  line: i + 1,\n                },\n        })\n    );\n  }\n\n  /**\n   * A static method that imports the `readFile` function from the\n   * `node:fs/promises` module. It is used to dynamically import the\n   * function when needed. If the import fails, it throws an error\n   * indicating that the `fs/promises` module is not available in the\n   * current environment.\n   * @returns A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.\n   */\n  static async imports(): Promise<{\n    readFile: typeof ReadFileT;\n  }> {\n    try {\n      const { readFile } = await import(\"node:fs/promises\");\n      return { readFile };\n    } catch (e) {\n      console.error(e);\n      throw new Error(\n        `Failed to load fs/promises. TextLoader available only on environment 'node'. It appears you are running environment '${getEnv()}'. See https://<link to docs> for alternatives.`\n      );\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAkBA,IAAa,aAAb,MAAa,mBAAmB,mBAAmB;CACjD,YAAmBA,gBAA+B;EAChD,OAAO;EADU;CAElB;;;;;;;;CASD,MAAgB,MAAMC,KAAgC;AACpD,SAAO,CAAC,GAAI;CACb;;;;;;;;;;;;CAaD,MAAa,OAA4B;EACvC,IAAIC;EACJ,IAAIC;AACJ,MAAI,OAAO,KAAK,mBAAmB,UAAU;GAC3C,MAAM,EAAE,UAAU,GAAG,MAAM,WAAW,SAAS;GAC/C,OAAO,MAAM,SAAS,KAAK,gBAAgB,OAAO;GAClD,WAAW,EAAE,QAAQ,KAAK,eAAgB;EAC3C,OAAM;GACL,OAAO,MAAM,KAAK,eAAe,MAAM;GACvC,WAAW;IAAE,QAAQ;IAAQ,UAAU,KAAK,eAAe;GAAM;EAClE;EACD,MAAM,SAAS,MAAM,KAAK,MAAM,KAAK;EACrC,OAAO,QAAQ,CAAC,aAAa,MAAM;AACjC,OAAI,OAAO,gBAAgB,SACzB,OAAM,IAAI,MACR,CAAC,6BAA6B,EAAE,EAAE,KAAK,EAAE,OAAO,aAAa;EAGlE,EAAC;AACF,SAAO,OAAO,IACZ,CAAC,aAAa,MACZ,IAAI,SAAS;GACX;GACA,UACE,OAAO,WAAW,IACd,WACA;IACE,GAAG;IACH,MAAM,IAAI;GACX;EACR,GACJ;CACF;;;;;;;;;CAUD,aAAa,UAEV;AACD,MAAI;GACF,MAAM,EAAE,UAAU,GAAG,MAAM,OAAO;AAClC,UAAO,EAAE,SAAU;EACpB,SAAQ,GAAG;GACV,QAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR,CAAC,qHAAqH,EAAE,QAAQ,CAAC,+CAA+C,CAAC;EAEpL;CACF;AACF"}
+{"version":3,"file":"text.js","names":[],"sources":["../../../src/document_loaders/fs/text.ts"],"sourcesContent":["import type { readFile as ReadFileT } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { getEnv } from \"@langchain/core/utils/env\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\n\n/**\n * A class that extends the `BaseDocumentLoader` class. It represents a\n * document loader that loads documents from a text file. The `load()`\n * method is implemented to read the text from the file or blob, parse it\n * using the `parse()` method, and create a `Document` instance for each\n * parsed page. The metadata includes the source of the text (file path or\n * blob) and, if there are multiple pages, the line number of each page.\n * @example\n * ```typescript\n * const loader = new TextLoader(\"src/document_loaders/example_data/example.txt\");\n * const docs = await loader.load();\n * ```\n */\nexport class TextLoader extends BaseDocumentLoader {\n  constructor(public filePathOrBlob: string | Blob) {\n    super();\n  }\n\n  /**\n   * A protected method that takes a `raw` string as a parameter and returns\n   * a promise that resolves to an array containing the raw text as a single\n   * element.\n   * @param raw The raw text to be parsed.\n   * @returns A promise that resolves to an array containing the raw text as a single element.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    return [raw];\n  }\n\n  /**\n   * A method that loads the text file or blob and returns a promise that\n   * resolves to an array of `Document` instances. It reads the text from\n   * the file or blob using the `readFile` function from the\n   * `node:fs/promises` module or the `text()` method of the blob. It then\n   * parses the text using the `parse()` method and creates a `Document`\n   * instance for each parsed page. The metadata includes the source of the\n   * text (file path or blob) and, if there are multiple pages, the line\n   * number of each page.\n   * @returns A promise that resolves to an array of `Document` instances.\n   */\n  public async load(): Promise<Document[]> {\n    let text: string;\n    let metadata: Record<string, string>;\n    if (typeof this.filePathOrBlob === \"string\") {\n      const { readFile } = await TextLoader.imports();\n      text = await readFile(this.filePathOrBlob, \"utf8\");\n      metadata = { source: this.filePathOrBlob };\n    } else {\n      text = await this.filePathOrBlob.text();\n      metadata = { source: \"blob\", blobType: this.filePathOrBlob.type };\n    }\n    const parsed = await this.parse(text);\n    parsed.forEach((pageContent, i) => {\n      if (typeof pageContent !== \"string\") {\n        throw new Error(\n          `Expected string, at position ${i} got ${typeof pageContent}`\n        );\n      }\n    });\n    return parsed.map(\n      (pageContent, i) =>\n        new Document({\n          pageContent,\n          metadata:\n            parsed.length === 1\n              ? metadata\n              : {\n                  ...metadata,\n                  line: i + 1,\n                },\n        })\n    );\n  }\n\n  /**\n   * A static method that imports the `readFile` function from the\n   * `node:fs/promises` module. It is used to dynamically import the\n   * function when needed. If the import fails, it throws an error\n   * indicating that the `fs/promises` module is not available in the\n   * current environment.\n   * @returns A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.\n   */\n  static async imports(): Promise<{\n    readFile: typeof ReadFileT;\n  }> {\n    try {\n      const { readFile } = await import(\"node:fs/promises\");\n      return { readFile };\n    } catch (e) {\n      console.error(e);\n      throw new Error(\n        `Failed to load fs/promises. TextLoader available only on environment 'node'. It appears you are running environment '${getEnv()}'. See https://<link to docs> for alternatives.`\n      );\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAkBA,IAAa,aAAb,MAAa,mBAAmB,mBAAmB;CACjD,YAAY,AAAO,gBAA+B;AAChD,SAAO;EADU;;;;;;;;;CAWnB,MAAgB,MAAM,KAAgC;AACpD,SAAO,CAAC,IAAI;;;;;;;;;;;;;CAcd,MAAa,OAA4B;EACvC,IAAI;EACJ,IAAI;AACJ,MAAI,OAAO,KAAK,mBAAmB,UAAU;GAC3C,MAAM,EAAE,aAAa,MAAM,WAAW,SAAS;AAC/C,UAAO,MAAM,SAAS,KAAK,gBAAgB,OAAO;AAClD,cAAW,EAAE,QAAQ,KAAK,gBAAgB;SACrC;AACL,UAAO,MAAM,KAAK,eAAe,MAAM;AACvC,cAAW;IAAE,QAAQ;IAAQ,UAAU,KAAK,eAAe;IAAM;;EAEnE,MAAM,SAAS,MAAM,KAAK,MAAM,KAAK;AACrC,SAAO,SAAS,aAAa,MAAM;AACjC,OAAI,OAAO,gBAAgB,SACzB,OAAM,IAAI,MACR,gCAAgC,EAAE,OAAO,OAAO,cACjD;IAEH;AACF,SAAO,OAAO,KACX,aAAa,MACZ,IAAI,SAAS;GACX;GACA,UACE,OAAO,WAAW,IACd,WACA;IACE,GAAG;IACH,MAAM,IAAI;IACX;GACR,CAAC,CACL;;;;;;;;;;CAWH,aAAa,UAEV;AACD,MAAI;GACF,MAAM,EAAE,aAAa,MAAM,OAAO;AAClC,UAAO,EAAE,UAAU;WACZ,GAAG;AACV,WAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR,wHAAwH,QAAQ,CAAC,iDAClI"}

package/dist/document_transformers/openai_functions.cjs

@@ -1,13 +1,13 @@
-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_tagging = require('../chains/openai_functions/tagging.cjs');
 require('../chains/openai_functions/index.cjs');
-const __langchain_core_documents = require_rolldown_runtime.__toESM(require("@langchain/core/documents"));
-const __langchain_core_utils_json_schema = require_rolldown_runtime.__toESM(require("@langchain/core/utils/json_schema"));
-const __langchain_openai = require_rolldown_runtime.__toESM(require("@langchain/openai"));
+let _langchain_core_utils_json_schema = require("@langchain/core/utils/json_schema");
+let _langchain_openai = require("@langchain/openai");
+let _langchain_core_documents = require("@langchain/core/documents");
 
 //#region src/document_transformers/openai_functions.ts
-var openai_functions_exports = {};
-require_rolldown_runtime.__export(openai_functions_exports, {
+var openai_functions_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	MetadataTagger: () => MetadataTagger,
 	createMetadataTagger: () => createMetadataTagger,
 	createMetadataTaggerFromZod: () => createMetadataTaggerFromZod
@@ -15,7 +15,7 @@ require_rolldown_runtime.__export(openai_functions_exports, {
 /**
 * A transformer that tags metadata to a document using a tagging chain.
 */
-var MetadataTagger = class extends __langchain_core_documents.MappingDocumentTransformer {
+var MetadataTagger = class extends _langchain_core_documents.MappingDocumentTransformer {
 	static lc_name() {
 		return "MetadataTagger";
 	}
@@ -27,9 +27,8 @@ var MetadataTagger = class extends __langchain_core_documents.MappingDocumentTra
 		if (this.taggingChain.outputKeys.length !== 1) throw new Error("Invalid input chain. The input chain must have exactly one output.");
 	}
 	async _transformDocument(document) {
-		const taggingChainResponse = await this.taggingChain.call({ [this.taggingChain.inputKeys[0]]: document.pageContent });
-		const extractedMetadata = taggingChainResponse[this.taggingChain.outputKeys[0]];
-		return new __langchain_core_documents.Document({
+		const extractedMetadata = (await this.taggingChain.call({ [this.taggingChain.inputKeys[0]]: document.pageContent }))[this.taggingChain.outputKeys[0]];
+		return new _langchain_core_documents.Document({
 			pageContent: document.pageContent,
 			metadata: {
 				...extractedMetadata,
@@ -39,12 +38,11 @@ var MetadataTagger = class extends __langchain_core_documents.MappingDocumentTra
 	}
 };
 function createMetadataTagger(schema, options) {
-	const { llm = new __langchain_openai.ChatOpenAI({ model: "gpt-3.5-turbo-0613" }),...rest } = options;
-	const taggingChain = require_tagging.createTaggingChain(schema, llm, rest);
-	return new MetadataTagger({ taggingChain });
+	const { llm = new _langchain_openai.ChatOpenAI({ model: "gpt-3.5-turbo-0613" }), ...rest } = options;
+	return new MetadataTagger({ taggingChain: require_tagging.createTaggingChain(schema, llm, rest) });
 }
 function createMetadataTaggerFromZod(schema, options) {
-	return createMetadataTagger((0, __langchain_core_utils_json_schema.toJsonSchema)(schema), options);
+	return createMetadataTagger((0, _langchain_core_utils_json_schema.toJsonSchema)(schema), options);
 }
 
 //#endregion