@langchain/classic 1.0.39 → 1.0.41

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

@@ -1 +1 @@
-{"version":3,"file":"directory.cjs","names":["BaseDocumentLoader"],"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;CACR;;;;;;;;;;;;;;;;;;;AAkCD,IAAa,kBAAb,MAAa,wBAAwBA,sCAAAA,mBAAmB;CACtD,YACE,eACA,SACA,YAA4B,MAC5B,UAAkC,gBAAgB,MAClD;AACA,SAAO;AALA,OAAA,gBAAA;AACA,OAAA,UAAA;AACA,OAAA,YAAA;AACA,OAAA,UAAA;AAIP,MAAI,OAAO,KAAK,QAAQ,CAAC,WAAW,EAClC,OAAM,IAAI,MAAM,mCAAmC;AAErD,OAAK,MAAM,aAAa,QACtB,KAAI,OAAO,OAAO,SAAS,UAAU;OAC/B,UAAU,OAAO,IACnB,OAAM,IAAI,MAAM,oCAAoC,YAAY;;;;;;;;;;;;;CAgBxE,MAAa,OAA4B;EACvC,MAAM,EAAE,SAAS,SAAS,YAAY,MAAM,gBAAgB,SAAS;EACrE,MAAM,QAAQ,MAAM,QAAQ,KAAK,eAAe,EAAE,eAAe,MAAM,CAAC;EAExE,MAAM,YAAwB,EAAE;AAEhC,OAAK,MAAM,QAAQ,OAAO;GACxB,MAAM,WAAW,QAAQ,KAAK,eAAe,KAAK,KAAK;AACvD,OAAI,KAAK,aAAa;QAChB,KAAK,WAAW;KAClB,MAAM,SAAS,IAAI,gBACjB,UACA,KAAK,SACL,KAAK,WACL,KAAK,QACN;AACD,eAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;;UAErC;IAGL,MAAM,gBAAgB,KAAK,QAAQ,QAAQ,KAAK,KAAK;AACrD,QAAI,eAAe;KACjB,MAAM,SAAS,cAAc,SAAS;AACtC,eAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;UAExC,SAAQ,KAAK,SAAb;KACE,KAAK,gBAAgB,OACnB;KACF,KAAK,gBAAgB;AACnB,cAAQ,KAAK,sBAAsB,KAAK,OAAO;AAC/C;KACF,KAAK,gBAAgB,MACnB,OAAM,IAAI,MAAM,sBAAsB,KAAK,OAAO;KACpD,QACE,OAAM,IAAI,MAAM,6BAA6B,KAAK,UAAU;;;;AAMtE,SAAO;;;;;;;;;CAUT,aAAa,UAIV;AACD,MAAI;GACF,MAAM,EAAE,SAAS,YAAY,MAAM,OAAO;GAC1C,MAAM,EAAE,YAAY,MAAM,OAAO;AACjC,UAAO;IAAE;IAAS;IAAS;IAAS;WAC7B,GAAG;AACV,WAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR,8HAAA,GAAA,0BAAA,SAAqI,CAAC,iDACvI"}
+{"version":3,"file":"directory.cjs","names":["BaseDocumentLoader"],"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;AACT;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,kBAAb,MAAa,wBAAwBA,sCAAAA,mBAAmB;CAE7C;CACA;CACA;CACA;CAJT,YACE,eACA,SACA,YAA4B,MAC5B,UAAkC,gBAAgB,MAClD;EACA,MAAM;EALC,KAAA,gBAAA;EACA,KAAA,UAAA;EACA,KAAA,YAAA;EACA,KAAA,UAAA;EAIP,IAAI,OAAO,KAAK,OAAO,CAAC,CAAC,WAAW,GAClC,MAAM,IAAI,MAAM,kCAAkC;EAEpD,KAAK,MAAM,aAAa,SACtB,IAAI,OAAO,OAAO,SAAS,SAAS,GAC9B;OAAA,UAAU,OAAO,KACnB,MAAM,IAAI,MAAM,oCAAoC,WAAW;EAAA;CAIvE;;;;;;;;;;;CAYA,MAAa,OAA4B;EACvC,MAAM,EAAE,SAAS,SAAS,YAAY,MAAM,gBAAgB,QAAQ;EACpE,MAAM,QAAQ,MAAM,QAAQ,KAAK,eAAe,EAAE,eAAe,KAAK,CAAC;EAEvE,MAAM,YAAwB,CAAC;EAE/B,KAAK,MAAM,QAAQ,OAAO;GACxB,MAAM,WAAW,QAAQ,KAAK,eAAe,KAAK,IAAI;GACtD,IAAI,KAAK,YAAY,GACf;QAAA,KAAK,WAAW;KAClB,MAAM,SAAS,IAAI,gBACjB,UACA,KAAK,SACL,KAAK,WACL,KAAK,OACP;KACA,UAAU,KAAK,GAAI,MAAM,OAAO,KAAK,CAAE;IACzC;UACK;IAGL,MAAM,gBAAgB,KAAK,QAAQ,QAAQ,KAAK,IAAI;IACpD,IAAI,eAAe;KACjB,MAAM,SAAS,cAAc,QAAQ;KACrC,UAAU,KAAK,GAAI,MAAM,OAAO,KAAK,CAAE;IACzC,OACE,QAAQ,KAAK,SAAb;KACE,KAAK,gBAAgB,QACnB;KACF,KAAK,gBAAgB;MACnB,QAAQ,KAAK,sBAAsB,KAAK,MAAM;MAC9C;KACF,KAAK,gBAAgB,OACnB,MAAM,IAAI,MAAM,sBAAsB,KAAK,MAAM;KACnD,SACE,MAAM,IAAI,MAAM,6BAA6B,KAAK,SAAS;IAC/D;GAEJ;EACF;EAEA,OAAO;CACT;;;;;;;;CASA,aAAa,UAIV;EACD,IAAI;GACF,MAAM,EAAE,SAAS,YAAY,MAAM,OAAO;GAC1C,MAAM,EAAE,YAAY,MAAM,OAAO;GACjC,OAAO;IAAE;IAAS;IAAS;GAAQ;EACrC,SAAS,GAAG;GACV,QAAQ,MAAM,CAAC;GACf,MAAM,IAAI,MACR,8HAAA,GAAA,0BAAA,OAAA,CAAoI,EAAE,gDACxI;EACF;CACF;AACF"}

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

@@ -2,7 +2,6 @@ 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
 declare const UnknownHandling: {
   readonly Ignore: "ignore";

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

@@ -1 +1 @@
-{"version":3,"file":"directory.d.cts","names":[],"sources":["../../../src/document_loaders/fs/directory.ts"],"mappings":";;;;;;cAQa,eAAA;EAAA,SACX,MAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA;AAAA;;;;KAKU,eAAA,WACF,eAAA,eAA8B,eAAA;;;AADxC;;;UAQiB,cAAA;EAAA,CACd,SAAA,YAAqB,QAAA,aAAqB,kBAAA;AAAA;;;;;;;;;AAqB7C;;;;;;;;;;cAAa,eAAA,SAAwB,kBAAA;EAE1B,aAAA;EACA,OAAA,EAAS,cAAA;EACT,SAAA;EACA,OAAA,EAAS,eAAA;EAJlB,WAAA,CACS,aAAA,UACA,OAAA,EAAS,cAAA,EACT,SAAA,YACA,OAAA,GAAS,eAAA;EALiB;;;;;;;;;;EA+BtB,IAAA,CAAA,GAAQ,OAAA,CAAQ,QAAA;EA3BpB;;;;;;;EAAA,OA8EI,OAAA,CAAA,GAAW,OAAA;IACtB,OAAA,SAAgB,OAAA;IAChB,OAAA,SAAgB,OAAA;IAChB,OAAA,SAAgB,OAAA;EAAA;AAAA"}
+{"version":3,"file":"directory.d.cts","names":[],"sources":["../../../src/document_loaders/fs/directory.ts"],"mappings":";;;;;cAQa;WACX;WACA;WACA;;;;;KAKU,0BACF,8BAA8B;;;;;;UAOvB;GACd,qBAAqB,qBAAqB;;;;;;;;;;;;;;;;;;;;cAqBhC,wBAAwB;EAE1B;EACA,SAAS;EACT;EACA,SAAS;EAJlB,YACS,uBACA,SAAS,gBACT,qBACA,UAAS;;;;;;;;;;;EA0BL,QAAQ,QAAQ;;;;;;;;SAmDhB,WAAW;IACtB,gBAAgB;IAChB,gBAAgB;IAChB,gBAAgB"}

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

@@ -2,7 +2,6 @@ import { extname, resolve } from "node:path";
 import { readdir } from "node:fs/promises";
 import { Document } from "@langchain/core/documents";
 import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
-
 //#region src/document_loaders/fs/directory.d.ts
 declare const UnknownHandling: {
   readonly Ignore: "ignore";

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

@@ -1 +1 @@
-{"version":3,"file":"directory.d.ts","names":[],"sources":["../../../src/document_loaders/fs/directory.ts"],"mappings":";;;;;;cAQa,eAAA;EAAA,SACX,MAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA;AAAA;;;;KAKU,eAAA,WACF,eAAA,eAA8B,eAAA;;;AADxC;;;UAQiB,cAAA;EAAA,CACd,SAAA,YAAqB,QAAA,aAAqB,kBAAA;AAAA;;;;;;;;;AAqB7C;;;;;;;;;;cAAa,eAAA,SAAwB,kBAAA;EAE1B,aAAA;EACA,OAAA,EAAS,cAAA;EACT,SAAA;EACA,OAAA,EAAS,eAAA;EAJlB,WAAA,CACS,aAAA,UACA,OAAA,EAAS,cAAA,EACT,SAAA,YACA,OAAA,GAAS,eAAA;EALiB;;;;;;;;;;EA+BtB,IAAA,CAAA,GAAQ,OAAA,CAAQ,QAAA;EA3BpB;;;;;;;EAAA,OA8EI,OAAA,CAAA,GAAW,OAAA;IACtB,OAAA,SAAgB,OAAA;IAChB,OAAA,SAAgB,OAAA;IAChB,OAAA,SAAgB,OAAA;EAAA;AAAA"}
+{"version":3,"file":"directory.d.ts","names":[],"sources":["../../../src/document_loaders/fs/directory.ts"],"mappings":";;;;;cAQa;WACX;WACA;WACA;;;;;KAKU,0BACF,8BAA8B;;;;;;UAOvB;GACd,qBAAqB,qBAAqB;;;;;;;;;;;;;;;;;;;;cAqBhC,wBAAwB;EAE1B;EACA,SAAS;EACT;EACA,SAAS;EAJlB,YACS,uBACA,SAAS,gBACT,qBACA,UAAS;;;;;;;;;;;EA0BL,QAAQ,QAAQ;;;;;;;;SAmDhB,WAAW;IACtB,gBAAgB;IAChB,gBAAgB;IAChB,gBAAgB"}

package/dist/document_loaders/fs/directory.js

@@ -30,6 +30,10 @@ const UnknownHandling = {
 * ```
 */
 var DirectoryLoader = class DirectoryLoader extends BaseDocumentLoader {
+	directoryPath;
+	loaders;
+	recursive;
+	unknown;
 	constructor(directoryPath, loaders, recursive = true, unknown = UnknownHandling.Warn) {
 		super();
 		this.directoryPath = directoryPath;

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

@@ -1 +1 @@
-{"version":3,"file":"directory.js","names":[],"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;CACR;;;;;;;;;;;;;;;;;;;AAkCD,IAAa,kBAAb,MAAa,wBAAwB,mBAAmB;CACtD,YACE,eACA,SACA,YAA4B,MAC5B,UAAkC,gBAAgB,MAClD;AACA,SAAO;AALA,OAAA,gBAAA;AACA,OAAA,UAAA;AACA,OAAA,YAAA;AACA,OAAA,UAAA;AAIP,MAAI,OAAO,KAAK,QAAQ,CAAC,WAAW,EAClC,OAAM,IAAI,MAAM,mCAAmC;AAErD,OAAK,MAAM,aAAa,QACtB,KAAI,OAAO,OAAO,SAAS,UAAU;OAC/B,UAAU,OAAO,IACnB,OAAM,IAAI,MAAM,oCAAoC,YAAY;;;;;;;;;;;;;CAgBxE,MAAa,OAA4B;EACvC,MAAM,EAAE,SAAS,SAAS,YAAY,MAAM,gBAAgB,SAAS;EACrE,MAAM,QAAQ,MAAM,QAAQ,KAAK,eAAe,EAAE,eAAe,MAAM,CAAC;EAExE,MAAM,YAAwB,EAAE;AAEhC,OAAK,MAAM,QAAQ,OAAO;GACxB,MAAM,WAAW,QAAQ,KAAK,eAAe,KAAK,KAAK;AACvD,OAAI,KAAK,aAAa;QAChB,KAAK,WAAW;KAClB,MAAM,SAAS,IAAI,gBACjB,UACA,KAAK,SACL,KAAK,WACL,KAAK,QACN;AACD,eAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;;UAErC;IAGL,MAAM,gBAAgB,KAAK,QAAQ,QAAQ,KAAK,KAAK;AACrD,QAAI,eAAe;KACjB,MAAM,SAAS,cAAc,SAAS;AACtC,eAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;UAExC,SAAQ,KAAK,SAAb;KACE,KAAK,gBAAgB,OACnB;KACF,KAAK,gBAAgB;AACnB,cAAQ,KAAK,sBAAsB,KAAK,OAAO;AAC/C;KACF,KAAK,gBAAgB,MACnB,OAAM,IAAI,MAAM,sBAAsB,KAAK,OAAO;KACpD,QACE,OAAM,IAAI,MAAM,6BAA6B,KAAK,UAAU;;;;AAMtE,SAAO;;;;;;;;;CAUT,aAAa,UAIV;AACD,MAAI;GACF,MAAM,EAAE,SAAS,YAAY,MAAM,OAAO;GAC1C,MAAM,EAAE,YAAY,MAAM,OAAO;AACjC,UAAO;IAAE;IAAS;IAAS;IAAS;WAC7B,GAAG;AACV,WAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR,6HAA6H,QAAQ,CAAC,iDACvI"}
+{"version":3,"file":"directory.js","names":[],"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;AACT;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,kBAAb,MAAa,wBAAwB,mBAAmB;CAE7C;CACA;CACA;CACA;CAJT,YACE,eACA,SACA,YAA4B,MAC5B,UAAkC,gBAAgB,MAClD;EACA,MAAM;EALC,KAAA,gBAAA;EACA,KAAA,UAAA;EACA,KAAA,YAAA;EACA,KAAA,UAAA;EAIP,IAAI,OAAO,KAAK,OAAO,CAAC,CAAC,WAAW,GAClC,MAAM,IAAI,MAAM,kCAAkC;EAEpD,KAAK,MAAM,aAAa,SACtB,IAAI,OAAO,OAAO,SAAS,SAAS,GAC9B;OAAA,UAAU,OAAO,KACnB,MAAM,IAAI,MAAM,oCAAoC,WAAW;EAAA;CAIvE;;;;;;;;;;;CAYA,MAAa,OAA4B;EACvC,MAAM,EAAE,SAAS,SAAS,YAAY,MAAM,gBAAgB,QAAQ;EACpE,MAAM,QAAQ,MAAM,QAAQ,KAAK,eAAe,EAAE,eAAe,KAAK,CAAC;EAEvE,MAAM,YAAwB,CAAC;EAE/B,KAAK,MAAM,QAAQ,OAAO;GACxB,MAAM,WAAW,QAAQ,KAAK,eAAe,KAAK,IAAI;GACtD,IAAI,KAAK,YAAY,GACf;QAAA,KAAK,WAAW;KAClB,MAAM,SAAS,IAAI,gBACjB,UACA,KAAK,SACL,KAAK,WACL,KAAK,OACP;KACA,UAAU,KAAK,GAAI,MAAM,OAAO,KAAK,CAAE;IACzC;UACK;IAGL,MAAM,gBAAgB,KAAK,QAAQ,QAAQ,KAAK,IAAI;IACpD,IAAI,eAAe;KACjB,MAAM,SAAS,cAAc,QAAQ;KACrC,UAAU,KAAK,GAAI,MAAM,OAAO,KAAK,CAAE;IACzC,OACE,QAAQ,KAAK,SAAb;KACE,KAAK,gBAAgB,QACnB;KACF,KAAK,gBAAgB;MACnB,QAAQ,KAAK,sBAAsB,KAAK,MAAM;MAC9C;KACF,KAAK,gBAAgB,OACnB,MAAM,IAAI,MAAM,sBAAsB,KAAK,MAAM;KACnD,SACE,MAAM,IAAI,MAAM,6BAA6B,KAAK,SAAS;IAC/D;GAEJ;EACF;EAEA,OAAO;CACT;;;;;;;;CASA,aAAa,UAIV;EACD,IAAI;GACF,MAAM,EAAE,SAAS,YAAY,MAAM,OAAO;GAC1C,MAAM,EAAE,YAAY,MAAM,OAAO;GACjC,OAAO;IAAE;IAAS;IAAS;GAAQ;EACrC,SAAS,GAAG;GACV,QAAQ,MAAM,CAAC;GACf,MAAM,IAAI,MACR,6HAA6H,OAAO,EAAE,gDACxI;EACF;CACF;AACF"}

package/dist/document_loaders/fs/json.cjs

@@ -89,6 +89,7 @@ var JSONLoader = class extends require_document_loaders_fs_text.TextLoader {
 * specifies the JSON pointer to extract.
 */
 var JSONLinesLoader = class extends require_document_loaders_fs_text.TextLoader {
+	pointer;
 	constructor(filePathOrBlob, pointer) {
 		super(filePathOrBlob);
 		this.pointer = pointer;

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

@@ -1 +1 @@
-{"version":3,"file":"json.cjs","names":["TextLoader"],"sources":["../../../src/document_loaders/fs/json.ts"],"sourcesContent":["import jsonpointer from \"jsonpointer\";\nimport { TextLoader } from \"./text.js\";\n\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON files. It has a constructor that\n * takes a `filePathOrBlob` parameter representing the path to the JSON\n * file or a `Blob` object, and an optional `pointers` parameter that\n * specifies the JSON pointers to extract.\n */\nexport class JSONLoader extends TextLoader {\n  public pointers: string[];\n\n  constructor(filePathOrBlob: string | Blob, pointers: string | string[] = []) {\n    super(filePathOrBlob);\n    this.pointers = Array.isArray(pointers) ? pointers : [pointers];\n  }\n\n  /**\n   * Method that takes a `raw` string as a parameter and returns a promise\n   * that resolves to an array of strings. It parses the raw JSON string and\n   * extracts the values based on the specified JSON pointers. If no JSON\n   * pointers are specified, it extracts all the strings from the JSON\n   * object.\n   * @param raw The raw JSON string to parse.\n   * @returns A promise that resolves to an array of strings.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    const json = JSON.parse(raw.trim());\n    // If there is no pointers specified we extract all strings we found\n    const extractAllStrings = !(this.pointers.length > 0);\n    const compiledPointers = this.pointers.map((pointer) =>\n      jsonpointer.compile(pointer)\n    );\n\n    return this.extractArrayStringsFromObject(\n      json,\n      compiledPointers,\n      extractAllStrings\n    );\n  }\n\n  /**\n   * If JSON pointers are specified, return all strings below any of them\n   * and exclude all other nodes expect if they match a JSON pointer (to allow to extract strings from different levels)\n   *\n   * If no JSON pointer is specified then return all string in the object\n   */\n  private extractArrayStringsFromObject(\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    json: any,\n    pointers: jsonpointer[],\n    extractAllStrings = false,\n    keyHasBeenFound = false\n  ): string[] {\n    if (!json) {\n      return [];\n    }\n\n    if (typeof json === \"string\" && extractAllStrings) {\n      return [json];\n    }\n\n    if (Array.isArray(json) && extractAllStrings) {\n      let extractedString: string[] = [];\n      for (const element of json) {\n        extractedString = extractedString.concat(\n          this.extractArrayStringsFromObject(element, pointers, true)\n        );\n      }\n\n      return extractedString;\n    }\n\n    if (typeof json === \"object\") {\n      if (extractAllStrings) {\n        return this.extractArrayStringsFromObject(\n          Object.values(json),\n          pointers,\n          true\n        );\n      }\n\n      const targetedEntries = this.getTargetedEntries(json, pointers);\n      const thisLevelEntries = Object.values(json) as object[];\n      const notTargetedEntries = thisLevelEntries.filter(\n        (entry: object) => !targetedEntries.includes(entry)\n      );\n\n      let extractedStrings: string[] = [];\n      // If we found a targeted entry, we extract all strings from it\n      if (targetedEntries.length > 0) {\n        for (const oneEntry of targetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(oneEntry, pointers, true, true)\n          );\n        }\n\n        for (const oneEntry of notTargetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(oneEntry, pointers, false, true)\n          );\n        }\n      } else if (extractAllStrings || !keyHasBeenFound) {\n        for (const oneEntry of notTargetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(\n              oneEntry,\n              pointers,\n              extractAllStrings\n            )\n          );\n        }\n      }\n\n      return extractedStrings;\n    }\n\n    return [];\n  }\n\n  /**\n   * Method that takes a `json` object and an array of `pointers` as\n   * parameters and returns an array of targeted entries. It iterates over\n   * the JSON pointers and uses the `jsonpointer.get()` function to get the\n   * targeted entries from the JSON object.\n   * @param json The JSON object to get targeted entries from.\n   * @param pointers The JSON pointers to get targeted entries.\n   * @returns An array of targeted entries.\n   */\n  private getTargetedEntries(json: object, pointers: jsonpointer[]): object[] {\n    const targetEntries = [];\n    for (const pointer of pointers) {\n      const targetedEntry = pointer.get(json);\n      if (targetedEntry) {\n        targetEntries.push(targetedEntry);\n      }\n    }\n\n    return targetEntries;\n  }\n}\n\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON Lines files. It has a constructor\n * that takes a `filePathOrBlob` parameter representing the path to the\n * JSON Lines file or a `Blob` object, and a `pointer` parameter that\n * specifies the JSON pointer to extract.\n */\nexport class JSONLinesLoader extends TextLoader {\n  constructor(\n    filePathOrBlob: string | Blob,\n    public pointer: string\n  ) {\n    super(filePathOrBlob);\n  }\n\n  /**\n   * Method that takes a `raw` string as a parameter and returns a promise\n   * that resolves to an array of strings. It parses the raw JSON Lines\n   * string, splits it into lines, parses each line as JSON, and extracts\n   * the values based on the specified JSON pointer.\n   * @param raw The raw JSON Lines string to parse.\n   * @returns A promise that resolves to an array of strings.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    const lines = raw.split(\"\\n\");\n    const jsons = lines\n      .map((line) => line.trim())\n      .filter(Boolean)\n      .map((line) => JSON.parse(line));\n    const pointer = jsonpointer.compile(this.pointer);\n    return jsons.map((json) => {\n      const data = pointer.get(json);\n      if (typeof data === \"string\") {\n        return data;\n      }\n      if (!data) {\n        return \"\";\n      }\n      if (typeof data === \"object\") {\n        return JSON.stringify(data);\n      }\n      return \"\";\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAUA,IAAa,aAAb,cAAgCA,iCAAAA,WAAW;CACzC;CAEA,YAAY,gBAA+B,WAA8B,EAAE,EAAE;AAC3E,QAAM,eAAe;AACrB,OAAK,WAAW,MAAM,QAAQ,SAAS,GAAG,WAAW,CAAC,SAAS;;;;;;;;;;;CAYjE,MAAgB,MAAM,KAAgC;EACpD,MAAM,OAAO,KAAK,MAAM,IAAI,MAAM,CAAC;EAEnC,MAAM,oBAAoB,EAAE,KAAK,SAAS,SAAS;EACnD,MAAM,mBAAmB,KAAK,SAAS,KAAK,YAC1C,YAAA,QAAY,QAAQ,QAAQ,CAC7B;AAED,SAAO,KAAK,8BACV,MACA,kBACA,kBACD;;;;;;;;CASH,8BAEE,MACA,UACA,oBAAoB,OACpB,kBAAkB,OACR;AACV,MAAI,CAAC,KACH,QAAO,EAAE;AAGX,MAAI,OAAO,SAAS,YAAY,kBAC9B,QAAO,CAAC,KAAK;AAGf,MAAI,MAAM,QAAQ,KAAK,IAAI,mBAAmB;GAC5C,IAAI,kBAA4B,EAAE;AAClC,QAAK,MAAM,WAAW,KACpB,mBAAkB,gBAAgB,OAChC,KAAK,8BAA8B,SAAS,UAAU,KAAK,CAC5D;AAGH,UAAO;;AAGT,MAAI,OAAO,SAAS,UAAU;AAC5B,OAAI,kBACF,QAAO,KAAK,8BACV,OAAO,OAAO,KAAK,EACnB,UACA,KACD;GAGH,MAAM,kBAAkB,KAAK,mBAAmB,MAAM,SAAS;GAE/D,MAAM,qBADmB,OAAO,OAAO,KACI,CAAC,QACzC,UAAkB,CAAC,gBAAgB,SAAS,MAAM,CACpD;GAED,IAAI,mBAA6B,EAAE;AAEnC,OAAI,gBAAgB,SAAS,GAAG;AAC9B,SAAK,MAAM,YAAY,gBACrB,oBAAmB,iBAAiB,OAClC,KAAK,8BAA8B,UAAU,UAAU,MAAM,KAAK,CACnE;AAGH,SAAK,MAAM,YAAY,mBACrB,oBAAmB,iBAAiB,OAClC,KAAK,8BAA8B,UAAU,UAAU,OAAO,KAAK,CACpE;cAEM,qBAAqB,CAAC,gBAC/B,MAAK,MAAM,YAAY,mBACrB,oBAAmB,iBAAiB,OAClC,KAAK,8BACH,UACA,UACA,kBACD,CACF;AAIL,UAAO;;AAGT,SAAO,EAAE;;;;;;;;;;;CAYX,mBAA2B,MAAc,UAAmC;EAC1E,MAAM,gBAAgB,EAAE;AACxB,OAAK,MAAM,WAAW,UAAU;GAC9B,MAAM,gBAAgB,QAAQ,IAAI,KAAK;AACvC,OAAI,cACF,eAAc,KAAK,cAAc;;AAIrC,SAAO;;;;;;;;;;AAWX,IAAa,kBAAb,cAAqCA,iCAAAA,WAAW;CAC9C,YACE,gBACA,SACA;AACA,QAAM,eAAe;AAFd,OAAA,UAAA;;;;;;;;;;CAaT,MAAgB,MAAM,KAAgC;EAEpD,MAAM,QADQ,IAAI,MAAM,KACL,CAChB,KAAK,SAAS,KAAK,MAAM,CAAC,CAC1B,OAAO,QAAQ,CACf,KAAK,SAAS,KAAK,MAAM,KAAK,CAAC;EAClC,MAAM,UAAU,YAAA,QAAY,QAAQ,KAAK,QAAQ;AACjD,SAAO,MAAM,KAAK,SAAS;GACzB,MAAM,OAAO,QAAQ,IAAI,KAAK;AAC9B,OAAI,OAAO,SAAS,SAClB,QAAO;AAET,OAAI,CAAC,KACH,QAAO;AAET,OAAI,OAAO,SAAS,SAClB,QAAO,KAAK,UAAU,KAAK;AAE7B,UAAO;IACP"}
+{"version":3,"file":"json.cjs","names":["TextLoader"],"sources":["../../../src/document_loaders/fs/json.ts"],"sourcesContent":["import jsonpointer from \"jsonpointer\";\nimport { TextLoader } from \"./text.js\";\n\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON files. It has a constructor that\n * takes a `filePathOrBlob` parameter representing the path to the JSON\n * file or a `Blob` object, and an optional `pointers` parameter that\n * specifies the JSON pointers to extract.\n */\nexport class JSONLoader extends TextLoader {\n  public pointers: string[];\n\n  constructor(filePathOrBlob: string | Blob, pointers: string | string[] = []) {\n    super(filePathOrBlob);\n    this.pointers = Array.isArray(pointers) ? pointers : [pointers];\n  }\n\n  /**\n   * Method that takes a `raw` string as a parameter and returns a promise\n   * that resolves to an array of strings. It parses the raw JSON string and\n   * extracts the values based on the specified JSON pointers. If no JSON\n   * pointers are specified, it extracts all the strings from the JSON\n   * object.\n   * @param raw The raw JSON string to parse.\n   * @returns A promise that resolves to an array of strings.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    const json = JSON.parse(raw.trim());\n    // If there is no pointers specified we extract all strings we found\n    const extractAllStrings = !(this.pointers.length > 0);\n    const compiledPointers = this.pointers.map((pointer) =>\n      jsonpointer.compile(pointer)\n    );\n\n    return this.extractArrayStringsFromObject(\n      json,\n      compiledPointers,\n      extractAllStrings\n    );\n  }\n\n  /**\n   * If JSON pointers are specified, return all strings below any of them\n   * and exclude all other nodes expect if they match a JSON pointer (to allow to extract strings from different levels)\n   *\n   * If no JSON pointer is specified then return all string in the object\n   */\n  private extractArrayStringsFromObject(\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    json: any,\n    pointers: jsonpointer[],\n    extractAllStrings = false,\n    keyHasBeenFound = false\n  ): string[] {\n    if (!json) {\n      return [];\n    }\n\n    if (typeof json === \"string\" && extractAllStrings) {\n      return [json];\n    }\n\n    if (Array.isArray(json) && extractAllStrings) {\n      let extractedString: string[] = [];\n      for (const element of json) {\n        extractedString = extractedString.concat(\n          this.extractArrayStringsFromObject(element, pointers, true)\n        );\n      }\n\n      return extractedString;\n    }\n\n    if (typeof json === \"object\") {\n      if (extractAllStrings) {\n        return this.extractArrayStringsFromObject(\n          Object.values(json),\n          pointers,\n          true\n        );\n      }\n\n      const targetedEntries = this.getTargetedEntries(json, pointers);\n      const thisLevelEntries = Object.values(json) as object[];\n      const notTargetedEntries = thisLevelEntries.filter(\n        (entry: object) => !targetedEntries.includes(entry)\n      );\n\n      let extractedStrings: string[] = [];\n      // If we found a targeted entry, we extract all strings from it\n      if (targetedEntries.length > 0) {\n        for (const oneEntry of targetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(oneEntry, pointers, true, true)\n          );\n        }\n\n        for (const oneEntry of notTargetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(oneEntry, pointers, false, true)\n          );\n        }\n      } else if (extractAllStrings || !keyHasBeenFound) {\n        for (const oneEntry of notTargetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(\n              oneEntry,\n              pointers,\n              extractAllStrings\n            )\n          );\n        }\n      }\n\n      return extractedStrings;\n    }\n\n    return [];\n  }\n\n  /**\n   * Method that takes a `json` object and an array of `pointers` as\n   * parameters and returns an array of targeted entries. It iterates over\n   * the JSON pointers and uses the `jsonpointer.get()` function to get the\n   * targeted entries from the JSON object.\n   * @param json The JSON object to get targeted entries from.\n   * @param pointers The JSON pointers to get targeted entries.\n   * @returns An array of targeted entries.\n   */\n  private getTargetedEntries(json: object, pointers: jsonpointer[]): object[] {\n    const targetEntries = [];\n    for (const pointer of pointers) {\n      const targetedEntry = pointer.get(json);\n      if (targetedEntry) {\n        targetEntries.push(targetedEntry);\n      }\n    }\n\n    return targetEntries;\n  }\n}\n\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON Lines files. It has a constructor\n * that takes a `filePathOrBlob` parameter representing the path to the\n * JSON Lines file or a `Blob` object, and a `pointer` parameter that\n * specifies the JSON pointer to extract.\n */\nexport class JSONLinesLoader extends TextLoader {\n  constructor(\n    filePathOrBlob: string | Blob,\n    public pointer: string\n  ) {\n    super(filePathOrBlob);\n  }\n\n  /**\n   * Method that takes a `raw` string as a parameter and returns a promise\n   * that resolves to an array of strings. It parses the raw JSON Lines\n   * string, splits it into lines, parses each line as JSON, and extracts\n   * the values based on the specified JSON pointer.\n   * @param raw The raw JSON Lines string to parse.\n   * @returns A promise that resolves to an array of strings.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    const lines = raw.split(\"\\n\");\n    const jsons = lines\n      .map((line) => line.trim())\n      .filter(Boolean)\n      .map((line) => JSON.parse(line));\n    const pointer = jsonpointer.compile(this.pointer);\n    return jsons.map((json) => {\n      const data = pointer.get(json);\n      if (typeof data === \"string\") {\n        return data;\n      }\n      if (!data) {\n        return \"\";\n      }\n      if (typeof data === \"object\") {\n        return JSON.stringify(data);\n      }\n      return \"\";\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAUA,IAAa,aAAb,cAAgCA,iCAAAA,WAAW;CACzC;CAEA,YAAY,gBAA+B,WAA8B,CAAC,GAAG;EAC3E,MAAM,cAAc;EACpB,KAAK,WAAW,MAAM,QAAQ,QAAQ,IAAI,WAAW,CAAC,QAAQ;CAChE;;;;;;;;;;CAWA,MAAgB,MAAM,KAAgC;EACpD,MAAM,OAAO,KAAK,MAAM,IAAI,KAAK,CAAC;EAElC,MAAM,oBAAoB,EAAE,KAAK,SAAS,SAAS;EACnD,MAAM,mBAAmB,KAAK,SAAS,KAAK,YAC1C,YAAA,QAAY,QAAQ,OAAO,CAC7B;EAEA,OAAO,KAAK,8BACV,MACA,kBACA,iBACF;CACF;;;;;;;CAQA,8BAEE,MACA,UACA,oBAAoB,OACpB,kBAAkB,OACR;EACV,IAAI,CAAC,MACH,OAAO,CAAC;EAGV,IAAI,OAAO,SAAS,YAAY,mBAC9B,OAAO,CAAC,IAAI;EAGd,IAAI,MAAM,QAAQ,IAAI,KAAK,mBAAmB;GAC5C,IAAI,kBAA4B,CAAC;GACjC,KAAK,MAAM,WAAW,MACpB,kBAAkB,gBAAgB,OAChC,KAAK,8BAA8B,SAAS,UAAU,IAAI,CAC5D;GAGF,OAAO;EACT;EAEA,IAAI,OAAO,SAAS,UAAU;GAC5B,IAAI,mBACF,OAAO,KAAK,8BACV,OAAO,OAAO,IAAI,GAClB,UACA,IACF;GAGF,MAAM,kBAAkB,KAAK,mBAAmB,MAAM,QAAQ;GAE9D,MAAM,qBADmB,OAAO,OAAO,IACG,CAAC,CAAC,QACzC,UAAkB,CAAC,gBAAgB,SAAS,KAAK,CACpD;GAEA,IAAI,mBAA6B,CAAC;GAElC,IAAI,gBAAgB,SAAS,GAAG;IAC9B,KAAK,MAAM,YAAY,iBACrB,mBAAmB,iBAAiB,OAClC,KAAK,8BAA8B,UAAU,UAAU,MAAM,IAAI,CACnE;IAGF,KAAK,MAAM,YAAY,oBACrB,mBAAmB,iBAAiB,OAClC,KAAK,8BAA8B,UAAU,UAAU,OAAO,IAAI,CACpE;GAEJ,OAAO,IAAI,qBAAqB,CAAC,iBAC/B,KAAK,MAAM,YAAY,oBACrB,mBAAmB,iBAAiB,OAClC,KAAK,8BACH,UACA,UACA,iBACF,CACF;GAIJ,OAAO;EACT;EAEA,OAAO,CAAC;CACV;;;;;;;;;;CAWA,mBAA2B,MAAc,UAAmC;EAC1E,MAAM,gBAAgB,CAAC;EACvB,KAAK,MAAM,WAAW,UAAU;GAC9B,MAAM,gBAAgB,QAAQ,IAAI,IAAI;GACtC,IAAI,eACF,cAAc,KAAK,aAAa;EAEpC;EAEA,OAAO;CACT;AACF;;;;;;;;AASA,IAAa,kBAAb,cAAqCA,iCAAAA,WAAW;CAGrC;CAFT,YACE,gBACA,SACA;EACA,MAAM,cAAc;EAFb,KAAA,UAAA;CAGT;;;;;;;;;CAUA,MAAgB,MAAM,KAAgC;EAEpD,MAAM,QADQ,IAAI,MAAM,IACN,CAAC,CAChB,KAAK,SAAS,KAAK,KAAK,CAAC,CAAC,CAC1B,OAAO,OAAO,CAAC,CACf,KAAK,SAAS,KAAK,MAAM,IAAI,CAAC;EACjC,MAAM,UAAU,YAAA,QAAY,QAAQ,KAAK,OAAO;EAChD,OAAO,MAAM,KAAK,SAAS;GACzB,MAAM,OAAO,QAAQ,IAAI,IAAI;GAC7B,IAAI,OAAO,SAAS,UAClB,OAAO;GAET,IAAI,CAAC,MACH,OAAO;GAET,IAAI,OAAO,SAAS,UAClB,OAAO,KAAK,UAAU,IAAI;GAE5B,OAAO;EACT,CAAC;CACH;AACF"}

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

@@ -1,5 +1,4 @@
 import { TextLoader } from "./text.cjs";
-
 //#region src/document_loaders/fs/json.d.ts
 /**
  * Class that extends the `TextLoader` class. It represents a document

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

@@ -1 +1 @@
-{"version":3,"file":"json.d.cts","names":[],"sources":["../../../src/document_loaders/fs/json.ts"],"mappings":";;;;;AAUA;;;;;cAAa,UAAA,SAAmB,UAAA;EACvB,QAAA;EAEP,WAAA,CAAY,cAAA,WAAyB,IAAA,EAAM,QAAA;EAHb;;;;;;;;;EAAA,UAiBd,KAAA,CAAM,GAAA,WAAc,OAAA;EAuG5B;;;AAoBV;;;EApBU,QAlFA,6BAAA;EAsH4B;;;;;;;;;EAAA,QApC5B,kBAAA;AAAA;;;;;;;;cAoBG,eAAA,SAAwB,UAAA;EAG1B,OAAA;EAFT,WAAA,CACE,cAAA,WAAyB,IAAA,EAClB,OAAA;;;;;;;;;YAaO,KAAA,CAAM,GAAA,WAAc,OAAA;AAAA"}
+{"version":3,"file":"json.d.cts","names":[],"sources":["../../../src/document_loaders/fs/json.ts"],"mappings":";;;;;;;;;cAUa,mBAAmB;EACvB;EAEP,YAAY,yBAAyB,MAAM;;;;;;;;;;YAc3B,MAAM,cAAc;;;;;;;UAqB5B;;;;;;;;;;UAkFA;;;;;;;;;cAoBG,wBAAwB;EAG1B;EAFT,YACE,yBAAyB,MAClB;;;;;;;;;YAaO,MAAM,cAAc"}

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

@@ -1,5 +1,4 @@
 import { TextLoader } from "./text.js";
-
 //#region src/document_loaders/fs/json.d.ts
 /**
  * Class that extends the `TextLoader` class. It represents a document

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

@@ -1 +1 @@
-{"version":3,"file":"json.d.ts","names":[],"sources":["../../../src/document_loaders/fs/json.ts"],"mappings":";;;;;AAUA;;;;;cAAa,UAAA,SAAmB,UAAA;EACvB,QAAA;EAEP,WAAA,CAAY,cAAA,WAAyB,IAAA,EAAM,QAAA;EAHb;;;;;;;;;EAAA,UAiBd,KAAA,CAAM,GAAA,WAAc,OAAA;EAuG5B;;;AAoBV;;;EApBU,QAlFA,6BAAA;EAsH4B;;;;;;;;;EAAA,QApC5B,kBAAA;AAAA;;;;;;;;cAoBG,eAAA,SAAwB,UAAA;EAG1B,OAAA;EAFT,WAAA,CACE,cAAA,WAAyB,IAAA,EAClB,OAAA;;;;;;;;;YAaO,KAAA,CAAM,GAAA,WAAc,OAAA;AAAA"}
+{"version":3,"file":"json.d.ts","names":[],"sources":["../../../src/document_loaders/fs/json.ts"],"mappings":";;;;;;;;;cAUa,mBAAmB;EACvB;EAEP,YAAY,yBAAyB,MAAM;;;;;;;;;;YAc3B,MAAM,cAAc;;;;;;;UAqB5B;;;;;;;;;;UAkFA;;;;;;;;;cAoBG,wBAAwB;EAG1B;EAFT,YACE,yBAAyB,MAClB;;;;;;;;;YAaO,MAAM,cAAc"}

package/dist/document_loaders/fs/json.js

@@ -87,6 +87,7 @@ var JSONLoader = class extends TextLoader {
 * specifies the JSON pointer to extract.
 */
 var JSONLinesLoader = class extends TextLoader {
+	pointer;
 	constructor(filePathOrBlob, pointer) {
 		super(filePathOrBlob);
 		this.pointer = pointer;

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

@@ -1 +1 @@
-{"version":3,"file":"json.js","names":[],"sources":["../../../src/document_loaders/fs/json.ts"],"sourcesContent":["import jsonpointer from \"jsonpointer\";\nimport { TextLoader } from \"./text.js\";\n\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON files. It has a constructor that\n * takes a `filePathOrBlob` parameter representing the path to the JSON\n * file or a `Blob` object, and an optional `pointers` parameter that\n * specifies the JSON pointers to extract.\n */\nexport class JSONLoader extends TextLoader {\n  public pointers: string[];\n\n  constructor(filePathOrBlob: string | Blob, pointers: string | string[] = []) {\n    super(filePathOrBlob);\n    this.pointers = Array.isArray(pointers) ? pointers : [pointers];\n  }\n\n  /**\n   * Method that takes a `raw` string as a parameter and returns a promise\n   * that resolves to an array of strings. It parses the raw JSON string and\n   * extracts the values based on the specified JSON pointers. If no JSON\n   * pointers are specified, it extracts all the strings from the JSON\n   * object.\n   * @param raw The raw JSON string to parse.\n   * @returns A promise that resolves to an array of strings.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    const json = JSON.parse(raw.trim());\n    // If there is no pointers specified we extract all strings we found\n    const extractAllStrings = !(this.pointers.length > 0);\n    const compiledPointers = this.pointers.map((pointer) =>\n      jsonpointer.compile(pointer)\n    );\n\n    return this.extractArrayStringsFromObject(\n      json,\n      compiledPointers,\n      extractAllStrings\n    );\n  }\n\n  /**\n   * If JSON pointers are specified, return all strings below any of them\n   * and exclude all other nodes expect if they match a JSON pointer (to allow to extract strings from different levels)\n   *\n   * If no JSON pointer is specified then return all string in the object\n   */\n  private extractArrayStringsFromObject(\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    json: any,\n    pointers: jsonpointer[],\n    extractAllStrings = false,\n    keyHasBeenFound = false\n  ): string[] {\n    if (!json) {\n      return [];\n    }\n\n    if (typeof json === \"string\" && extractAllStrings) {\n      return [json];\n    }\n\n    if (Array.isArray(json) && extractAllStrings) {\n      let extractedString: string[] = [];\n      for (const element of json) {\n        extractedString = extractedString.concat(\n          this.extractArrayStringsFromObject(element, pointers, true)\n        );\n      }\n\n      return extractedString;\n    }\n\n    if (typeof json === \"object\") {\n      if (extractAllStrings) {\n        return this.extractArrayStringsFromObject(\n          Object.values(json),\n          pointers,\n          true\n        );\n      }\n\n      const targetedEntries = this.getTargetedEntries(json, pointers);\n      const thisLevelEntries = Object.values(json) as object[];\n      const notTargetedEntries = thisLevelEntries.filter(\n        (entry: object) => !targetedEntries.includes(entry)\n      );\n\n      let extractedStrings: string[] = [];\n      // If we found a targeted entry, we extract all strings from it\n      if (targetedEntries.length > 0) {\n        for (const oneEntry of targetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(oneEntry, pointers, true, true)\n          );\n        }\n\n        for (const oneEntry of notTargetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(oneEntry, pointers, false, true)\n          );\n        }\n      } else if (extractAllStrings || !keyHasBeenFound) {\n        for (const oneEntry of notTargetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(\n              oneEntry,\n              pointers,\n              extractAllStrings\n            )\n          );\n        }\n      }\n\n      return extractedStrings;\n    }\n\n    return [];\n  }\n\n  /**\n   * Method that takes a `json` object and an array of `pointers` as\n   * parameters and returns an array of targeted entries. It iterates over\n   * the JSON pointers and uses the `jsonpointer.get()` function to get the\n   * targeted entries from the JSON object.\n   * @param json The JSON object to get targeted entries from.\n   * @param pointers The JSON pointers to get targeted entries.\n   * @returns An array of targeted entries.\n   */\n  private getTargetedEntries(json: object, pointers: jsonpointer[]): object[] {\n    const targetEntries = [];\n    for (const pointer of pointers) {\n      const targetedEntry = pointer.get(json);\n      if (targetedEntry) {\n        targetEntries.push(targetedEntry);\n      }\n    }\n\n    return targetEntries;\n  }\n}\n\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON Lines files. It has a constructor\n * that takes a `filePathOrBlob` parameter representing the path to the\n * JSON Lines file or a `Blob` object, and a `pointer` parameter that\n * specifies the JSON pointer to extract.\n */\nexport class JSONLinesLoader extends TextLoader {\n  constructor(\n    filePathOrBlob: string | Blob,\n    public pointer: string\n  ) {\n    super(filePathOrBlob);\n  }\n\n  /**\n   * Method that takes a `raw` string as a parameter and returns a promise\n   * that resolves to an array of strings. It parses the raw JSON Lines\n   * string, splits it into lines, parses each line as JSON, and extracts\n   * the values based on the specified JSON pointer.\n   * @param raw The raw JSON Lines string to parse.\n   * @returns A promise that resolves to an array of strings.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    const lines = raw.split(\"\\n\");\n    const jsons = lines\n      .map((line) => line.trim())\n      .filter(Boolean)\n      .map((line) => JSON.parse(line));\n    const pointer = jsonpointer.compile(this.pointer);\n    return jsons.map((json) => {\n      const data = pointer.get(json);\n      if (typeof data === \"string\") {\n        return data;\n      }\n      if (!data) {\n        return \"\";\n      }\n      if (typeof data === \"object\") {\n        return JSON.stringify(data);\n      }\n      return \"\";\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAUA,IAAa,aAAb,cAAgC,WAAW;CACzC;CAEA,YAAY,gBAA+B,WAA8B,EAAE,EAAE;AAC3E,QAAM,eAAe;AACrB,OAAK,WAAW,MAAM,QAAQ,SAAS,GAAG,WAAW,CAAC,SAAS;;;;;;;;;;;CAYjE,MAAgB,MAAM,KAAgC;EACpD,MAAM,OAAO,KAAK,MAAM,IAAI,MAAM,CAAC;EAEnC,MAAM,oBAAoB,EAAE,KAAK,SAAS,SAAS;EACnD,MAAM,mBAAmB,KAAK,SAAS,KAAK,YAC1C,YAAY,QAAQ,QAAQ,CAC7B;AAED,SAAO,KAAK,8BACV,MACA,kBACA,kBACD;;;;;;;;CASH,8BAEE,MACA,UACA,oBAAoB,OACpB,kBAAkB,OACR;AACV,MAAI,CAAC,KACH,QAAO,EAAE;AAGX,MAAI,OAAO,SAAS,YAAY,kBAC9B,QAAO,CAAC,KAAK;AAGf,MAAI,MAAM,QAAQ,KAAK,IAAI,mBAAmB;GAC5C,IAAI,kBAA4B,EAAE;AAClC,QAAK,MAAM,WAAW,KACpB,mBAAkB,gBAAgB,OAChC,KAAK,8BAA8B,SAAS,UAAU,KAAK,CAC5D;AAGH,UAAO;;AAGT,MAAI,OAAO,SAAS,UAAU;AAC5B,OAAI,kBACF,QAAO,KAAK,8BACV,OAAO,OAAO,KAAK,EACnB,UACA,KACD;GAGH,MAAM,kBAAkB,KAAK,mBAAmB,MAAM,SAAS;GAE/D,MAAM,qBADmB,OAAO,OAAO,KACI,CAAC,QACzC,UAAkB,CAAC,gBAAgB,SAAS,MAAM,CACpD;GAED,IAAI,mBAA6B,EAAE;AAEnC,OAAI,gBAAgB,SAAS,GAAG;AAC9B,SAAK,MAAM,YAAY,gBACrB,oBAAmB,iBAAiB,OAClC,KAAK,8BAA8B,UAAU,UAAU,MAAM,KAAK,CACnE;AAGH,SAAK,MAAM,YAAY,mBACrB,oBAAmB,iBAAiB,OAClC,KAAK,8BAA8B,UAAU,UAAU,OAAO,KAAK,CACpE;cAEM,qBAAqB,CAAC,gBAC/B,MAAK,MAAM,YAAY,mBACrB,oBAAmB,iBAAiB,OAClC,KAAK,8BACH,UACA,UACA,kBACD,CACF;AAIL,UAAO;;AAGT,SAAO,EAAE;;;;;;;;;;;CAYX,mBAA2B,MAAc,UAAmC;EAC1E,MAAM,gBAAgB,EAAE;AACxB,OAAK,MAAM,WAAW,UAAU;GAC9B,MAAM,gBAAgB,QAAQ,IAAI,KAAK;AACvC,OAAI,cACF,eAAc,KAAK,cAAc;;AAIrC,SAAO;;;;;;;;;;AAWX,IAAa,kBAAb,cAAqC,WAAW;CAC9C,YACE,gBACA,SACA;AACA,QAAM,eAAe;AAFd,OAAA,UAAA;;;;;;;;;;CAaT,MAAgB,MAAM,KAAgC;EAEpD,MAAM,QADQ,IAAI,MAAM,KACL,CAChB,KAAK,SAAS,KAAK,MAAM,CAAC,CAC1B,OAAO,QAAQ,CACf,KAAK,SAAS,KAAK,MAAM,KAAK,CAAC;EAClC,MAAM,UAAU,YAAY,QAAQ,KAAK,QAAQ;AACjD,SAAO,MAAM,KAAK,SAAS;GACzB,MAAM,OAAO,QAAQ,IAAI,KAAK;AAC9B,OAAI,OAAO,SAAS,SAClB,QAAO;AAET,OAAI,CAAC,KACH,QAAO;AAET,OAAI,OAAO,SAAS,SAClB,QAAO,KAAK,UAAU,KAAK;AAE7B,UAAO;IACP"}
+{"version":3,"file":"json.js","names":[],"sources":["../../../src/document_loaders/fs/json.ts"],"sourcesContent":["import jsonpointer from \"jsonpointer\";\nimport { TextLoader } from \"./text.js\";\n\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON files. It has a constructor that\n * takes a `filePathOrBlob` parameter representing the path to the JSON\n * file or a `Blob` object, and an optional `pointers` parameter that\n * specifies the JSON pointers to extract.\n */\nexport class JSONLoader extends TextLoader {\n  public pointers: string[];\n\n  constructor(filePathOrBlob: string | Blob, pointers: string | string[] = []) {\n    super(filePathOrBlob);\n    this.pointers = Array.isArray(pointers) ? pointers : [pointers];\n  }\n\n  /**\n   * Method that takes a `raw` string as a parameter and returns a promise\n   * that resolves to an array of strings. It parses the raw JSON string and\n   * extracts the values based on the specified JSON pointers. If no JSON\n   * pointers are specified, it extracts all the strings from the JSON\n   * object.\n   * @param raw The raw JSON string to parse.\n   * @returns A promise that resolves to an array of strings.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    const json = JSON.parse(raw.trim());\n    // If there is no pointers specified we extract all strings we found\n    const extractAllStrings = !(this.pointers.length > 0);\n    const compiledPointers = this.pointers.map((pointer) =>\n      jsonpointer.compile(pointer)\n    );\n\n    return this.extractArrayStringsFromObject(\n      json,\n      compiledPointers,\n      extractAllStrings\n    );\n  }\n\n  /**\n   * If JSON pointers are specified, return all strings below any of them\n   * and exclude all other nodes expect if they match a JSON pointer (to allow to extract strings from different levels)\n   *\n   * If no JSON pointer is specified then return all string in the object\n   */\n  private extractArrayStringsFromObject(\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    json: any,\n    pointers: jsonpointer[],\n    extractAllStrings = false,\n    keyHasBeenFound = false\n  ): string[] {\n    if (!json) {\n      return [];\n    }\n\n    if (typeof json === \"string\" && extractAllStrings) {\n      return [json];\n    }\n\n    if (Array.isArray(json) && extractAllStrings) {\n      let extractedString: string[] = [];\n      for (const element of json) {\n        extractedString = extractedString.concat(\n          this.extractArrayStringsFromObject(element, pointers, true)\n        );\n      }\n\n      return extractedString;\n    }\n\n    if (typeof json === \"object\") {\n      if (extractAllStrings) {\n        return this.extractArrayStringsFromObject(\n          Object.values(json),\n          pointers,\n          true\n        );\n      }\n\n      const targetedEntries = this.getTargetedEntries(json, pointers);\n      const thisLevelEntries = Object.values(json) as object[];\n      const notTargetedEntries = thisLevelEntries.filter(\n        (entry: object) => !targetedEntries.includes(entry)\n      );\n\n      let extractedStrings: string[] = [];\n      // If we found a targeted entry, we extract all strings from it\n      if (targetedEntries.length > 0) {\n        for (const oneEntry of targetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(oneEntry, pointers, true, true)\n          );\n        }\n\n        for (const oneEntry of notTargetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(oneEntry, pointers, false, true)\n          );\n        }\n      } else if (extractAllStrings || !keyHasBeenFound) {\n        for (const oneEntry of notTargetedEntries) {\n          extractedStrings = extractedStrings.concat(\n            this.extractArrayStringsFromObject(\n              oneEntry,\n              pointers,\n              extractAllStrings\n            )\n          );\n        }\n      }\n\n      return extractedStrings;\n    }\n\n    return [];\n  }\n\n  /**\n   * Method that takes a `json` object and an array of `pointers` as\n   * parameters and returns an array of targeted entries. It iterates over\n   * the JSON pointers and uses the `jsonpointer.get()` function to get the\n   * targeted entries from the JSON object.\n   * @param json The JSON object to get targeted entries from.\n   * @param pointers The JSON pointers to get targeted entries.\n   * @returns An array of targeted entries.\n   */\n  private getTargetedEntries(json: object, pointers: jsonpointer[]): object[] {\n    const targetEntries = [];\n    for (const pointer of pointers) {\n      const targetedEntry = pointer.get(json);\n      if (targetedEntry) {\n        targetEntries.push(targetedEntry);\n      }\n    }\n\n    return targetEntries;\n  }\n}\n\n/**\n * Class that extends the `TextLoader` class. It represents a document\n * loader that loads documents from JSON Lines files. It has a constructor\n * that takes a `filePathOrBlob` parameter representing the path to the\n * JSON Lines file or a `Blob` object, and a `pointer` parameter that\n * specifies the JSON pointer to extract.\n */\nexport class JSONLinesLoader extends TextLoader {\n  constructor(\n    filePathOrBlob: string | Blob,\n    public pointer: string\n  ) {\n    super(filePathOrBlob);\n  }\n\n  /**\n   * Method that takes a `raw` string as a parameter and returns a promise\n   * that resolves to an array of strings. It parses the raw JSON Lines\n   * string, splits it into lines, parses each line as JSON, and extracts\n   * the values based on the specified JSON pointer.\n   * @param raw The raw JSON Lines string to parse.\n   * @returns A promise that resolves to an array of strings.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    const lines = raw.split(\"\\n\");\n    const jsons = lines\n      .map((line) => line.trim())\n      .filter(Boolean)\n      .map((line) => JSON.parse(line));\n    const pointer = jsonpointer.compile(this.pointer);\n    return jsons.map((json) => {\n      const data = pointer.get(json);\n      if (typeof data === \"string\") {\n        return data;\n      }\n      if (!data) {\n        return \"\";\n      }\n      if (typeof data === \"object\") {\n        return JSON.stringify(data);\n      }\n      return \"\";\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAUA,IAAa,aAAb,cAAgC,WAAW;CACzC;CAEA,YAAY,gBAA+B,WAA8B,CAAC,GAAG;EAC3E,MAAM,cAAc;EACpB,KAAK,WAAW,MAAM,QAAQ,QAAQ,IAAI,WAAW,CAAC,QAAQ;CAChE;;;;;;;;;;CAWA,MAAgB,MAAM,KAAgC;EACpD,MAAM,OAAO,KAAK,MAAM,IAAI,KAAK,CAAC;EAElC,MAAM,oBAAoB,EAAE,KAAK,SAAS,SAAS;EACnD,MAAM,mBAAmB,KAAK,SAAS,KAAK,YAC1C,YAAY,QAAQ,OAAO,CAC7B;EAEA,OAAO,KAAK,8BACV,MACA,kBACA,iBACF;CACF;;;;;;;CAQA,8BAEE,MACA,UACA,oBAAoB,OACpB,kBAAkB,OACR;EACV,IAAI,CAAC,MACH,OAAO,CAAC;EAGV,IAAI,OAAO,SAAS,YAAY,mBAC9B,OAAO,CAAC,IAAI;EAGd,IAAI,MAAM,QAAQ,IAAI,KAAK,mBAAmB;GAC5C,IAAI,kBAA4B,CAAC;GACjC,KAAK,MAAM,WAAW,MACpB,kBAAkB,gBAAgB,OAChC,KAAK,8BAA8B,SAAS,UAAU,IAAI,CAC5D;GAGF,OAAO;EACT;EAEA,IAAI,OAAO,SAAS,UAAU;GAC5B,IAAI,mBACF,OAAO,KAAK,8BACV,OAAO,OAAO,IAAI,GAClB,UACA,IACF;GAGF,MAAM,kBAAkB,KAAK,mBAAmB,MAAM,QAAQ;GAE9D,MAAM,qBADmB,OAAO,OAAO,IACG,CAAC,CAAC,QACzC,UAAkB,CAAC,gBAAgB,SAAS,KAAK,CACpD;GAEA,IAAI,mBAA6B,CAAC;GAElC,IAAI,gBAAgB,SAAS,GAAG;IAC9B,KAAK,MAAM,YAAY,iBACrB,mBAAmB,iBAAiB,OAClC,KAAK,8BAA8B,UAAU,UAAU,MAAM,IAAI,CACnE;IAGF,KAAK,MAAM,YAAY,oBACrB,mBAAmB,iBAAiB,OAClC,KAAK,8BAA8B,UAAU,UAAU,OAAO,IAAI,CACpE;GAEJ,OAAO,IAAI,qBAAqB,CAAC,iBAC/B,KAAK,MAAM,YAAY,oBACrB,mBAAmB,iBAAiB,OAClC,KAAK,8BACH,UACA,UACA,iBACF,CACF;GAIJ,OAAO;EACT;EAEA,OAAO,CAAC;CACV;;;;;;;;;;CAWA,mBAA2B,MAAc,UAAmC;EAC1E,MAAM,gBAAgB,CAAC;EACvB,KAAK,MAAM,WAAW,UAAU;GAC9B,MAAM,gBAAgB,QAAQ,IAAI,IAAI;GACtC,IAAI,eACF,cAAc,KAAK,aAAa;EAEpC;EAEA,OAAO;CACT;AACF;;;;;;;;AASA,IAAa,kBAAb,cAAqC,WAAW;CAGrC;CAFT,YACE,gBACA,SACA;EACA,MAAM,cAAc;EAFb,KAAA,UAAA;CAGT;;;;;;;;;CAUA,MAAgB,MAAM,KAAgC;EAEpD,MAAM,QADQ,IAAI,MAAM,IACN,CAAC,CAChB,KAAK,SAAS,KAAK,KAAK,CAAC,CAAC,CAC1B,OAAO,OAAO,CAAC,CACf,KAAK,SAAS,KAAK,MAAM,IAAI,CAAC;EACjC,MAAM,UAAU,YAAY,QAAQ,KAAK,OAAO;EAChD,OAAO,MAAM,KAAK,SAAS;GACzB,MAAM,OAAO,QAAQ,IAAI,IAAI;GAC7B,IAAI,OAAO,SAAS,UAClB,OAAO;GAET,IAAI,CAAC,MACH,OAAO;GAET,IAAI,OAAO,SAAS,UAClB,OAAO,KAAK,UAAU,IAAI;GAE5B,OAAO;EACT,CAAC;CACH;AACF"}

package/dist/document_loaders/fs/multi_file.cjs

@@ -25,6 +25,9 @@ var multi_file_exports = /* @__PURE__ */ require_runtime.__exportAll({ MultiFile
 * ```
 */
 var MultiFileLoader = class extends _langchain_core_document_loaders_base.BaseDocumentLoader {
+	filePaths;
+	loaders;
+	unknown;
 	constructor(filePaths, loaders, unknown = require_document_loaders_fs_directory.UnknownHandling.Warn) {
 		super();
 		this.filePaths = filePaths;

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

@@ -1 +1 @@
-{"version":3,"file":"multi_file.cjs","names":["BaseDocumentLoader","UnknownHandling"],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"sourcesContent":["import { extname, resolve } from \"node:path\";\nimport { stat } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport { type LoadersMapping, UnknownHandling } from \"./directory.js\";\n\n/**\n * A document loader that loads documents from multiple files. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const multiFileLoader = new MultiFileLoader(\n *   [\"path/to/file1.pdf\", \"path/to/file2.txt\"],\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await multiFileLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport class MultiFileLoader extends BaseDocumentLoader {\n  constructor(\n    public filePaths: string[],\n    public loaders: LoadersMapping,\n    public unknown: UnknownHandling = UnknownHandling.Warn\n  ) {\n    super();\n\n    if (Object.keys(loaders).length === 0) {\n      throw new Error(\"Must provide at least one loader\");\n    }\n    for (const extension in loaders) {\n      if (Object.hasOwn(loaders, extension)) {\n        if (extension[0] !== \".\") {\n          throw new Error(`Extension must start with a dot: ${extension}`);\n        }\n      }\n    }\n  }\n\n  /**\n   * Loads the documents from the provided file paths. It checks if the file\n   * is a directory and ignores it. If a file is a file, it checks if there\n   * is a corresponding loader function for the file extension in the `loaders`\n   * mapping. If there is, it loads the documents. If there is no\n   * corresponding loader function and `unknown` is set to `Warn`, it logs a\n   * warning message. If `unknown` is set to `Error`, it throws an error.\n   * @returns A promise that resolves to an array of loaded documents.\n   */\n  public async load(): Promise<Document[]> {\n    const documents: Document[] = [];\n\n    for (const filePath of this.filePaths) {\n      const fullPath = resolve(filePath);\n      const fileStat = await stat(fullPath);\n\n      if (fileStat.isDirectory()) {\n        console.warn(`Ignoring directory: ${fullPath}`);\n        continue;\n      }\n\n      const loaderFactory = this.loaders[extname(fullPath)];\n      if (loaderFactory) {\n        const loader = loaderFactory(fullPath);\n        documents.push(...(await loader.load()));\n      } else {\n        switch (this.unknown) {\n          case UnknownHandling.Ignore:\n            break;\n          case UnknownHandling.Warn:\n            console.warn(`Unknown file type: ${fullPath}`);\n            break;\n          case UnknownHandling.Error:\n            throw new Error(`Unknown file type: ${fullPath}`);\n          default:\n            throw new Error(`Unknown unknown handling: ${this.unknown}`);\n        }\n      }\n    }\n\n    return documents;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,kBAAb,cAAqCA,sCAAAA,mBAAmB;CACtD,YACE,WACA,SACA,UAAkCC,sCAAAA,gBAAgB,MAClD;AACA,SAAO;AAJA,OAAA,YAAA;AACA,OAAA,UAAA;AACA,OAAA,UAAA;AAIP,MAAI,OAAO,KAAK,QAAQ,CAAC,WAAW,EAClC,OAAM,IAAI,MAAM,mCAAmC;AAErD,OAAK,MAAM,aAAa,QACtB,KAAI,OAAO,OAAO,SAAS,UAAU;OAC/B,UAAU,OAAO,IACnB,OAAM,IAAI,MAAM,oCAAoC,YAAY;;;;;;;;;;;;CAexE,MAAa,OAA4B;EACvC,MAAM,YAAwB,EAAE;AAEhC,OAAK,MAAM,YAAY,KAAK,WAAW;GACrC,MAAM,YAAA,GAAA,UAAA,SAAmB,SAAS;AAGlC,QAAI,OAAA,GAAA,iBAAA,MAFwB,SAAS,EAExB,aAAa,EAAE;AAC1B,YAAQ,KAAK,uBAAuB,WAAW;AAC/C;;GAGF,MAAM,gBAAgB,KAAK,SAAA,GAAA,UAAA,SAAgB,SAAS;AACpD,OAAI,eAAe;IACjB,MAAM,SAAS,cAAc,SAAS;AACtC,cAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;SAExC,SAAQ,KAAK,SAAb;IACE,KAAKA,sCAAAA,gBAAgB,OACnB;IACF,KAAKA,sCAAAA,gBAAgB;AACnB,aAAQ,KAAK,sBAAsB,WAAW;AAC9C;IACF,KAAKA,sCAAAA,gBAAgB,MACnB,OAAM,IAAI,MAAM,sBAAsB,WAAW;IACnD,QACE,OAAM,IAAI,MAAM,6BAA6B,KAAK,UAAU;;;AAKpE,SAAO"}
+{"version":3,"file":"multi_file.cjs","names":["BaseDocumentLoader","UnknownHandling"],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"sourcesContent":["import { extname, resolve } from \"node:path\";\nimport { stat } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport { type LoadersMapping, UnknownHandling } from \"./directory.js\";\n\n/**\n * A document loader that loads documents from multiple files. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const multiFileLoader = new MultiFileLoader(\n *   [\"path/to/file1.pdf\", \"path/to/file2.txt\"],\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await multiFileLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport class MultiFileLoader extends BaseDocumentLoader {\n  constructor(\n    public filePaths: string[],\n    public loaders: LoadersMapping,\n    public unknown: UnknownHandling = UnknownHandling.Warn\n  ) {\n    super();\n\n    if (Object.keys(loaders).length === 0) {\n      throw new Error(\"Must provide at least one loader\");\n    }\n    for (const extension in loaders) {\n      if (Object.hasOwn(loaders, extension)) {\n        if (extension[0] !== \".\") {\n          throw new Error(`Extension must start with a dot: ${extension}`);\n        }\n      }\n    }\n  }\n\n  /**\n   * Loads the documents from the provided file paths. It checks if the file\n   * is a directory and ignores it. If a file is a file, it checks if there\n   * is a corresponding loader function for the file extension in the `loaders`\n   * mapping. If there is, it loads the documents. If there is no\n   * corresponding loader function and `unknown` is set to `Warn`, it logs a\n   * warning message. If `unknown` is set to `Error`, it throws an error.\n   * @returns A promise that resolves to an array of loaded documents.\n   */\n  public async load(): Promise<Document[]> {\n    const documents: Document[] = [];\n\n    for (const filePath of this.filePaths) {\n      const fullPath = resolve(filePath);\n      const fileStat = await stat(fullPath);\n\n      if (fileStat.isDirectory()) {\n        console.warn(`Ignoring directory: ${fullPath}`);\n        continue;\n      }\n\n      const loaderFactory = this.loaders[extname(fullPath)];\n      if (loaderFactory) {\n        const loader = loaderFactory(fullPath);\n        documents.push(...(await loader.load()));\n      } else {\n        switch (this.unknown) {\n          case UnknownHandling.Ignore:\n            break;\n          case UnknownHandling.Warn:\n            console.warn(`Unknown file type: ${fullPath}`);\n            break;\n          case UnknownHandling.Error:\n            throw new Error(`Unknown file type: ${fullPath}`);\n          default:\n            throw new Error(`Unknown unknown handling: ${this.unknown}`);\n        }\n      }\n    }\n\n    return documents;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,kBAAb,cAAqCA,sCAAAA,mBAAmB;CAE7C;CACA;CACA;CAHT,YACE,WACA,SACA,UAAkCC,sCAAAA,gBAAgB,MAClD;EACA,MAAM;EAJC,KAAA,YAAA;EACA,KAAA,UAAA;EACA,KAAA,UAAA;EAIP,IAAI,OAAO,KAAK,OAAO,CAAC,CAAC,WAAW,GAClC,MAAM,IAAI,MAAM,kCAAkC;EAEpD,KAAK,MAAM,aAAa,SACtB,IAAI,OAAO,OAAO,SAAS,SAAS,GAC9B;OAAA,UAAU,OAAO,KACnB,MAAM,IAAI,MAAM,oCAAoC,WAAW;EAAA;CAIvE;;;;;;;;;;CAWA,MAAa,OAA4B;EACvC,MAAM,YAAwB,CAAC;EAE/B,KAAK,MAAM,YAAY,KAAK,WAAW;GACrC,MAAM,YAAA,GAAA,UAAA,QAAA,CAAmB,QAAQ;GAGjC,KAAI,OAAA,GAAA,iBAAA,KAAA,CAFwB,QAAQ,EAAA,CAEvB,YAAY,GAAG;IAC1B,QAAQ,KAAK,uBAAuB,UAAU;IAC9C;GACF;GAEA,MAAM,gBAAgB,KAAK,SAAA,GAAA,UAAA,QAAA,CAAgB,QAAQ;GACnD,IAAI,eAAe;IACjB,MAAM,SAAS,cAAc,QAAQ;IACrC,UAAU,KAAK,GAAI,MAAM,OAAO,KAAK,CAAE;GACzC,OACE,QAAQ,KAAK,SAAb;IACE,KAAKA,sCAAAA,gBAAgB,QACnB;IACF,KAAKA,sCAAAA,gBAAgB;KACnB,QAAQ,KAAK,sBAAsB,UAAU;KAC7C;IACF,KAAKA,sCAAAA,gBAAgB,OACnB,MAAM,IAAI,MAAM,sBAAsB,UAAU;IAClD,SACE,MAAM,IAAI,MAAM,6BAA6B,KAAK,SAAS;GAC/D;EAEJ;EAEA,OAAO;CACT;AACF"}

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

@@ -1,7 +1,6 @@
 import { LoadersMapping, UnknownHandling } from "./directory.cjs";
 import { Document } from "@langchain/core/documents";
 import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
-
 //#region src/document_loaders/fs/multi_file.d.ts
 /**
  * A document loader that loads documents from multiple files. It extends the

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

@@ -1 +1 @@
-{"version":3,"file":"multi_file.d.cts","names":[],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"mappings":";;;;;;;AAwBA;;;;;;;;;;;;;;;;cAAa,eAAA,SAAwB,kBAAA;EAE1B,SAAA;EACA,OAAA,EAAS,cAAA;EACT,OAAA,EAAS,eAAA;EAHlB,WAAA,CACS,SAAA,YACA,OAAA,EAAS,cAAA,EACT,OAAA,GAAS,eAAA;EADT;;;;;;;;;EA0BI,IAAA,CAAA,GAAQ,OAAA,CAAQ,QAAA;AAAA"}
+{"version":3,"file":"multi_file.d.cts","names":[],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;cAwBa,wBAAwB;EAE1B;EACA,SAAS;EACT,SAAS;EAHlB,YACS,qBACA,SAAS,gBACT,UAAS;;;;;;;;;;EAyBL,QAAQ,QAAQ"}

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

@@ -1,7 +1,6 @@
 import { LoadersMapping, UnknownHandling } from "./directory.js";
 import { Document } from "@langchain/core/documents";
 import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
-
 //#region src/document_loaders/fs/multi_file.d.ts
 /**
  * A document loader that loads documents from multiple files. It extends the

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

@@ -1 +1 @@
-{"version":3,"file":"multi_file.d.ts","names":[],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"mappings":";;;;;;;AAwBA;;;;;;;;;;;;;;;;cAAa,eAAA,SAAwB,kBAAA;EAE1B,SAAA;EACA,OAAA,EAAS,cAAA;EACT,OAAA,EAAS,eAAA;EAHlB,WAAA,CACS,SAAA,YACA,OAAA,EAAS,cAAA,EACT,OAAA,GAAS,eAAA;EADT;;;;;;;;;EA0BI,IAAA,CAAA,GAAQ,OAAA,CAAQ,QAAA;AAAA"}
+{"version":3,"file":"multi_file.d.ts","names":[],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;cAwBa,wBAAwB;EAE1B;EACA,SAAS;EACT,SAAS;EAHlB,YACS,qBACA,SAAS,gBACT,UAAS;;;;;;;;;;EAyBL,QAAQ,QAAQ"}

package/dist/document_loaders/fs/multi_file.js

@@ -24,6 +24,9 @@ var multi_file_exports = /* @__PURE__ */ __exportAll({ MultiFileLoader: () => Mu
 * ```
 */
 var MultiFileLoader = class extends BaseDocumentLoader {
+	filePaths;
+	loaders;
+	unknown;
 	constructor(filePaths, loaders, unknown = UnknownHandling.Warn) {
 		super();
 		this.filePaths = filePaths;

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

@@ -1 +1 @@
-{"version":3,"file":"multi_file.js","names":[],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"sourcesContent":["import { extname, resolve } from \"node:path\";\nimport { stat } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport { type LoadersMapping, UnknownHandling } from \"./directory.js\";\n\n/**\n * A document loader that loads documents from multiple files. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const multiFileLoader = new MultiFileLoader(\n *   [\"path/to/file1.pdf\", \"path/to/file2.txt\"],\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await multiFileLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport class MultiFileLoader extends BaseDocumentLoader {\n  constructor(\n    public filePaths: string[],\n    public loaders: LoadersMapping,\n    public unknown: UnknownHandling = UnknownHandling.Warn\n  ) {\n    super();\n\n    if (Object.keys(loaders).length === 0) {\n      throw new Error(\"Must provide at least one loader\");\n    }\n    for (const extension in loaders) {\n      if (Object.hasOwn(loaders, extension)) {\n        if (extension[0] !== \".\") {\n          throw new Error(`Extension must start with a dot: ${extension}`);\n        }\n      }\n    }\n  }\n\n  /**\n   * Loads the documents from the provided file paths. It checks if the file\n   * is a directory and ignores it. If a file is a file, it checks if there\n   * is a corresponding loader function for the file extension in the `loaders`\n   * mapping. If there is, it loads the documents. If there is no\n   * corresponding loader function and `unknown` is set to `Warn`, it logs a\n   * warning message. If `unknown` is set to `Error`, it throws an error.\n   * @returns A promise that resolves to an array of loaded documents.\n   */\n  public async load(): Promise<Document[]> {\n    const documents: Document[] = [];\n\n    for (const filePath of this.filePaths) {\n      const fullPath = resolve(filePath);\n      const fileStat = await stat(fullPath);\n\n      if (fileStat.isDirectory()) {\n        console.warn(`Ignoring directory: ${fullPath}`);\n        continue;\n      }\n\n      const loaderFactory = this.loaders[extname(fullPath)];\n      if (loaderFactory) {\n        const loader = loaderFactory(fullPath);\n        documents.push(...(await loader.load()));\n      } else {\n        switch (this.unknown) {\n          case UnknownHandling.Ignore:\n            break;\n          case UnknownHandling.Warn:\n            console.warn(`Unknown file type: ${fullPath}`);\n            break;\n          case UnknownHandling.Error:\n            throw new Error(`Unknown file type: ${fullPath}`);\n          default:\n            throw new Error(`Unknown unknown handling: ${this.unknown}`);\n        }\n      }\n    }\n\n    return documents;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,kBAAb,cAAqC,mBAAmB;CACtD,YACE,WACA,SACA,UAAkC,gBAAgB,MAClD;AACA,SAAO;AAJA,OAAA,YAAA;AACA,OAAA,UAAA;AACA,OAAA,UAAA;AAIP,MAAI,OAAO,KAAK,QAAQ,CAAC,WAAW,EAClC,OAAM,IAAI,MAAM,mCAAmC;AAErD,OAAK,MAAM,aAAa,QACtB,KAAI,OAAO,OAAO,SAAS,UAAU;OAC/B,UAAU,OAAO,IACnB,OAAM,IAAI,MAAM,oCAAoC,YAAY;;;;;;;;;;;;CAexE,MAAa,OAA4B;EACvC,MAAM,YAAwB,EAAE;AAEhC,OAAK,MAAM,YAAY,KAAK,WAAW;GACrC,MAAM,WAAW,QAAQ,SAAS;AAGlC,QAAI,MAFmB,KAAK,SAAS,EAExB,aAAa,EAAE;AAC1B,YAAQ,KAAK,uBAAuB,WAAW;AAC/C;;GAGF,MAAM,gBAAgB,KAAK,QAAQ,QAAQ,SAAS;AACpD,OAAI,eAAe;IACjB,MAAM,SAAS,cAAc,SAAS;AACtC,cAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;SAExC,SAAQ,KAAK,SAAb;IACE,KAAK,gBAAgB,OACnB;IACF,KAAK,gBAAgB;AACnB,aAAQ,KAAK,sBAAsB,WAAW;AAC9C;IACF,KAAK,gBAAgB,MACnB,OAAM,IAAI,MAAM,sBAAsB,WAAW;IACnD,QACE,OAAM,IAAI,MAAM,6BAA6B,KAAK,UAAU;;;AAKpE,SAAO"}
+{"version":3,"file":"multi_file.js","names":[],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"sourcesContent":["import { extname, resolve } from \"node:path\";\nimport { stat } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport { type LoadersMapping, UnknownHandling } from \"./directory.js\";\n\n/**\n * A document loader that loads documents from multiple files. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const multiFileLoader = new MultiFileLoader(\n *   [\"path/to/file1.pdf\", \"path/to/file2.txt\"],\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await multiFileLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport class MultiFileLoader extends BaseDocumentLoader {\n  constructor(\n    public filePaths: string[],\n    public loaders: LoadersMapping,\n    public unknown: UnknownHandling = UnknownHandling.Warn\n  ) {\n    super();\n\n    if (Object.keys(loaders).length === 0) {\n      throw new Error(\"Must provide at least one loader\");\n    }\n    for (const extension in loaders) {\n      if (Object.hasOwn(loaders, extension)) {\n        if (extension[0] !== \".\") {\n          throw new Error(`Extension must start with a dot: ${extension}`);\n        }\n      }\n    }\n  }\n\n  /**\n   * Loads the documents from the provided file paths. It checks if the file\n   * is a directory and ignores it. If a file is a file, it checks if there\n   * is a corresponding loader function for the file extension in the `loaders`\n   * mapping. If there is, it loads the documents. If there is no\n   * corresponding loader function and `unknown` is set to `Warn`, it logs a\n   * warning message. If `unknown` is set to `Error`, it throws an error.\n   * @returns A promise that resolves to an array of loaded documents.\n   */\n  public async load(): Promise<Document[]> {\n    const documents: Document[] = [];\n\n    for (const filePath of this.filePaths) {\n      const fullPath = resolve(filePath);\n      const fileStat = await stat(fullPath);\n\n      if (fileStat.isDirectory()) {\n        console.warn(`Ignoring directory: ${fullPath}`);\n        continue;\n      }\n\n      const loaderFactory = this.loaders[extname(fullPath)];\n      if (loaderFactory) {\n        const loader = loaderFactory(fullPath);\n        documents.push(...(await loader.load()));\n      } else {\n        switch (this.unknown) {\n          case UnknownHandling.Ignore:\n            break;\n          case UnknownHandling.Warn:\n            console.warn(`Unknown file type: ${fullPath}`);\n            break;\n          case UnknownHandling.Error:\n            throw new Error(`Unknown file type: ${fullPath}`);\n          default:\n            throw new Error(`Unknown unknown handling: ${this.unknown}`);\n        }\n      }\n    }\n\n    return documents;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,kBAAb,cAAqC,mBAAmB;CAE7C;CACA;CACA;CAHT,YACE,WACA,SACA,UAAkC,gBAAgB,MAClD;EACA,MAAM;EAJC,KAAA,YAAA;EACA,KAAA,UAAA;EACA,KAAA,UAAA;EAIP,IAAI,OAAO,KAAK,OAAO,CAAC,CAAC,WAAW,GAClC,MAAM,IAAI,MAAM,kCAAkC;EAEpD,KAAK,MAAM,aAAa,SACtB,IAAI,OAAO,OAAO,SAAS,SAAS,GAC9B;OAAA,UAAU,OAAO,KACnB,MAAM,IAAI,MAAM,oCAAoC,WAAW;EAAA;CAIvE;;;;;;;;;;CAWA,MAAa,OAA4B;EACvC,MAAM,YAAwB,CAAC;EAE/B,KAAK,MAAM,YAAY,KAAK,WAAW;GACrC,MAAM,WAAW,QAAQ,QAAQ;GAGjC,KAAI,MAFmB,KAAK,QAAQ,EAAA,CAEvB,YAAY,GAAG;IAC1B,QAAQ,KAAK,uBAAuB,UAAU;IAC9C;GACF;GAEA,MAAM,gBAAgB,KAAK,QAAQ,QAAQ,QAAQ;GACnD,IAAI,eAAe;IACjB,MAAM,SAAS,cAAc,QAAQ;IACrC,UAAU,KAAK,GAAI,MAAM,OAAO,KAAK,CAAE;GACzC,OACE,QAAQ,KAAK,SAAb;IACE,KAAK,gBAAgB,QACnB;IACF,KAAK,gBAAgB;KACnB,QAAQ,KAAK,sBAAsB,UAAU;KAC7C;IACF,KAAK,gBAAgB,OACnB,MAAM,IAAI,MAAM,sBAAsB,UAAU;IAClD,SACE,MAAM,IAAI,MAAM,6BAA6B,KAAK,SAAS;GAC/D;EAEJ;EAEA,OAAO;CACT;AACF"}

package/dist/document_loaders/fs/text.cjs

@@ -19,6 +19,7 @@ var text_exports = /* @__PURE__ */ require_runtime.__exportAll({ TextLoader: ()
 * ```
 */
 var TextLoader = class TextLoader extends _langchain_core_document_loaders_base.BaseDocumentLoader {
+	filePathOrBlob;
 	constructor(filePathOrBlob) {
 		super();
 		this.filePathOrBlob = filePathOrBlob;

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

@@ -1 +1 @@
-{"version":3,"file":"text.cjs","names":["BaseDocumentLoader","Document"],"sources":["../../../src/document_loaders/fs/text.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 * A class that extends the `BaseDocumentLoader` class. It represents a\n * document loader that loads documents from a text file. The `load()`\n * method is implemented to read the text from the file or blob, parse it\n * using the `parse()` method, and create a `Document` instance for each\n * parsed page. The metadata includes the source of the text (file path or\n * blob) and, if there are multiple pages, the line number of each page.\n * @example\n * ```typescript\n * const loader = new TextLoader(\"src/document_loaders/example_data/example.txt\");\n * const docs = await loader.load();\n * ```\n */\nexport class TextLoader extends BaseDocumentLoader {\n  constructor(public filePathOrBlob: string | Blob) {\n    super();\n  }\n\n  /**\n   * A protected method that takes a `raw` string as a parameter and returns\n   * a promise that resolves to an array containing the raw text as a single\n   * element.\n   * @param raw The raw text to be parsed.\n   * @returns A promise that resolves to an array containing the raw text as a single element.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    return [raw];\n  }\n\n  /**\n   * A method that loads the text file or blob and returns a promise that\n   * resolves to an array of `Document` instances. It reads the text from\n   * the file or blob using the `readFile` function from the\n   * `node:fs/promises` module or the `text()` method of the blob. It then\n   * parses the text using the `parse()` method and creates a `Document`\n   * instance for each parsed page. The metadata includes the source of the\n   * text (file path or blob) and, if there are multiple pages, the line\n   * number of each page.\n   * @returns A promise that resolves to an array of `Document` instances.\n   */\n  public async load(): Promise<Document[]> {\n    let text: string;\n    let metadata: Record<string, string>;\n    if (typeof this.filePathOrBlob === \"string\") {\n      const { readFile } = await TextLoader.imports();\n      text = await readFile(this.filePathOrBlob, \"utf8\");\n      metadata = { source: this.filePathOrBlob };\n    } else {\n      text = await this.filePathOrBlob.text();\n      metadata = { source: \"blob\", blobType: this.filePathOrBlob.type };\n    }\n    const parsed = await this.parse(text);\n    parsed.forEach((pageContent, i) => {\n      if (typeof pageContent !== \"string\") {\n        throw new Error(\n          `Expected string, at position ${i} got ${typeof pageContent}`\n        );\n      }\n    });\n    return parsed.map(\n      (pageContent, i) =>\n        new Document({\n          pageContent,\n          metadata:\n            parsed.length === 1\n              ? metadata\n              : {\n                  ...metadata,\n                  line: i + 1,\n                },\n        })\n    );\n  }\n\n  /**\n   * A static method that imports the `readFile` function from the\n   * `node:fs/promises` module. 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 A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.\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":";;;;;;;;;;;;;;;;;;;;AAkBA,IAAa,aAAb,MAAa,mBAAmBA,sCAAAA,mBAAmB;CACjD,YAAY,gBAAsC;AAChD,SAAO;AADU,OAAA,iBAAA;;;;;;;;;CAWnB,MAAgB,MAAM,KAAgC;AACpD,SAAO,CAAC,IAAI;;;;;;;;;;;;;CAcd,MAAa,OAA4B;EACvC,IAAI;EACJ,IAAI;AACJ,MAAI,OAAO,KAAK,mBAAmB,UAAU;GAC3C,MAAM,EAAE,aAAa,MAAM,WAAW,SAAS;AAC/C,UAAO,MAAM,SAAS,KAAK,gBAAgB,OAAO;AAClD,cAAW,EAAE,QAAQ,KAAK,gBAAgB;SACrC;AACL,UAAO,MAAM,KAAK,eAAe,MAAM;AACvC,cAAW;IAAE,QAAQ;IAAQ,UAAU,KAAK,eAAe;IAAM;;EAEnE,MAAM,SAAS,MAAM,KAAK,MAAM,KAAK;AACrC,SAAO,SAAS,aAAa,MAAM;AACjC,OAAI,OAAO,gBAAgB,SACzB,OAAM,IAAI,MACR,gCAAgC,EAAE,OAAO,OAAO,cACjD;IAEH;AACF,SAAO,OAAO,KACX,aAAa,MACZ,IAAIC,0BAAAA,SAAS;GACX;GACA,UACE,OAAO,WAAW,IACd,WACA;IACE,GAAG;IACH,MAAM,IAAI;IACX;GACR,CAAC,CACL;;;;;;;;;;CAWH,aAAa,UAEV;AACD,MAAI;GACF,MAAM,EAAE,aAAa,MAAM,OAAO;AAClC,UAAO,EAAE,UAAU;WACZ,GAAG;AACV,WAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR,yHAAA,GAAA,0BAAA,SAAgI,CAAC,iDAClI"}
+{"version":3,"file":"text.cjs","names":["BaseDocumentLoader","Document"],"sources":["../../../src/document_loaders/fs/text.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 * A class that extends the `BaseDocumentLoader` class. It represents a\n * document loader that loads documents from a text file. The `load()`\n * method is implemented to read the text from the file or blob, parse it\n * using the `parse()` method, and create a `Document` instance for each\n * parsed page. The metadata includes the source of the text (file path or\n * blob) and, if there are multiple pages, the line number of each page.\n * @example\n * ```typescript\n * const loader = new TextLoader(\"src/document_loaders/example_data/example.txt\");\n * const docs = await loader.load();\n * ```\n */\nexport class TextLoader extends BaseDocumentLoader {\n  constructor(public filePathOrBlob: string | Blob) {\n    super();\n  }\n\n  /**\n   * A protected method that takes a `raw` string as a parameter and returns\n   * a promise that resolves to an array containing the raw text as a single\n   * element.\n   * @param raw The raw text to be parsed.\n   * @returns A promise that resolves to an array containing the raw text as a single element.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    return [raw];\n  }\n\n  /**\n   * A method that loads the text file or blob and returns a promise that\n   * resolves to an array of `Document` instances. It reads the text from\n   * the file or blob using the `readFile` function from the\n   * `node:fs/promises` module or the `text()` method of the blob. It then\n   * parses the text using the `parse()` method and creates a `Document`\n   * instance for each parsed page. The metadata includes the source of the\n   * text (file path or blob) and, if there are multiple pages, the line\n   * number of each page.\n   * @returns A promise that resolves to an array of `Document` instances.\n   */\n  public async load(): Promise<Document[]> {\n    let text: string;\n    let metadata: Record<string, string>;\n    if (typeof this.filePathOrBlob === \"string\") {\n      const { readFile } = await TextLoader.imports();\n      text = await readFile(this.filePathOrBlob, \"utf8\");\n      metadata = { source: this.filePathOrBlob };\n    } else {\n      text = await this.filePathOrBlob.text();\n      metadata = { source: \"blob\", blobType: this.filePathOrBlob.type };\n    }\n    const parsed = await this.parse(text);\n    parsed.forEach((pageContent, i) => {\n      if (typeof pageContent !== \"string\") {\n        throw new Error(\n          `Expected string, at position ${i} got ${typeof pageContent}`\n        );\n      }\n    });\n    return parsed.map(\n      (pageContent, i) =>\n        new Document({\n          pageContent,\n          metadata:\n            parsed.length === 1\n              ? metadata\n              : {\n                  ...metadata,\n                  line: i + 1,\n                },\n        })\n    );\n  }\n\n  /**\n   * A static method that imports the `readFile` function from the\n   * `node:fs/promises` module. 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 A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.\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":";;;;;;;;;;;;;;;;;;;;AAkBA,IAAa,aAAb,MAAa,mBAAmBA,sCAAAA,mBAAmB;CAC9B;CAAnB,YAAY,gBAAsC;EAChD,MAAM;EADW,KAAA,iBAAA;CAEnB;;;;;;;;CASA,MAAgB,MAAM,KAAgC;EACpD,OAAO,CAAC,GAAG;CACb;;;;;;;;;;;;CAaA,MAAa,OAA4B;EACvC,IAAI;EACJ,IAAI;EACJ,IAAI,OAAO,KAAK,mBAAmB,UAAU;GAC3C,MAAM,EAAE,aAAa,MAAM,WAAW,QAAQ;GAC9C,OAAO,MAAM,SAAS,KAAK,gBAAgB,MAAM;GACjD,WAAW,EAAE,QAAQ,KAAK,eAAe;EAC3C,OAAO;GACL,OAAO,MAAM,KAAK,eAAe,KAAK;GACtC,WAAW;IAAE,QAAQ;IAAQ,UAAU,KAAK,eAAe;GAAK;EAClE;EACA,MAAM,SAAS,MAAM,KAAK,MAAM,IAAI;EACpC,OAAO,SAAS,aAAa,MAAM;GACjC,IAAI,OAAO,gBAAgB,UACzB,MAAM,IAAI,MACR,gCAAgC,EAAE,OAAO,OAAO,aAClD;EAEJ,CAAC;EACD,OAAO,OAAO,KACX,aAAa,MACZ,IAAIC,0BAAAA,SAAS;GACX;GACA,UACE,OAAO,WAAW,IACd,WACA;IACE,GAAG;IACH,MAAM,IAAI;GACZ;EACR,CAAC,CACL;CACF;;;;;;;;;CAUA,aAAa,UAEV;EACD,IAAI;GACF,MAAM,EAAE,aAAa,MAAM,OAAO;GAClC,OAAO,EAAE,SAAS;EACpB,SAAS,GAAG;GACV,QAAQ,MAAM,CAAC;GACf,MAAM,IAAI,MACR,yHAAA,GAAA,0BAAA,OAAA,CAA+H,EAAE,gDACnI;EACF;CACF;AACF"}

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

@@ -1,7 +1,6 @@
 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/text.d.ts
 /**
  * A class that extends the `BaseDocumentLoader` class. It represents a

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

@@ -1 +1 @@
-{"version":3,"file":"text.d.cts","names":[],"sources":["../../../src/document_loaders/fs/text.ts"],"mappings":";;;;;;;AAkBA;;;;;;;;;;;cAAa,UAAA,SAAmB,kBAAA;EACX,cAAA,WAAyB,IAAA;EAA5C,WAAA,CAAmB,cAAA,WAAyB,IAAA;EAAzB;;;;;;;EAAA,UAWH,KAAA,CAAM,GAAA,WAAc,OAAA;EAevB;;;;;;;;;;;EAAA,IAAA,CAAA,GAAQ,OAAA,CAAQ,QAAA;;;;;;;;;SA0ChB,OAAA,CAAA,GAAW,OAAA;IACtB,QAAA,SAAiB,QAAA;EAAA;AAAA"}
+{"version":3,"file":"text.d.cts","names":[],"sources":["../../../src/document_loaders/fs/text.ts"],"mappings":";;;;;;;;;;;;;;;;;cAkBa,mBAAmB;EACX,yBAAyB;EAA5C,YAAmB,yBAAyB;;;;;;;;YAW5B,MAAM,cAAc;;;;;;;;;;;;EAevB,QAAQ,QAAQ;;;;;;;;;SA0ChB,WAAW;IACtB,iBAAiB"}

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

@@ -1,7 +1,6 @@
 import { readFile } from "node:fs/promises";
 import { Document } from "@langchain/core/documents";
 import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
-
 //#region src/document_loaders/fs/text.d.ts
 /**
  * A class that extends the `BaseDocumentLoader` class. It represents a

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

@@ -1 +1 @@
-{"version":3,"file":"text.d.ts","names":[],"sources":["../../../src/document_loaders/fs/text.ts"],"mappings":";;;;;;;AAkBA;;;;;;;;;;;cAAa,UAAA,SAAmB,kBAAA;EACX,cAAA,WAAyB,IAAA;EAA5C,WAAA,CAAmB,cAAA,WAAyB,IAAA;EAAzB;;;;;;;EAAA,UAWH,KAAA,CAAM,GAAA,WAAc,OAAA;EAevB;;;;;;;;;;;EAAA,IAAA,CAAA,GAAQ,OAAA,CAAQ,QAAA;;;;;;;;;SA0ChB,OAAA,CAAA,GAAW,OAAA;IACtB,QAAA,SAAiB,QAAA;EAAA;AAAA"}
+{"version":3,"file":"text.d.ts","names":[],"sources":["../../../src/document_loaders/fs/text.ts"],"mappings":";;;;;;;;;;;;;;;;;cAkBa,mBAAmB;EACX,yBAAyB;EAA5C,YAAmB,yBAAyB;;;;;;;;YAW5B,MAAM,cAAc;;;;;;;;;;;;EAevB,QAAQ,QAAQ;;;;;;;;;SA0ChB,WAAW;IACtB,iBAAiB"}

package/dist/document_loaders/fs/text.js

@@ -18,6 +18,7 @@ var text_exports = /* @__PURE__ */ __exportAll({ TextLoader: () => TextLoader })
 * ```
 */
 var TextLoader = class TextLoader extends BaseDocumentLoader {
+	filePathOrBlob;
 	constructor(filePathOrBlob) {
 		super();
 		this.filePathOrBlob = filePathOrBlob;

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

@@ -1 +1 @@
-{"version":3,"file":"text.js","names":[],"sources":["../../../src/document_loaders/fs/text.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 * A class that extends the `BaseDocumentLoader` class. It represents a\n * document loader that loads documents from a text file. The `load()`\n * method is implemented to read the text from the file or blob, parse it\n * using the `parse()` method, and create a `Document` instance for each\n * parsed page. The metadata includes the source of the text (file path or\n * blob) and, if there are multiple pages, the line number of each page.\n * @example\n * ```typescript\n * const loader = new TextLoader(\"src/document_loaders/example_data/example.txt\");\n * const docs = await loader.load();\n * ```\n */\nexport class TextLoader extends BaseDocumentLoader {\n  constructor(public filePathOrBlob: string | Blob) {\n    super();\n  }\n\n  /**\n   * A protected method that takes a `raw` string as a parameter and returns\n   * a promise that resolves to an array containing the raw text as a single\n   * element.\n   * @param raw The raw text to be parsed.\n   * @returns A promise that resolves to an array containing the raw text as a single element.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    return [raw];\n  }\n\n  /**\n   * A method that loads the text file or blob and returns a promise that\n   * resolves to an array of `Document` instances. It reads the text from\n   * the file or blob using the `readFile` function from the\n   * `node:fs/promises` module or the `text()` method of the blob. It then\n   * parses the text using the `parse()` method and creates a `Document`\n   * instance for each parsed page. The metadata includes the source of the\n   * text (file path or blob) and, if there are multiple pages, the line\n   * number of each page.\n   * @returns A promise that resolves to an array of `Document` instances.\n   */\n  public async load(): Promise<Document[]> {\n    let text: string;\n    let metadata: Record<string, string>;\n    if (typeof this.filePathOrBlob === \"string\") {\n      const { readFile } = await TextLoader.imports();\n      text = await readFile(this.filePathOrBlob, \"utf8\");\n      metadata = { source: this.filePathOrBlob };\n    } else {\n      text = await this.filePathOrBlob.text();\n      metadata = { source: \"blob\", blobType: this.filePathOrBlob.type };\n    }\n    const parsed = await this.parse(text);\n    parsed.forEach((pageContent, i) => {\n      if (typeof pageContent !== \"string\") {\n        throw new Error(\n          `Expected string, at position ${i} got ${typeof pageContent}`\n        );\n      }\n    });\n    return parsed.map(\n      (pageContent, i) =>\n        new Document({\n          pageContent,\n          metadata:\n            parsed.length === 1\n              ? metadata\n              : {\n                  ...metadata,\n                  line: i + 1,\n                },\n        })\n    );\n  }\n\n  /**\n   * A static method that imports the `readFile` function from the\n   * `node:fs/promises` module. 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 A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.\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":";;;;;;;;;;;;;;;;;;;AAkBA,IAAa,aAAb,MAAa,mBAAmB,mBAAmB;CACjD,YAAY,gBAAsC;AAChD,SAAO;AADU,OAAA,iBAAA;;;;;;;;;CAWnB,MAAgB,MAAM,KAAgC;AACpD,SAAO,CAAC,IAAI;;;;;;;;;;;;;CAcd,MAAa,OAA4B;EACvC,IAAI;EACJ,IAAI;AACJ,MAAI,OAAO,KAAK,mBAAmB,UAAU;GAC3C,MAAM,EAAE,aAAa,MAAM,WAAW,SAAS;AAC/C,UAAO,MAAM,SAAS,KAAK,gBAAgB,OAAO;AAClD,cAAW,EAAE,QAAQ,KAAK,gBAAgB;SACrC;AACL,UAAO,MAAM,KAAK,eAAe,MAAM;AACvC,cAAW;IAAE,QAAQ;IAAQ,UAAU,KAAK,eAAe;IAAM;;EAEnE,MAAM,SAAS,MAAM,KAAK,MAAM,KAAK;AACrC,SAAO,SAAS,aAAa,MAAM;AACjC,OAAI,OAAO,gBAAgB,SACzB,OAAM,IAAI,MACR,gCAAgC,EAAE,OAAO,OAAO,cACjD;IAEH;AACF,SAAO,OAAO,KACX,aAAa,MACZ,IAAI,SAAS;GACX;GACA,UACE,OAAO,WAAW,IACd,WACA;IACE,GAAG;IACH,MAAM,IAAI;IACX;GACR,CAAC,CACL;;;;;;;;;;CAWH,aAAa,UAEV;AACD,MAAI;GACF,MAAM,EAAE,aAAa,MAAM,OAAO;AAClC,UAAO,EAAE,UAAU;WACZ,GAAG;AACV,WAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR,wHAAwH,QAAQ,CAAC,iDAClI"}
+{"version":3,"file":"text.js","names":[],"sources":["../../../src/document_loaders/fs/text.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 * A class that extends the `BaseDocumentLoader` class. It represents a\n * document loader that loads documents from a text file. The `load()`\n * method is implemented to read the text from the file or blob, parse it\n * using the `parse()` method, and create a `Document` instance for each\n * parsed page. The metadata includes the source of the text (file path or\n * blob) and, if there are multiple pages, the line number of each page.\n * @example\n * ```typescript\n * const loader = new TextLoader(\"src/document_loaders/example_data/example.txt\");\n * const docs = await loader.load();\n * ```\n */\nexport class TextLoader extends BaseDocumentLoader {\n  constructor(public filePathOrBlob: string | Blob) {\n    super();\n  }\n\n  /**\n   * A protected method that takes a `raw` string as a parameter and returns\n   * a promise that resolves to an array containing the raw text as a single\n   * element.\n   * @param raw The raw text to be parsed.\n   * @returns A promise that resolves to an array containing the raw text as a single element.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    return [raw];\n  }\n\n  /**\n   * A method that loads the text file or blob and returns a promise that\n   * resolves to an array of `Document` instances. It reads the text from\n   * the file or blob using the `readFile` function from the\n   * `node:fs/promises` module or the `text()` method of the blob. It then\n   * parses the text using the `parse()` method and creates a `Document`\n   * instance for each parsed page. The metadata includes the source of the\n   * text (file path or blob) and, if there are multiple pages, the line\n   * number of each page.\n   * @returns A promise that resolves to an array of `Document` instances.\n   */\n  public async load(): Promise<Document[]> {\n    let text: string;\n    let metadata: Record<string, string>;\n    if (typeof this.filePathOrBlob === \"string\") {\n      const { readFile } = await TextLoader.imports();\n      text = await readFile(this.filePathOrBlob, \"utf8\");\n      metadata = { source: this.filePathOrBlob };\n    } else {\n      text = await this.filePathOrBlob.text();\n      metadata = { source: \"blob\", blobType: this.filePathOrBlob.type };\n    }\n    const parsed = await this.parse(text);\n    parsed.forEach((pageContent, i) => {\n      if (typeof pageContent !== \"string\") {\n        throw new Error(\n          `Expected string, at position ${i} got ${typeof pageContent}`\n        );\n      }\n    });\n    return parsed.map(\n      (pageContent, i) =>\n        new Document({\n          pageContent,\n          metadata:\n            parsed.length === 1\n              ? metadata\n              : {\n                  ...metadata,\n                  line: i + 1,\n                },\n        })\n    );\n  }\n\n  /**\n   * A static method that imports the `readFile` function from the\n   * `node:fs/promises` module. 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 A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.\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":";;;;;;;;;;;;;;;;;;;AAkBA,IAAa,aAAb,MAAa,mBAAmB,mBAAmB;CAC9B;CAAnB,YAAY,gBAAsC;EAChD,MAAM;EADW,KAAA,iBAAA;CAEnB;;;;;;;;CASA,MAAgB,MAAM,KAAgC;EACpD,OAAO,CAAC,GAAG;CACb;;;;;;;;;;;;CAaA,MAAa,OAA4B;EACvC,IAAI;EACJ,IAAI;EACJ,IAAI,OAAO,KAAK,mBAAmB,UAAU;GAC3C,MAAM,EAAE,aAAa,MAAM,WAAW,QAAQ;GAC9C,OAAO,MAAM,SAAS,KAAK,gBAAgB,MAAM;GACjD,WAAW,EAAE,QAAQ,KAAK,eAAe;EAC3C,OAAO;GACL,OAAO,MAAM,KAAK,eAAe,KAAK;GACtC,WAAW;IAAE,QAAQ;IAAQ,UAAU,KAAK,eAAe;GAAK;EAClE;EACA,MAAM,SAAS,MAAM,KAAK,MAAM,IAAI;EACpC,OAAO,SAAS,aAAa,MAAM;GACjC,IAAI,OAAO,gBAAgB,UACzB,MAAM,IAAI,MACR,gCAAgC,EAAE,OAAO,OAAO,aAClD;EAEJ,CAAC;EACD,OAAO,OAAO,KACX,aAAa,MACZ,IAAI,SAAS;GACX;GACA,UACE,OAAO,WAAW,IACd,WACA;IACE,GAAG;IACH,MAAM,IAAI;GACZ;EACR,CAAC,CACL;CACF;;;;;;;;;CAUA,aAAa,UAEV;EACD,IAAI;GACF,MAAM,EAAE,aAAa,MAAM,OAAO;GAClC,OAAO,EAAE,SAAS;EACpB,SAAS,GAAG;GACV,QAAQ,MAAM,CAAC;GACf,MAAM,IAAI,MACR,wHAAwH,OAAO,EAAE,gDACnI;EACF;CACF;AACF"}

package/dist/document_transformers/openai_functions.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"openai_functions.cjs","names":["MappingDocumentTransformer","Document","ChatOpenAI","createTaggingChain"],"sources":["../../src/document_transformers/openai_functions.ts"],"sourcesContent":["import {\n  Document,\n  MappingDocumentTransformer,\n} from \"@langchain/core/documents\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nimport { InteropZodObject } from \"@langchain/core/utils/types\";\nimport {\n  type JsonSchema7ObjectType,\n  toJsonSchema,\n} from \"@langchain/core/utils/json_schema\";\nimport { BaseChain } from \"../chains/base.js\";\nimport {\n  TaggingChainOptions,\n  createTaggingChain,\n} from \"../chains/openai_functions/index.js\";\n\n/**\n * A transformer that tags metadata to a document using a tagging chain.\n */\nexport class MetadataTagger extends MappingDocumentTransformer {\n  static lc_name() {\n    return \"MetadataTagger\";\n  }\n\n  protected taggingChain: BaseChain;\n\n  constructor(fields: { taggingChain: BaseChain }) {\n    super();\n    this.taggingChain = fields.taggingChain;\n    if (this.taggingChain.inputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one input.\"\n      );\n    }\n    if (this.taggingChain.outputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one output.\"\n      );\n    }\n  }\n\n  async _transformDocument(document: Document): Promise<Document> {\n    const taggingChainResponse = await this.taggingChain.call({\n      [this.taggingChain.inputKeys[0]]: document.pageContent,\n    });\n    const extractedMetadata =\n      taggingChainResponse[this.taggingChain.outputKeys[0]];\n    return new Document({\n      pageContent: document.pageContent,\n      metadata: { ...extractedMetadata, ...document.metadata },\n    });\n  }\n}\n\nexport function createMetadataTagger(\n  schema: JsonSchema7ObjectType,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  const { llm = new ChatOpenAI({ model: \"gpt-3.5-turbo-0613\" }), ...rest } =\n    options;\n  const taggingChain = createTaggingChain(schema, llm, rest);\n  return new MetadataTagger({ taggingChain });\n}\n\nexport function createMetadataTaggerFromZod(\n  schema: InteropZodObject,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  return createMetadataTagger(\n    toJsonSchema(schema) as JsonSchema7ObjectType,\n    options\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAmBA,IAAa,iBAAb,cAAoCA,0BAAAA,2BAA2B;CAC7D,OAAO,UAAU;AACf,SAAO;;CAGT;CAEA,YAAY,QAAqC;AAC/C,SAAO;AACP,OAAK,eAAe,OAAO;AAC3B,MAAI,KAAK,aAAa,UAAU,WAAW,EACzC,OAAM,IAAI,MACR,oEACD;AAEH,MAAI,KAAK,aAAa,WAAW,WAAW,EAC1C,OAAM,IAAI,MACR,qEACD;;CAIL,MAAM,mBAAmB,UAAuC;EAI9D,MAAM,qBACJ,MAJiC,KAAK,aAAa,KAAK,GACvD,KAAK,aAAa,UAAU,KAAK,SAAS,aAC5C,CAAC,EAEqB,KAAK,aAAa,WAAW;AACpD,SAAO,IAAIC,0BAAAA,SAAS;GAClB,aAAa,SAAS;GACtB,UAAU;IAAE,GAAG;IAAmB,GAAG,SAAS;IAAU;GACzD,CAAC;;;AAIN,SAAgB,qBACd,QACA,SACA;CACA,MAAM,EAAE,MAAM,IAAIC,kBAAAA,WAAW,EAAE,OAAO,sBAAsB,CAAC,EAAE,GAAG,SAChE;AAEF,QAAO,IAAI,eAAe,EAAE,cADPC,gBAAAA,mBAAmB,QAAQ,KAAK,KACb,EAAE,CAAC;;AAG7C,SAAgB,4BACd,QACA,SACA;AACA,QAAO,sBAAA,GAAA,kCAAA,cACQ,OAAO,EACpB,QACD"}
+{"version":3,"file":"openai_functions.cjs","names":["MappingDocumentTransformer","Document","ChatOpenAI","createTaggingChain"],"sources":["../../src/document_transformers/openai_functions.ts"],"sourcesContent":["import {\n  Document,\n  MappingDocumentTransformer,\n} from \"@langchain/core/documents\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nimport { InteropZodObject } from \"@langchain/core/utils/types\";\nimport {\n  type JsonSchema7ObjectType,\n  toJsonSchema,\n} from \"@langchain/core/utils/json_schema\";\nimport { BaseChain } from \"../chains/base.js\";\nimport {\n  TaggingChainOptions,\n  createTaggingChain,\n} from \"../chains/openai_functions/index.js\";\n\n/**\n * A transformer that tags metadata to a document using a tagging chain.\n */\nexport class MetadataTagger extends MappingDocumentTransformer {\n  static lc_name() {\n    return \"MetadataTagger\";\n  }\n\n  protected taggingChain: BaseChain;\n\n  constructor(fields: { taggingChain: BaseChain }) {\n    super();\n    this.taggingChain = fields.taggingChain;\n    if (this.taggingChain.inputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one input.\"\n      );\n    }\n    if (this.taggingChain.outputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one output.\"\n      );\n    }\n  }\n\n  async _transformDocument(document: Document): Promise<Document> {\n    const taggingChainResponse = await this.taggingChain.call({\n      [this.taggingChain.inputKeys[0]]: document.pageContent,\n    });\n    const extractedMetadata =\n      taggingChainResponse[this.taggingChain.outputKeys[0]];\n    return new Document({\n      pageContent: document.pageContent,\n      metadata: { ...extractedMetadata, ...document.metadata },\n    });\n  }\n}\n\nexport function createMetadataTagger(\n  schema: JsonSchema7ObjectType,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  const { llm = new ChatOpenAI({ model: \"gpt-3.5-turbo-0613\" }), ...rest } =\n    options;\n  const taggingChain = createTaggingChain(schema, llm, rest);\n  return new MetadataTagger({ taggingChain });\n}\n\nexport function createMetadataTaggerFromZod(\n  schema: InteropZodObject,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  return createMetadataTagger(\n    toJsonSchema(schema) as JsonSchema7ObjectType,\n    options\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAmBA,IAAa,iBAAb,cAAoCA,0BAAAA,2BAA2B;CAC7D,OAAO,UAAU;EACf,OAAO;CACT;CAEA;CAEA,YAAY,QAAqC;EAC/C,MAAM;EACN,KAAK,eAAe,OAAO;EAC3B,IAAI,KAAK,aAAa,UAAU,WAAW,GACzC,MAAM,IAAI,MACR,mEACF;EAEF,IAAI,KAAK,aAAa,WAAW,WAAW,GAC1C,MAAM,IAAI,MACR,oEACF;CAEJ;CAEA,MAAM,mBAAmB,UAAuC;EAI9D,MAAM,qBACJ,MAJiC,KAAK,aAAa,KAAK,GACvD,KAAK,aAAa,UAAU,KAAK,SAAS,YAC7C,CAAC,EAAA,CAEsB,KAAK,aAAa,WAAW;EACpD,OAAO,IAAIC,0BAAAA,SAAS;GAClB,aAAa,SAAS;GACtB,UAAU;IAAE,GAAG;IAAmB,GAAG,SAAS;GAAS;EACzD,CAAC;CACH;AACF;AAEA,SAAgB,qBACd,QACA,SACA;CACA,MAAM,EAAE,MAAM,IAAIC,kBAAAA,WAAW,EAAE,OAAO,qBAAqB,CAAC,GAAG,GAAG,SAChE;CAEF,OAAO,IAAI,eAAe,EAAE,cADPC,gBAAAA,mBAAmB,QAAQ,KAAK,IACzB,EAAa,CAAC;AAC5C;AAEA,SAAgB,4BACd,QACA,SACA;CACA,OAAO,sBAAA,GAAA,kCAAA,aAAA,CACQ,MAAM,GACnB,OACF;AACF"}

package/dist/document_transformers/openai_functions.d.cts

@@ -1,10 +1,10 @@
 import { BaseChain } from "../chains/base.cjs";
 import { TaggingChainOptions } from "../chains/openai_functions/tagging.cjs";
+import "../chains/openai_functions/index.cjs";
 import { InteropZodObject } from "@langchain/core/utils/types";
 import { ChatOpenAI } from "@langchain/openai";
 import { Document, MappingDocumentTransformer } from "@langchain/core/documents";
 import { JsonSchema7ObjectType } from "@langchain/core/utils/json_schema";
-
 //#region src/document_transformers/openai_functions.d.ts
 /**
  * A transformer that tags metadata to a document using a tagging chain.

package/dist/document_transformers/openai_functions.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"openai_functions.d.cts","names":[],"sources":["../../src/document_transformers/openai_functions.ts"],"mappings":";;;;;;;;;;;cAmBa,cAAA,SAAuB,0BAAA;EAAA,OAC3B,OAAA,CAAA;EAAA,UAIG,YAAA,EAAc,SAAA;EAExB,WAAA,CAAY,MAAA;IAAU,YAAA,EAAc,SAAA;EAAA;EAe9B,kBAAA,CAAmB,QAAA,EAAU,QAAA,GAAW,OAAA,CAAQ,QAAA;AAAA;AAAA,iBAaxC,oBAAA,CACd,MAAA,EAAQ,qBAAA,EACR,OAAA,EAAS,mBAAA;EAAwB,GAAA,GAAM,UAAA;AAAA,IAAY,cAAA;AAAA,iBAQrC,2BAAA,CACd,MAAA,EAAQ,gBAAA,EACR,OAAA,EAAS,mBAAA;EAAwB,GAAA,GAAM,UAAA;AAAA,IAAY,cAAA"}
+{"version":3,"file":"openai_functions.d.cts","names":[],"sources":["../../src/document_transformers/openai_functions.ts"],"mappings":";;;;;;;;;;;cAmBa,uBAAuB;SAC3B;YAIG,cAAc;EAExB,YAAY;IAAU,cAAc;;EAe9B,mBAAmB,UAAU,WAAW,QAAQ;;iBAaxC,qBACd,QAAQ,uBACR,SAAS;EAAwB,MAAM;IAAY;iBAQrC,4BACd,QAAQ,kBACR,SAAS;EAAwB,MAAM;IAAY"}

package/dist/document_transformers/openai_functions.d.ts

@@ -1,10 +1,10 @@
 import { BaseChain } from "../chains/base.js";
 import { TaggingChainOptions } from "../chains/openai_functions/tagging.js";
+import "../chains/openai_functions/index.js";
 import { InteropZodObject } from "@langchain/core/utils/types";
 import { JsonSchema7ObjectType } from "@langchain/core/utils/json_schema";
 import { ChatOpenAI } from "@langchain/openai";
 import { Document, MappingDocumentTransformer } from "@langchain/core/documents";
-
 //#region src/document_transformers/openai_functions.d.ts
 /**
  * A transformer that tags metadata to a document using a tagging chain.

package/dist/document_transformers/openai_functions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai_functions.d.ts","names":[],"sources":["../../src/document_transformers/openai_functions.ts"],"mappings":";;;;;;;;;;;cAmBa,cAAA,SAAuB,0BAAA;EAAA,OAC3B,OAAA,CAAA;EAAA,UAIG,YAAA,EAAc,SAAA;EAExB,WAAA,CAAY,MAAA;IAAU,YAAA,EAAc,SAAA;EAAA;EAe9B,kBAAA,CAAmB,QAAA,EAAU,QAAA,GAAW,OAAA,CAAQ,QAAA;AAAA;AAAA,iBAaxC,oBAAA,CACd,MAAA,EAAQ,qBAAA,EACR,OAAA,EAAS,mBAAA;EAAwB,GAAA,GAAM,UAAA;AAAA,IAAY,cAAA;AAAA,iBAQrC,2BAAA,CACd,MAAA,EAAQ,gBAAA,EACR,OAAA,EAAS,mBAAA;EAAwB,GAAA,GAAM,UAAA;AAAA,IAAY,cAAA"}
+{"version":3,"file":"openai_functions.d.ts","names":[],"sources":["../../src/document_transformers/openai_functions.ts"],"mappings":";;;;;;;;;;;cAmBa,uBAAuB;SAC3B;YAIG,cAAc;EAExB,YAAY;IAAU,cAAc;;EAe9B,mBAAmB,UAAU,WAAW,QAAQ;;iBAaxC,qBACd,QAAQ,uBACR,SAAS;EAAwB,MAAM;IAAY;iBAQrC,4BACd,QAAQ,kBACR,SAAS;EAAwB,MAAM;IAAY"}

package/dist/document_transformers/openai_functions.js.map

@@ -1 +1 @@
-{"version":3,"file":"openai_functions.js","names":[],"sources":["../../src/document_transformers/openai_functions.ts"],"sourcesContent":["import {\n  Document,\n  MappingDocumentTransformer,\n} from \"@langchain/core/documents\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nimport { InteropZodObject } from \"@langchain/core/utils/types\";\nimport {\n  type JsonSchema7ObjectType,\n  toJsonSchema,\n} from \"@langchain/core/utils/json_schema\";\nimport { BaseChain } from \"../chains/base.js\";\nimport {\n  TaggingChainOptions,\n  createTaggingChain,\n} from \"../chains/openai_functions/index.js\";\n\n/**\n * A transformer that tags metadata to a document using a tagging chain.\n */\nexport class MetadataTagger extends MappingDocumentTransformer {\n  static lc_name() {\n    return \"MetadataTagger\";\n  }\n\n  protected taggingChain: BaseChain;\n\n  constructor(fields: { taggingChain: BaseChain }) {\n    super();\n    this.taggingChain = fields.taggingChain;\n    if (this.taggingChain.inputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one input.\"\n      );\n    }\n    if (this.taggingChain.outputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one output.\"\n      );\n    }\n  }\n\n  async _transformDocument(document: Document): Promise<Document> {\n    const taggingChainResponse = await this.taggingChain.call({\n      [this.taggingChain.inputKeys[0]]: document.pageContent,\n    });\n    const extractedMetadata =\n      taggingChainResponse[this.taggingChain.outputKeys[0]];\n    return new Document({\n      pageContent: document.pageContent,\n      metadata: { ...extractedMetadata, ...document.metadata },\n    });\n  }\n}\n\nexport function createMetadataTagger(\n  schema: JsonSchema7ObjectType,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  const { llm = new ChatOpenAI({ model: \"gpt-3.5-turbo-0613\" }), ...rest } =\n    options;\n  const taggingChain = createTaggingChain(schema, llm, rest);\n  return new MetadataTagger({ taggingChain });\n}\n\nexport function createMetadataTaggerFromZod(\n  schema: InteropZodObject,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  return createMetadataTagger(\n    toJsonSchema(schema) as JsonSchema7ObjectType,\n    options\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,IAAa,iBAAb,cAAoC,2BAA2B;CAC7D,OAAO,UAAU;AACf,SAAO;;CAGT;CAEA,YAAY,QAAqC;AAC/C,SAAO;AACP,OAAK,eAAe,OAAO;AAC3B,MAAI,KAAK,aAAa,UAAU,WAAW,EACzC,OAAM,IAAI,MACR,oEACD;AAEH,MAAI,KAAK,aAAa,WAAW,WAAW,EAC1C,OAAM,IAAI,MACR,qEACD;;CAIL,MAAM,mBAAmB,UAAuC;EAI9D,MAAM,qBACJ,MAJiC,KAAK,aAAa,KAAK,GACvD,KAAK,aAAa,UAAU,KAAK,SAAS,aAC5C,CAAC,EAEqB,KAAK,aAAa,WAAW;AACpD,SAAO,IAAI,SAAS;GAClB,aAAa,SAAS;GACtB,UAAU;IAAE,GAAG;IAAmB,GAAG,SAAS;IAAU;GACzD,CAAC;;;AAIN,SAAgB,qBACd,QACA,SACA;CACA,MAAM,EAAE,MAAM,IAAI,WAAW,EAAE,OAAO,sBAAsB,CAAC,EAAE,GAAG,SAChE;AAEF,QAAO,IAAI,eAAe,EAAE,cADP,mBAAmB,QAAQ,KAAK,KACb,EAAE,CAAC;;AAG7C,SAAgB,4BACd,QACA,SACA;AACA,QAAO,qBACL,aAAa,OAAO,EACpB,QACD"}
+{"version":3,"file":"openai_functions.js","names":[],"sources":["../../src/document_transformers/openai_functions.ts"],"sourcesContent":["import {\n  Document,\n  MappingDocumentTransformer,\n} from \"@langchain/core/documents\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nimport { InteropZodObject } from \"@langchain/core/utils/types\";\nimport {\n  type JsonSchema7ObjectType,\n  toJsonSchema,\n} from \"@langchain/core/utils/json_schema\";\nimport { BaseChain } from \"../chains/base.js\";\nimport {\n  TaggingChainOptions,\n  createTaggingChain,\n} from \"../chains/openai_functions/index.js\";\n\n/**\n * A transformer that tags metadata to a document using a tagging chain.\n */\nexport class MetadataTagger extends MappingDocumentTransformer {\n  static lc_name() {\n    return \"MetadataTagger\";\n  }\n\n  protected taggingChain: BaseChain;\n\n  constructor(fields: { taggingChain: BaseChain }) {\n    super();\n    this.taggingChain = fields.taggingChain;\n    if (this.taggingChain.inputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one input.\"\n      );\n    }\n    if (this.taggingChain.outputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one output.\"\n      );\n    }\n  }\n\n  async _transformDocument(document: Document): Promise<Document> {\n    const taggingChainResponse = await this.taggingChain.call({\n      [this.taggingChain.inputKeys[0]]: document.pageContent,\n    });\n    const extractedMetadata =\n      taggingChainResponse[this.taggingChain.outputKeys[0]];\n    return new Document({\n      pageContent: document.pageContent,\n      metadata: { ...extractedMetadata, ...document.metadata },\n    });\n  }\n}\n\nexport function createMetadataTagger(\n  schema: JsonSchema7ObjectType,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  const { llm = new ChatOpenAI({ model: \"gpt-3.5-turbo-0613\" }), ...rest } =\n    options;\n  const taggingChain = createTaggingChain(schema, llm, rest);\n  return new MetadataTagger({ taggingChain });\n}\n\nexport function createMetadataTaggerFromZod(\n  schema: InteropZodObject,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  return createMetadataTagger(\n    toJsonSchema(schema) as JsonSchema7ObjectType,\n    options\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,IAAa,iBAAb,cAAoC,2BAA2B;CAC7D,OAAO,UAAU;EACf,OAAO;CACT;CAEA;CAEA,YAAY,QAAqC;EAC/C,MAAM;EACN,KAAK,eAAe,OAAO;EAC3B,IAAI,KAAK,aAAa,UAAU,WAAW,GACzC,MAAM,IAAI,MACR,mEACF;EAEF,IAAI,KAAK,aAAa,WAAW,WAAW,GAC1C,MAAM,IAAI,MACR,oEACF;CAEJ;CAEA,MAAM,mBAAmB,UAAuC;EAI9D,MAAM,qBACJ,MAJiC,KAAK,aAAa,KAAK,GACvD,KAAK,aAAa,UAAU,KAAK,SAAS,YAC7C,CAAC,EAAA,CAEsB,KAAK,aAAa,WAAW;EACpD,OAAO,IAAI,SAAS;GAClB,aAAa,SAAS;GACtB,UAAU;IAAE,GAAG;IAAmB,GAAG,SAAS;GAAS;EACzD,CAAC;CACH;AACF;AAEA,SAAgB,qBACd,QACA,SACA;CACA,MAAM,EAAE,MAAM,IAAI,WAAW,EAAE,OAAO,qBAAqB,CAAC,GAAG,GAAG,SAChE;CAEF,OAAO,IAAI,eAAe,EAAE,cADP,mBAAmB,QAAQ,KAAK,IACzB,EAAa,CAAC;AAC5C;AAEA,SAAgB,4BACd,QACA,SACA;CACA,OAAO,qBACL,aAAa,MAAM,GACnB,OACF;AACF"}