langchain 0.3.30 → 1.0.0-alpha.1

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

@@ -0,0 +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"],"mappings":";;;;;;AAQA;;;;;AAAkD,cAA7BC,UAAAA,SAAmBD,UAAAA,CAAU;EAsC7BI,QAAAA,EAAAA,MAAAA,EAAe;EAAA,WAAA,CAAA,cAAA,EAAA,MAAA,GApCKF,IAoCL,EAAA,QAAA,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA;EAAA;;;AAAmB;;;;;;gCA1BrBC;;;;;;;;;;;;;;;;;;;;;;;;;;cA0BbC,eAAAA,SAAwBJ,UAAAA;;uCAEJE;;;;;;;;;gCASPC"}

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

@@ -1,4 +1,7 @@
 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
@@ -6,36 +9,36 @@ import { TextLoader } from "./text.js";
  * file or a `Blob` object, and an optional `pointers` parameter that
  * specifies the JSON pointers to extract.
  */
-export declare class JSONLoader extends TextLoader {
-    pointers: string[];
-    constructor(filePathOrBlob: string | Blob, pointers?: string | string[]);
-    /**
-     * Method that takes a `raw` string as a parameter and returns a promise
-     * that resolves to an array of strings. It parses the raw JSON string and
-     * extracts the values based on the specified JSON pointers. If no JSON
-     * pointers are specified, it extracts all the strings from the JSON
-     * object.
-     * @param raw The raw JSON string to parse.
-     * @returns A promise that resolves to an array of strings.
-     */
-    protected parse(raw: string): Promise<string[]>;
-    /**
-     * If JSON pointers are specified, return all strings below any of them
-     * and exclude all other nodes expect if they match a JSON pointer (to allow to extract strings from different levels)
-     *
-     * If no JSON pointer is specified then return all string in the object
-     */
-    private extractArrayStringsFromObject;
-    /**
-     * Method that takes a `json` object and an array of `pointers` as
-     * parameters and returns an array of targeted entries. It iterates over
-     * the JSON pointers and uses the `jsonpointer.get()` function to get the
-     * targeted entries from the JSON object.
-     * @param json The JSON object to get targeted entries from.
-     * @param pointers The JSON pointers to get targeted entries.
-     * @returns An array of targeted entries.
-     */
-    private getTargetedEntries;
+declare class JSONLoader extends TextLoader {
+  pointers: string[];
+  constructor(filePathOrBlob: string | Blob, pointers?: string | string[]);
+  /**
+   * Method that takes a `raw` string as a parameter and returns a promise
+   * that resolves to an array of strings. It parses the raw JSON string and
+   * extracts the values based on the specified JSON pointers. If no JSON
+   * pointers are specified, it extracts all the strings from the JSON
+   * object.
+   * @param raw The raw JSON string to parse.
+   * @returns A promise that resolves to an array of strings.
+   */
+  protected parse(raw: string): Promise<string[]>;
+  /**
+   * If JSON pointers are specified, return all strings below any of them
+   * and exclude all other nodes expect if they match a JSON pointer (to allow to extract strings from different levels)
+   *
+   * If no JSON pointer is specified then return all string in the object
+   */
+  private extractArrayStringsFromObject;
+  /**
+   * Method that takes a `json` object and an array of `pointers` as
+   * parameters and returns an array of targeted entries. It iterates over
+   * the JSON pointers and uses the `jsonpointer.get()` function to get the
+   * targeted entries from the JSON object.
+   * @param json The JSON object to get targeted entries from.
+   * @param pointers The JSON pointers to get targeted entries.
+   * @returns An array of targeted entries.
+   */
+  private getTargetedEntries;
 }
 /**
  * Class that extends the `TextLoader` class. It represents a document
@@ -44,16 +47,19 @@ export declare class JSONLoader extends TextLoader {
  * JSON Lines file or a `Blob` object, and a `pointer` parameter that
  * specifies the JSON pointer to extract.
  */
-export declare class JSONLinesLoader extends TextLoader {
-    pointer: string;
-    constructor(filePathOrBlob: string | Blob, pointer: string);
-    /**
-     * Method that takes a `raw` string as a parameter and returns a promise
-     * that resolves to an array of strings. It parses the raw JSON Lines
-     * string, splits it into lines, parses each line as JSON, and extracts
-     * the values based on the specified JSON pointer.
-     * @param raw The raw JSON Lines string to parse.
-     * @returns A promise that resolves to an array of strings.
-     */
-    protected parse(raw: string): Promise<string[]>;
+declare class JSONLinesLoader extends TextLoader {
+  pointer: string;
+  constructor(filePathOrBlob: string | Blob, pointer: string);
+  /**
+   * Method that takes a `raw` string as a parameter and returns a promise
+   * that resolves to an array of strings. It parses the raw JSON Lines
+   * string, splits it into lines, parses each line as JSON, and extracts
+   * the values based on the specified JSON pointer.
+   * @param raw The raw JSON Lines string to parse.
+   * @returns A promise that resolves to an array of strings.
+   */
+  protected parse(raw: string): Promise<string[]>;
 }
+//#endregion
+export { JSONLinesLoader, JSONLoader };
+//# sourceMappingURL=json.d.ts.map

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

@@ -0,0 +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"],"mappings":";;;;;;AAQA;;;;;AAAkD,cAA7BC,UAAAA,SAAmBD,UAAAA,CAAU;EAsC7BI,QAAAA,EAAAA,MAAAA,EAAe;EAAA,WAAA,CAAA,cAAA,EAAA,MAAA,GApCKF,IAoCL,EAAA,QAAA,CAAA,EAAA,MAAA,GAAA,MAAA,EAAA;EAAA;;;AAAmB;;;;;;gCA1BrBC;;;;;;;;;;;;;;;;;;;;;;;;;;cA0BbC,eAAAA,SAAwBJ,UAAAA;;uCAEJE;;;;;;;;;gCASPC"}

package/dist/document_loaders/fs/json.js

@@ -1,139 +1,115 @@
-import jsonpointer from "jsonpointer";
+import { __export } 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, {
+	JSONLinesLoader: () => JSONLinesLoader,
+	JSONLoader: () => JSONLoader
+});
 /**
- * Class that extends the `TextLoader` class. It represents a document
- * loader that loads documents from JSON files. It has a constructor that
- * takes a `filePathOrBlob` parameter representing the path to the JSON
- * file or a `Blob` object, and an optional `pointers` parameter that
- * specifies the JSON pointers to extract.
- */
-export class JSONLoader extends TextLoader {
-    constructor(filePathOrBlob, pointers = []) {
-        super(filePathOrBlob);
-        Object.defineProperty(this, "pointers", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.pointers = Array.isArray(pointers) ? pointers : [pointers];
-    }
-    /**
-     * Method that takes a `raw` string as a parameter and returns a promise
-     * that resolves to an array of strings. It parses the raw JSON string and
-     * extracts the values based on the specified JSON pointers. If no JSON
-     * pointers are specified, it extracts all the strings from the JSON
-     * object.
-     * @param raw The raw JSON string to parse.
-     * @returns A promise that resolves to an array of strings.
-     */
-    async parse(raw) {
-        const json = JSON.parse(raw.trim());
-        // If there is no pointers specified we extract all strings we found
-        const extractAllStrings = !(this.pointers.length > 0);
-        const compiledPointers = this.pointers.map((pointer) => jsonpointer.compile(pointer));
-        return this.extractArrayStringsFromObject(json, compiledPointers, extractAllStrings);
-    }
-    /**
-     * If JSON pointers are specified, return all strings below any of them
-     * and exclude all other nodes expect if they match a JSON pointer (to allow to extract strings from different levels)
-     *
-     * If no JSON pointer is specified then return all string in the object
-     */
-    extractArrayStringsFromObject(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    json, pointers, extractAllStrings = false, keyHasBeenFound = false) {
-        if (!json) {
-            return [];
-        }
-        if (typeof json === "string" && extractAllStrings) {
-            return [json];
-        }
-        if (Array.isArray(json) && extractAllStrings) {
-            let extractedString = [];
-            for (const element of json) {
-                extractedString = extractedString.concat(this.extractArrayStringsFromObject(element, pointers, true));
-            }
-            return extractedString;
-        }
-        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));
-            let extractedStrings = [];
-            // If we found a targeted entry, we extract all strings from it
-            if (targetedEntries.length > 0) {
-                for (const oneEntry of targetedEntries) {
-                    extractedStrings = extractedStrings.concat(this.extractArrayStringsFromObject(oneEntry, pointers, true, true));
-                }
-                for (const oneEntry of notTargetedEntries) {
-                    extractedStrings = extractedStrings.concat(this.extractArrayStringsFromObject(oneEntry, pointers, false, true));
-                }
-            }
-            else if (extractAllStrings || !keyHasBeenFound) {
-                for (const oneEntry of notTargetedEntries) {
-                    extractedStrings = extractedStrings.concat(this.extractArrayStringsFromObject(oneEntry, pointers, extractAllStrings));
-                }
-            }
-            return extractedStrings;
-        }
-        return [];
-    }
-    /**
-     * Method that takes a `json` object and an array of `pointers` as
-     * parameters and returns an array of targeted entries. It iterates over
-     * the JSON pointers and uses the `jsonpointer.get()` function to get the
-     * targeted entries from the JSON object.
-     * @param json The JSON object to get targeted entries from.
-     * @param pointers The JSON pointers to get targeted entries.
-     * @returns An array of targeted entries.
-     */
-    getTargetedEntries(json, pointers) {
-        const targetEntries = [];
-        for (const pointer of pointers) {
-            const targetedEntry = pointer.get(json);
-            if (targetedEntry) {
-                targetEntries.push(targetedEntry);
-            }
-        }
-        return targetEntries;
-    }
-}
+* Class that extends the `TextLoader` class. It represents a document
+* loader that loads documents from JSON files. It has a constructor that
+* takes a `filePathOrBlob` parameter representing the path to the JSON
+* file or a `Blob` object, and an optional `pointers` parameter that
+* specifies the JSON pointers to extract.
+*/
+var JSONLoader = class extends TextLoader {
+	pointers;
+	constructor(filePathOrBlob, pointers = []) {
+		super(filePathOrBlob);
+		this.pointers = Array.isArray(pointers) ? pointers : [pointers];
+	}
+	/**
+	* Method that takes a `raw` string as a parameter and returns a promise
+	* that resolves to an array of strings. It parses the raw JSON string and
+	* extracts the values based on the specified JSON pointers. If no JSON
+	* pointers are specified, it extracts all the strings from the JSON
+	* object.
+	* @param raw The raw JSON string to parse.
+	* @returns A promise that resolves to an array of strings.
+	*/
+	async parse(raw) {
+		const json = JSON.parse(raw.trim());
+		const extractAllStrings = !(this.pointers.length > 0);
+		const compiledPointers = this.pointers.map((pointer) => jsonpointer.compile(pointer));
+		return this.extractArrayStringsFromObject(json, compiledPointers, extractAllStrings);
+	}
+	/**
+	* If JSON pointers are specified, return all strings below any of them
+	* and exclude all other nodes expect if they match a JSON pointer (to allow to extract strings from different levels)
+	*
+	* If no JSON pointer is specified then return all string in the object
+	*/
+	extractArrayStringsFromObject(json, pointers, extractAllStrings = false, keyHasBeenFound = false) {
+		if (!json) return [];
+		if (typeof json === "string" && extractAllStrings) return [json];
+		if (Array.isArray(json) && extractAllStrings) {
+			let extractedString = [];
+			for (const element of json) extractedString = extractedString.concat(this.extractArrayStringsFromObject(element, pointers, true));
+			return extractedString;
+		}
+		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));
+			let extractedStrings = [];
+			if (targetedEntries.length > 0) {
+				for (const oneEntry of targetedEntries) extractedStrings = extractedStrings.concat(this.extractArrayStringsFromObject(oneEntry, pointers, true, true));
+				for (const oneEntry of notTargetedEntries) extractedStrings = extractedStrings.concat(this.extractArrayStringsFromObject(oneEntry, pointers, false, true));
+			} else if (extractAllStrings || !keyHasBeenFound) for (const oneEntry of notTargetedEntries) extractedStrings = extractedStrings.concat(this.extractArrayStringsFromObject(oneEntry, pointers, extractAllStrings));
+			return extractedStrings;
+		}
+		return [];
+	}
+	/**
+	* Method that takes a `json` object and an array of `pointers` as
+	* parameters and returns an array of targeted entries. It iterates over
+	* the JSON pointers and uses the `jsonpointer.get()` function to get the
+	* targeted entries from the JSON object.
+	* @param json The JSON object to get targeted entries from.
+	* @param pointers The JSON pointers to get targeted entries.
+	* @returns An array of targeted entries.
+	*/
+	getTargetedEntries(json, pointers) {
+		const targetEntries = [];
+		for (const pointer of pointers) {
+			const targetedEntry = pointer.get(json);
+			if (targetedEntry) targetEntries.push(targetedEntry);
+		}
+		return targetEntries;
+	}
+};
 /**
- * Class that extends the `TextLoader` class. It represents a document
- * loader that loads documents from JSON Lines files. It has a constructor
- * that takes a `filePathOrBlob` parameter representing the path to the
- * JSON Lines file or a `Blob` object, and a `pointer` parameter that
- * specifies the JSON pointer to extract.
- */
-export class JSONLinesLoader extends TextLoader {
-    constructor(filePathOrBlob, pointer) {
-        super(filePathOrBlob);
-        Object.defineProperty(this, "pointer", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: pointer
-        });
-    }
-    /**
-     * Method that takes a `raw` string as a parameter and returns a promise
-     * that resolves to an array of strings. It parses the raw JSON Lines
-     * string, splits it into lines, parses each line as JSON, and extracts
-     * the values based on the specified JSON pointer.
-     * @param raw The raw JSON Lines string to parse.
-     * @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 pointer = jsonpointer.compile(this.pointer);
-        return jsons.map((json) => pointer.get(json));
-    }
-}
+* Class that extends the `TextLoader` class. It represents a document
+* loader that loads documents from JSON Lines files. It has a constructor
+* that takes a `filePathOrBlob` parameter representing the path to the
+* JSON Lines file or a `Blob` object, and a `pointer` parameter that
+* specifies the JSON pointer to extract.
+*/
+var JSONLinesLoader = class extends TextLoader {
+	constructor(filePathOrBlob, pointer) {
+		super(filePathOrBlob);
+		this.pointer = pointer;
+	}
+	/**
+	* Method that takes a `raw` string as a parameter and returns a promise
+	* that resolves to an array of strings. It parses the raw JSON Lines
+	* string, splits it into lines, parses each line as JSON, and extracts
+	* the values based on the specified JSON pointer.
+	* @param raw The raw JSON Lines string to parse.
+	* @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 pointer = jsonpointer.compile(this.pointer);
+		return jsons.map((json) => pointer.get(json));
+	}
+};
+
+//#endregion
+export { JSONLinesLoader, JSONLoader, json_exports };
+//# sourceMappingURL=json.js.map

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

@@ -0,0 +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(filePathOrBlob: string | Blob, public pointer: string) {\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) => pointer.get(json));\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,YAAYJ,gBAAsCS,SAAiB;EACjE,MAAM,eAAe;EAD2B;CAEjD;;;;;;;;;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,QAAQ,IAAI,KAAK,CAAC;CAC9C;AACF"}

package/dist/document_loaders/fs/multi_file.cjs

@@ -1,98 +1,82 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiFileLoader = void 0;
-const node_path_1 = require("node:path");
-const promises_1 = require("node:fs/promises");
-const base_js_1 = require("../base.cjs");
-const directory_js_1 = require("./directory.cjs");
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_document_loaders_fs_directory = require('./directory.cjs');
+const __langchain_core_document_loaders_base = require_rolldown_runtime.__toESM(require("@langchain/core/document_loaders/base"));
+const node_path = require_rolldown_runtime.__toESM(require("node:path"));
+const node_fs_promises = require_rolldown_runtime.__toESM(require("node:fs/promises"));
+
+//#region src/document_loaders/fs/multi_file.ts
+var multi_file_exports = {};
+require_rolldown_runtime.__export(multi_file_exports, { MultiFileLoader: () => MultiFileLoader });
 /**
- * A document loader that loads documents from multiple files. It extends the
- * `BaseDocumentLoader` class and implements the `load()` method.
- * @example
- * ```typescript
- *
- * const multiFileLoader = new MultiFileLoader(
- *   ["path/to/file1.pdf", "path/to/file2.txt"],
- *   {
- *     ".pdf": (path: string) => new PDFLoader(path),
- *   },
- * );
- *
- * const docs = await multiFileLoader.load();
- * console.log({ docs });
- *
- * ```
- */
-class MultiFileLoader extends base_js_1.BaseDocumentLoader {
-    constructor(filePaths, loaders, unknown = directory_js_1.UnknownHandling.Warn) {
-        super();
-        Object.defineProperty(this, "filePaths", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: filePaths
-        });
-        Object.defineProperty(this, "loaders", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: loaders
-        });
-        Object.defineProperty(this, "unknown", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: unknown
-        });
-        if (Object.keys(loaders).length === 0) {
-            throw new Error("Must provide at least one loader");
-        }
-        for (const extension in loaders) {
-            if (Object.hasOwn(loaders, extension)) {
-                if (extension[0] !== ".") {
-                    throw new Error(`Extension must start with a dot: ${extension}`);
-                }
-            }
-        }
-    }
-    /**
-     * Loads the documents from the provided file paths. It checks if the file
-     * is a directory and ignores it. If a file is a file, it checks if there
-     * is a corresponding loader function for the file extension in the `loaders`
-     * mapping. If there is, it loads the documents. If there is no
-     * corresponding loader function and `unknown` is set to `Warn`, it logs a
-     * warning message. If `unknown` is set to `Error`, it throws an error.
-     * @returns A promise that resolves to an array of loaded documents.
-     */
-    async load() {
-        const documents = [];
-        for (const filePath of this.filePaths) {
-            const fullPath = (0, node_path_1.resolve)(filePath);
-            const fileStat = await (0, promises_1.stat)(fullPath);
-            if (fileStat.isDirectory()) {
-                console.warn(`Ignoring directory: ${fullPath}`);
-                continue;
-            }
-            const loaderFactory = this.loaders[(0, node_path_1.extname)(fullPath)];
-            if (loaderFactory) {
-                const loader = loaderFactory(fullPath);
-                documents.push(...(await loader.load()));
-            }
-            else {
-                switch (this.unknown) {
-                    case directory_js_1.UnknownHandling.Ignore:
-                        break;
-                    case directory_js_1.UnknownHandling.Warn:
-                        console.warn(`Unknown file type: ${fullPath}`);
-                        break;
-                    case directory_js_1.UnknownHandling.Error:
-                        throw new Error(`Unknown file type: ${fullPath}`);
-                    default:
-                        throw new Error(`Unknown unknown handling: ${this.unknown}`);
-                }
-            }
-        }
-        return documents;
-    }
-}
+* A document loader that loads documents from multiple files. It extends the
+* `BaseDocumentLoader` class and implements the `load()` method.
+* @example
+* ```typescript
+*
+* const multiFileLoader = new MultiFileLoader(
+*   ["path/to/file1.pdf", "path/to/file2.txt"],
+*   {
+*     ".pdf": (path: string) => new PDFLoader(path),
+*   },
+* );
+*
+* const docs = await multiFileLoader.load();
+* console.log({ docs });
+*
+* ```
+*/
+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;
+		this.loaders = loaders;
+		this.unknown = unknown;
+		if (Object.keys(loaders).length === 0) throw new Error("Must provide at least one loader");
+		for (const extension in loaders) if (Object.hasOwn(loaders, extension)) {
+			if (extension[0] !== ".") throw new Error(`Extension must start with a dot: ${extension}`);
+		}
+	}
+	/**
+	* Loads the documents from the provided file paths. It checks if the file
+	* is a directory and ignores it. If a file is a file, it checks if there
+	* is a corresponding loader function for the file extension in the `loaders`
+	* mapping. If there is, it loads the documents. If there is no
+	* corresponding loader function and `unknown` is set to `Warn`, it logs a
+	* warning message. If `unknown` is set to `Error`, it throws an error.
+	* @returns A promise that resolves to an array of loaded documents.
+	*/
+	async load() {
+		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()) {
+				console.warn(`Ignoring directory: ${fullPath}`);
+				continue;
+			}
+			const loaderFactory = this.loaders[(0, node_path.extname)(fullPath)];
+			if (loaderFactory) {
+				const loader = loaderFactory(fullPath);
+				documents.push(...await loader.load());
+			} else switch (this.unknown) {
+				case require_document_loaders_fs_directory.UnknownHandling.Ignore: break;
+				case require_document_loaders_fs_directory.UnknownHandling.Warn:
+					console.warn(`Unknown file type: ${fullPath}`);
+					break;
+				case require_document_loaders_fs_directory.UnknownHandling.Error: throw new Error(`Unknown file type: ${fullPath}`);
+				default: throw new Error(`Unknown unknown handling: ${this.unknown}`);
+			}
+		}
+		return documents;
+	}
+};
+
+//#endregion
 exports.MultiFileLoader = MultiFileLoader;
+Object.defineProperty(exports, 'multi_file_exports', {
+  enumerable: true,
+  get: function () {
+    return multi_file_exports;
+  }
+});
+//# sourceMappingURL=multi_file.cjs.map

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

@@ -0,0 +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"}