langchain 1.0.0-alpha.6 → 1.0.0-alpha.8

package/dist/document_loaders/fs/directory.cjs

@@ -1,116 +0,0 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
-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"));
-
-//#region src/document_loaders/fs/directory.ts
-var directory_exports = {};
-require_rolldown_runtime.__export(directory_exports, {
-	DirectoryLoader: () => DirectoryLoader,
-	UnknownHandling: () => UnknownHandling
-});
-const UnknownHandling = {
-	Ignore: "ignore",
-	Warn: "warn",
-	Error: "error"
-};
-/**
-* A document loader that loads documents from a directory. It extends the
-* `BaseDocumentLoader` class and implements the `load()` method.
-* @example
-* ```typescript
-*
-* const directoryLoader = new DirectoryLoader(
-*   "src/document_loaders/example_data/",
-*   {
-*     ".pdf": (path: string) => new PDFLoader(path),
-*   },
-* );
-*
-* const docs = await directoryLoader.load();
-* console.log({ docs });
-*
-* ```
-*/
-var DirectoryLoader = class DirectoryLoader extends __langchain_core_document_loaders_base.BaseDocumentLoader {
-	constructor(directoryPath, loaders, recursive = true, unknown = UnknownHandling.Warn) {
-		super();
-		this.directoryPath = directoryPath;
-		this.loaders = loaders;
-		this.recursive = recursive;
-		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 directory. If a file is a directory and
-	* `recursive` is `true`, it recursively loads documents from the
-	* subdirectory. 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 { readdir, extname, resolve } = await DirectoryLoader.imports();
-		const files = await readdir(this.directoryPath, { withFileTypes: true });
-		const documents = [];
-		for (const file of files) {
-			const fullPath = resolve(this.directoryPath, file.name);
-			if (file.isDirectory()) {
-				if (this.recursive) {
-					const loader = new DirectoryLoader(fullPath, this.loaders, this.recursive, this.unknown);
-					documents.push(...await loader.load());
-				}
-			} else {
-				const loaderFactory = this.loaders[extname(file.name)];
-				if (loaderFactory) {
-					const loader = loaderFactory(fullPath);
-					documents.push(...await loader.load());
-				} else switch (this.unknown) {
-					case UnknownHandling.Ignore: break;
-					case UnknownHandling.Warn:
-						console.warn(`Unknown file type: ${file.name}`);
-						break;
-					case UnknownHandling.Error: throw new Error(`Unknown file type: ${file.name}`);
-					default: throw new Error(`Unknown unknown handling: ${this.unknown}`);
-				}
-			}
-		}
-		return documents;
-	}
-	/**
-	* Imports the necessary functions from the `node:path` and
-	* `node:fs/promises` modules. It is used to dynamically import the
-	* functions when needed. If the import fails, it throws an error
-	* indicating that the modules failed to load.
-	* @returns A promise that resolves to an object containing the imported functions.
-	*/
-	static async imports() {
-		try {
-			const { extname, resolve } = await import("node:path");
-			const { readdir } = await import("node:fs/promises");
-			return {
-				readdir,
-				extname,
-				resolve
-			};
-		} catch (e) {
-			console.error(e);
-			throw new Error(`Failed to load fs/promises. DirectoryLoader available only on environment 'node'. It appears you are running environment '${(0, __langchain_core_utils_env.getEnv)()}'. See https://<link to docs> for alternatives.`);
-		}
-	}
-};
-
-//#endregion
-exports.DirectoryLoader = DirectoryLoader;
-exports.UnknownHandling = UnknownHandling;
-Object.defineProperty(exports, 'directory_exports', {
-  enumerable: true,
-  get: function () {
-    return directory_exports;
-  }
-});
-//# sourceMappingURL=directory.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"directory.cjs","names":["BaseDocumentLoader","directoryPath: string","loaders: LoadersMapping","recursive: boolean","unknown: UnknownHandling","documents: Document[]"],"sources":["../../../src/document_loaders/fs/directory.ts"],"sourcesContent":["import type { extname as ExtnameT, resolve as ResolveT } from \"node:path\";\nimport type { readdir as ReaddirT } 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// TypeScript enums are not tree-shakeable, so doing this instead\n// See https://bargsten.org/jsts/enums/\nexport const UnknownHandling = {\n  Ignore: \"ignore\",\n  Warn: \"warn\",\n  Error: \"error\",\n} as const;\n/**\n * An enumeration of possible handling strategies for unknown file types.\n */\nexport type UnknownHandling =\n  (typeof UnknownHandling)[keyof typeof UnknownHandling];\n\n/**\n * A mapping of file extensions to loader functions. Each loader function\n * takes a file path as a parameter and returns a `BaseDocumentLoader`\n * instance.\n */\nexport interface LoadersMapping {\n  [extension: string]: (filePath: string) => BaseDocumentLoader;\n}\n\n/**\n * A document loader that loads documents from a directory. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const directoryLoader = new DirectoryLoader(\n *   \"src/document_loaders/example_data/\",\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await directoryLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport class DirectoryLoader extends BaseDocumentLoader {\n  constructor(\n    public directoryPath: string,\n    public loaders: LoadersMapping,\n    public recursive: boolean = true,\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 directory. If a file is a directory and\n   * `recursive` is `true`, it recursively loads documents from the\n   * subdirectory. If a file is a file, it checks if there is a\n   * 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 { readdir, extname, resolve } = await DirectoryLoader.imports();\n    const files = await readdir(this.directoryPath, { withFileTypes: true });\n\n    const documents: Document[] = [];\n\n    for (const file of files) {\n      const fullPath = resolve(this.directoryPath, file.name);\n      if (file.isDirectory()) {\n        if (this.recursive) {\n          const loader = new DirectoryLoader(\n            fullPath,\n            this.loaders,\n            this.recursive,\n            this.unknown\n          );\n          documents.push(...(await loader.load()));\n        }\n      } else {\n        // I'm aware some things won't be files,\n        // but they will be caught by the \"unknown\" handling below.\n        const loaderFactory = this.loaders[extname(file.name)];\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: ${file.name}`);\n              break;\n            case UnknownHandling.Error:\n              throw new Error(`Unknown file type: ${file.name}`);\n            default:\n              throw new Error(`Unknown unknown handling: ${this.unknown}`);\n          }\n        }\n      }\n    }\n\n    return documents;\n  }\n\n  /**\n   * Imports the necessary functions from the `node:path` and\n   * `node:fs/promises` modules. It is used to dynamically import the\n   * functions when needed. If the import fails, it throws an error\n   * indicating that the modules failed to load.\n   * @returns A promise that resolves to an object containing the imported functions.\n   */\n  static async imports(): Promise<{\n    readdir: typeof ReaddirT;\n    extname: typeof ExtnameT;\n    resolve: typeof ResolveT;\n  }> {\n    try {\n      const { extname, resolve } = await import(\"node:path\");\n      const { readdir } = await import(\"node:fs/promises\");\n      return { readdir, extname, resolve };\n    } catch (e) {\n      console.error(e);\n      throw new Error(\n        `Failed to load fs/promises. DirectoryLoader 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":";;;;;;;;;;AAQA,MAAa,kBAAkB;CAC7B,QAAQ;CACR,MAAM;CACN,OAAO;AACR;;;;;;;;;;;;;;;;;;;AAkCD,IAAa,kBAAb,MAAa,wBAAwBA,0DAAmB;CACtD,YACSC,eACAC,SACAC,YAAqB,MACrBC,UAA2B,gBAAgB,MAClD;EACA,OAAO;EALA;EACA;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;;;;;;;;;;;CAYD,MAAa,OAA4B;EACvC,MAAM,EAAE,SAAS,SAAS,SAAS,GAAG,MAAM,gBAAgB,SAAS;EACrE,MAAM,QAAQ,MAAM,QAAQ,KAAK,eAAe,EAAE,eAAe,KAAM,EAAC;EAExE,MAAMC,YAAwB,CAAE;AAEhC,OAAK,MAAM,QAAQ,OAAO;GACxB,MAAM,WAAW,QAAQ,KAAK,eAAe,KAAK,KAAK;AACvD,OAAI,KAAK,aAAa,EACpB;QAAI,KAAK,WAAW;KAClB,MAAM,SAAS,IAAI,gBACjB,UACA,KAAK,SACL,KAAK,WACL,KAAK;KAEP,UAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;IACzC;UACI;IAGL,MAAM,gBAAgB,KAAK,QAAQ,QAAQ,KAAK,KAAK;AACrD,QAAI,eAAe;KACjB,MAAM,SAAS,cAAc,SAAS;KACtC,UAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;IACzC,MACC,SAAQ,KAAK,SAAb;KACE,KAAK,gBAAgB,OACnB;KACF,KAAK,gBAAgB;MACnB,QAAQ,KAAK,CAAC,mBAAmB,EAAE,KAAK,MAAM,CAAC;AAC/C;KACF,KAAK,gBAAgB,MACnB,OAAM,IAAI,MAAM,CAAC,mBAAmB,EAAE,KAAK,MAAM;KACnD,QACE,OAAM,IAAI,MAAM,CAAC,0BAA0B,EAAE,KAAK,SAAS;IAC9D;GAEJ;EACF;AAED,SAAO;CACR;;;;;;;;CASD,aAAa,UAIV;AACD,MAAI;GACF,MAAM,EAAE,SAAS,SAAS,GAAG,MAAM,OAAO;GAC1C,MAAM,EAAE,SAAS,GAAG,MAAM,OAAO;AACjC,UAAO;IAAE;IAAS;IAAS;GAAS;EACrC,SAAQ,GAAG;GACV,QAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR,CAAC,0HAA0H,0CAAU,CAAC,+CAA+C,CAAC;EAEzL;CACF;AACF"}

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

@@ -1,76 +0,0 @@
-import { Document } from "@langchain/core/documents";
-import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
-import { readdir } from "node:fs/promises";
-import { extname, resolve } from "node:path";
-
-//#region src/document_loaders/fs/directory.d.ts
-// TypeScript enums are not tree-shakeable, so doing this instead
-// See https://bargsten.org/jsts/enums/
-declare const UnknownHandling: {
-  readonly Ignore: "ignore";
-  readonly Warn: "warn";
-  readonly Error: "error";
-};
-/**
- * An enumeration of possible handling strategies for unknown file types.
- */
-type UnknownHandling = (typeof UnknownHandling)[keyof typeof UnknownHandling];
-/**
- * A mapping of file extensions to loader functions. Each loader function
- * takes a file path as a parameter and returns a `BaseDocumentLoader`
- * instance.
- */
-interface LoadersMapping {
-  [extension: string]: (filePath: string) => BaseDocumentLoader;
-}
-/**
- * A document loader that loads documents from a directory. It extends the
- * `BaseDocumentLoader` class and implements the `load()` method.
- * @example
- * ```typescript
- *
- * const directoryLoader = new DirectoryLoader(
- *   "src/document_loaders/example_data/",
- *   {
- *     ".pdf": (path: string) => new PDFLoader(path),
- *   },
- * );
- *
- * const docs = await directoryLoader.load();
- * console.log({ docs });
- *
- * ```
- */
-declare class DirectoryLoader extends BaseDocumentLoader {
-  directoryPath: string;
-  loaders: LoadersMapping;
-  recursive: boolean;
-  unknown: UnknownHandling;
-  constructor(directoryPath: string, loaders: LoadersMapping, recursive?: boolean, unknown?: UnknownHandling);
-  /**
-   * Loads the documents from the directory. If a file is a directory and
-   * `recursive` is `true`, it recursively loads documents from the
-   * subdirectory. 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.
-   */
-  load(): Promise<Document[]>;
-  /**
-   * Imports the necessary functions from the `node:path` and
-   * `node:fs/promises` modules. It is used to dynamically import the
-   * functions when needed. If the import fails, it throws an error
-   * indicating that the modules failed to load.
-   * @returns A promise that resolves to an object containing the imported functions.
-   */
-  static imports(): Promise<{
-    readdir: typeof readdir;
-    extname: typeof extname;
-    resolve: typeof resolve;
-  }>;
-}
-//#endregion
-export { DirectoryLoader, LoadersMapping, UnknownHandling };
-//# sourceMappingURL=directory.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"directory.d.cts","names":["extname","ExtnameT","resolve","ResolveT","readdir","ReaddirT","Document","BaseDocumentLoader","UnknownHandling","LoadersMapping","DirectoryLoader","Promise"],"sources":["../../../src/document_loaders/fs/directory.d.ts"],"sourcesContent":["import type { extname as ExtnameT, resolve as ResolveT } from \"node:path\";\nimport type { readdir as ReaddirT } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\n// TypeScript enums are not tree-shakeable, so doing this instead\n// See https://bargsten.org/jsts/enums/\nexport declare const UnknownHandling: {\n    readonly Ignore: \"ignore\";\n    readonly Warn: \"warn\";\n    readonly Error: \"error\";\n};\n/**\n * An enumeration of possible handling strategies for unknown file types.\n */\nexport type UnknownHandling = (typeof UnknownHandling)[keyof typeof UnknownHandling];\n/**\n * A mapping of file extensions to loader functions. Each loader function\n * takes a file path as a parameter and returns a `BaseDocumentLoader`\n * instance.\n */\nexport interface LoadersMapping {\n    [extension: string]: (filePath: string) => BaseDocumentLoader;\n}\n/**\n * A document loader that loads documents from a directory. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const directoryLoader = new DirectoryLoader(\n *   \"src/document_loaders/example_data/\",\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await directoryLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport declare class DirectoryLoader extends BaseDocumentLoader {\n    directoryPath: string;\n    loaders: LoadersMapping;\n    recursive: boolean;\n    unknown: UnknownHandling;\n    constructor(directoryPath: string, loaders: LoadersMapping, recursive?: boolean, unknown?: UnknownHandling);\n    /**\n     * Loads the documents from the directory. If a file is a directory and\n     * `recursive` is `true`, it recursively loads documents from the\n     * subdirectory. If a file is a file, it checks if there is a\n     * 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     * Imports the necessary functions from the `node:path` and\n     * `node:fs/promises` modules. It is used to dynamically import the\n     * functions when needed. If the import fails, it throws an error\n     * indicating that the modules failed to load.\n     * @returns A promise that resolves to an object containing the imported functions.\n     */\n    static imports(): Promise<{\n        readdir: typeof ReaddirT;\n        extname: typeof ExtnameT;\n        resolve: typeof ResolveT;\n    }>;\n}\n"],"mappings":";;;;;;;;AAMqBQ,cAAAA,eAIpB,EAAA;EAIWA,SAAAA,MAAAA,EAAAA,QAAe;EAAA,SAAA,IAAA,EAAA,MAAA;EAAA,SAAWA,KAAAA,EAAAA,OAAAA;CAAe;AAA8B;AAMnF;AAqBA;AAAoC,KA3BxBA,eAAAA,GA2BwB,CAAA,OA3BEA,eA2BF,CAAA,CAAA,MAAA,OA3BgCA,eA2BhC,CAAA;;;;;;AAgBxBG,UArCKF,cAAAA,CAqCLE;EAAO,CAAA,SASKN,EAAAA,MAAAA,CAAAA,EAAAA,CAAAA,QAAAA,EAAAA,MAAAA,EAAAA,GA7CuBE,kBA6CvBF;;;;;AAzBuC;;;;;;;;;;;;;;;cAA1CK,eAAAA,SAAwBH,kBAAAA;;WAEhCE;;WAEAD;8CACmCC,+CAA+CD;;;;;;;;;;;UAWnFG,QAAQL;;;;;;;;oBAQEK;oBACEN;oBACAJ;oBACAE"}

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

@@ -1,76 +0,0 @@
-import { Document } from "@langchain/core/documents";
-import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
-import { extname, resolve } from "node:path";
-import { readdir } from "node:fs/promises";
-
-//#region src/document_loaders/fs/directory.d.ts
-// TypeScript enums are not tree-shakeable, so doing this instead
-// See https://bargsten.org/jsts/enums/
-declare const UnknownHandling: {
-  readonly Ignore: "ignore";
-  readonly Warn: "warn";
-  readonly Error: "error";
-};
-/**
- * An enumeration of possible handling strategies for unknown file types.
- */
-type UnknownHandling = (typeof UnknownHandling)[keyof typeof UnknownHandling];
-/**
- * A mapping of file extensions to loader functions. Each loader function
- * takes a file path as a parameter and returns a `BaseDocumentLoader`
- * instance.
- */
-interface LoadersMapping {
-  [extension: string]: (filePath: string) => BaseDocumentLoader;
-}
-/**
- * A document loader that loads documents from a directory. It extends the
- * `BaseDocumentLoader` class and implements the `load()` method.
- * @example
- * ```typescript
- *
- * const directoryLoader = new DirectoryLoader(
- *   "src/document_loaders/example_data/",
- *   {
- *     ".pdf": (path: string) => new PDFLoader(path),
- *   },
- * );
- *
- * const docs = await directoryLoader.load();
- * console.log({ docs });
- *
- * ```
- */
-declare class DirectoryLoader extends BaseDocumentLoader {
-  directoryPath: string;
-  loaders: LoadersMapping;
-  recursive: boolean;
-  unknown: UnknownHandling;
-  constructor(directoryPath: string, loaders: LoadersMapping, recursive?: boolean, unknown?: UnknownHandling);
-  /**
-   * Loads the documents from the directory. If a file is a directory and
-   * `recursive` is `true`, it recursively loads documents from the
-   * subdirectory. 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.
-   */
-  load(): Promise<Document[]>;
-  /**
-   * Imports the necessary functions from the `node:path` and
-   * `node:fs/promises` modules. It is used to dynamically import the
-   * functions when needed. If the import fails, it throws an error
-   * indicating that the modules failed to load.
-   * @returns A promise that resolves to an object containing the imported functions.
-   */
-  static imports(): Promise<{
-    readdir: typeof readdir;
-    extname: typeof extname;
-    resolve: typeof resolve;
-  }>;
-}
-//#endregion
-export { DirectoryLoader, LoadersMapping, UnknownHandling };
-//# sourceMappingURL=directory.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"directory.d.ts","names":["extname","ExtnameT","resolve","ResolveT","readdir","ReaddirT","Document","BaseDocumentLoader","UnknownHandling","LoadersMapping","DirectoryLoader","Promise"],"sources":["../../../src/document_loaders/fs/directory.d.ts"],"sourcesContent":["import type { extname as ExtnameT, resolve as ResolveT } from \"node:path\";\nimport type { readdir as ReaddirT } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\n// TypeScript enums are not tree-shakeable, so doing this instead\n// See https://bargsten.org/jsts/enums/\nexport declare const UnknownHandling: {\n    readonly Ignore: \"ignore\";\n    readonly Warn: \"warn\";\n    readonly Error: \"error\";\n};\n/**\n * An enumeration of possible handling strategies for unknown file types.\n */\nexport type UnknownHandling = (typeof UnknownHandling)[keyof typeof UnknownHandling];\n/**\n * A mapping of file extensions to loader functions. Each loader function\n * takes a file path as a parameter and returns a `BaseDocumentLoader`\n * instance.\n */\nexport interface LoadersMapping {\n    [extension: string]: (filePath: string) => BaseDocumentLoader;\n}\n/**\n * A document loader that loads documents from a directory. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const directoryLoader = new DirectoryLoader(\n *   \"src/document_loaders/example_data/\",\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await directoryLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport declare class DirectoryLoader extends BaseDocumentLoader {\n    directoryPath: string;\n    loaders: LoadersMapping;\n    recursive: boolean;\n    unknown: UnknownHandling;\n    constructor(directoryPath: string, loaders: LoadersMapping, recursive?: boolean, unknown?: UnknownHandling);\n    /**\n     * Loads the documents from the directory. If a file is a directory and\n     * `recursive` is `true`, it recursively loads documents from the\n     * subdirectory. If a file is a file, it checks if there is a\n     * 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     * Imports the necessary functions from the `node:path` and\n     * `node:fs/promises` modules. It is used to dynamically import the\n     * functions when needed. If the import fails, it throws an error\n     * indicating that the modules failed to load.\n     * @returns A promise that resolves to an object containing the imported functions.\n     */\n    static imports(): Promise<{\n        readdir: typeof ReaddirT;\n        extname: typeof ExtnameT;\n        resolve: typeof ResolveT;\n    }>;\n}\n"],"mappings":";;;;;;;;AAMqBQ,cAAAA,eAIpB,EAAA;EAIWA,SAAAA,MAAAA,EAAAA,QAAe;EAAA,SAAA,IAAA,EAAA,MAAA;EAAA,SAAWA,KAAAA,EAAAA,OAAAA;CAAe;AAA8B;AAMnF;AAqBA;AAAoC,KA3BxBA,eAAAA,GA2BwB,CAAA,OA3BEA,eA2BF,CAAA,CAAA,MAAA,OA3BgCA,eA2BhC,CAAA;;;;;;AAgBxBG,UArCKF,cAAAA,CAqCLE;EAAO,CAAA,SASKN,EAAAA,MAAAA,CAAAA,EAAAA,CAAAA,QAAAA,EAAAA,MAAAA,EAAAA,GA7CuBE,kBA6CvBF;;;;;AAzBuC;;;;;;;;;;;;;;;cAA1CK,eAAAA,SAAwBH,kBAAAA;;WAEhCE;;WAEAD;8CACmCC,+CAA+CD;;;;;;;;;;;UAWnFG,QAAQL;;;;;;;;oBAQEK;oBACEN;oBACAJ;oBACAE"}

package/dist/document_loaders/fs/directory.js

@@ -1,109 +0,0 @@
-import { __export } from "../../_virtual/rolldown_runtime.js";
-import { getEnv } from "@langchain/core/utils/env";
-import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
-
-//#region src/document_loaders/fs/directory.ts
-var directory_exports = {};
-__export(directory_exports, {
-	DirectoryLoader: () => DirectoryLoader,
-	UnknownHandling: () => UnknownHandling
-});
-const UnknownHandling = {
-	Ignore: "ignore",
-	Warn: "warn",
-	Error: "error"
-};
-/**
-* A document loader that loads documents from a directory. It extends the
-* `BaseDocumentLoader` class and implements the `load()` method.
-* @example
-* ```typescript
-*
-* const directoryLoader = new DirectoryLoader(
-*   "src/document_loaders/example_data/",
-*   {
-*     ".pdf": (path: string) => new PDFLoader(path),
-*   },
-* );
-*
-* const docs = await directoryLoader.load();
-* console.log({ docs });
-*
-* ```
-*/
-var DirectoryLoader = class DirectoryLoader extends BaseDocumentLoader {
-	constructor(directoryPath, loaders, recursive = true, unknown = UnknownHandling.Warn) {
-		super();
-		this.directoryPath = directoryPath;
-		this.loaders = loaders;
-		this.recursive = recursive;
-		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 directory. If a file is a directory and
-	* `recursive` is `true`, it recursively loads documents from the
-	* subdirectory. 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 { readdir, extname, resolve } = await DirectoryLoader.imports();
-		const files = await readdir(this.directoryPath, { withFileTypes: true });
-		const documents = [];
-		for (const file of files) {
-			const fullPath = resolve(this.directoryPath, file.name);
-			if (file.isDirectory()) {
-				if (this.recursive) {
-					const loader = new DirectoryLoader(fullPath, this.loaders, this.recursive, this.unknown);
-					documents.push(...await loader.load());
-				}
-			} else {
-				const loaderFactory = this.loaders[extname(file.name)];
-				if (loaderFactory) {
-					const loader = loaderFactory(fullPath);
-					documents.push(...await loader.load());
-				} else switch (this.unknown) {
-					case UnknownHandling.Ignore: break;
-					case UnknownHandling.Warn:
-						console.warn(`Unknown file type: ${file.name}`);
-						break;
-					case UnknownHandling.Error: throw new Error(`Unknown file type: ${file.name}`);
-					default: throw new Error(`Unknown unknown handling: ${this.unknown}`);
-				}
-			}
-		}
-		return documents;
-	}
-	/**
-	* Imports the necessary functions from the `node:path` and
-	* `node:fs/promises` modules. It is used to dynamically import the
-	* functions when needed. If the import fails, it throws an error
-	* indicating that the modules failed to load.
-	* @returns A promise that resolves to an object containing the imported functions.
-	*/
-	static async imports() {
-		try {
-			const { extname, resolve } = await import("node:path");
-			const { readdir } = await import("node:fs/promises");
-			return {
-				readdir,
-				extname,
-				resolve
-			};
-		} catch (e) {
-			console.error(e);
-			throw new Error(`Failed to load fs/promises. DirectoryLoader available only on environment 'node'. It appears you are running environment '${getEnv()}'. See https://<link to docs> for alternatives.`);
-		}
-	}
-};
-
-//#endregion
-export { DirectoryLoader, UnknownHandling, directory_exports };
-//# sourceMappingURL=directory.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"directory.js","names":["directoryPath: string","loaders: LoadersMapping","recursive: boolean","unknown: UnknownHandling","documents: Document[]"],"sources":["../../../src/document_loaders/fs/directory.ts"],"sourcesContent":["import type { extname as ExtnameT, resolve as ResolveT } from \"node:path\";\nimport type { readdir as ReaddirT } 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// TypeScript enums are not tree-shakeable, so doing this instead\n// See https://bargsten.org/jsts/enums/\nexport const UnknownHandling = {\n  Ignore: \"ignore\",\n  Warn: \"warn\",\n  Error: \"error\",\n} as const;\n/**\n * An enumeration of possible handling strategies for unknown file types.\n */\nexport type UnknownHandling =\n  (typeof UnknownHandling)[keyof typeof UnknownHandling];\n\n/**\n * A mapping of file extensions to loader functions. Each loader function\n * takes a file path as a parameter and returns a `BaseDocumentLoader`\n * instance.\n */\nexport interface LoadersMapping {\n  [extension: string]: (filePath: string) => BaseDocumentLoader;\n}\n\n/**\n * A document loader that loads documents from a directory. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const directoryLoader = new DirectoryLoader(\n *   \"src/document_loaders/example_data/\",\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await directoryLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport class DirectoryLoader extends BaseDocumentLoader {\n  constructor(\n    public directoryPath: string,\n    public loaders: LoadersMapping,\n    public recursive: boolean = true,\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 directory. If a file is a directory and\n   * `recursive` is `true`, it recursively loads documents from the\n   * subdirectory. If a file is a file, it checks if there is a\n   * 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 { readdir, extname, resolve } = await DirectoryLoader.imports();\n    const files = await readdir(this.directoryPath, { withFileTypes: true });\n\n    const documents: Document[] = [];\n\n    for (const file of files) {\n      const fullPath = resolve(this.directoryPath, file.name);\n      if (file.isDirectory()) {\n        if (this.recursive) {\n          const loader = new DirectoryLoader(\n            fullPath,\n            this.loaders,\n            this.recursive,\n            this.unknown\n          );\n          documents.push(...(await loader.load()));\n        }\n      } else {\n        // I'm aware some things won't be files,\n        // but they will be caught by the \"unknown\" handling below.\n        const loaderFactory = this.loaders[extname(file.name)];\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: ${file.name}`);\n              break;\n            case UnknownHandling.Error:\n              throw new Error(`Unknown file type: ${file.name}`);\n            default:\n              throw new Error(`Unknown unknown handling: ${this.unknown}`);\n          }\n        }\n      }\n    }\n\n    return documents;\n  }\n\n  /**\n   * Imports the necessary functions from the `node:path` and\n   * `node:fs/promises` modules. It is used to dynamically import the\n   * functions when needed. If the import fails, it throws an error\n   * indicating that the modules failed to load.\n   * @returns A promise that resolves to an object containing the imported functions.\n   */\n  static async imports(): Promise<{\n    readdir: typeof ReaddirT;\n    extname: typeof ExtnameT;\n    resolve: typeof ResolveT;\n  }> {\n    try {\n      const { extname, resolve } = await import(\"node:path\");\n      const { readdir } = await import(\"node:fs/promises\");\n      return { readdir, extname, resolve };\n    } catch (e) {\n      console.error(e);\n      throw new Error(\n        `Failed to load fs/promises. DirectoryLoader 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":";;;;;;;;;;AAQA,MAAa,kBAAkB;CAC7B,QAAQ;CACR,MAAM;CACN,OAAO;AACR;;;;;;;;;;;;;;;;;;;AAkCD,IAAa,kBAAb,MAAa,wBAAwB,mBAAmB;CACtD,YACSA,eACAC,SACAC,YAAqB,MACrBC,UAA2B,gBAAgB,MAClD;EACA,OAAO;EALA;EACA;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;;;;;;;;;;;CAYD,MAAa,OAA4B;EACvC,MAAM,EAAE,SAAS,SAAS,SAAS,GAAG,MAAM,gBAAgB,SAAS;EACrE,MAAM,QAAQ,MAAM,QAAQ,KAAK,eAAe,EAAE,eAAe,KAAM,EAAC;EAExE,MAAMC,YAAwB,CAAE;AAEhC,OAAK,MAAM,QAAQ,OAAO;GACxB,MAAM,WAAW,QAAQ,KAAK,eAAe,KAAK,KAAK;AACvD,OAAI,KAAK,aAAa,EACpB;QAAI,KAAK,WAAW;KAClB,MAAM,SAAS,IAAI,gBACjB,UACA,KAAK,SACL,KAAK,WACL,KAAK;KAEP,UAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;IACzC;UACI;IAGL,MAAM,gBAAgB,KAAK,QAAQ,QAAQ,KAAK,KAAK;AACrD,QAAI,eAAe;KACjB,MAAM,SAAS,cAAc,SAAS;KACtC,UAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;IACzC,MACC,SAAQ,KAAK,SAAb;KACE,KAAK,gBAAgB,OACnB;KACF,KAAK,gBAAgB;MACnB,QAAQ,KAAK,CAAC,mBAAmB,EAAE,KAAK,MAAM,CAAC;AAC/C;KACF,KAAK,gBAAgB,MACnB,OAAM,IAAI,MAAM,CAAC,mBAAmB,EAAE,KAAK,MAAM;KACnD,QACE,OAAM,IAAI,MAAM,CAAC,0BAA0B,EAAE,KAAK,SAAS;IAC9D;GAEJ;EACF;AAED,SAAO;CACR;;;;;;;;CASD,aAAa,UAIV;AACD,MAAI;GACF,MAAM,EAAE,SAAS,SAAS,GAAG,MAAM,OAAO;GAC1C,MAAM,EAAE,SAAS,GAAG,MAAM,OAAO;AACjC,UAAO;IAAE;IAAS;IAAS;GAAS;EACrC,SAAQ,GAAG;GACV,QAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR,CAAC,0HAA0H,EAAE,QAAQ,CAAC,+CAA+C,CAAC;EAEzL;CACF;AACF"}

package/dist/document_loaders/fs/json.cjs

@@ -1,128 +0,0 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
-const require_document_loaders_fs_text = require('./text.cjs');
-const jsonpointer = require_rolldown_runtime.__toESM(require("jsonpointer"));
-
-//#region src/document_loaders/fs/json.ts
-var json_exports = {};
-require_rolldown_runtime.__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.
-*/
-var JSONLoader = class extends require_document_loaders_fs_text.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.default.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.
-*/
-var JSONLinesLoader = class extends require_document_loaders_fs_text.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.default.compile(this.pointer);
-		return jsons.map((json) => {
-			const data = pointer.get(json);
-			if (typeof data === "string") return data;
-			if (!data) return "";
-			if (typeof data === "object") return JSON.stringify(data);
-			return "";
-		});
-	}
-};
-
-//#endregion
-exports.JSONLinesLoader = JSONLinesLoader;
-exports.JSONLoader = JSONLoader;
-Object.defineProperty(exports, 'json_exports', {
-  enumerable: true,
-  get: function () {
-    return json_exports;
-  }
-});
-//# sourceMappingURL=json.cjs.map

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

@@ -1 +0,0 @@
-{"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(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) => {\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,YAAYC,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,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"}

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

@@ -1,65 +0,0 @@
-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
- * 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.
- */
-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
- * 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.
- */
-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.cts.map

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

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