langchain 0.0.130 → 0.0.132

package/dist/document_loaders/fs/directory.cjs

@@ -10,6 +10,10 @@ exports.UnknownHandling = {
     Warn: "warn",
     Error: "error",
 };
+/**
+ * A document loader that loads documents from a directory. It extends the
+ * `BaseDocumentLoader` class and implements the `load()` method.
+ */
 class DirectoryLoader extends base_js_1.BaseDocumentLoader {
     constructor(directoryPath, loaders, recursive = true, unknown = exports.UnknownHandling.Warn) {
         super();
@@ -48,6 +52,16 @@ class DirectoryLoader extends base_js_1.BaseDocumentLoader {
             }
         }
     }
+    /**
+     * 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 });
@@ -85,6 +99,13 @@ class DirectoryLoader extends base_js_1.BaseDocumentLoader {
         }
         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");

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

@@ -9,17 +9,46 @@ export declare const UnknownHandling: {
     readonly Warn: "warn";
     readonly Error: "error";
 };
+/**
+ * An enumeration of possible handling strategies for unknown file types.
+ */
 export 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.
+ */
 export 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.
+ */
 export 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 ReaddirT;
         extname: typeof ExtnameT;

package/dist/document_loaders/fs/directory.js

@@ -7,6 +7,10 @@ export const UnknownHandling = {
     Warn: "warn",
     Error: "error",
 };
+/**
+ * A document loader that loads documents from a directory. It extends the
+ * `BaseDocumentLoader` class and implements the `load()` method.
+ */
 export class DirectoryLoader extends BaseDocumentLoader {
     constructor(directoryPath, loaders, recursive = true, unknown = UnknownHandling.Warn) {
         super();
@@ -45,6 +49,16 @@ export class DirectoryLoader extends BaseDocumentLoader {
             }
         }
     }
+    /**
+     * 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 });
@@ -82,6 +96,13 @@ export class DirectoryLoader extends BaseDocumentLoader {
         }
         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");

package/dist/document_loaders/fs/docx.cjs

@@ -3,10 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DocxLoader = void 0;
 const document_js_1 = require("../../document.cjs");
 const buffer_js_1 = require("./buffer.cjs");
+/**
+ * A class that extends the `BufferLoader` class. It represents a document
+ * loader that loads documents from DOCX files.
+ */
 class DocxLoader extends buffer_js_1.BufferLoader {
     constructor(filePathOrBlob) {
         super(filePathOrBlob);
     }
+    /**
+     * A method that takes a `raw` buffer and `metadata` as parameters and
+     * returns a promise that resolves to an array of `Document` instances. It
+     * uses the `extractRawText` function from the `mammoth` module to extract
+     * the raw text content from the buffer. If the extracted text content is
+     * empty, it returns an empty array. Otherwise, it creates a new
+     * `Document` instance with the extracted text content and the provided
+     * metadata, and returns it as an array.
+     * @param raw The raw buffer from which to extract text content.
+     * @param metadata The metadata to be associated with the created `Document` instance.
+     * @returns A promise that resolves to an array of `Document` instances.
+     */
     async parse(raw, metadata) {
         const { extractRawText } = await DocxLoaderImports();
         const docx = await extractRawText({

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

@@ -1,7 +1,23 @@
 /// <reference types="node" resolution-mode="require"/>
 import { Document } from "../../document.js";
 import { BufferLoader } from "./buffer.js";
+/**
+ * A class that extends the `BufferLoader` class. It represents a document
+ * loader that loads documents from DOCX files.
+ */
 export declare class DocxLoader extends BufferLoader {
     constructor(filePathOrBlob: string | Blob);
+    /**
+     * A method that takes a `raw` buffer and `metadata` as parameters and
+     * returns a promise that resolves to an array of `Document` instances. It
+     * uses the `extractRawText` function from the `mammoth` module to extract
+     * the raw text content from the buffer. If the extracted text content is
+     * empty, it returns an empty array. Otherwise, it creates a new
+     * `Document` instance with the extracted text content and the provided
+     * metadata, and returns it as an array.
+     * @param raw The raw buffer from which to extract text content.
+     * @param metadata The metadata to be associated with the created `Document` instance.
+     * @returns A promise that resolves to an array of `Document` instances.
+     */
     parse(raw: Buffer, metadata: Document["metadata"]): Promise<Document[]>;
 }

package/dist/document_loaders/fs/docx.js

@@ -1,9 +1,25 @@
 import { Document } from "../../document.js";
 import { BufferLoader } from "./buffer.js";
+/**
+ * A class that extends the `BufferLoader` class. It represents a document
+ * loader that loads documents from DOCX files.
+ */
 export class DocxLoader extends BufferLoader {
     constructor(filePathOrBlob) {
         super(filePathOrBlob);
     }
+    /**
+     * A method that takes a `raw` buffer and `metadata` as parameters and
+     * returns a promise that resolves to an array of `Document` instances. It
+     * uses the `extractRawText` function from the `mammoth` module to extract
+     * the raw text content from the buffer. If the extracted text content is
+     * empty, it returns an empty array. Otherwise, it creates a new
+     * `Document` instance with the extracted text content and the provided
+     * metadata, and returns it as an array.
+     * @param raw The raw buffer from which to extract text content.
+     * @param metadata The metadata to be associated with the created `Document` instance.
+     * @returns A promise that resolves to an array of `Document` instances.
+     */
     async parse(raw, metadata) {
         const { extractRawText } = await DocxLoaderImports();
         const docx = await extractRawText({

package/dist/document_loaders/fs/epub.cjs

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EPubLoader = void 0;
 const document_js_1 = require("../../document.cjs");
 const base_js_1 = require("../base.cjs");
+/**
+ * A class that extends the `BaseDocumentLoader` class. It represents a
+ * document loader that loads documents from EPUB files.
+ */
 class EPubLoader extends base_js_1.BaseDocumentLoader {
     constructor(filePath, { splitChapters = true } = {}) {
         super();
@@ -20,6 +24,13 @@ class EPubLoader extends base_js_1.BaseDocumentLoader {
         });
         this.splitChapters = splitChapters;
     }
+    /**
+     * A protected method that takes an EPUB object as a parameter and returns
+     * a promise that resolves to an array of objects representing the content
+     * and metadata of each chapter.
+     * @param epub The EPUB object to parse.
+     * @returns A promise that resolves to an array of objects representing the content and metadata of each chapter.
+     */
     async parse(epub) {
         const { htmlToText } = await HtmlToTextImport();
         const chapters = await Promise.all(epub.flow.map(async (chapter) => {
@@ -40,6 +51,11 @@ class EPubLoader extends base_js_1.BaseDocumentLoader {
             },
         }));
     }
+    /**
+     * A method that loads the EPUB file and returns a promise that resolves
+     * to an array of `Document` instances.
+     * @returns A promise that resolves to an array of `Document` instances.
+     */
     async load() {
         const { EPub } = await EpubImport();
         const epub = await EPub.createAsync(this.filePath);

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

@@ -1,15 +1,31 @@
 import type { EPub } from "epub2";
 import { Document } from "../../document.js";
 import { BaseDocumentLoader } from "../base.js";
+/**
+ * A class that extends the `BaseDocumentLoader` class. It represents a
+ * document loader that loads documents from EPUB files.
+ */
 export declare class EPubLoader extends BaseDocumentLoader {
     filePath: string;
     private splitChapters;
     constructor(filePath: string, { splitChapters }?: {
         splitChapters?: boolean | undefined;
     });
+    /**
+     * A protected method that takes an EPUB object as a parameter and returns
+     * a promise that resolves to an array of objects representing the content
+     * and metadata of each chapter.
+     * @param epub The EPUB object to parse.
+     * @returns A promise that resolves to an array of objects representing the content and metadata of each chapter.
+     */
     protected parse(epub: EPub): Promise<{
         pageContent: string;
         metadata?: object;
     }[]>;
+    /**
+     * A method that loads the EPUB file and returns a promise that resolves
+     * to an array of `Document` instances.
+     * @returns A promise that resolves to an array of `Document` instances.
+     */
     load(): Promise<Document[]>;
 }

package/dist/document_loaders/fs/epub.js

@@ -1,5 +1,9 @@
 import { Document } from "../../document.js";
 import { BaseDocumentLoader } from "../base.js";
+/**
+ * A class that extends the `BaseDocumentLoader` class. It represents a
+ * document loader that loads documents from EPUB files.
+ */
 export class EPubLoader extends BaseDocumentLoader {
     constructor(filePath, { splitChapters = true } = {}) {
         super();
@@ -17,6 +21,13 @@ export class EPubLoader extends BaseDocumentLoader {
         });
         this.splitChapters = splitChapters;
     }
+    /**
+     * A protected method that takes an EPUB object as a parameter and returns
+     * a promise that resolves to an array of objects representing the content
+     * and metadata of each chapter.
+     * @param epub The EPUB object to parse.
+     * @returns A promise that resolves to an array of objects representing the content and metadata of each chapter.
+     */
     async parse(epub) {
         const { htmlToText } = await HtmlToTextImport();
         const chapters = await Promise.all(epub.flow.map(async (chapter) => {
@@ -37,6 +48,11 @@ export class EPubLoader extends BaseDocumentLoader {
             },
         }));
     }
+    /**
+     * A method that loads the EPUB file and returns a promise that resolves
+     * to an array of `Document` instances.
+     * @returns A promise that resolves to an array of `Document` instances.
+     */
     async load() {
         const { EPub } = await EpubImport();
         const epub = await EPub.createAsync(this.filePath);

package/dist/document_loaders/fs/json.cjs

@@ -6,6 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JSONLinesLoader = exports.JSONLoader = void 0;
 const jsonpointer_1 = __importDefault(require("jsonpointer"));
 const text_js_1 = require("./text.cjs");
+/**
+ * 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.
+ */
 class JSONLoader extends text_js_1.TextLoader {
     constructor(filePathOrBlob, pointers = []) {
         super(filePathOrBlob);
@@ -17,6 +24,15 @@ class JSONLoader extends text_js_1.TextLoader {
         });
         this.pointers = Array.isArray(pointers) ? pointers : [pointers];
     }
+    /**
+     * Method that takes a `raw` string as a parameter and returns a promise
+     * that resolves to an array of strings. It parses the raw JSON string and
+     * extracts the values based on the specified JSON pointers. If no JSON
+     * pointers are specified, it extracts all the strings from the JSON
+     * object.
+     * @param raw The raw JSON string to parse.
+     * @returns A promise that resolves to an array of strings.
+     */
     async parse(raw) {
         const json = JSON.parse(raw.trim());
         // If there is no pointers specified we extract all strings we found
@@ -72,6 +88,15 @@ class JSONLoader extends text_js_1.TextLoader {
         }
         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) {
@@ -84,6 +109,13 @@ class JSONLoader extends text_js_1.TextLoader {
     }
 }
 exports.JSONLoader = JSONLoader;
+/**
+ * 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.
+ */
 class JSONLinesLoader extends text_js_1.TextLoader {
     constructor(filePathOrBlob, pointer) {
         super(filePathOrBlob);
@@ -94,6 +126,14 @@ class JSONLinesLoader extends text_js_1.TextLoader {
             value: pointer
         });
     }
+    /**
+     * Method that takes a `raw` string as a parameter and returns a promise
+     * that resolves to an array of strings. It parses the raw JSON Lines
+     * string, splits it into lines, parses each line as JSON, and extracts
+     * the values based on the specified JSON pointer.
+     * @param raw The raw JSON Lines string to parse.
+     * @returns A promise that resolves to an array of strings.
+     */
     async parse(raw) {
         const lines = raw.split("\n");
         const jsons = lines

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

@@ -1,7 +1,23 @@
 import { TextLoader } from "./text.js";
+/**
+ * Class that extends the `TextLoader` class. It represents a document
+ * loader that loads documents from JSON files. It has a constructor that
+ * takes a `filePathOrBlob` parameter representing the path to the JSON
+ * file or a `Blob` object, and an optional `pointers` parameter that
+ * specifies the JSON pointers to extract.
+ */
 export 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
@@ -10,10 +26,34 @@ export declare class JSONLoader extends TextLoader {
      * 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.
+ */
 export declare class JSONLinesLoader extends TextLoader {
     pointer: string;
     constructor(filePathOrBlob: string | Blob, pointer: string);
+    /**
+     * Method that takes a `raw` string as a parameter and returns a promise
+     * that resolves to an array of strings. It parses the raw JSON Lines
+     * string, splits it into lines, parses each line as JSON, and extracts
+     * the values based on the specified JSON pointer.
+     * @param raw The raw JSON Lines string to parse.
+     * @returns A promise that resolves to an array of strings.
+     */
     protected parse(raw: string): Promise<string[]>;
 }

package/dist/document_loaders/fs/json.js

@@ -1,5 +1,12 @@
 import jsonpointer from "jsonpointer";
 import { TextLoader } from "./text.js";
+/**
+ * Class that extends the `TextLoader` class. It represents a document
+ * loader that loads documents from JSON files. It has a constructor that
+ * takes a `filePathOrBlob` parameter representing the path to the JSON
+ * file or a `Blob` object, and an optional `pointers` parameter that
+ * specifies the JSON pointers to extract.
+ */
 export class JSONLoader extends TextLoader {
     constructor(filePathOrBlob, pointers = []) {
         super(filePathOrBlob);
@@ -11,6 +18,15 @@ export class JSONLoader extends TextLoader {
         });
         this.pointers = Array.isArray(pointers) ? pointers : [pointers];
     }
+    /**
+     * Method that takes a `raw` string as a parameter and returns a promise
+     * that resolves to an array of strings. It parses the raw JSON string and
+     * extracts the values based on the specified JSON pointers. If no JSON
+     * pointers are specified, it extracts all the strings from the JSON
+     * object.
+     * @param raw The raw JSON string to parse.
+     * @returns A promise that resolves to an array of strings.
+     */
     async parse(raw) {
         const json = JSON.parse(raw.trim());
         // If there is no pointers specified we extract all strings we found
@@ -66,6 +82,15 @@ export class JSONLoader extends TextLoader {
         }
         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) {
@@ -77,6 +102,13 @@ export class JSONLoader extends TextLoader {
         return targetEntries;
     }
 }
+/**
+ * Class that extends the `TextLoader` class. It represents a document
+ * loader that loads documents from JSON Lines files. It has a constructor
+ * that takes a `filePathOrBlob` parameter representing the path to the
+ * JSON Lines file or a `Blob` object, and a `pointer` parameter that
+ * specifies the JSON pointer to extract.
+ */
 export class JSONLinesLoader extends TextLoader {
     constructor(filePathOrBlob, pointer) {
         super(filePathOrBlob);
@@ -87,6 +119,14 @@ export class JSONLinesLoader extends TextLoader {
             value: pointer
         });
     }
+    /**
+     * Method that takes a `raw` string as a parameter and returns a promise
+     * that resolves to an array of strings. It parses the raw JSON Lines
+     * string, splits it into lines, parses each line as JSON, and extracts
+     * the values based on the specified JSON pointer.
+     * @param raw The raw JSON Lines string to parse.
+     * @returns A promise that resolves to an array of strings.
+     */
     async parse(raw) {
         const lines = raw.split("\n");
         const jsons = lines

package/dist/document_loaders/fs/notion.cjs

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotionLoader = void 0;
 const directory_js_1 = require("./directory.cjs");
 const text_js_1 = require("./text.cjs");
+/**
+ * A class that extends the DirectoryLoader class. It represents a
+ * document loader that loads documents from a directory in the Notion
+ * format. It uses the TextLoader for loading '.md' files and ignores
+ * unknown file types.
+ */
 class NotionLoader extends directory_js_1.DirectoryLoader {
     constructor(directoryPath) {
         super(directoryPath, {

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

@@ -1,4 +1,10 @@
 import { DirectoryLoader } from "./directory.js";
+/**
+ * A class that extends the DirectoryLoader class. It represents a
+ * document loader that loads documents from a directory in the Notion
+ * format. It uses the TextLoader for loading '.md' files and ignores
+ * unknown file types.
+ */
 export declare class NotionLoader extends DirectoryLoader {
     constructor(directoryPath: string);
 }

package/dist/document_loaders/fs/notion.js

@@ -1,5 +1,11 @@
 import { DirectoryLoader, UnknownHandling } from "./directory.js";
 import { TextLoader } from "./text.js";
+/**
+ * A class that extends the DirectoryLoader class. It represents a
+ * document loader that loads documents from a directory in the Notion
+ * format. It uses the TextLoader for loading '.md' files and ignores
+ * unknown file types.
+ */
 export class NotionLoader extends DirectoryLoader {
     constructor(directoryPath) {
         super(directoryPath, {

package/dist/document_loaders/fs/pdf.cjs

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PDFLoader = void 0;
 const document_js_1 = require("../../document.cjs");
 const buffer_js_1 = require("./buffer.cjs");
+/**
+ * A class that extends the `BufferLoader` class. It represents a document
+ * loader that loads documents from PDF files.
+ */
 class PDFLoader extends buffer_js_1.BufferLoader {
     constructor(filePathOrBlob, { splitPages = true, pdfjs = PDFLoaderImports } = {}) {
         super(filePathOrBlob);
@@ -21,6 +25,23 @@ class PDFLoader extends buffer_js_1.BufferLoader {
         this.splitPages = splitPages;
         this.pdfjs = pdfjs;
     }
+    /**
+     * A method that takes a `raw` buffer and `metadata` as parameters and
+     * returns a promise that resolves to an array of `Document` instances. It
+     * uses the `getDocument` function from the PDF.js library to load the PDF
+     * from the buffer. It then iterates over each page of the PDF, retrieves
+     * the text content using the `getTextContent` method, and joins the text
+     * items to form the page content. It creates a new `Document` instance
+     * for each page with the extracted text content and metadata, and adds it
+     * to the `documents` array. If `splitPages` is `true`, it returns the
+     * array of `Document` instances. Otherwise, if there are no documents, it
+     * returns an empty array. Otherwise, it concatenates the page content of
+     * all documents and creates a single `Document` instance with the
+     * concatenated content.
+     * @param raw The buffer to be parsed.
+     * @param metadata The metadata of the document.
+     * @returns A promise that resolves to an array of `Document` instances.
+     */
     async parse(raw, metadata) {
         const { getDocument, version } = await this.pdfjs();
         const pdf = await getDocument({

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

@@ -2,6 +2,10 @@
 /// <reference types="node" resolution-mode="require"/>
 import { Document } from "../../document.js";
 import { BufferLoader } from "./buffer.js";
+/**
+ * A class that extends the `BufferLoader` class. It represents a document
+ * loader that loads documents from PDF files.
+ */
 export declare class PDFLoader extends BufferLoader {
     private splitPages;
     private pdfjs;
@@ -9,6 +13,23 @@ export declare class PDFLoader extends BufferLoader {
         splitPages?: boolean | undefined;
         pdfjs?: typeof PDFLoaderImports | undefined;
     });
+    /**
+     * A method that takes a `raw` buffer and `metadata` as parameters and
+     * returns a promise that resolves to an array of `Document` instances. It
+     * uses the `getDocument` function from the PDF.js library to load the PDF
+     * from the buffer. It then iterates over each page of the PDF, retrieves
+     * the text content using the `getTextContent` method, and joins the text
+     * items to form the page content. It creates a new `Document` instance
+     * for each page with the extracted text content and metadata, and adds it
+     * to the `documents` array. If `splitPages` is `true`, it returns the
+     * array of `Document` instances. Otherwise, if there are no documents, it
+     * returns an empty array. Otherwise, it concatenates the page content of
+     * all documents and creates a single `Document` instance with the
+     * concatenated content.
+     * @param raw The buffer to be parsed.
+     * @param metadata The metadata of the document.
+     * @returns A promise that resolves to an array of `Document` instances.
+     */
     parse(raw: Buffer, metadata: Document["metadata"]): Promise<Document[]>;
 }
 declare function PDFLoaderImports(): Promise<{

package/dist/document_loaders/fs/pdf.js

@@ -1,5 +1,9 @@
 import { Document } from "../../document.js";
 import { BufferLoader } from "./buffer.js";
+/**
+ * A class that extends the `BufferLoader` class. It represents a document
+ * loader that loads documents from PDF files.
+ */
 export class PDFLoader extends BufferLoader {
     constructor(filePathOrBlob, { splitPages = true, pdfjs = PDFLoaderImports } = {}) {
         super(filePathOrBlob);
@@ -18,6 +22,23 @@ export class PDFLoader extends BufferLoader {
         this.splitPages = splitPages;
         this.pdfjs = pdfjs;
     }
+    /**
+     * A method that takes a `raw` buffer and `metadata` as parameters and
+     * returns a promise that resolves to an array of `Document` instances. It
+     * uses the `getDocument` function from the PDF.js library to load the PDF
+     * from the buffer. It then iterates over each page of the PDF, retrieves
+     * the text content using the `getTextContent` method, and joins the text
+     * items to form the page content. It creates a new `Document` instance
+     * for each page with the extracted text content and metadata, and adds it
+     * to the `documents` array. If `splitPages` is `true`, it returns the
+     * array of `Document` instances. Otherwise, if there are no documents, it
+     * returns an empty array. Otherwise, it concatenates the page content of
+     * all documents and creates a single `Document` instance with the
+     * concatenated content.
+     * @param raw The buffer to be parsed.
+     * @param metadata The metadata of the document.
+     * @returns A promise that resolves to an array of `Document` instances.
+     */
     async parse(raw, metadata) {
         const { getDocument, version } = await this.pdfjs();
         const pdf = await getDocument({