any-extractor 2.0.0 → 2.0.1

package/dist/index.js

@@ -0,0 +1,1040 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  getAnyExtractor: () => getAnyExtractor
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/extractors/any-extractor.ts
+var import_file_type_mime = require("file-type-mime");
+
+// src/util.ts
+var import_undici = require("undici");
+var import_yauzl = __toESM(require("yauzl"));
+
+// src/constant.ts
+var ERRORMSG = {
+  extensionUnsupported: (ext) => `Sorry, AnyExtractor currently support docx, pptx, xlsx, odt, odp, ods, pdf files only. Create a ticket in Issues on github to add support for ${ext} files. Stay tuned for further updates.`,
+  fileCorrupted: (filepath) => `Your file ${filepath} seems to be corrupted. If you are sure it is fine, please create a ticket in Issues on github with the file to reproduce error.`,
+  fileDoesNotExist: (filepath) => `File ${filepath} could not be found! Check if the file exists or verify if the relative path to the file is correct from your terminal's location.`,
+  locationNotFound: (location) => `Entered location ${location} is not reachable! Please make sure that the entered directory location exists. Check relative paths and reenter.`,
+  improperArguments: `Improper arguments`,
+  improperBuffers: `Error occured while reading the file buffers`,
+  invalidInput: `Invalid input type: Expected a Buffer or a valid file path`
+};
+
+// src/util.ts
+var import_concat_stream = __toESM(require("concat-stream"));
+var import_xmldom = require("@xmldom/xmldom");
+var import_fs = require("fs");
+async function readFile(filePath) {
+  return await import_fs.promises.readFile(filePath);
+}
+var readFileUrl = async (url, basicAuth) => {
+  const res = await (0, import_undici.fetch)(url, {
+    headers: {
+      ...basicAuth ? { Authorization: basicAuth } : {}
+    }
+  });
+  if (!res.ok) throw new Error(`Failed to fetch: ${res.statusText}`);
+  return Buffer.from(await res.arrayBuffer());
+};
+var extractFiles = (zipInput, filterFn) => {
+  return new Promise((res, rej) => {
+    const processZipfile = (zipfile) => {
+      const extractedFiles = [];
+      zipfile.readEntry();
+      function processEntry(entry) {
+        if (filterFn(entry.fileName)) {
+          zipfile.openReadStream(entry, (err, readStream) => {
+            if (err) return rej(err);
+            readStream.pipe(
+              (0, import_concat_stream.default)((data) => {
+                extractedFiles.push({
+                  path: entry.fileName,
+                  content: data
+                });
+                zipfile.readEntry();
+              })
+            );
+          });
+        } else zipfile.readEntry();
+      }
+      zipfile.on("entry", processEntry);
+      zipfile.on("end", () => res(extractedFiles));
+      zipfile.on("error", rej);
+    };
+    if (Buffer.isBuffer(zipInput)) {
+      import_yauzl.default.fromBuffer(zipInput, { lazyEntries: true }, (err, zipfile) => {
+        if (err) return rej(err);
+        processZipfile(zipfile);
+      });
+    } else if (typeof zipInput === "string") {
+      import_yauzl.default.open(zipInput, { lazyEntries: true }, (err, zipfile) => {
+        if (err) return rej(err);
+        processZipfile(zipfile);
+      });
+    } else rej(ERRORMSG.invalidInput);
+  });
+};
+var parseString = (xml) => {
+  const parser = new import_xmldom.DOMParser();
+  return parser.parseFromString(xml, "text/xml");
+};
+function isValidUrl(str) {
+  try {
+    if (!str) return false;
+    new URL(str);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/crawler/confluence-crawler.ts
+var import_undici2 = require("undici");
+var cheerio = __toESM(require("cheerio"));
+var ConfluenceCrawler = class {
+  constructor(baseUrl, email, apiKey) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.email = email;
+    this.apiKey = apiKey;
+    this.apiEndpoint = this.baseUrl.includes("atlassian.net") ? `${this.baseUrl}/wiki/rest/api` : `${this.baseUrl}/rest/api`;
+  }
+  async extractPageContent(pageId) {
+    const xmlContent = await this.fetchPageContent(pageId);
+    return this.extractOrderedContentFromXml(xmlContent, pageId);
+  }
+  async fetchPageContent(pageId) {
+    const url = `${this.apiEndpoint}/content/${pageId}?expand=body.storage`;
+    const response = await (0, import_undici2.fetch)(url, {
+      headers: {
+        Authorization: `Basic ${Buffer.from(`${this.email}:${this.apiKey}`).toString("base64")}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Request failed: ${response.status} ${response.statusText}. Response body: ${errorText}`
+      );
+    }
+    const data = await response.json();
+    return data.body.storage.value;
+  }
+  extractOrderedContentFromXml(xml, pageId) {
+    const $ = cheerio.load(xml, { xmlMode: true });
+    const node = $("ac\\:layout").first();
+    const orderedContent = this.parseNodeContents(node, $, pageId);
+    return orderedContent;
+  }
+  parseNodeContents(node, $, pageId, ignoreTags = []) {
+    let result = [];
+    const contents = node.contents();
+    contents.each((_, ele) => {
+      switch (ele.type) {
+        case "text":
+          result.push(this.parseTextNode(ele));
+          break;
+        case "tag":
+          const tagResult = this.parseTagNode(ele, $, pageId, ignoreTags);
+          result = result.concat(tagResult);
+          break;
+        default:
+          break;
+      }
+    });
+    return result;
+  }
+  parseTextNode(ele) {
+    const text = ele.data.trim();
+    return { type: "text", content: text };
+  }
+  parseTagNode(ele, $, pageId, ignoreTags) {
+    let result = [];
+    const tagName = ele.tagName;
+    if (ignoreTags.includes(tagName)) {
+      return result;
+    }
+    switch (tagName) {
+      case "ac:structured-macro":
+        result = result.concat(this.parseStructuredMacro(ele, $, pageId));
+        break;
+      case "ac:adf-extension":
+        result = result.concat(this.parseAdfExtension(ele, $));
+        break;
+      case "ac:task-list":
+        result = result.concat(this.parseTaskList(ele, $, pageId));
+        break;
+      case "ac:image":
+        result = result.concat(this.parseImage(ele, $, pageId));
+        break;
+      case "table":
+        result = result.concat(this.parseTable(ele, $));
+        break;
+      case "a":
+        result = result.concat(this.parseLink(ele, $, pageId));
+        break;
+      default:
+        result = result.concat(this.parseNodeContents($(ele), $, pageId));
+        break;
+    }
+    return result;
+  }
+  parseStructuredMacro(ele, $, pageId) {
+    const macroName = ele.attribs["ac:name"];
+    const result = [];
+    switch (macroName) {
+      case "code":
+        result.push(this.parseCodeMacro(ele, $));
+        break;
+      case "info":
+        result.push(this.parseInfoMacro(ele, $, pageId));
+        break;
+      case "warning":
+        result.push(this.parseWarningMacro(ele, $, pageId));
+        break;
+      case "note":
+        result.push(this.parseNoteMacro(ele, $, pageId));
+        break;
+      case "tip":
+        result.push(this.parseTipMacro(ele, $, pageId));
+        break;
+      case "panel":
+        result.push(this.parsePanelMacro(ele, $, pageId));
+        break;
+      case "expand":
+        result.push(this.parseExpandMacro(ele, $, pageId));
+        break;
+      case "status":
+        result.push(this.parseStatusMacro(ele, $, pageId));
+        break;
+      case "view-file":
+        result.push(this.parseViewFileMacro(ele, $, pageId));
+        break;
+    }
+    return result;
+  }
+  parseLink(ele, $, pageId) {
+    const href = $(ele).attr("href");
+    const text = this.parseNodeContents($(ele), $, pageId);
+    return [{ type: "link", content: `${text.map((t) => t.content).join("")} (${href})` }];
+  }
+  parseTaskList(ele, $, pageId) {
+    const result = [];
+    const tasks = $(ele).find("ac\\:task");
+    tasks.each((_, task) => {
+      const taskStatus = $(task).find("ac\\:task-status").text().trim();
+      const taskBody = this.parseNodeContents($(task).find("ac\\:task-body"), $, pageId);
+      result.push({
+        type: "task",
+        content: `${taskBody.map((t) => t.content).join("")} [Status: ${taskStatus}]`
+      });
+    });
+    return result;
+  }
+  parseImage(ele, $, pageId) {
+    const attachment = $(ele).find("ri\\:attachment");
+    const filename = attachment.attr("ri:filename")?.trim();
+    if (!filename) {
+      return [];
+    }
+    const imageUrl = this.baseUrl.includes("atlassian.net") ? `${this.baseUrl}/wiki/download/attachments/${pageId}/${encodeURIComponent(filename)}` : `${this.baseUrl}/download/attachments/${pageId}/${encodeURIComponent(filename)}`;
+    return [{ type: "image", content: imageUrl }];
+  }
+  parseTable(ele, $) {
+    const result = [];
+    const rows = $(ele).find("tr");
+    const tableData = [];
+    rows.each((_, row) => {
+      const cells = $(row).find("th, td");
+      const rowData = [];
+      cells.each((_2, cell) => {
+        rowData.push($(cell).text().trim());
+      });
+      tableData.push(rowData.join(" | "));
+    });
+    result.push({ type: "table", content: tableData.join("\n") });
+    return result;
+  }
+  parseCodeMacro(ele, $) {
+    const code = $(ele).find("ac\\:plain-text-body").text().trim();
+    return { type: "code", content: code };
+  }
+  parseInfoMacro(ele, $, pageId) {
+    const info = this.parseNodeContents($(ele), $, pageId);
+    return { type: "info", content: info.map((t) => t.content).join("") };
+  }
+  parseWarningMacro(ele, $, pageId) {
+    const warning = this.parseNodeContents($(ele), $, pageId);
+    return { type: "warning", content: warning.map((t) => t.content).join("") };
+  }
+  parseNoteMacro(ele, $, pageId) {
+    const note = this.parseNodeContents($(ele), $, pageId);
+    return { type: "note", content: note.map((t) => t.content).join("") };
+  }
+  parseTipMacro(ele, $, pageId) {
+    const tip = this.parseNodeContents($(ele), $, pageId);
+    return { type: "tip", content: tip.map((t) => t.content).join("") };
+  }
+  parsePanelMacro(ele, $, pageId) {
+    const panel = this.parseNodeContents($(ele), $, pageId, ["ac:parameter"]);
+    return { type: "panel", content: panel.map((t) => t.content).join("") };
+  }
+  parseExpandMacro(ele, $, pageId) {
+    const expand = this.parseNodeContents($(ele), $, pageId);
+    return { type: "expand", content: expand.map((t) => t.content).join("") };
+  }
+  parseStatusMacro(ele, $, pageId) {
+    const status = this.parseNodeContents($(ele), $, pageId);
+    return { type: "status", content: status.map((t) => t.content).join("") };
+  }
+  parseAdfExtension(ele, $) {
+    const adfNode = $(ele).find("ac\\:adf-node");
+    const content = adfNode.find("ac\\:adf-content").text().trim();
+    return [{ type: "adf-extension", content }];
+  }
+  parseViewFileMacro(ele, $, pageId) {
+    const attachment = $(ele).find('ac\\:parameter[ac\\:name="name"] ri\\:attachment');
+    const filename = attachment.attr("ri:filename")?.trim();
+    if (!filename) {
+      return { type: "view-file", content: "" };
+    }
+    const fileUrl = this.baseUrl.includes("atlassian.net") ? `${this.baseUrl}/wiki/download/attachments/${pageId}/${encodeURIComponent(filename)}` : `${this.baseUrl}/download/attachments/${pageId}/${encodeURIComponent(filename)}`;
+    return { type: "view-file", content: fileUrl };
+  }
+};
+
+// src/extractors/any-extractor.ts
+var AnyExtractor = class {
+  constructor(extractorConfig) {
+    this.extractorConfig = {
+      llm: {
+        llmProvider: "openai",
+        visionModel: "",
+        apikey: ""
+      },
+      confluence: {
+        baseUrl: "",
+        email: "",
+        apiKey: ""
+      }
+    };
+    this.mimeParserMap = /* @__PURE__ */ new Map();
+    this.parsers = [];
+    this.addParser = (method) => {
+      this.parsers.push(method);
+      method.mimes.forEach((mime) => {
+        this.mimeParserMap.set(mime, method);
+      });
+      return this;
+    };
+    this.parseFile = async (input, basicAuth = null, extractingOptions = {
+      extractImages: false,
+      imageExtractionMethod: "ocr",
+      language: "eng"
+    }) => {
+      let preparedInput;
+      if (typeof input === "string") {
+        if (isValidUrl(input)) {
+          preparedInput = await readFileUrl(input, basicAuth);
+        } else {
+          preparedInput = await readFile(input);
+        }
+      } else {
+        preparedInput = input;
+      }
+      if (!preparedInput) {
+        throw new Error("AnyExtractor: No input provided");
+      }
+      const mimeDetails = (0, import_file_type_mime.parse)(
+        preparedInput.buffer.slice(
+          preparedInput.byteOffset,
+          preparedInput.byteOffset + preparedInput.byteLength
+        )
+      );
+      if (!mimeDetails) {
+        return preparedInput.toString("utf-8");
+      }
+      const extractor = this.mimeParserMap.get(mimeDetails.mime);
+      if (!extractor?.apply) {
+        const message = `AnyExtractor: No extraction method registered for MIME type '${mimeDetails.mime}'`;
+        throw new Error(message);
+      }
+      return extractor.apply(preparedInput, extractingOptions, this.extractorConfig);
+    };
+    this.parseConfluenceDoc = async (pageId, extractingOptions = {
+      extractAttachments: false,
+      extractImages: false,
+      imageExtractionMethod: "ocr",
+      language: "eng"
+    }) => {
+      const { baseUrl, email, apiKey } = this.extractorConfig.confluence || {};
+      if (!baseUrl || !email || !apiKey) {
+        throw new Error("AnyExtractor: Confluence base URL, email, and API key are required");
+      }
+      const confCrawler = new ConfluenceCrawler(baseUrl, email, apiKey);
+      const content = await confCrawler.extractPageContent(pageId);
+      let textContent = "";
+      for (const item of content) {
+        if (item.type === "image" && extractingOptions.extractImages) {
+          const parsedFile = await this.parseFile(
+            item.content,
+            `Basic ${Buffer.from(`${email}:${apiKey}`).toString("base64")}`,
+            extractingOptions
+          );
+          textContent += parsedFile ? `
+(Image): ${parsedFile}
+` : "";
+        } else if (item.type === "view-file" && extractingOptions.extractAttachments) {
+          const parsedFile = await this.parseFile(
+            item.content,
+            `Basic ${Buffer.from(`${email}:${apiKey}`).toString("base64")}`,
+            extractingOptions
+          );
+          textContent += parsedFile ? `
+[Attachment]: ${parsedFile}
+` : "";
+        } else if ([
+          "h1",
+          "h2",
+          "h3",
+          "h4",
+          "h5",
+          "h6",
+          "p",
+          "table",
+          "li",
+          "code",
+          "info",
+          "warning",
+          "tip",
+          "note",
+          "panel",
+          "expand",
+          "adf-extension"
+        ].includes(item.type)) {
+          textContent += `
+${item.content}
+`;
+        } else if (item.type === "text") {
+          textContent += ` ${item.content}`;
+        }
+      }
+      return textContent;
+    };
+    if (extractorConfig) {
+      this.extractorConfig = extractorConfig;
+    }
+  }
+};
+
+// src/file-parser/excel-parser.ts
+var ExcelParser = class {
+  constructor(anyExtractor) {
+    this.mimes = ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"];
+    this.anyExtractor = anyExtractor;
+  }
+  async apply(file, extractingOptions) {
+    const patterns = {
+      sheets: /xl\/worksheets\/sheet\d+.xml/g,
+      drawings: /xl\/drawings\/drawing\d+.xml/g,
+      charts: /xl\/charts\/chart\d+.xml/g,
+      sharedStrings: "xl/sharedStrings.xml",
+      images: /xl\/media\/image\d+\.(png|jpeg|jpg|webp)/g
+    };
+    try {
+      const files = await extractFiles(
+        file,
+        (path) => [patterns.sheets, patterns.drawings, patterns.charts, patterns.images].some(
+          (regex) => regex.test(path)
+        ) || path === patterns.sharedStrings
+      );
+      if (files.length === 0 || !files.some((file2) => patterns.sheets.test(file2.path))) {
+        throw ERRORMSG.fileCorrupted("Missing or corrupted sheet files.");
+      }
+      const xmlContent = {
+        sheets: files.filter((file2) => patterns.sheets.test(file2.path)).map((file2) => file2.content.toString()),
+        drawings: files.filter((file2) => patterns.drawings.test(file2.path)).map((file2) => file2.content.toString()),
+        charts: files.filter((file2) => patterns.charts.test(file2.path)).map((file2) => file2.content.toString()),
+        sharedStrings: files.find((file2) => file2.path === patterns.sharedStrings)?.content.toString(),
+        images: files.filter((file2) => patterns.images.test(file2.path))
+      };
+      const sharedStrings = this.parseSharedStrings(xmlContent.sharedStrings);
+      const orderedText = files.map(async (file2) => {
+        if (patterns.sheets.test(file2.path)) {
+          return this.extractSheetText([file2.content.toString()], sharedStrings);
+        } else if (patterns.drawings.test(file2.path)) {
+          return this.extractDrawingText([file2.content.toString()]);
+        } else if (patterns.charts.test(file2.path)) {
+          return this.extractChartText([file2.content.toString()]);
+        } else if (patterns.images.test(file2.path)) {
+          return await this.extractImageText([file2], extractingOptions);
+        }
+        return null;
+      }).filter(Boolean);
+      const resolvedText = await Promise.all(orderedText);
+      return resolvedText.filter(Boolean).join("\n");
+    } catch (error) {
+      console.error("AnyExtractor: Error parsing Excel file:", error);
+      throw error;
+    }
+  }
+  parseSharedStrings(sharedStringsXml) {
+    if (!sharedStringsXml) return [];
+    const tNodes = parseString(sharedStringsXml).getElementsByTagName("t");
+    return Array.from(tNodes).map((node) => node.childNodes[0]?.nodeValue ?? "");
+  }
+  extractSheetText(sheetFiles, sharedStrings) {
+    return sheetFiles.map((content) => {
+      const cNodes = parseString(content).getElementsByTagName("c");
+      return Array.from(cNodes).filter((node) => this.isValidInlineString(node) || this.hasValidValueNode(node)).map((node) => this.getCellValue(node, sharedStrings)).join("\n");
+    }).join("\n");
+  }
+  extractDrawingText(drawingFiles) {
+    return drawingFiles.map((content) => {
+      const pNodes = parseString(content).getElementsByTagName("a:p");
+      return Array.from(pNodes).map((node) => {
+        const tNodes = node.getElementsByTagName("a:t");
+        return Array.from(tNodes).map((tNode) => tNode.childNodes[0]?.nodeValue ?? "").join("");
+      }).join("\n");
+    }).join("\n");
+  }
+  extractChartText(chartFiles) {
+    return chartFiles.map((content) => {
+      const vNodes = parseString(content).getElementsByTagName("c:v");
+      return Array.from(vNodes).map((node) => node.childNodes[0]?.nodeValue ?? "").join("\n");
+    }).join("\n");
+  }
+  async extractImageText(imageFiles, extractingOptions) {
+    const texts = await Promise.all(
+      imageFiles.map(async (file) => {
+        try {
+          return await this.anyExtractor.parseFile(file.content, null, extractingOptions);
+        } catch (e) {
+          console.log(`AnyExtractor: Error extracting text from image ${file.path}:`, e);
+          return "";
+        }
+      })
+    );
+    return texts.filter(Boolean).join("\n");
+  }
+  isValidInlineString(cNode) {
+    if (cNode.tagName.toLowerCase() !== "c" || cNode.getAttribute("t") !== "inlineStr")
+      return false;
+    const isNodes = cNode.getElementsByTagName("is");
+    const tNodes = isNodes[0]?.getElementsByTagName("t");
+    return tNodes?.[0]?.childNodes[0]?.nodeValue !== void 0;
+  }
+  hasValidValueNode(cNode) {
+    const vNodes = cNode.getElementsByTagName("v");
+    return vNodes[0]?.childNodes[0]?.nodeValue !== void 0;
+  }
+  getCellValue(cNode, sharedStrings) {
+    if (this.isValidInlineString(cNode)) {
+      return cNode.getElementsByTagName("is")[0].getElementsByTagName("t")[0].childNodes[0].nodeValue ?? "";
+    }
+    if (this.hasValidValueNode(cNode)) {
+      const isSharedString = cNode.getAttribute("t") === "s";
+      const valueIndex = parseInt(
+        cNode.getElementsByTagName("v")[0].childNodes[0].nodeValue ?? "",
+        10
+      );
+      if (isSharedString) {
+        if (valueIndex >= sharedStrings.length) {
+          throw ERRORMSG.fileCorrupted("AnyExtractor: Invalid shared string index.");
+        }
+        return sharedStrings[valueIndex];
+      }
+      return valueIndex.toString();
+    }
+    return "";
+  }
+};
+
+// src/file-parser/image-parser.ts
+var import_tesseract = __toESM(require("tesseract.js"));
+var import_undici3 = require("undici");
+var import_file_type_mime2 = require("file-type-mime");
+var ImageParser = class {
+  constructor() {
+    this.mimes = ["image/jpeg", "image/png", "image/webp"];
+    this.apply = async (file, extractingOptions, extractorConfig) => {
+      const { extractImages, imageExtractionMethod, language } = extractingOptions;
+      if (!extractImages) {
+        return "";
+      }
+      const mimeDetails = (0, import_file_type_mime2.parse)(
+        file.buffer.slice(file.byteOffset, file.byteOffset + file.byteLength)
+      );
+      if (!mimeDetails) {
+        throw new Error("AnyExtractor: Unable to parse MIME type");
+      }
+      const mimeType = mimeDetails.mime;
+      if (!this.mimes.includes(mimeType)) {
+        return "";
+      }
+      if (imageExtractionMethod === "ocr") {
+        return await this.performOCR(file, language);
+      }
+      const { llmProvider, visionModel, apikey } = extractorConfig.llm || {};
+      if (!llmProvider || !visionModel || !apikey) {
+        throw new Error(
+          "AnyExtractor: LLM provider, vision model and API key are required for image extraction"
+        );
+      }
+      const base64Image = file.toString("base64");
+      switch (llmProvider) {
+        case "openai":
+          return this.handleOpenAI(base64Image, mimeType, visionModel, apikey);
+        case "google":
+          return this.handleGoogle(base64Image, mimeType, visionModel, apikey);
+        case "anthropic":
+          return this.handleAnthropic(base64Image, mimeType, visionModel, apikey);
+        default:
+          throw new Error(`ImageParser: Unsupported LLM provider '${llmProvider}'`);
+      }
+    };
+    this.performOCR = async (file, language) => {
+      const worker = await import_tesseract.default.createWorker(language);
+      const {
+        data: { text }
+      } = await worker.recognize(file);
+      await worker.terminate();
+      return text;
+    };
+    this.handleOpenAI = async (base64Image, mimeType, visionModel, apikey) => {
+      const response = await (0, import_undici3.fetch)("https://api.openai.com/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apikey}`
+        },
+        body: JSON.stringify({
+          model: visionModel,
+          messages: [
+            {
+              role: "user",
+              content: [
+                {
+                  type: "text",
+                  text: "Provide a concise summary of the image for semantic search. Exclude any introductions, labels, or formatting \u2014 just return the core content. Also include visible text and contextual details about layout, content type, or purpose."
+                },
+                {
+                  type: "image_url",
+                  image_url: {
+                    url: `data:${mimeType};base64,${base64Image}`
+                  }
+                }
+              ]
+            }
+          ]
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`ImageParser: OpenAI API error ${response.status}`);
+      }
+      const data = await response.json();
+      return data.choices[0].message.content;
+    };
+    this.handleGoogle = async (base64Image, mimeType, visionModel, apikey) => {
+      const response = await (0, import_undici3.fetch)(
+        `https://generativelanguage.googleapis.com/v1beta/models/${visionModel}:generateContent?key=${apikey}`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            contents: [
+              {
+                parts: [
+                  {
+                    text: "Provide a concise summary of the image for semantic search. Exclude any introductions, labels, or formatting \u2014 just return the core content. Also include visible text and contextual details about layout, content type, or purpose."
+                  },
+                  {
+                    inlineData: {
+                      mimeType,
+                      data: base64Image
+                    }
+                  }
+                ]
+              }
+            ]
+          })
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`Google Gemini error: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return data.candidates[0].content.parts[0].text;
+    };
+    this.handleAnthropic = async (base64Image, mimeType, visionModel, apikey) => {
+      const response = await (0, import_undici3.fetch)("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apikey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: visionModel,
+          max_tokens: 300,
+          messages: [
+            {
+              role: "user",
+              content: [
+                {
+                  type: "text",
+                  text: "Provide a concise summary of the image for semantic search. Exclude any introductions, labels, or formatting \u2014 just return the core content. Also include visible text and contextual details about layout, content type, or purpose."
+                },
+                {
+                  type: "image",
+                  source: {
+                    type: "base64",
+                    media_type: mimeType,
+                    data: base64Image
+                  }
+                }
+              ]
+            }
+          ]
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Anthropic Claude error: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return data.content[0].text;
+    };
+  }
+};
+
+// src/file-parser/openoffice-paser.ts
+var OpenOfficeParser = class {
+  constructor() {
+    this.mimes = [
+      "application/vnd.oasis.opendocument.text",
+      "application/vnd.oasis.opendocument.spreadsheet",
+      "application/vnd.oasis.opendocument.presentation",
+      "application/vnd.oasis.opendocument.graphics",
+      "application/vnd.oasis.opendocument.formula"
+    ];
+    this.apply = async (file) => {
+      const MAIN_CONTENT_FILE = "content.xml";
+      const OBJECT_CONTENT_REGEX = /Object \d+\/content.xml/;
+      try {
+        const files = await extractFiles(
+          file,
+          (path) => path === MAIN_CONTENT_FILE || OBJECT_CONTENT_REGEX.test(path)
+        );
+        const contentFiles = files.filter((file2) => file2.path === MAIN_CONTENT_FILE || OBJECT_CONTENT_REGEX.test(file2.path)).sort((a, b) => a.path.localeCompare(b.path));
+        const notesText = [];
+        const outputChunks = [];
+        const ALLOWED_TEXT_TAGS = ["text:p", "text:h"];
+        const NOTES_TAG = "presentation:notes";
+        const extractAllTextsFromNode = (root) => {
+          const textArray = [];
+          traverseNode(root, textArray, true);
+          return textArray.join("");
+        };
+        const traverseNode = (node, textArray, isFirstRecursion) => {
+          if (!node.childNodes || node.childNodes.length === 0) {
+            if (node.parentNode && node.parentNode.tagName.startsWith("text") && node.nodeValue) {
+              const parent = node.parentNode;
+              if (isNotesNode(parent)) {
+                notesText.push(node.nodeValue);
+                if (ALLOWED_TEXT_TAGS.includes(parent.tagName) && !isFirstRecursion) {
+                  notesText.push("\n");
+                }
+              } else {
+                textArray.push(node.nodeValue);
+                if (ALLOWED_TEXT_TAGS.includes(parent.tagName) && !isFirstRecursion) {
+                  textArray.push("\n");
+                }
+              }
+            }
+            return;
+          }
+          for (let i = 0; i < node.childNodes.length; i++) {
+            traverseNode(node.childNodes[i], textArray, false);
+          }
+        };
+        const isNotesNode = (node) => {
+          return node.tagName === NOTES_TAG ? true : node.parentNode ? isNotesNode(node.parentNode) : false;
+        };
+        const isInvalidTextNode = (node) => {
+          return ALLOWED_TEXT_TAGS.includes(node.tagName) ? true : node.parentNode ? isInvalidTextNode(node.parentNode) : false;
+        };
+        for (const contentFile of contentFiles) {
+          const xmlDoc = parseString(contentFile.content.toString());
+          const textNodes = Array.from(xmlDoc.getElementsByTagName("*")).filter(
+            (node) => ALLOWED_TEXT_TAGS.includes(node.tagName) && !isInvalidTextNode(node.parentNode)
+          );
+          const textChunk = textNodes.map((node) => extractAllTextsFromNode(node)).filter((text) => text.trim() !== "").join("\n");
+          if (textChunk) {
+            outputChunks.push(textChunk);
+          }
+        }
+        return [...outputChunks, ...notesText].join("\n\n");
+      } catch (error) {
+        console.error("AnyExtractor: Error parsing OpenOffice file:", error);
+        throw error;
+      }
+    };
+  }
+};
+
+// src/file-parser/pdf-parser.ts
+var import_pdf_parse = __toESM(require("pdf-parse"));
+var PDFParser = class {
+  constructor() {
+    this.mimes = ["application/pdf"];
+    this.apply = async (file) => {
+      try {
+        const data = await (0, import_pdf_parse.default)(file);
+        const textContent = data.text;
+        return textContent;
+      } catch (error) {
+        console.error("AnyExtractor: Error parsing PDF file:", error);
+        throw error;
+      }
+    };
+  }
+};
+
+// src/file-parser/powerpoint-parser.ts
+var PowerPointParser = class {
+  constructor(anyExtractor) {
+    this.mimes = ["application/vnd.openxmlformats-officedocument.presentationml.presentation"];
+    this.anyExtractor = anyExtractor;
+  }
+  async apply(file, extractingOptions) {
+    const fileMatchRegex = /ppt\/(notesSlides|slides)\/(notesSlide|slide)\d+\.xml|ppt\/media\/image\d+\..+|ppt\/slides\/_rels\/slide\d+\.xml.rels/i;
+    const slideNumberRegex = /slide(\d+)\.xml/;
+    const imageRegex = /^ppt\/media\/image\d+\..+$/i;
+    try {
+      const files = await extractFiles(file, (x) => fileMatchRegex.test(x));
+      const imageBuffers = {};
+      const slideXmls = {};
+      const relsFiles = {};
+      for (const file2 of files) {
+        if (imageRegex.test(file2.path)) {
+          imageBuffers[file2.path] = file2.content;
+        } else if (/ppt\/slides\/slide\d+\.xml/.test(file2.path)) {
+          const match = file2.path.match(slideNumberRegex);
+          if (match) slideXmls[+match[1]] = file2.content.toString();
+        } else if (/ppt\/slides\/_rels\/slide\d+\.xml.rels/.test(file2.path)) {
+          const match = file2.path.match(slideNumberRegex);
+          if (match) relsFiles[+match[1]] = file2.content.toString();
+        }
+      }
+      const results = [];
+      const sortedSlideNumbers = Object.keys(slideXmls).map(Number).sort((a, b) => a - b);
+      for (const slideNumber of sortedSlideNumbers) {
+        const xmlContent = slideXmls[slideNumber];
+        const slideText = this.extractTextFromXml(xmlContent);
+        if (slideText) results.push(slideText);
+        const imagePaths = this.extractImagePathsFromRels(relsFiles[slideNumber]);
+        for (const imagePath of imagePaths) {
+          const imageFullPath = `ppt/${imagePath.replace(/^(\.\.\/)+/, "")}`;
+          const imageBuffer = imageBuffers[imageFullPath];
+          if (imageBuffer) {
+            const imageDescription = await this.convertImageToText(imageBuffer, extractingOptions);
+            if (imageDescription) {
+              results.push(`[Image]: ${imageDescription}`);
+            }
+          }
+        }
+      }
+      return results.join("\n");
+    } catch (error) {
+      console.error("AnyExtractor: Error parsing PowerPoint file:", error);
+      throw error;
+    }
+  }
+  extractTextFromXml(xml) {
+    const xmlParagraphNodesList = parseString(xml).getElementsByTagName("a:p");
+    return Array.from(xmlParagraphNodesList).filter((paragraphNode) => paragraphNode.getElementsByTagName("a:t").length > 0).map((paragraphNode) => {
+      const xmlTextNodeList = paragraphNode.getElementsByTagName("a:t");
+      return Array.from(xmlTextNodeList).map((textNode) => textNode.childNodes[0]?.nodeValue || "").join("");
+    }).join("\n");
+  }
+  extractImagePathsFromRels(relsXml) {
+    if (!relsXml) return [];
+    const rels = parseString(relsXml).getElementsByTagName("Relationship");
+    return Array.from(rels).filter((rel) => rel.getAttribute("Type")?.includes("/image") && rel.getAttribute("Target")).map((rel) => rel.getAttribute("Target"));
+  }
+  async convertImageToText(imageBuffer, extractingOptions) {
+    return this.anyExtractor.parseFile(imageBuffer, null, extractingOptions);
+  }
+};
+
+// src/file-parser/simple-parser.ts
+var SimpleParser = class {
+  constructor() {
+    this.mimes = ["text/plain", "application/json"];
+    this.apply = async (file) => {
+      return file.toString("utf-8");
+    };
+  }
+};
+
+// src/file-parser/word-parser.ts
+var WordParser = class {
+  constructor(anyExtractor) {
+    this.mimes = ["application/vnd.openxmlformats-officedocument.wordprocessingml.document"];
+    this.anyExtractor = anyExtractor;
+  }
+  async apply(file, extractingOptions) {
+    const mainRegex = /word\/document[\d+]?.xml/;
+    const footnotesRegex = /word\/footnotes[\d+]?.xml/;
+    const endnotesRegex = /word\/endnotes[\d+]?.xml/;
+    const mediaRegex = /^word\/media\//;
+    const relsRegex = /^word\/_rels\/document.xml.rels$/;
+    try {
+      const files = await extractFiles(
+        file,
+        (filePath) => [mainRegex, footnotesRegex, endnotesRegex, relsRegex].some((r) => r.test(filePath)) || mediaRegex.test(filePath)
+      );
+      const getFile = (regex) => files.find((f) => regex.test(f.path));
+      const mainDoc = getFile(mainRegex);
+      const footnotesDoc = getFile(footnotesRegex);
+      const endnotesDoc = getFile(endnotesRegex);
+      const relsFile = getFile(relsRegex);
+      if (!mainDoc || !relsFile) {
+        throw ERRORMSG.fileCorrupted("Main content or relationships file is missing.");
+      }
+      const mediaFiles = {};
+      for (const file2 of files) {
+        if (mediaRegex.test(file2.path)) {
+          const fileName = file2.path.split("/").pop();
+          mediaFiles[fileName] = file2;
+        }
+      }
+      const embedMap = this.parseRelationships(relsFile.content.toString());
+      const mainText = await this.extractTextAndImages(
+        mainDoc.content.toString(),
+        embedMap,
+        mediaFiles,
+        extractingOptions
+      );
+      const footnotesText = footnotesDoc ? await this.extractTextAndImages(
+        footnotesDoc.content.toString(),
+        embedMap,
+        mediaFiles,
+        extractingOptions
+      ) : "";
+      const endnotesText = endnotesDoc ? await this.extractTextAndImages(
+        endnotesDoc.content.toString(),
+        embedMap,
+        mediaFiles,
+        extractingOptions
+      ) : "";
+      return [
+        mainText,
+        footnotesText ? "\n--- Footnotes ---\n" + footnotesText : "",
+        endnotesText ? "\n--- Endnotes ---\n" + endnotesText : ""
+      ].join("\n");
+    } catch (error) {
+      console.error("AnyExtractor: Error parsing Word file:", error);
+      throw error;
+    }
+  }
+  parseRelationships(xmlContent) {
+    const doc = parseString(xmlContent);
+    const rels = doc.getElementsByTagName("Relationship");
+    const map = {};
+    for (const rel of Array.from(rels)) {
+      const id = rel.getAttribute("Id");
+      const target = rel.getAttribute("Target");
+      if (id && target?.startsWith("media/")) {
+        const filename = target.split("/").pop();
+        map[id] = filename;
+      }
+    }
+    return map;
+  }
+  async extractTextAndImages(xmlContent, embedMap, mediaFiles, extractingOptions) {
+    const doc = parseString(xmlContent);
+    const paragraphs = Array.from(doc.getElementsByTagName("w:p"));
+    const parts = [];
+    for (const paragraph of paragraphs) {
+      let paragraphText = "";
+      const texts = Array.from(paragraph.getElementsByTagName("w:t"));
+      paragraphText += texts.map((t) => t.childNodes[0]?.nodeValue || "").join("");
+      const drawings = Array.from(paragraph.getElementsByTagName("w:drawing"));
+      for (const drawing of drawings) {
+        const blip = drawing.getElementsByTagName("a:blip")[0];
+        const embedId = blip?.getAttribute("r:embed");
+        if (embedId && embedMap[embedId]) {
+          const imageFile = mediaFiles[embedMap[embedId]];
+          if (imageFile) {
+            const imageBuffer = imageFile.content;
+            const imageDescription = await this.convertImageToText(imageBuffer, extractingOptions);
+            paragraphText += `
+[Image: ${imageDescription}]`;
+          }
+        }
+      }
+      if (paragraphText.trim()) {
+        parts.push(paragraphText.trim());
+      }
+    }
+    return parts.join("\n");
+  }
+  async convertImageToText(imageBuffer, extractingOptions) {
+    return await this.anyExtractor.parseFile(imageBuffer, null, extractingOptions);
+  }
+};
+
+// src/index.ts
+var getAnyExtractor = (config) => {
+  const anyExtractor = new AnyExtractor(config);
+  const parsers = [
+    new ExcelParser(anyExtractor),
+    new ImageParser(),
+    new OpenOfficeParser(),
+    new PDFParser(),
+    new PowerPointParser(anyExtractor),
+    new SimpleParser(),
+    new WordParser(anyExtractor)
+  ];
+  parsers.forEach((parser) => anyExtractor.addParser(parser));
+  return anyExtractor;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAnyExtractor
+});
+//# sourceMappingURL=index.js.map