@langchain/classic 1.0.0-alpha.1

package/dist/document.js

@@ -0,0 +1,10 @@
+import { __export } from "./_virtual/rolldown_runtime.js";
+import { Document } from "@langchain/core/documents";
+
+//#region src/document.ts
+var document_exports = {};
+__export(document_exports, { Document: () => Document });
+
+//#endregion
+export { Document, document_exports };
+//# sourceMappingURL=document.js.map

package/dist/document.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.js","names":[],"sources":["../src/document.ts"],"sourcesContent":["export { type DocumentInput, Document } from \"@langchain/core/documents\";\n"],"mappings":""}

package/dist/document_loaders/base.cjs

@@ -0,0 +1,22 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+
+//#region src/document_loaders/base.ts
+var base_exports = {};
+require_rolldown_runtime.__reExport(base_exports, require("@langchain/core/document_loaders/base"));
+
+//#endregion
+Object.defineProperty(exports, 'base_exports', {
+  enumerable: true,
+  get: function () {
+    return base_exports;
+  }
+});
+var __langchain_core_document_loaders_base = require("@langchain/core/document_loaders/base");
+Object.keys(__langchain_core_document_loaders_base).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return __langchain_core_document_loaders_base[k]; }
+  });
+});
+
+//# sourceMappingURL=base.cjs.map

package/dist/document_loaders/base.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.cjs","names":[],"sources":["../../src/document_loaders/base.ts"],"sourcesContent":["export * from \"@langchain/core/document_loaders/base\";\n"],"mappings":""}

package/dist/document_loaders/base.d.cts

@@ -0,0 +1 @@
+export * from "@langchain/core/document_loaders/base";

package/dist/document_loaders/base.d.ts

@@ -0,0 +1 @@
+export * from "@langchain/core/document_loaders/base";

package/dist/document_loaders/base.js

@@ -0,0 +1,12 @@
+import { __reExport } from "../_virtual/rolldown_runtime.js";
+
+export * from "@langchain/core/document_loaders/base"
+
+//#region src/document_loaders/base.ts
+var base_exports = {};
+import * as import___langchain_core_document_loaders_base from "@langchain/core/document_loaders/base";
+__reExport(base_exports, import___langchain_core_document_loaders_base);
+
+//#endregion
+export { base_exports };
+//# sourceMappingURL=base.js.map

package/dist/document_loaders/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","names":[],"sources":["../../src/document_loaders/base.ts"],"sourcesContent":["export * from \"@langchain/core/document_loaders/base\";\n"],"mappings":""}

package/dist/document_loaders/fs/buffer.cjs

@@ -0,0 +1,69 @@
+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/buffer.ts
+var buffer_exports = {};
+require_rolldown_runtime.__export(buffer_exports, { BufferLoader: () => BufferLoader });
+/**
+* Abstract class that extends the `BaseDocumentLoader` class. It
+* represents a document loader that loads documents from a buffer. The
+* `load()` method is implemented to read the buffer contents and metadata
+* based on the type of `filePathOrBlob`, and then calls the `parse()`
+* method to parse the buffer and return the documents.
+*/
+var BufferLoader = class BufferLoader extends __langchain_core_document_loaders_base.BaseDocumentLoader {
+	constructor(filePathOrBlob) {
+		super();
+		this.filePathOrBlob = filePathOrBlob;
+	}
+	/**
+	* Method that reads the buffer contents and metadata based on the type of
+	* `filePathOrBlob`, and then calls the `parse()` method to parse the
+	* buffer and return the documents.
+	* @returns Promise that resolves with an array of `Document` objects.
+	*/
+	async load() {
+		let buffer;
+		let metadata;
+		if (typeof this.filePathOrBlob === "string") {
+			const { readFile } = await BufferLoader.imports();
+			buffer = await readFile(this.filePathOrBlob);
+			metadata = { source: this.filePathOrBlob };
+		} else {
+			buffer = await this.filePathOrBlob.arrayBuffer().then((ab) => Buffer.from(ab));
+			metadata = {
+				source: "blob",
+				blobType: this.filePathOrBlob.type
+			};
+		}
+		return this.parse(buffer, metadata);
+	}
+	/**
+	* Static method that imports the `readFile` function from the
+	* `fs/promises` module in Node.js. It is used to dynamically import the
+	* function when needed. If the import fails, it throws an error
+	* indicating that the `fs/promises` module is not available in the
+	* current environment.
+	* @returns Promise that resolves with an object containing the `readFile` function.
+	*/
+	static async imports() {
+		try {
+			const { readFile } = await import("node:fs/promises");
+			return { readFile };
+		} catch (e) {
+			console.error(e);
+			throw new Error(`Failed to load fs/promises. TextLoader available only on environment 'node'. It appears you are running environment '${(0, __langchain_core_utils_env.getEnv)()}'. See https://<link to docs> for alternatives.`);
+		}
+	}
+};
+
+//#endregion
+exports.BufferLoader = BufferLoader;
+Object.defineProperty(exports, 'buffer_exports', {
+  enumerable: true,
+  get: function () {
+    return buffer_exports;
+  }
+});
+//# sourceMappingURL=buffer.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.cjs","names":["BaseDocumentLoader","filePathOrBlob: string | Blob","buffer: Buffer","metadata: Record<string, string>"],"sources":["../../../src/document_loaders/fs/buffer.ts"],"sourcesContent":["import type { readFile as ReadFileT } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { getEnv } from \"@langchain/core/utils/env\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\n\n/**\n * Abstract class that extends the `BaseDocumentLoader` class. It\n * represents a document loader that loads documents from a buffer. The\n * `load()` method is implemented to read the buffer contents and metadata\n * based on the type of `filePathOrBlob`, and then calls the `parse()`\n * method to parse the buffer and return the documents.\n */\nexport abstract class BufferLoader extends BaseDocumentLoader {\n  constructor(public filePathOrBlob: string | Blob) {\n    super();\n  }\n\n  /**\n   * Abstract method that needs to be implemented by subclasses. It is used\n   * to parse the buffer and return the documents.\n   * @param raw The buffer to be parsed.\n   * @param metadata Metadata of the document.\n   * @returns Promise that resolves with an array of `Document` objects.\n   */\n  protected abstract parse(\n    raw: Buffer,\n    metadata: Document[\"metadata\"]\n  ): Promise<Document[]>;\n\n  /**\n   * Method that reads the buffer contents and metadata based on the type of\n   * `filePathOrBlob`, and then calls the `parse()` method to parse the\n   * buffer and return the documents.\n   * @returns Promise that resolves with an array of `Document` objects.\n   */\n  public async load(): Promise<Document[]> {\n    let buffer: Buffer;\n    let metadata: Record<string, string>;\n    if (typeof this.filePathOrBlob === \"string\") {\n      const { readFile } = await BufferLoader.imports();\n      buffer = await readFile(this.filePathOrBlob);\n      metadata = { source: this.filePathOrBlob };\n    } else {\n      buffer = await this.filePathOrBlob\n        .arrayBuffer()\n        .then((ab) => Buffer.from(ab));\n      metadata = { source: \"blob\", blobType: this.filePathOrBlob.type };\n    }\n    return this.parse(buffer, metadata);\n  }\n\n  /**\n   * Static method that imports the `readFile` function from the\n   * `fs/promises` module in Node.js. It is used to dynamically import the\n   * function when needed. If the import fails, it throws an error\n   * indicating that the `fs/promises` module is not available in the\n   * current environment.\n   * @returns Promise that resolves with an object containing the `readFile` function.\n   */\n  static async imports(): Promise<{\n    readFile: typeof ReadFileT;\n  }> {\n    try {\n      const { readFile } = await import(\"node:fs/promises\");\n      return { readFile };\n    } catch (e) {\n      console.error(e);\n      throw new Error(\n        `Failed to load fs/promises. TextLoader available only on environment 'node'. It appears you are running environment '${getEnv()}'. See https://<link to docs> for alternatives.`\n      );\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAYA,IAAsB,eAAtB,MAAsB,qBAAqBA,0DAAmB;CAC5D,YAAmBC,gBAA+B;EAChD,OAAO;EADU;CAElB;;;;;;;CAoBD,MAAa,OAA4B;EACvC,IAAIC;EACJ,IAAIC;AACJ,MAAI,OAAO,KAAK,mBAAmB,UAAU;GAC3C,MAAM,EAAE,UAAU,GAAG,MAAM,aAAa,SAAS;GACjD,SAAS,MAAM,SAAS,KAAK,eAAe;GAC5C,WAAW,EAAE,QAAQ,KAAK,eAAgB;EAC3C,OAAM;GACL,SAAS,MAAM,KAAK,eACjB,aAAa,CACb,KAAK,CAAC,OAAO,OAAO,KAAK,GAAG,CAAC;GAChC,WAAW;IAAE,QAAQ;IAAQ,UAAU,KAAK,eAAe;GAAM;EAClE;AACD,SAAO,KAAK,MAAM,QAAQ,SAAS;CACpC;;;;;;;;;CAUD,aAAa,UAEV;AACD,MAAI;GACF,MAAM,EAAE,UAAU,GAAG,MAAM,OAAO;AAClC,UAAO,EAAE,SAAU;EACpB,SAAQ,GAAG;GACV,QAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR,CAAC,qHAAqH,0CAAU,CAAC,+CAA+C,CAAC;EAEpL;CACF;AACF"}

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

@@ -0,0 +1,46 @@
+import { Document } from "@langchain/core/documents";
+import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
+import { readFile } from "node:fs/promises";
+
+//#region src/document_loaders/fs/buffer.d.ts
+
+/**
+ * Abstract class that extends the `BaseDocumentLoader` class. It
+ * represents a document loader that loads documents from a buffer. The
+ * `load()` method is implemented to read the buffer contents and metadata
+ * based on the type of `filePathOrBlob`, and then calls the `parse()`
+ * method to parse the buffer and return the documents.
+ */
+declare abstract class BufferLoader extends BaseDocumentLoader {
+  filePathOrBlob: string | Blob;
+  constructor(filePathOrBlob: string | Blob);
+  /**
+   * Abstract method that needs to be implemented by subclasses. It is used
+   * to parse the buffer and return the documents.
+   * @param raw The buffer to be parsed.
+   * @param metadata Metadata of the document.
+   * @returns Promise that resolves with an array of `Document` objects.
+   */
+  protected abstract parse(raw: Buffer, metadata: Document["metadata"]): Promise<Document[]>;
+  /**
+   * Method that reads the buffer contents and metadata based on the type of
+   * `filePathOrBlob`, and then calls the `parse()` method to parse the
+   * buffer and return the documents.
+   * @returns Promise that resolves with an array of `Document` objects.
+   */
+  load(): Promise<Document[]>;
+  /**
+   * Static method that imports the `readFile` function from the
+   * `fs/promises` module in Node.js. It is used to dynamically import the
+   * function when needed. If the import fails, it throws an error
+   * indicating that the `fs/promises` module is not available in the
+   * current environment.
+   * @returns Promise that resolves with an object containing the `readFile` function.
+   */
+  static imports(): Promise<{
+    readFile: typeof readFile;
+  }>;
+}
+//#endregion
+export { BufferLoader };
+//# sourceMappingURL=buffer.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.d.cts","names":["readFile","ReadFileT","Document","BaseDocumentLoader","BufferLoader","Blob","Buffer","Promise"],"sources":["../../../src/document_loaders/fs/buffer.d.ts"],"sourcesContent":["import type { readFile as ReadFileT } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\n/**\n * Abstract class that extends the `BaseDocumentLoader` class. It\n * represents a document loader that loads documents from a buffer. The\n * `load()` method is implemented to read the buffer contents and metadata\n * based on the type of `filePathOrBlob`, and then calls the `parse()`\n * method to parse the buffer and return the documents.\n */\nexport declare abstract class BufferLoader extends BaseDocumentLoader {\n    filePathOrBlob: string | Blob;\n    constructor(filePathOrBlob: string | Blob);\n    /**\n     * Abstract method that needs to be implemented by subclasses. It is used\n     * to parse the buffer and return the documents.\n     * @param raw The buffer to be parsed.\n     * @param metadata Metadata of the document.\n     * @returns Promise that resolves with an array of `Document` objects.\n     */\n    protected abstract parse(raw: Buffer, metadata: Document[\"metadata\"]): Promise<Document[]>;\n    /**\n     * Method that reads the buffer contents and metadata based on the type of\n     * `filePathOrBlob`, and then calls the `parse()` method to parse the\n     * buffer and return the documents.\n     * @returns Promise that resolves with an array of `Document` objects.\n     */\n    load(): Promise<Document[]>;\n    /**\n     * Static method that imports the `readFile` function from the\n     * `fs/promises` module in Node.js. It is used to dynamically import the\n     * function when needed. If the import fails, it throws an error\n     * indicating that the `fs/promises` module is not available in the\n     * current environment.\n     * @returns Promise that resolves with an object containing the `readFile` function.\n     */\n    static imports(): Promise<{\n        readFile: typeof ReadFileT;\n    }>;\n}\n"],"mappings":";;;;;;;;AAUA;;;;;AAUoDE,uBAVtBE,YAAAA,SAAqBD,kBAAAA,CAUCD;EAAQ,cAAuBA,EAAAA,MAAAA,GATtDG,IASsDH;EAAQ,WAAhBK,CAAAA,cAAAA,EAAAA,MAAAA,GARlCF,IAQkCE;EAAO;;;;;AAVb;;gCAUnCD,kBAAkBJ,uBAAuBK,QAAQL;;;;;;;UAOvEK,QAAQL;;;;;;;;;oBASEK;qBACGN"}

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

@@ -0,0 +1,46 @@
+import { Document } from "@langchain/core/documents";
+import { readFile } from "node:fs/promises";
+import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
+
+//#region src/document_loaders/fs/buffer.d.ts
+
+/**
+ * Abstract class that extends the `BaseDocumentLoader` class. It
+ * represents a document loader that loads documents from a buffer. The
+ * `load()` method is implemented to read the buffer contents and metadata
+ * based on the type of `filePathOrBlob`, and then calls the `parse()`
+ * method to parse the buffer and return the documents.
+ */
+declare abstract class BufferLoader extends BaseDocumentLoader {
+  filePathOrBlob: string | Blob;
+  constructor(filePathOrBlob: string | Blob);
+  /**
+   * Abstract method that needs to be implemented by subclasses. It is used
+   * to parse the buffer and return the documents.
+   * @param raw The buffer to be parsed.
+   * @param metadata Metadata of the document.
+   * @returns Promise that resolves with an array of `Document` objects.
+   */
+  protected abstract parse(raw: Buffer, metadata: Document["metadata"]): Promise<Document[]>;
+  /**
+   * Method that reads the buffer contents and metadata based on the type of
+   * `filePathOrBlob`, and then calls the `parse()` method to parse the
+   * buffer and return the documents.
+   * @returns Promise that resolves with an array of `Document` objects.
+   */
+  load(): Promise<Document[]>;
+  /**
+   * Static method that imports the `readFile` function from the
+   * `fs/promises` module in Node.js. It is used to dynamically import the
+   * function when needed. If the import fails, it throws an error
+   * indicating that the `fs/promises` module is not available in the
+   * current environment.
+   * @returns Promise that resolves with an object containing the `readFile` function.
+   */
+  static imports(): Promise<{
+    readFile: typeof readFile;
+  }>;
+}
+//#endregion
+export { BufferLoader };
+//# sourceMappingURL=buffer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.d.ts","names":["readFile","ReadFileT","Document","BaseDocumentLoader","BufferLoader","Blob","Buffer","Promise"],"sources":["../../../src/document_loaders/fs/buffer.d.ts"],"sourcesContent":["import type { readFile as ReadFileT } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\n/**\n * Abstract class that extends the `BaseDocumentLoader` class. It\n * represents a document loader that loads documents from a buffer. The\n * `load()` method is implemented to read the buffer contents and metadata\n * based on the type of `filePathOrBlob`, and then calls the `parse()`\n * method to parse the buffer and return the documents.\n */\nexport declare abstract class BufferLoader extends BaseDocumentLoader {\n    filePathOrBlob: string | Blob;\n    constructor(filePathOrBlob: string | Blob);\n    /**\n     * Abstract method that needs to be implemented by subclasses. It is used\n     * to parse the buffer and return the documents.\n     * @param raw The buffer to be parsed.\n     * @param metadata Metadata of the document.\n     * @returns Promise that resolves with an array of `Document` objects.\n     */\n    protected abstract parse(raw: Buffer, metadata: Document[\"metadata\"]): Promise<Document[]>;\n    /**\n     * Method that reads the buffer contents and metadata based on the type of\n     * `filePathOrBlob`, and then calls the `parse()` method to parse the\n     * buffer and return the documents.\n     * @returns Promise that resolves with an array of `Document` objects.\n     */\n    load(): Promise<Document[]>;\n    /**\n     * Static method that imports the `readFile` function from the\n     * `fs/promises` module in Node.js. It is used to dynamically import the\n     * function when needed. If the import fails, it throws an error\n     * indicating that the `fs/promises` module is not available in the\n     * current environment.\n     * @returns Promise that resolves with an object containing the `readFile` function.\n     */\n    static imports(): Promise<{\n        readFile: typeof ReadFileT;\n    }>;\n}\n"],"mappings":";;;;;;;;AAUA;;;;;AAUoDE,uBAVtBE,YAAAA,SAAqBD,kBAAAA,CAUCD;EAAQ,cAAuBA,EAAAA,MAAAA,GATtDG,IASsDH;EAAQ,WAAhBK,CAAAA,cAAAA,EAAAA,MAAAA,GARlCF,IAQkCE;EAAO;;;;;AAVb;;gCAUnCD,kBAAkBJ,uBAAuBK,QAAQL;;;;;;;UAOvEK,QAAQL;;;;;;;;;oBASEK;qBACGN"}

package/dist/document_loaders/fs/buffer.js

@@ -0,0 +1,63 @@
+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/buffer.ts
+var buffer_exports = {};
+__export(buffer_exports, { BufferLoader: () => BufferLoader });
+/**
+* Abstract class that extends the `BaseDocumentLoader` class. It
+* represents a document loader that loads documents from a buffer. The
+* `load()` method is implemented to read the buffer contents and metadata
+* based on the type of `filePathOrBlob`, and then calls the `parse()`
+* method to parse the buffer and return the documents.
+*/
+var BufferLoader = class BufferLoader extends BaseDocumentLoader {
+	constructor(filePathOrBlob) {
+		super();
+		this.filePathOrBlob = filePathOrBlob;
+	}
+	/**
+	* Method that reads the buffer contents and metadata based on the type of
+	* `filePathOrBlob`, and then calls the `parse()` method to parse the
+	* buffer and return the documents.
+	* @returns Promise that resolves with an array of `Document` objects.
+	*/
+	async load() {
+		let buffer;
+		let metadata;
+		if (typeof this.filePathOrBlob === "string") {
+			const { readFile } = await BufferLoader.imports();
+			buffer = await readFile(this.filePathOrBlob);
+			metadata = { source: this.filePathOrBlob };
+		} else {
+			buffer = await this.filePathOrBlob.arrayBuffer().then((ab) => Buffer.from(ab));
+			metadata = {
+				source: "blob",
+				blobType: this.filePathOrBlob.type
+			};
+		}
+		return this.parse(buffer, metadata);
+	}
+	/**
+	* Static method that imports the `readFile` function from the
+	* `fs/promises` module in Node.js. It is used to dynamically import the
+	* function when needed. If the import fails, it throws an error
+	* indicating that the `fs/promises` module is not available in the
+	* current environment.
+	* @returns Promise that resolves with an object containing the `readFile` function.
+	*/
+	static async imports() {
+		try {
+			const { readFile } = await import("node:fs/promises");
+			return { readFile };
+		} catch (e) {
+			console.error(e);
+			throw new Error(`Failed to load fs/promises. TextLoader available only on environment 'node'. It appears you are running environment '${getEnv()}'. See https://<link to docs> for alternatives.`);
+		}
+	}
+};
+
+//#endregion
+export { BufferLoader, buffer_exports };
+//# sourceMappingURL=buffer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.js","names":["filePathOrBlob: string | Blob","buffer: Buffer","metadata: Record<string, string>"],"sources":["../../../src/document_loaders/fs/buffer.ts"],"sourcesContent":["import type { readFile as ReadFileT } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { getEnv } from \"@langchain/core/utils/env\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\n\n/**\n * Abstract class that extends the `BaseDocumentLoader` class. It\n * represents a document loader that loads documents from a buffer. The\n * `load()` method is implemented to read the buffer contents and metadata\n * based on the type of `filePathOrBlob`, and then calls the `parse()`\n * method to parse the buffer and return the documents.\n */\nexport abstract class BufferLoader extends BaseDocumentLoader {\n  constructor(public filePathOrBlob: string | Blob) {\n    super();\n  }\n\n  /**\n   * Abstract method that needs to be implemented by subclasses. It is used\n   * to parse the buffer and return the documents.\n   * @param raw The buffer to be parsed.\n   * @param metadata Metadata of the document.\n   * @returns Promise that resolves with an array of `Document` objects.\n   */\n  protected abstract parse(\n    raw: Buffer,\n    metadata: Document[\"metadata\"]\n  ): Promise<Document[]>;\n\n  /**\n   * Method that reads the buffer contents and metadata based on the type of\n   * `filePathOrBlob`, and then calls the `parse()` method to parse the\n   * buffer and return the documents.\n   * @returns Promise that resolves with an array of `Document` objects.\n   */\n  public async load(): Promise<Document[]> {\n    let buffer: Buffer;\n    let metadata: Record<string, string>;\n    if (typeof this.filePathOrBlob === \"string\") {\n      const { readFile } = await BufferLoader.imports();\n      buffer = await readFile(this.filePathOrBlob);\n      metadata = { source: this.filePathOrBlob };\n    } else {\n      buffer = await this.filePathOrBlob\n        .arrayBuffer()\n        .then((ab) => Buffer.from(ab));\n      metadata = { source: \"blob\", blobType: this.filePathOrBlob.type };\n    }\n    return this.parse(buffer, metadata);\n  }\n\n  /**\n   * Static method that imports the `readFile` function from the\n   * `fs/promises` module in Node.js. It is used to dynamically import the\n   * function when needed. If the import fails, it throws an error\n   * indicating that the `fs/promises` module is not available in the\n   * current environment.\n   * @returns Promise that resolves with an object containing the `readFile` function.\n   */\n  static async imports(): Promise<{\n    readFile: typeof ReadFileT;\n  }> {\n    try {\n      const { readFile } = await import(\"node:fs/promises\");\n      return { readFile };\n    } catch (e) {\n      console.error(e);\n      throw new Error(\n        `Failed to load fs/promises. TextLoader available only on environment 'node'. It appears you are running environment '${getEnv()}'. See https://<link to docs> for alternatives.`\n      );\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAYA,IAAsB,eAAtB,MAAsB,qBAAqB,mBAAmB;CAC5D,YAAmBA,gBAA+B;EAChD,OAAO;EADU;CAElB;;;;;;;CAoBD,MAAa,OAA4B;EACvC,IAAIC;EACJ,IAAIC;AACJ,MAAI,OAAO,KAAK,mBAAmB,UAAU;GAC3C,MAAM,EAAE,UAAU,GAAG,MAAM,aAAa,SAAS;GACjD,SAAS,MAAM,SAAS,KAAK,eAAe;GAC5C,WAAW,EAAE,QAAQ,KAAK,eAAgB;EAC3C,OAAM;GACL,SAAS,MAAM,KAAK,eACjB,aAAa,CACb,KAAK,CAAC,OAAO,OAAO,KAAK,GAAG,CAAC;GAChC,WAAW;IAAE,QAAQ;IAAQ,UAAU,KAAK,eAAe;GAAM;EAClE;AACD,SAAO,KAAK,MAAM,QAAQ,SAAS;CACpC;;;;;;;;;CAUD,aAAa,UAEV;AACD,MAAI;GACF,MAAM,EAAE,UAAU,GAAG,MAAM,OAAO;AAClC,UAAO,EAAE,SAAU;EACpB,SAAQ,GAAG;GACV,QAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR,CAAC,qHAAqH,EAAE,QAAQ,CAAC,+CAA+C,CAAC;EAEpL;CACF;AACF"}

package/dist/document_loaders/fs/directory.cjs

@@ -0,0 +1,116 @@
+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

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

@@ -0,0 +1,76 @@
+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

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

@@ -0,0 +1,76 @@
+import { Document } from "@langchain/core/documents";
+import { extname, resolve } from "node:path";
+import { readdir } from "node:fs/promises";
+import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
+
+//#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

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