langchain 0.0.131 → 0.0.132

package/dist/chat_models/ollama.cjs

@@ -4,6 +4,11 @@ exports.ChatOllama = void 0;
 const base_js_1 = require("./base.cjs");
 const ollama_js_1 = require("../util/ollama.cjs");
 const index_js_1 = require("../schema/index.cjs");
+/**
+ * A class that enables calls to the Ollama API to access large language
+ * models in a chat-like fashion. It extends the SimpleChatModel class and
+ * implements the OllamaInput interface.
+ */
 class ChatOllama extends base_js_1.SimpleChatModel {
     static lc_name() {
         return "ChatOllama";
@@ -127,6 +132,12 @@ class ChatOllama extends base_js_1.SimpleChatModel {
     _llmType() {
         return "ollama";
     }
+    /**
+     * A method that returns the parameters for an Ollama API call. It
+     * includes model and options parameters.
+     * @param options Optional parsed call options.
+     * @returns An object containing the parameters for an Ollama API call.
+     */
     invocationParams(options) {
         return {
             model: this.model,

package/dist/chat_models/ollama.d.ts

@@ -3,8 +3,17 @@ import { BaseLanguageModelCallOptions } from "../base_language/index.js";
 import { OllamaInput } from "../util/ollama.js";
 import { CallbackManagerForLLMRun } from "../callbacks/manager.js";
 import { BaseMessage, ChatGenerationChunk } from "../schema/index.js";
+/**
+ * An interface defining the options for an Ollama API call. It extends
+ * the BaseLanguageModelCallOptions interface.
+ */
 export interface OllamaCallOptions extends BaseLanguageModelCallOptions {
 }
+/**
+ * A class that enables calls to the Ollama API to access large language
+ * models in a chat-like fashion. It extends the SimpleChatModel class and
+ * implements the OllamaInput interface.
+ */
 export declare class ChatOllama extends SimpleChatModel implements OllamaInput {
     CallOptions: OllamaCallOptions;
     static lc_name(): string;
@@ -26,6 +35,12 @@ export declare class ChatOllama extends SimpleChatModel implements OllamaInput {
     topP?: number;
     constructor(fields: OllamaInput & BaseChatModelParams);
     _llmType(): string;
+    /**
+     * A method that returns the parameters for an Ollama API call. It
+     * includes model and options parameters.
+     * @param options Optional parsed call options.
+     * @returns An object containing the parameters for an Ollama API call.
+     */
     invocationParams(options?: this["ParsedCallOptions"]): {
         model: string;
         options: {

package/dist/chat_models/ollama.js

@@ -1,6 +1,11 @@
 import { SimpleChatModel } from "./base.js";
 import { createOllamaStream } from "../util/ollama.js";
 import { AIMessageChunk, ChatGenerationChunk, ChatMessage, } from "../schema/index.js";
+/**
+ * A class that enables calls to the Ollama API to access large language
+ * models in a chat-like fashion. It extends the SimpleChatModel class and
+ * implements the OllamaInput interface.
+ */
 export class ChatOllama extends SimpleChatModel {
     static lc_name() {
         return "ChatOllama";
@@ -124,6 +129,12 @@ export class ChatOllama extends SimpleChatModel {
     _llmType() {
         return "ollama";
     }
+    /**
+     * A method that returns the parameters for an Ollama API call. It
+     * includes model and options parameters.
+     * @param options Optional parsed call options.
+     * @returns An object containing the parameters for an Ollama API call.
+     */
     invocationParams(options) {
         return {
             model: this.model,

package/dist/document_loaders/base.cjs

@@ -2,7 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseDocumentLoader = void 0;
 const text_splitter_js_1 = require("../text_splitter.cjs");
+/**
+ * Abstract class that provides a default implementation for the
+ * loadAndSplit() method from the DocumentLoader interface. The load()
+ * method is left abstract and needs to be implemented by subclasses.
+ */
 class BaseDocumentLoader {
+    /**
+     * Loads the documents and splits them using a specified text splitter.
+     * @param textSplitter The TextSplitter instance to use for splitting the loaded documents. Defaults to a RecursiveCharacterTextSplitter instance.
+     * @returns A Promise that resolves with an array of Document instances, each split according to the provided TextSplitter.
+     */
     async loadAndSplit(splitter = new text_splitter_js_1.RecursiveCharacterTextSplitter()) {
         const docs = await this.load();
         return splitter.splitDocuments(docs);

package/dist/document_loaders/base.d.ts

@@ -1,10 +1,27 @@
 import { TextSplitter } from "../text_splitter.js";
 import { Document } from "../document.js";
+/**
+ * Interface that defines the methods for loading and splitting documents.
+ */
 export interface DocumentLoader {
     load(): Promise<Document[]>;
     loadAndSplit(textSplitter?: TextSplitter): Promise<Document[]>;
 }
+/**
+ * Abstract class that provides a default implementation for the
+ * loadAndSplit() method from the DocumentLoader interface. The load()
+ * method is left abstract and needs to be implemented by subclasses.
+ */
 export declare abstract class BaseDocumentLoader implements DocumentLoader {
+    /**
+     * Loads the documents.
+     * @returns A Promise that resolves with an array of Document instances.
+     */
     abstract load(): Promise<Document[]>;
+    /**
+     * Loads the documents and splits them using a specified text splitter.
+     * @param textSplitter The TextSplitter instance to use for splitting the loaded documents. Defaults to a RecursiveCharacterTextSplitter instance.
+     * @returns A Promise that resolves with an array of Document instances, each split according to the provided TextSplitter.
+     */
     loadAndSplit(splitter?: TextSplitter): Promise<Document[]>;
 }

package/dist/document_loaders/base.js

@@ -1,5 +1,15 @@
 import { RecursiveCharacterTextSplitter, } from "../text_splitter.js";
+/**
+ * Abstract class that provides a default implementation for the
+ * loadAndSplit() method from the DocumentLoader interface. The load()
+ * method is left abstract and needs to be implemented by subclasses.
+ */
 export class BaseDocumentLoader {
+    /**
+     * Loads the documents and splits them using a specified text splitter.
+     * @param textSplitter The TextSplitter instance to use for splitting the loaded documents. Defaults to a RecursiveCharacterTextSplitter instance.
+     * @returns A Promise that resolves with an array of Document instances, each split according to the provided TextSplitter.
+     */
     async loadAndSplit(splitter = new RecursiveCharacterTextSplitter()) {
         const docs = await this.load();
         return splitter.splitDocuments(docs);

package/dist/document_loaders/fs/buffer.cjs

@@ -3,6 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BufferLoader = void 0;
 const env_js_1 = require("../../util/env.cjs");
 const base_js_1 = require("../base.cjs");
+/**
+ * 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.
+ */
 class BufferLoader extends base_js_1.BaseDocumentLoader {
     constructor(filePathOrBlob) {
         super();
@@ -13,6 +20,12 @@ class BufferLoader extends base_js_1.BaseDocumentLoader {
             value: 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;
@@ -29,6 +42,14 @@ class BufferLoader extends base_js_1.BaseDocumentLoader {
         }
         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");

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

@@ -3,11 +3,39 @@
 import type { readFile as ReadFileT } from "node:fs/promises";
 import { Document } from "../../document.js";
 import { BaseDocumentLoader } from "../base.js";
+/**
+ * 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.
+ */
 export 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 ReadFileT;
     }>;

package/dist/document_loaders/fs/buffer.js

@@ -1,5 +1,12 @@
 import { getEnv } from "../../util/env.js";
 import { BaseDocumentLoader } from "../base.js";
+/**
+ * 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.
+ */
 export class BufferLoader extends BaseDocumentLoader {
     constructor(filePathOrBlob) {
         super();
@@ -10,6 +17,12 @@ export class BufferLoader extends BaseDocumentLoader {
             value: 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;
@@ -26,6 +39,14 @@ export class BufferLoader extends BaseDocumentLoader {
         }
         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");

package/dist/document_loaders/fs/csv.cjs

@@ -2,6 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CSVLoader = void 0;
 const text_js_1 = require("./text.cjs");
+/**
+ * A class that extends the TextLoader class. It represents a document
+ * loader that loads documents from a CSV file. It has a constructor that
+ * takes a `filePathOrBlob` parameter representing the path to the CSV
+ * file or a Blob object, and an optional `options` parameter of type
+ * `CSVLoaderOptions` or a string representing the column to use as the
+ * document's pageContent.
+ */
 class CSVLoader extends text_js_1.TextLoader {
     constructor(filePathOrBlob, options) {
         super(filePathOrBlob);
@@ -18,6 +26,17 @@ class CSVLoader extends text_js_1.TextLoader {
             this.options = options ?? this.options;
         }
     }
+    /**
+     * A protected method that parses the raw CSV data and returns an array of
+     * strings representing the pageContent of each document. It uses the
+     * `dsvFormat` function from the `d3-dsv` module to parse the CSV data. If
+     * the `column` option is specified, it checks if the column exists in the
+     * CSV file and returns the values of that column as the pageContent. If
+     * the `column` option is not specified, it converts each row of the CSV
+     * data into key/value pairs and joins them with newline characters.
+     * @param raw The raw CSV data to be parsed.
+     * @returns An array of strings representing the pageContent of each document.
+     */
     async parse(raw) {
         const { column, separator = "," } = this.options;
         const { dsvFormat } = await CSVLoaderImports();

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

@@ -38,9 +38,28 @@ type CSVLoaderOptions = {
     column?: string;
     separator?: string;
 };
+/**
+ * A class that extends the TextLoader class. It represents a document
+ * loader that loads documents from a CSV file. It has a constructor that
+ * takes a `filePathOrBlob` parameter representing the path to the CSV
+ * file or a Blob object, and an optional `options` parameter of type
+ * `CSVLoaderOptions` or a string representing the column to use as the
+ * document's pageContent.
+ */
 export declare class CSVLoader extends TextLoader {
     protected options: CSVLoaderOptions;
     constructor(filePathOrBlob: string | Blob, options?: CSVLoaderOptions | string);
+    /**
+     * A protected method that parses the raw CSV data and returns an array of
+     * strings representing the pageContent of each document. It uses the
+     * `dsvFormat` function from the `d3-dsv` module to parse the CSV data. If
+     * the `column` option is specified, it checks if the column exists in the
+     * CSV file and returns the values of that column as the pageContent. If
+     * the `column` option is not specified, it converts each row of the CSV
+     * data into key/value pairs and joins them with newline characters.
+     * @param raw The raw CSV data to be parsed.
+     * @returns An array of strings representing the pageContent of each document.
+     */
     protected parse(raw: string): Promise<string[]>;
 }
 export {};

package/dist/document_loaders/fs/csv.js

@@ -1,4 +1,12 @@
 import { TextLoader } from "./text.js";
+/**
+ * A class that extends the TextLoader class. It represents a document
+ * loader that loads documents from a CSV file. It has a constructor that
+ * takes a `filePathOrBlob` parameter representing the path to the CSV
+ * file or a Blob object, and an optional `options` parameter of type
+ * `CSVLoaderOptions` or a string representing the column to use as the
+ * document's pageContent.
+ */
 export class CSVLoader extends TextLoader {
     constructor(filePathOrBlob, options) {
         super(filePathOrBlob);
@@ -15,6 +23,17 @@ export class CSVLoader extends TextLoader {
             this.options = options ?? this.options;
         }
     }
+    /**
+     * A protected method that parses the raw CSV data and returns an array of
+     * strings representing the pageContent of each document. It uses the
+     * `dsvFormat` function from the `d3-dsv` module to parse the CSV data. If
+     * the `column` option is specified, it checks if the column exists in the
+     * CSV file and returns the values of that column as the pageContent. If
+     * the `column` option is not specified, it converts each row of the CSV
+     * data into key/value pairs and joins them with newline characters.
+     * @param raw The raw CSV data to be parsed.
+     * @returns An array of strings representing the pageContent of each document.
+     */
     async parse(raw) {
         const { column, separator = "," } = this.options;
         const { dsvFormat } = await CSVLoaderImports();

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[]>;
 }