@elizaos/plugin-pdf 2.0.0-alpha.13 → 2.0.0-alpha.15

package/dist/cjs/index.node.cjs

@@ -64,76 +64,1637 @@ var __export = (target, all) => {
 var exports_index_node = {};
 __export(exports_index_node, {
   pdfPlugin: () => pdfPlugin,
-  default: () => typescript_default,
+  default: () => import__.default,
   PdfService: () => PdfService
 });
 module.exports = __toCommonJS(exports_index_node);
 
 // services/pdf.ts
 var import_core = require("@elizaos/core");
+
+// node_modules/pdf-parse/dist/pdf-parse/esm/index.js
+var exports_esm = {};
+__export(exports_esm, {
+  getException: () => getException,
+  VerbosityLevel: () => import_pdf.VerbosityLevel,
+  UnknownErrorException: () => UnknownErrorException,
+  Table: () => Table,
+  Shape: () => Shape,
+  ResponseException: () => ResponseException,
+  Rectangle: () => Rectangle,
+  Point: () => Point,
+  PasswordException: () => PasswordException,
+  PDFParse: () => PDFParse,
+  LineStore: () => LineStore,
+  LineDirection: () => LineDirection,
+  Line: () => Line,
+  InvalidPDFException: () => InvalidPDFException,
+  FormatError: () => FormatError,
+  AbortException: () => AbortException
+});
+
+// node_modules/pdf-parse/dist/pdf-parse/esm/PDFParse.js
+var pdfjs2 = __toESM(require("pdfjs-dist/legacy/build/pdf.mjs"));
+
+// node_modules/pdf-parse/dist/pdf-parse/esm/Exception.js
+class InvalidPDFException extends Error {
+  constructor(message, cause) {
+    if (cause !== undefined) {
+      super(message ?? "Invalid PDF", { cause });
+    } else {
+      super(message ?? "Invalid PDF");
+    }
+    this.name = "InvalidPDFException";
+    Object.setPrototypeOf(this, InvalidPDFException.prototype);
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, InvalidPDFException);
+    }
+  }
+}
+
+class PasswordException extends Error {
+  constructor(message, cause) {
+    if (cause !== undefined) {
+      super(message ?? "Password required or incorrect", { cause });
+    } else {
+      super(message ?? "Password required or incorrect");
+    }
+    this.name = "PasswordException";
+    Object.setPrototypeOf(this, PasswordException.prototype);
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, PasswordException);
+    }
+  }
+}
+
+class FormatError extends Error {
+  constructor(message, cause) {
+    if (cause !== undefined) {
+      super(message ?? "PDF format error", { cause });
+    } else {
+      super(message ?? "PDF format error");
+    }
+    this.name = "FormatError";
+    Object.setPrototypeOf(this, FormatError.prototype);
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, FormatError);
+    }
+  }
+}
+
+class UnknownErrorException extends Error {
+  constructor(message, details, cause) {
+    if (cause !== undefined) {
+      super(message ?? "Unknown error", { cause });
+    } else {
+      super(message ?? "Unknown error");
+    }
+    this.name = "UnknownErrorException";
+    Object.setPrototypeOf(this, UnknownErrorException.prototype);
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, UnknownErrorException);
+    }
+    this.details = details;
+  }
+}
+
+class ResponseException extends Error {
+  constructor(message, status, missing, cause) {
+    if (cause !== undefined) {
+      super(message ?? "Response error", { cause });
+    } else {
+      super(message ?? "Response error");
+    }
+    this.name = "ResponseException";
+    Object.setPrototypeOf(this, ResponseException.prototype);
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, ResponseException);
+    }
+    this.status = status;
+    this.missing = missing;
+  }
+}
+
+class AbortException extends Error {
+  constructor(message, cause) {
+    if (cause !== undefined) {
+      super(message ?? "Operation aborted", { cause });
+    } else {
+      super(message ?? "Operation aborted");
+    }
+    this.name = "AbortException";
+    Object.setPrototypeOf(this, AbortException.prototype);
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, AbortException);
+    }
+  }
+}
+function getException(error) {
+  if (error instanceof Error) {
+    switch (error.name) {
+      case "InvalidPDFException":
+        return new InvalidPDFException(error.message, error);
+      case "PasswordException":
+        return new PasswordException(error.message, error);
+      case "FormatError":
+        return new FormatError(error.message, error);
+      case "UnknownErrorException":
+        return new UnknownErrorException(error.message, error.details, error);
+      case "ResponseException":
+        return new ResponseException(error.message, error.status, error.missing, error);
+      case "AbortException":
+        return new AbortException(error.message, error);
+      default:
+        return error;
+    }
+  }
+  return new Error(String(error));
+}
+
+// node_modules/pdf-parse/dist/pdf-parse/esm/geometry/Shape.js
+class Shape {
+  static tolerance = 2;
+  static applyTransform(p, m) {
+    const xt = p[0] * m[0] + p[1] * m[2] + m[4];
+    const yt = p[0] * m[1] + p[1] * m[3] + m[5];
+    return [xt, yt];
+  }
+}
+
+// node_modules/pdf-parse/dist/pdf-parse/esm/geometry/Point.js
+class Point extends Shape {
+  x;
+  y;
+  constructor(x, y) {
+    super();
+    this.x = x;
+    this.y = y;
+  }
+  equal(point) {
+    return point.x === this.x && point.y === this.y;
+  }
+  transform(matrix) {
+    const p = Shape.applyTransform([this.x, this.y], matrix);
+    this.x = p[0];
+    this.y = p[1];
+    return this;
+  }
+}
+
+// node_modules/pdf-parse/dist/pdf-parse/esm/geometry/Line.js
+var LineDirection;
+(function(LineDirection2) {
+  LineDirection2[LineDirection2["None"] = 0] = "None";
+  LineDirection2[LineDirection2["Horizontal"] = 1] = "Horizontal";
+  LineDirection2[LineDirection2["Vertical"] = 2] = "Vertical";
+})(LineDirection || (LineDirection = {}));
+
+class Line extends Shape {
+  from;
+  to;
+  direction = LineDirection.None;
+  length = 0;
+  intersections = [];
+  gaps = [];
+  constructor(from, to) {
+    super();
+    this.from = from;
+    this.to = to;
+    this.init();
+  }
+  init() {
+    let from = this.from;
+    let to = this.to;
+    if (Math.abs(from.y - to.y) < Shape.tolerance) {
+      this.direction = LineDirection.Horizontal;
+      to.y = from.y;
+      if (from.x > to.x) {
+        const temp = from;
+        from = to;
+        to = temp;
+      }
+      this.length = to.x - from.x;
+    } else if (Math.abs(from.x - to.x) < Shape.tolerance) {
+      this.direction = LineDirection.Vertical;
+      to.x = from.x;
+      if (from.y > to.y) {
+        const temp = from;
+        from = to;
+        to = temp;
+      }
+      this.length = to.y - from.y;
+    }
+    this.from = from;
+    this.to = to;
+  }
+  _valid = undefined;
+  get valid() {
+    if (this._valid === undefined) {
+      this._valid = this.direction !== LineDirection.None && this.length > Shape.tolerance;
+    }
+    return this._valid;
+  }
+  get normalized() {
+    if (this.direction === LineDirection.Horizontal) {
+      return new Line(new Point(this.from.x - Shape.tolerance, this.from.y), new Point(this.to.x + Shape.tolerance, this.from.y));
+    } else if (this.direction === LineDirection.Vertical) {
+      return new Line(new Point(this.from.x, this.from.y - Shape.tolerance), new Point(this.from.x, this.to.y + Shape.tolerance));
+    }
+    return this;
+  }
+  addGap(line) {
+    this.gaps.push(line);
+  }
+  containsPoint(p) {
+    if (this.direction === LineDirection.Vertical) {
+      return this.from.x === p.x && p.y >= this.from.y && p.y <= this.to.y;
+    } else if (this.direction === LineDirection.Horizontal) {
+      return this.from.y === p.y && p.x >= this.from.x && p.x <= this.to.x;
+    }
+    return false;
+  }
+  addIntersectionPoint(point) {
+    for (const intPoint of this.intersections) {
+      if (intPoint.equal(point))
+        return;
+    }
+    this.intersections.push(point);
+  }
+  intersection(line) {
+    let result;
+    if (!this.valid || !line.valid) {
+      return result;
+    }
+    const thisNormalized = this.normalized;
+    const lineNormalized = line.normalized;
+    if (this.direction === LineDirection.Horizontal && line.direction === LineDirection.Vertical) {
+      const x = lineNormalized.from.x;
+      const y = thisNormalized.from.y;
+      const isOk = x > thisNormalized.from.x && x < thisNormalized.to.x && y > lineNormalized.from.y && y < lineNormalized.to.y;
+      if (isOk) {
+        const intPoint = new Point(x, y);
+        this.addIntersectionPoint(intPoint);
+        line.addIntersectionPoint(intPoint);
+        result = intPoint;
+      }
+    } else if (this.direction === LineDirection.Vertical && line.direction === LineDirection.Horizontal) {
+      const x = thisNormalized.from.x;
+      const y = lineNormalized.from.y;
+      const isOk = x > lineNormalized.from.x && x < lineNormalized.to.x && y > thisNormalized.from.y && y < thisNormalized.to.y;
+      if (isOk) {
+        const intPoint = new Point(x, y);
+        this.addIntersectionPoint(intPoint);
+        line.addIntersectionPoint(intPoint);
+        result = intPoint;
+      }
+    }
+    return result;
+  }
+  transform(matrix) {
+    const p1 = this.from.transform(matrix);
+    const p2 = this.to.transform(matrix);
+    const x = Math.min(p1.x, p2.x);
+    const y = Math.min(p1.y, p2.y);
+    const width = Math.abs(p1.x - p2.x);
+    const height = Math.abs(p1.y - p2.y);
+    this.from = new Point(x, y);
+    this.to = new Point(x + width, y + height);
+    this.init();
+    return this;
+  }
+}
+// node_modules/pdf-parse/dist/pdf-parse/esm/geometry/TableData.js
+class TableData {
+  minXY;
+  maxXY;
+  rows;
+  rowPivots;
+  colPivots;
+  constructor(minXY, maxXY, rowPivots, colPivots) {
+    this.minXY = minXY;
+    this.maxXY = maxXY;
+    this.rows = [];
+    this.rowPivots = rowPivots;
+    this.colPivots = colPivots;
+  }
+  findCell(x, y) {
+    if (x >= this.minXY.x && y >= this.minXY.y && x <= this.maxXY.x && y <= this.maxXY.y) {
+      for (const row of this.rows) {
+        for (const cell of row) {
+          if (cell.minXY.x <= x && cell.minXY.y <= y && cell.maxXY.x >= x && cell.maxXY.y >= y) {
+            return cell;
+          }
+        }
+      }
+    }
+    return;
+  }
+  get cellCount() {
+    return this.rows.reduce((acc, row) => acc + row.length, 0);
+  }
+  get rowCount() {
+    return this.rows.length;
+  }
+  check() {
+    const virtualCellCount = (this.colPivots.length - 1) * (this.rowPivots.length - 1);
+    let allCellCount = 0;
+    for (const row of this.rows) {
+      for (const cell of row) {
+        const count = (cell.colspan || 1) * (cell.rowspan || 1);
+        allCellCount += count;
+      }
+    }
+    if (virtualCellCount !== allCellCount) {
+      return false;
+    }
+    return true;
+  }
+  toArray() {
+    const tableArr = [];
+    for (const row of this.rows) {
+      const rowArr = [];
+      for (const cell of row) {
+        let text = cell.text.join("");
+        text = text.replace(/^[\s]+|[\s]+$/g, "");
+        text = text.trim();
+        rowArr.push(text);
+      }
+      tableArr.push(rowArr);
+    }
+    return tableArr;
+  }
+}
+
+// node_modules/pdf-parse/dist/pdf-parse/esm/geometry/Table.js
+class Table {
+  hLines = [];
+  vLines = [];
+  constructor(line) {
+    if (line.direction === LineDirection.Horizontal) {
+      this.hLines.push(line);
+    } else if (line.direction === LineDirection.Vertical) {
+      this.vLines.push(line);
+    }
+  }
+  get isValid() {
+    return this.hLines.length + this.vLines.length > 4;
+  }
+  get rowPivots() {
+    const rowSet = new Set;
+    for (const line of this.hLines) {
+      rowSet.add(line.from.y);
+    }
+    return [...rowSet].sort((a, b) => a - b);
+  }
+  get colPivots() {
+    const colSet = new Set;
+    for (const line of this.vLines) {
+      colSet.add(line.from.x);
+    }
+    return [...colSet].sort((a, b) => a - b);
+  }
+  add(line) {
+    const hasIntersection = this.intersection(line);
+    if (hasIntersection) {
+      if (line.direction === LineDirection.Horizontal) {
+        this.hLines.push(line);
+        return true;
+      } else if (line.direction === LineDirection.Vertical) {
+        this.vLines.push(line);
+        return true;
+      }
+    }
+    return false;
+  }
+  intersection(line) {
+    let flag = false;
+    if (!line.valid)
+      return flag;
+    if (line.direction === LineDirection.Horizontal) {
+      for (const vLine of this.vLines) {
+        const p = line.intersection(vLine);
+        if (p) {
+          flag = true;
+        }
+      }
+    } else if (line.direction === LineDirection.Vertical) {
+      for (const hLine of this.hLines) {
+        const p = line.intersection(hLine);
+        if (p) {
+          flag = true;
+        }
+      }
+    }
+    return flag;
+  }
+  getSameHorizontal(line) {
+    const same = [line];
+    const other = [];
+    while (this.hLines.length > 0) {
+      const hLine = this.hLines.shift();
+      if (!hLine)
+        continue;
+      if (hLine.from.y === line.from.y) {
+        same.push(hLine);
+      } else {
+        other.push(hLine);
+      }
+    }
+    this.hLines = other;
+    return same;
+  }
+  getSameVertical(line) {
+    const same = [line];
+    const other = [];
+    while (this.vLines.length > 0) {
+      const vLine = this.vLines.shift();
+      if (!vLine)
+        continue;
+      if (vLine.from.x === line.from.x) {
+        same.push(vLine);
+      } else {
+        other.push(vLine);
+      }
+    }
+    this.vLines = other;
+    return same;
+  }
+  mergeHorizontalLines(lines) {
+    lines.sort((l1, l2) => l1.from.x - l2.from.x);
+    const minX = lines[0].from.x;
+    const maxX = lines[lines.length - 1].to.x;
+    const resultLine = new Line(new Point(minX, lines[0].from.y), new Point(maxX, lines[0].from.y));
+    for (let i = 1;i < lines.length; i++) {
+      const prevLine = lines[i - 1];
+      const currLine = lines[i];
+      if (Math.abs(prevLine.to.x - currLine.from.x) > Shape.tolerance) {
+        const gapLine = new Line(new Point(prevLine.to.x, prevLine.from.y), new Point(currLine.from.x, currLine.from.y));
+        resultLine.addGap(gapLine);
+      }
+    }
+    return resultLine;
+  }
+  mergeVerticalLines(lines) {
+    lines.sort((l1, l2) => l1.from.y - l2.from.y);
+    const minY = lines[0].from.y;
+    const maxY = lines[lines.length - 1].to.y;
+    const resultLine = new Line(new Point(lines[0].from.x, minY), new Point(lines[0].from.x, maxY));
+    for (let i = 1;i < lines.length; i++) {
+      const prevLine = lines[i - 1];
+      const currLine = lines[i];
+      if (Math.abs(prevLine.to.y - currLine.from.y) > Shape.tolerance) {
+        const gapLine = new Line(new Point(prevLine.to.x, prevLine.to.y), new Point(prevLine.to.x, currLine.from.y));
+        resultLine.addGap(gapLine);
+      }
+    }
+    return resultLine;
+  }
+  normalize() {
+    this.hLines = this.hLines.filter((l) => l.intersections.length > 1);
+    this.vLines = this.vLines.filter((l) => l.intersections.length > 1);
+    this.hLines.sort((l1, l2) => l1.from.y - l2.from.y);
+    this.vLines.sort((l1, l2) => l1.from.x - l2.from.x);
+    const newHLines = [];
+    while (this.hLines.length > 0) {
+      const line = this.hLines.shift();
+      if (!line)
+        continue;
+      const lines = this.getSameHorizontal(line);
+      const merged = this.mergeHorizontalLines(lines);
+      newHLines.push(merged);
+    }
+    this.hLines = newHLines;
+    const newVLines = [];
+    while (this.vLines.length > 0) {
+      const line = this.vLines.shift();
+      if (!line)
+        continue;
+      const lines = this.getSameVertical(line);
+      const merged = this.mergeVerticalLines(lines);
+      newVLines.push(merged);
+    }
+    this.vLines = newVLines;
+  }
+  verticalExists(line, y1, y2) {
+    if (line.direction !== LineDirection.Vertical) {
+      throw new Error("Line is not vertical");
+    }
+    if (y1 >= y2) {
+      throw new Error("y1 must be less than y2");
+    }
+    if (line.from.y <= y1 && line.to.y >= y2) {
+      for (const gap of line.gaps) {
+        if (gap.from.y <= y1 && gap.to.y >= y2) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+  horizontalExists(line, x1, x2) {
+    if (line.direction !== LineDirection.Horizontal) {
+      throw new Error("Line is not horizontal");
+    }
+    if (x1 >= x2) {
+      throw new Error("x1 must be less than x2");
+    }
+    if (line.from.x <= x1 && line.to.x >= x2) {
+      for (const gap of line.gaps) {
+        if (gap.from.x <= x1 && gap.to.x >= x2) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+  findBottomLineIndex(h2Index, xMiddle) {
+    for (let i = h2Index;i < this.hLines.length; i++) {
+      const hLine = this.hLines[i];
+      if (hLine.from.x <= xMiddle && hLine.to.x >= xMiddle) {
+        return i;
+      }
+    }
+    return -1;
+  }
+  findVerticalLineIndexs(topHLine, yMiddle) {
+    const result = [];
+    for (let i = 0;i < this.vLines.length; i++) {
+      const vLine = this.vLines[i];
+      if (vLine.from.y <= yMiddle && vLine.to.y >= yMiddle && topHLine.intersection(vLine)) {
+        result.push(i);
+      }
+    }
+    return result;
+  }
+  getRow(h1Index, h2Index, yMiddle) {
+    const tableRow = [];
+    const topHLine = this.hLines[h1Index];
+    const vLineIndexes = this.findVerticalLineIndexs(topHLine, yMiddle);
+    for (let i = 1;i < vLineIndexes.length; i++) {
+      const leftVLine = this.vLines[vLineIndexes[i - 1]];
+      const rightVLine = this.vLines[vLineIndexes[i]];
+      const xMiddle = (leftVLine.from.x + rightVLine.from.x) / 2;
+      const bottomHLineIndex = this.findBottomLineIndex(h2Index, xMiddle);
+      const bottomHLine = this.hLines[bottomHLineIndex];
+      const tableCell = {
+        minXY: new Point(leftVLine.from.x, topHLine.from.y),
+        maxXY: new Point(rightVLine.from.x, bottomHLine.from.y),
+        width: rightVLine.from.x - leftVLine.from.x,
+        height: bottomHLine.from.y - topHLine.from.y,
+        text: []
+      };
+      const colSpan = vLineIndexes[i] - vLineIndexes[i - 1];
+      const rowSpan = bottomHLineIndex - h1Index;
+      if (colSpan > 1) {
+        tableCell.colspan = colSpan;
+      }
+      if (rowSpan > 1) {
+        tableCell.rowspan = rowSpan;
+      }
+      tableRow.push(tableCell);
+    }
+    return tableRow;
+  }
+  toData() {
+    const rowPivots = this.rowPivots;
+    const colPivots = this.colPivots;
+    const minXY = new Point(colPivots[0], rowPivots[0]);
+    const maxXY = new Point(colPivots[colPivots.length - 1], rowPivots[rowPivots.length - 1]);
+    const result = new TableData(minXY, maxXY, rowPivots, colPivots);
+    for (let h1 = 1;h1 < this.hLines.length; h1++) {
+      const prevHLine = this.hLines[h1 - 1];
+      const currHLine = this.hLines[h1];
+      const YMiddle = (prevHLine.from.y + currHLine.from.y) / 2;
+      const rowData = this.getRow(h1 - 1, h1, YMiddle);
+      result.rows.push(rowData);
+    }
+    return result;
+  }
+}
+
+// node_modules/pdf-parse/dist/pdf-parse/esm/geometry/LineStore.js
+class LineStore {
+  hLines = [];
+  vLines = [];
+  add(line) {
+    if (line.valid) {
+      if (line.direction === LineDirection.Horizontal) {
+        this.hLines.push(line);
+      } else if (line.direction === LineDirection.Vertical) {
+        this.vLines.push(line);
+      }
+    }
+  }
+  addRectangle(rect) {
+    for (const line of rect.getLines()) {
+      this.add(line);
+    }
+  }
+  getTableData() {
+    const result = [];
+    const tables = this.getTables();
+    for (const table of tables) {
+      const data = table.toData();
+      if (data) {
+        result.push(data);
+      }
+    }
+    return result;
+  }
+  getTables() {
+    const result = [];
+    while (this.hLines.length !== 0) {
+      const hLine = this.hLines.shift();
+      if (!hLine)
+        continue;
+      const filled = this.tryFill(result, hLine);
+      if (filled)
+        continue;
+      const table = new Table(hLine);
+      this.fillTable(table);
+      result.push(table);
+    }
+    while (this.vLines.length !== 0) {
+      const vLine = this.vLines.shift();
+      if (!vLine)
+        continue;
+      const filled = this.tryFill(result, vLine);
+      if (filled)
+        continue;
+      const table = new Table(vLine);
+      this.fillTable(table);
+      result.push(table);
+    }
+    const validTables = result.filter((t) => t.isValid);
+    for (const table of validTables) {
+      table.normalize();
+    }
+    return validTables;
+  }
+  normalize() {
+    this.normalizeHorizontal();
+    this.normalizeVertical();
+  }
+  normalizeHorizontal() {
+    this.hLines.sort((l1, l2) => l1.from.y - l2.from.y);
+    const newLines = [];
+    let sameY = [];
+    for (const line of this.hLines) {
+      if (sameY.length === 0) {
+        sameY.push(line);
+      } else if (Math.abs(sameY[0]?.from.y - line.from.y) < Shape.tolerance) {
+        sameY.push(line);
+      } else {
+        const merged = this.margeHorizontalLines(sameY);
+        newLines.push(...merged);
+        sameY = [line];
+      }
+    }
+    if (sameY.length > 0) {
+      const merged = this.margeHorizontalLines(sameY);
+      newLines.push(...merged);
+    }
+    this.hLines = newLines;
+  }
+  normalizeVertical() {
+    this.vLines.sort((l1, l2) => l1.from.x - l2.from.x);
+    const newLines = [];
+    let sameX = [];
+    for (const line of this.vLines) {
+      if (sameX.length === 0) {
+        sameX.push(line);
+      } else if (Math.abs(sameX[0]?.from.x - line.from.x) < Shape.tolerance) {
+        sameX.push(line);
+      } else {
+        const merged = this.margeVerticalLines(sameX);
+        newLines.push(...merged);
+        sameX = [line];
+      }
+    }
+    if (sameX.length > 0) {
+      const merged = this.margeVerticalLines(sameX);
+      newLines.push(...merged);
+    }
+    this.vLines = newLines;
+  }
+  fillTable(table) {
+    const newVLines = [];
+    const newHLines = [];
+    for (const vLine of this.vLines) {
+      if (!table.add(vLine)) {
+        newVLines.push(vLine);
+      }
+    }
+    for (const hLine of this.hLines) {
+      if (!table.add(hLine)) {
+        newHLines.push(hLine);
+      }
+    }
+    this.hLines = newHLines;
+    this.vLines = newVLines;
+  }
+  tryFill(tables, line) {
+    for (const table of tables) {
+      if (table.add(line)) {
+        this.fillTable(table);
+        return true;
+      }
+    }
+    return false;
+  }
+  margeHorizontalLines(sameYLines) {
+    const result = [];
+    sameYLines.sort((l1, l2) => l1.from.x - l2.from.x);
+    const sameY = sameYLines[0]?.from.y;
+    if (sameY === undefined)
+      return result;
+    let minX = Number.MAX_SAFE_INTEGER;
+    let maxX = Number.MIN_SAFE_INTEGER;
+    for (const line of sameYLines) {
+      if (line.from.x - maxX < Shape.tolerance) {
+        if (line.from.x < minX) {
+          minX = line.from.x;
+        }
+        if (line.to.x > maxX) {
+          maxX = line.to.x;
+        }
+      } else {
+        if (maxX > minX) {
+          result.push(new Line(new Point(minX, sameY), new Point(maxX, sameY)));
+        }
+        minX = line.from.x;
+        maxX = line.to.x;
+      }
+    }
+    const last = result[result.length - 1];
+    if (last) {
+      if (last.from.x !== minX && last.to.x !== maxX) {
+        result.push(new Line(new Point(minX, sameY), new Point(maxX, sameY)));
+      }
+    } else {
+      result.push(new Line(new Point(minX, sameY), new Point(maxX, sameY)));
+    }
+    return result;
+  }
+  margeVerticalLines(sameXLines) {
+    const result = [];
+    sameXLines.sort((l1, l2) => l1.from.y - l2.from.y);
+    const sameX = sameXLines[0]?.from.x;
+    if (sameX === undefined)
+      return result;
+    let minY = Number.MAX_SAFE_INTEGER;
+    let maxY = Number.MIN_SAFE_INTEGER;
+    for (const line of sameXLines) {
+      if (line.from.y - maxY < Shape.tolerance) {
+        if (line.from.y < minY) {
+          minY = line.from.y;
+        }
+        if (line.to.y > maxY) {
+          maxY = line.to.y;
+        }
+      } else {
+        if (maxY > minY) {
+          result.push(new Line(new Point(sameX, minY), new Point(sameX, maxY)));
+        }
+        minY = line.from.y;
+        maxY = line.to.y;
+      }
+    }
+    const last = result[result.length - 1];
+    if (last) {
+      if (last.from.y !== minY && last.to.y !== maxY) {
+        result.push(new Line(new Point(sameX, minY), new Point(sameX, maxY)));
+      }
+    } else {
+      result.push(new Line(new Point(sameX, minY), new Point(sameX, maxY)));
+    }
+    return result;
+  }
+}
+// node_modules/pdf-parse/dist/pdf-parse/esm/geometry/Rectangle.js
+class Rectangle extends Shape {
+  from;
+  width;
+  height;
+  constructor(from, width, height) {
+    super();
+    this.from = from;
+    this.width = width;
+    this.height = height;
+  }
+  get to() {
+    return new Point(this.from.x + this.width, this.from.y + this.height);
+  }
+  getLines() {
+    const to = this.to;
+    const lines = [
+      new Line(this.from, new Point(to.x, this.from.y)),
+      new Line(this.from, new Point(this.from.x, to.y)),
+      new Line(new Point(to.x, this.from.y), to),
+      new Line(new Point(this.from.x, to.y), to)
+    ];
+    return lines.filter((l) => l.valid);
+  }
+  transform(matrix) {
+    const p1 = Shape.applyTransform([this.from.x, this.from.y], matrix);
+    const p2 = Shape.applyTransform([this.from.x + this.width, this.from.y + this.height], matrix);
+    const x = Math.min(p1[0], p2[0]);
+    const y = Math.min(p1[1], p2[1]);
+    const width = Math.abs(p1[0] - p2[0]);
+    const height = Math.abs(p1[1] - p2[1]);
+    this.from = new Point(x, y);
+    this.width = width;
+    this.height = height;
+    return this;
+  }
+}
+// node_modules/pdf-parse/dist/pdf-parse/esm/ImageResult.js
+class ImageResult {
+  pages = [];
+  total = 0;
+  getPageImage(num, name) {
+    for (const pageData of this.pages) {
+      if (pageData.pageNumber === num) {
+        for (const img of pageData.images) {
+          if (img.name === name) {
+            return img;
+          }
+        }
+      }
+    }
+    return null;
+  }
+  constructor(total) {
+    this.total = total;
+  }
+}
+
+// node_modules/pdf-parse/dist/pdf-parse/esm/InfoResult.js
 var pdfjs = __toESM(require("pdfjs-dist/legacy/build/pdf.mjs"));
-var { getDocument } = pdfjs;
-function isTextItem(item) {
-  return "str" in item;
+var XMP_DATE_PROPERTIES = [
+  "xmp:createdate",
+  "xmp:modifydate",
+  "xmp:metadatadate",
+  "xap:createdate",
+  "xap:modifydate",
+  "xap:metadatadate"
+];
+
+class InfoResult {
+  total;
+  info;
+  metadata;
+  fingerprints;
+  permission;
+  outline;
+  pages = [];
+  getDateNode() {
+    const result = {};
+    const CreationDate = this.info?.CreationDate;
+    if (CreationDate) {
+      result.CreationDate = pdfjs.PDFDateString.toDateObject(CreationDate);
+    }
+    const ModDate = this.info?.ModDate;
+    if (ModDate) {
+      result.ModDate = pdfjs.PDFDateString.toDateObject(ModDate);
+    }
+    if (!this.metadata) {
+      return result;
+    }
+    for (const prop of XMP_DATE_PROPERTIES) {
+      const value = this.metadata?.get(prop);
+      const date = this.parseISODateString(value);
+      switch (prop) {
+        case XMP_DATE_PROPERTIES[0]:
+          result.XmpCreateDate = date;
+          break;
+        case XMP_DATE_PROPERTIES[1]:
+          result.XmpModifyDate = date;
+          break;
+        case XMP_DATE_PROPERTIES[2]:
+          result.XmpMetadataDate = date;
+          break;
+        case XMP_DATE_PROPERTIES[3]:
+          result.XapCreateDate = date;
+          break;
+        case XMP_DATE_PROPERTIES[4]:
+          result.XapModifyDate = date;
+          break;
+        case XMP_DATE_PROPERTIES[5]:
+          result.XapMetadataDate = date;
+          break;
+      }
+    }
+    return result;
+  }
+  parseISODateString(isoDateString) {
+    if (!isoDateString)
+      return;
+    const parsedDate = Date.parse(isoDateString);
+    if (!Number.isNaN(parsedDate)) {
+      return new Date(parsedDate);
+    }
+    return;
+  }
+  constructor(total) {
+    this.total = total;
+  }
+}
+
+// node_modules/pdf-parse/dist/pdf-parse/esm/ParseParameters.js
+function setDefaultParseParameters(params) {
+  params.lineThreshold = params?.lineThreshold ?? 4.6;
+  params.cellThreshold = params?.cellThreshold ?? 7;
+  params.cellSeparator = params?.cellSeparator ?? "\t";
+  params.lineEnforce = params?.lineEnforce ?? true;
+  params.pageJoiner = params?.pageJoiner ?? `
+-- page_number of total_number --`;
+  params.imageThreshold = params?.imageThreshold ?? 80;
+  params.imageDataUrl = params?.imageDataUrl ?? true;
+  params.imageBuffer = params?.imageBuffer ?? true;
+  params.scale = params?.scale ?? 1;
+  return params;
+}
+
+// node_modules/pdf-parse/dist/pdf-parse/esm/PathGeometry.js
+var PathGeometry;
+(function(PathGeometry2) {
+  PathGeometry2[PathGeometry2["undefined"] = 0] = "undefined";
+  PathGeometry2[PathGeometry2["hline"] = 1] = "hline";
+  PathGeometry2[PathGeometry2["vline"] = 2] = "vline";
+  PathGeometry2[PathGeometry2["rectangle"] = 3] = "rectangle";
+})(PathGeometry || (PathGeometry = {}));
+var DrawOPS;
+(function(DrawOPS2) {
+  DrawOPS2[DrawOPS2["moveTo"] = 0] = "moveTo";
+  DrawOPS2[DrawOPS2["lineTo"] = 1] = "lineTo";
+  DrawOPS2[DrawOPS2["curveTo"] = 2] = "curveTo";
+  DrawOPS2[DrawOPS2["closePath"] = 3] = "closePath";
+  DrawOPS2[DrawOPS2["rectangle"] = 4] = "rectangle";
+})(DrawOPS || (DrawOPS = {}));
+
+// node_modules/pdf-parse/dist/pdf-parse/esm/ScreenshotResult.js
+class ScreenshotResult {
+  pages = [];
+  total = 0;
+  constructor(total) {
+    this.total = total;
+  }
+}
+
+// node_modules/pdf-parse/dist/pdf-parse/esm/TableResult.js
+class TableResult {
+  pages = [];
+  mergedTables = [];
+  total = 0;
+  constructor(total) {
+    this.total = total;
+  }
+}
+
+// node_modules/pdf-parse/dist/pdf-parse/esm/TextResult.js
+class TextResult {
+  pages = [];
+  text = "";
+  total = 0;
+  getPageText(num) {
+    for (const pageData of this.pages) {
+      if (pageData.num === num)
+        return pageData.text;
+    }
+    return "";
+  }
+  constructor(total) {
+    this.total = total;
+  }
 }
 
+// node_modules/pdf-parse/dist/pdf-parse/esm/PDFParse.js
+class PDFParse {
+  options;
+  doc;
+  progress = { loaded: -1, total: 0 };
+  constructor(options) {
+    if (options.verbosity === undefined) {
+      options.verbosity = pdfjs2.VerbosityLevel.ERRORS;
+    }
+    if (typeof Buffer !== "undefined" && options.data instanceof Buffer) {
+      options.data = new Uint8Array(options.data);
+    }
+    this.options = options;
+  }
+  async destroy() {
+    if (this.doc) {
+      await this.doc.destroy();
+      this.doc = undefined;
+    }
+  }
+  static get isNodeJS() {
+    const isNodeJS = typeof process === "object" && `${process}` === "[object process]" && !process.versions.nw && !(process.versions.electron && typeof process.type !== "undefined" && process.type !== "browser");
+    return isNodeJS;
+  }
+  static setWorker(workerSrc) {
+    if (typeof globalThis.pdfjs === "undefined") {
+      globalThis.pdfjs = pdfjs2;
+    }
+    if (pdfjs2?.GlobalWorkerOptions === null)
+      return "";
+    if (workerSrc !== undefined) {
+      pdfjs2.GlobalWorkerOptions.workerSrc = workerSrc;
+      return pdfjs2.GlobalWorkerOptions.workerSrc;
+    }
+    return pdfjs2.GlobalWorkerOptions.workerSrc;
+  }
+  async getInfo(params = {}) {
+    const doc = await this.load();
+    const result = new InfoResult(doc.numPages);
+    const { info, metadata } = await doc.getMetadata();
+    result.info = info;
+    result.metadata = metadata;
+    result.fingerprints = doc.fingerprints;
+    result.outline = await doc.getOutline();
+    result.permission = await doc.getPermissions();
+    const pageLabels = await doc.getPageLabels();
+    if (params.parsePageInfo) {
+      for (let i = 1;i <= result.total; i++) {
+        if (this.shouldParse(i, result.total, params)) {
+          const page = await doc.getPage(i);
+          const pageLinkResult = await this.getPageLinks(page);
+          pageLinkResult.pageLabel = pageLabels?.[page.pageNumber];
+          result.pages.push(pageLinkResult);
+          page.cleanup();
+        }
+      }
+    }
+    return result;
+  }
+  async getPageLinks(page) {
+    const viewport = page.getViewport({ scale: 1 });
+    const result = {
+      pageNumber: page.pageNumber,
+      links: [],
+      width: viewport.width,
+      height: viewport.height
+    };
+    const annotations = await page.getAnnotations({ intent: "display" }) || [];
+    for (const i of annotations) {
+      if (i.subtype !== "Link")
+        continue;
+      const url = i.url ?? i.unsafeUrl;
+      if (!url)
+        continue;
+      const text = i.overlaidText || "";
+      result.links.push({ url, text });
+    }
+    return result;
+  }
+  async getText(params = {}) {
+    const doc = await this.load();
+    const result = new TextResult(doc.numPages);
+    for (let i = 1;i <= result.total; i++) {
+      if (this.shouldParse(i, result.total, params)) {
+        const page = await doc.getPage(i);
+        const text = await this.getPageText(page, params, result.total);
+        result.pages.push({
+          text,
+          num: i
+        });
+        page.cleanup();
+      }
+    }
+    for (const page of result.pages) {
+      if (params.pageJoiner) {
+        let pageNumber = params.pageJoiner.replace("page_number", `${page.num}`);
+        pageNumber = pageNumber.replace("total_number", `${result.total}`);
+        result.text += `${page.text}
+${pageNumber}
+
+`;
+      } else {
+        result.text += `${page.text}
+
+`;
+      }
+    }
+    return result;
+  }
+  async load() {
+    try {
+      if (this.doc === undefined) {
+        const loadingTask = pdfjs2.getDocument(this.options);
+        loadingTask.onProgress = (progress) => {
+          this.progress = progress;
+        };
+        this.doc = await loadingTask.promise;
+      }
+      return this.doc;
+    } catch (error) {
+      throw getException(error);
+    }
+  }
+  shouldParse(currentPage, totalPage, params) {
+    params.partial = params?.partial ?? [];
+    params.first = params?.first ?? 0;
+    params.last = params?.last ?? 0;
+    if (params.partial.length > 0) {
+      if (params.partial.includes(currentPage)) {
+        return true;
+      }
+      return false;
+    }
+    if (params.first > 0 && params.last > 0) {
+      if (currentPage >= params.first && currentPage <= params.last) {
+        return true;
+      }
+      return false;
+    }
+    if (params.first > 0) {
+      if (currentPage <= params.first) {
+        return true;
+      }
+      return false;
+    }
+    if (params.last > 0) {
+      if (currentPage > totalPage - params.last) {
+        return true;
+      }
+      return false;
+    }
+    return true;
+  }
+  async getPageText(page, parseParams, total) {
+    const viewport = page.getViewport({ scale: 1 });
+    const params = setDefaultParseParameters(parseParams);
+    const textContent = await page.getTextContent({
+      includeMarkedContent: !!params.includeMarkedContent,
+      disableNormalization: !!params.disableNormalization
+    });
+    let links = new Map;
+    if (params.parseHyperlinks) {
+      links = await this.getHyperlinks(page, viewport);
+    }
+    const strBuf = [];
+    let lastX;
+    let lastY;
+    let lineHeight = 0;
+    for (const item of textContent.items) {
+      if (!("str" in item))
+        continue;
+      const tm = item.transform ?? item.transform;
+      const [x, y] = viewport.convertToViewportPoint(tm[4], tm[5]);
+      if (params.parseHyperlinks) {
+        const posArr = links.get(item.str) || [];
+        const hit = posArr.find((l) => x >= l.rect.left && x <= l.rect.right && y >= l.rect.top && y <= l.rect.bottom);
+        if (hit) {
+          item.str = `[${item.str}](${hit.url})`;
+        }
+      }
+      if (params.lineEnforce) {
+        if (lastY !== undefined && Math.abs(lastY - y) > params.lineThreshold) {
+          const lastItem = strBuf.length ? strBuf[strBuf.length - 1] : undefined;
+          const isCurrentItemHasNewLine = item.str.startsWith(`
+`) || item.str.trim() === "" && item.hasEOL;
+          if (lastItem?.endsWith(`
+`) === false && !isCurrentItemHasNewLine) {
+            const ydiff = Math.abs(lastY - y);
+            if (ydiff - 1 > lineHeight) {
+              strBuf.push(`
+`);
+              lineHeight = 0;
+            }
+          }
+        }
+      }
+      if (params.cellSeparator) {
+        if (lastY !== undefined && Math.abs(lastY - y) < params.lineThreshold) {
+          if (lastX !== undefined && Math.abs(lastX - x) > params.cellThreshold) {
+            item.str = `${params.cellSeparator}${item.str}`;
+          }
+        }
+      }
+      strBuf.push(item.str);
+      lastX = x + item.width;
+      lastY = y;
+      lineHeight = Math.max(lineHeight, item.height);
+      if (item.hasEOL) {
+        strBuf.push(`
+`);
+      }
+      if (item.hasEOL || item.str.endsWith(`
+`)) {
+        lineHeight = 0;
+      }
+    }
+    if (params.itemJoiner) {
+      return strBuf.join(params.itemJoiner);
+    }
+    return strBuf.join("");
+  }
+  async getHyperlinks(page, viewport) {
+    const result = new Map;
+    const annotations = await page.getAnnotations({ intent: "display" }) || [];
+    for (const i of annotations) {
+      if (i.subtype !== "Link")
+        continue;
+      const url = i.url ?? i.unsafeUrl;
+      if (!url)
+        continue;
+      const text = i.overlaidText;
+      if (!text)
+        continue;
+      const rectVp = viewport.convertToViewportRectangle(i.rect);
+      const left = Math.min(rectVp[0], rectVp[2]) - 0.5;
+      const top = Math.min(rectVp[1], rectVp[3]) - 0.5;
+      const right = Math.max(rectVp[0], rectVp[2]) + 0.5;
+      const bottom = Math.max(rectVp[1], rectVp[3]) + 0.5;
+      const pos = { rect: { left, top, right, bottom }, url, text, used: false };
+      const el = result.get(text);
+      if (el) {
+        el.push(pos);
+      } else {
+        result.set(text, [pos]);
+      }
+    }
+    return result;
+  }
+  async getImage(params = {}) {
+    const doc = await this.load();
+    const result = new ImageResult(doc.numPages);
+    setDefaultParseParameters(params);
+    for (let i = 1;i <= result.total; i++) {
+      if (this.shouldParse(i, result.total, params)) {
+        const page = await doc.getPage(i);
+        const ops = await page.getOperatorList();
+        const pageImages = { pageNumber: i, images: [] };
+        result.pages.push(pageImages);
+        for (let j = 0;j < ops.fnArray.length; j++) {
+          if (ops.fnArray[j] === pdfjs2.OPS.paintInlineImageXObject || ops.fnArray[j] === pdfjs2.OPS.paintImageXObject) {
+            const name = ops.argsArray[j][0];
+            const isCommon = page.commonObjs.has(name);
+            const imgPromise = isCommon ? this.resolveEmbeddedImage(page.commonObjs, name) : this.resolveEmbeddedImage(page.objs, name);
+            const { width, height, kind, data } = await imgPromise;
+            if (params.imageThreshold) {
+              if (params.imageThreshold >= width || params.imageThreshold >= height) {
+                continue;
+              }
+            }
+            const canvasFactory = doc.canvasFactory;
+            const canvasAndContext = canvasFactory.create(width, height);
+            const context = canvasAndContext.context;
+            let imgData = null;
+            if (kind === pdfjs2.ImageKind.RGBA_32BPP) {
+              imgData = context.createImageData(width, height);
+              imgData.data.set(data);
+            } else {
+              imgData = context.createImageData(width, height);
+              this.convertToRGBA({
+                src: data,
+                dest: new Uint32Array(imgData.data.buffer),
+                width,
+                height,
+                kind
+              });
+            }
+            context.putImageData(imgData, 0, 0);
+            let buffer = new Uint8Array;
+            let dataUrl = "";
+            if (typeof canvasAndContext.canvas.toBuffer === "function") {
+              let nodeBuffer;
+              if (params.imageBuffer) {
+                nodeBuffer = canvasAndContext.canvas.toBuffer("image/png");
+                buffer = new Uint8Array(nodeBuffer);
+              }
+              if (params.imageDataUrl) {
+                if (nodeBuffer) {
+                  dataUrl = `data:image/png;base64,${nodeBuffer.toString("base64")}`;
+                } else {
+                  nodeBuffer = canvasAndContext.canvas.toBuffer("image/png");
+                  buffer = new Uint8Array(nodeBuffer);
+                  dataUrl = `data:image/png;base64,${nodeBuffer.toString("base64")}`;
+                }
+              }
+            } else {
+              if (params.imageBuffer) {
+                const imageData = canvasAndContext.context.getImageData(0, 0, canvasAndContext.canvas.width, canvasAndContext.canvas.height);
+                buffer = new Uint8Array(imageData.data);
+              }
+              if (params.imageDataUrl) {
+                dataUrl = canvasAndContext.canvas.toDataURL("image/png");
+              }
+            }
+            pageImages.images.push({
+              data: buffer,
+              dataUrl,
+              name,
+              height,
+              width,
+              kind
+            });
+          }
+        }
+      }
+    }
+    return result;
+  }
+  convertToRGBA({ src, dest, width, height, kind }) {
+    if (kind === pdfjs2.ImageKind.RGB_24BPP) {
+      for (let i = 0, j = 0;i < src.length; i += 3, j++) {
+        const r = src[i];
+        const g = src[i + 1];
+        const b = src[i + 2];
+        dest[j] = 255 << 24 | b << 16 | g << 8 | r;
+      }
+    } else if (kind === pdfjs2.ImageKind.GRAYSCALE_1BPP) {
+      let pixelIndex = 0;
+      for (let i = 0;i < src.length; i++) {
+        const byte = src[i];
+        for (let bit = 7;bit >= 0; bit--) {
+          if (pixelIndex >= width * height)
+            break;
+          const isWhite = (byte >> bit & 1) === 1;
+          const gray = isWhite ? 255 : 0;
+          dest[pixelIndex++] = 255 << 24 | gray << 16 | gray << 8 | gray;
+        }
+      }
+    } else if (kind === undefined || kind === null) {
+      const bytesPerPixel = src.length / (width * height);
+      if (Math.abs(bytesPerPixel - 3) < 0.1) {
+        for (let i = 0, j = 0;i < src.length; i += 3, j++) {
+          const r = src[i];
+          const g = src[i + 1];
+          const b = src[i + 2];
+          dest[j] = 255 << 24 | b << 16 | g << 8 | r;
+        }
+      } else if (Math.abs(bytesPerPixel - 4) < 0.1) {
+        for (let i = 0, j = 0;i < src.length; i += 4, j++) {
+          const r = src[i];
+          const g = src[i + 1];
+          const b = src[i + 2];
+          const a = src[i + 3];
+          dest[j] = a << 24 | b << 16 | g << 8 | r;
+        }
+      } else if (Math.abs(bytesPerPixel - 1) < 0.1) {
+        for (let i = 0;i < src.length; i++) {
+          const gray = src[i];
+          dest[i] = 255 << 24 | gray << 16 | gray << 8 | gray;
+        }
+      } else {
+        throw new Error(`convertToRGBA: Cannot infer image format. kind: ${kind}, bytesPerPixel: ${bytesPerPixel}, width: ${width}, height: ${height}, dataLength: ${src.length}`);
+      }
+    } else {
+      throw new Error(`convertToRGBA: Unsupported image kind: ${kind}. Available kinds: GRAYSCALE_1BPP=${pdfjs2.ImageKind.GRAYSCALE_1BPP}, RGB_24BPP=${pdfjs2.ImageKind.RGB_24BPP}, RGBA_32BPP=${pdfjs2.ImageKind.RGBA_32BPP}`);
+    }
+  }
+  resolveEmbeddedImage(pdfObjects, name) {
+    return new Promise((resolve, reject) => {
+      pdfObjects.get(name, (imgData) => {
+        if (imgData) {
+          let dataBuff;
+          if (imgData.data instanceof Uint8Array) {
+            dataBuff = imgData.data;
+          } else if (imgData.data instanceof Uint8ClampedArray) {
+            dataBuff = new Uint8Array(imgData.data);
+          } else if (imgData.data?.buffer) {
+            dataBuff = new Uint8Array(imgData.data.buffer);
+          } else if (imgData.bitmap) {
+            const canvasFactory = this.doc.canvasFactory;
+            const canvasAndContext = canvasFactory.create(imgData.bitmap.width, imgData.bitmap.height);
+            canvasAndContext.context.drawImage(imgData.bitmap, 0, 0);
+            const imageData = canvasAndContext.context.getImageData(0, 0, imgData.bitmap.width, imgData.bitmap.height);
+            dataBuff = new Uint8Array(imageData.data.buffer);
+          } else if (ArrayBuffer.isView(imgData.data)) {
+            dataBuff = new Uint8Array(imgData.data.buffer, imgData.data.byteOffset, imgData.data.byteLength);
+          }
+          if (!dataBuff) {
+            reject(new Error(`Image object ${name}: data field is empty or invalid. Available fields: ${Object.keys(imgData).join(", ")}`));
+            return;
+          }
+          if (dataBuff.length === 0) {
+            reject(new Error(`Image object ${name}: data buffer is empty (length: 0)`));
+            return;
+          }
+          resolve({ width: imgData.width, height: imgData.height, kind: imgData.kind, data: dataBuff });
+        } else {
+          reject(new Error(`Image object ${name} not found`));
+        }
+      });
+    });
+  }
+  async getScreenshot(parseParams = {}) {
+    const params = setDefaultParseParameters(parseParams);
+    const doc = await this.load();
+    const result = new ScreenshotResult(doc.numPages);
+    if (this.doc === undefined) {
+      throw new Error("PDF document not loaded");
+    }
+    for (let i = 1;i <= result.total; i++) {
+      if (this.shouldParse(i, result.total, params)) {
+        const page = await this.doc.getPage(i);
+        let viewport = page.getViewport({ scale: params.scale });
+        if (params.desiredWidth) {
+          viewport = page.getViewport({ scale: 1 });
+          const scale = params.desiredWidth / viewport.width;
+          viewport = page.getViewport({ scale });
+        }
+        const canvasFactory = this.doc.canvasFactory;
+        const canvasAndContext = canvasFactory.create(viewport.width, viewport.height);
+        const renderContext = {
+          canvasContext: canvasAndContext.context,
+          viewport,
+          canvas: canvasAndContext.canvas
+        };
+        const renderTask = page.render(renderContext);
+        await renderTask.promise;
+        let data = new Uint8Array;
+        let dataUrl = "";
+        if (typeof canvasAndContext.canvas.toBuffer === "function") {
+          let nodeBuffer;
+          if (params.imageBuffer) {
+            nodeBuffer = canvasAndContext.canvas.toBuffer("image/png");
+            data = new Uint8Array(nodeBuffer);
+          }
+          if (params.imageDataUrl) {
+            if (nodeBuffer) {
+              dataUrl = `data:image/png;base64,${nodeBuffer.toString("base64")}`;
+            } else {
+              nodeBuffer = canvasAndContext.canvas.toBuffer("image/png");
+              data = new Uint8Array(nodeBuffer);
+              dataUrl = `data:image/png;base64,${nodeBuffer.toString("base64")}`;
+            }
+          }
+        } else {
+          if (params.imageBuffer) {
+            const imageData = canvasAndContext.context.getImageData(0, 0, canvasAndContext.canvas.width, canvasAndContext.canvas.height);
+            data = new Uint8Array(imageData.data);
+          }
+          if (params.imageDataUrl) {
+            dataUrl = canvasAndContext.canvas.toDataURL("image/png");
+          }
+        }
+        result.pages.push({
+          data,
+          dataUrl,
+          pageNumber: i,
+          width: viewport.width,
+          height: viewport.height,
+          scale: viewport.scale
+        });
+        page.cleanup();
+      }
+    }
+    return result;
+  }
+  async getTable(params = {}) {
+    const doc = await this.load();
+    const result = new TableResult(doc.numPages);
+    if (this.doc === undefined) {
+      throw new Error("PDF document not loaded");
+    }
+    for (let i = 1;i <= result.total; i++) {
+      if (this.shouldParse(i, result.total, params)) {
+        const page = await this.doc.getPage(i);
+        const store = await this.getPageTables(page);
+        store.normalize();
+        const tableDataArr = store.getTableData();
+        await this.fillPageTables(page, tableDataArr);
+        const pageTableResult = { num: i, tables: [] };
+        for (const table of tableDataArr) {
+          pageTableResult.tables.push(table.toArray());
+        }
+        result.pages.push(pageTableResult);
+        page.cleanup();
+      }
+    }
+    return result;
+  }
+  getPathGeometry(mm) {
+    const width = mm[2] - mm[0];
+    const height = mm[3] - mm[1];
+    if (mm[0] === Infinity) {
+      return PathGeometry.undefined;
+    }
+    if (width > 5 && height > 5) {
+      return PathGeometry.rectangle;
+    } else if (width > 5 && height === 0) {
+      return PathGeometry.hline;
+    } else if (width === 0 && height > 5) {
+      return PathGeometry.vline;
+    }
+    return PathGeometry.undefined;
+  }
+  async getPageTables(page) {
+    const lineStore = new LineStore;
+    const viewport = page.getViewport({ scale: 1 });
+    let transformMatrix = [1, 0, 0, 1, 0, 0];
+    const transformStack = [];
+    const opList = await page.getOperatorList();
+    for (let i = 0;i < opList.fnArray.length; i++) {
+      const fn = opList.fnArray[i];
+      const args = opList.argsArray[i];
+      const op = args?.[0] ?? 0;
+      const mm = args?.[2] ?? [Infinity, Infinity, -Infinity, -Infinity];
+      if (fn === pdfjs2.OPS.constructPath) {
+        if (op === pdfjs2.OPS.fill) {}
+        if (op !== pdfjs2.OPS.stroke) {
+          continue;
+        }
+        const pg = this.getPathGeometry(mm);
+        if (pg === PathGeometry.rectangle) {
+          const rect = new Rectangle(new Point(mm[0], mm[1]), mm[2] - mm[0], mm[3] - mm[1]);
+          rect.transform(transformMatrix);
+          rect.transform(viewport.transform);
+          lineStore.addRectangle(rect);
+        } else if (pg === PathGeometry.hline || pg === PathGeometry.vline) {
+          const from = new Point(mm[0], mm[1]);
+          const to = new Point(mm[2], mm[3]);
+          const line = new Line(from, to);
+          line.transform(transformMatrix);
+          line.transform(viewport.transform);
+          lineStore.add(line);
+        } else {}
+      } else if (fn === pdfjs2.OPS.setLineWidth) {} else if (fn === pdfjs2.OPS.save) {
+        transformStack.push(transformMatrix);
+      } else if (fn === pdfjs2.OPS.restore) {
+        const restoredMatrix = transformStack.pop();
+        if (restoredMatrix) {
+          transformMatrix = restoredMatrix;
+        }
+      } else if (fn === pdfjs2.OPS.transform) {
+        transformMatrix = pdfjs2.Util.transform(transformMatrix, args);
+      }
+    }
+    return lineStore;
+  }
+  async fillPageTables(page, pageTables) {
+    const viewport = page.getViewport({ scale: 1 });
+    const textContent = await page.getTextContent({
+      includeMarkedContent: false,
+      disableNormalization: false
+    });
+    for (const textItem of textContent.items) {
+      if (!("str" in textItem))
+        continue;
+      const tx = pdfjs2.Util.transform(pdfjs2.Util.transform(viewport.transform, textItem.transform), [1, 0, 0, -1, 0, 0]);
+      for (const pageTable of pageTables) {
+        const cell = pageTable.findCell(tx[4], tx[5]);
+        if (cell) {
+          cell.text.push(textItem.str);
+          if (textItem.hasEOL) {
+            cell.text.push(`
+`);
+          }
+          break;
+        }
+      }
+    }
+  }
+}
+
+// node_modules/pdf-parse/dist/pdf-parse/esm/index.js
+var import_pdf = require("pdfjs-dist/legacy/build/pdf.mjs");
+
+// services/pdf.ts
+var pdfParse = undefined || exports_esm;
+
 class PdfService extends import_core.Service {
   static serviceType = import_core.ServiceType.PDF;
   capabilityDescription = "The agent is able to convert PDF files to text";
-  static async start(runtime) {
-    const service = new PdfService(runtime);
-    return service;
+  static async start(_runtime) {
+    return new PdfService;
   }
   static async stop(runtime) {
     const service = runtime.getService(import_core.ServiceType.PDF);
     if (service) {
-      await service.stop();
+      await service.stop?.();
     }
   }
   async stop() {}
   async convertPdfToText(pdfBuffer) {
     try {
-      const uint8Array = new Uint8Array(pdfBuffer);
-      const pdf = await getDocument({ data: uint8Array }).promise;
-      const numPages = pdf.numPages;
-      const textPages = [];
-      for (let pageNum = 1;pageNum <= numPages; pageNum++) {
-        const page = await pdf.getPage(pageNum);
-        const textContent = await page.getTextContent();
-        const pageText = textContent.items.filter(isTextItem).map((item) => item.str).join(" ");
-        textPages.push(pageText);
-      }
-      const rawText = textPages.join(`
-`);
-      return this.cleanUpContent(rawText);
+      const data = await pdfParse(pdfBuffer);
+      return this.cleanUpContent(data.text);
     } catch (error) {
-      import_core.logger.error(`PdfService: Failed to convert PDF to text - error: ${error}, bufferSize: ${pdfBuffer.length}`);
+      import_core.logger.error(`PdfService: Failed to convert PDF to text - error: ${error}`);
       throw error;
     }
   }
   async convertPdfToTextWithOptions(pdfBuffer, options = {}) {
     try {
-      const uint8Array = new Uint8Array(pdfBuffer);
-      const pdf = await getDocument({ data: uint8Array }).promise;
-      const numPages = pdf.numPages;
-      const startPage = Math.max(1, options.startPage || 1);
-      const endPage = Math.min(numPages, options.endPage || numPages);
-      const textPages = [];
-      for (let pageNum = startPage;pageNum <= endPage; pageNum++) {
-        const page = await pdf.getPage(pageNum);
-        const textContent = await page.getTextContent();
-        const pageText = textContent.items.filter(isTextItem).map((item) => item.str).join(options.preserveWhitespace ? "" : " ");
-        textPages.push(pageText);
-      }
-      let text = textPages.join(`
-`);
+      const parseOptions = {};
+      if (options.endPage) {
+        parseOptions.max = options.endPage;
+      }
+      const data = await pdfParse(pdfBuffer, parseOptions);
+      let text = data.text;
       if (options.cleanContent !== false) {
         text = this.cleanUpContent(text);
       }
       return {
         success: true,
         text,
-        pageCount: numPages
+        pageCount: data.numpages
       };
     } catch (error) {
       return {
@@ -143,54 +1704,30 @@ class PdfService extends import_core.Service {
     }
   }
   async getDocumentInfo(pdfBuffer) {
-    const uint8Array = new Uint8Array(pdfBuffer);
-    const pdf = await getDocument({ data: uint8Array }).promise;
-    const numPages = pdf.numPages;
-    const metadataResult = await pdf.getMetadata();
-    const info = metadataResult.info;
-    const metadata = {
-      title: info.Title,
-      author: info.Author,
-      subject: info.Subject,
-      keywords: info.Keywords,
-      creator: info.Creator,
-      producer: info.Producer,
-      creationDate: info.CreationDate ? new Date(info.CreationDate) : undefined,
-      modificationDate: info.ModDate ? new Date(info.ModDate) : undefined
-    };
-    const pages = [];
-    const allText = [];
-    for (let pageNum = 1;pageNum <= numPages; pageNum++) {
-      const page = await pdf.getPage(pageNum);
-      const viewport = page.getViewport({ scale: 1 });
-      const textContent = await page.getTextContent();
-      const pageText = textContent.items.filter(isTextItem).map((item) => item.str).join(" ");
-      pages.push({
-        pageNumber: pageNum,
-        width: viewport.width,
-        height: viewport.height,
-        text: this.cleanUpContent(pageText)
-      });
-      allText.push(pageText);
-    }
-    return {
-      pageCount: numPages,
-      metadata,
-      text: this.cleanUpContent(allText.join(`
-`)),
-      pages
-    };
+    try {
+      const data = await pdfParse(pdfBuffer);
+      return {
+        pageCount: data.numpages,
+        metadata: {
+          title: data.info?.Title,
+          author: data.info?.Author,
+          creator: data.info?.Creator,
+          producer: data.info?.Producer
+        },
+        text: this.cleanUpContent(data.text),
+        pages: []
+      };
+    } catch (error) {
+      import_core.logger.error(`PdfService: Failed to get document info - error: ${error}`);
+      throw error;
+    }
   }
   cleanUpContent(content) {
     try {
-      const filtered = content.split("").filter((char) => {
-        const charCode = char.charCodeAt(0);
-        return !(charCode === 0 || charCode >= 1 && charCode <= 8 || charCode >= 11 && charCode <= 12 || charCode >= 14 && charCode <= 31 || charCode === 127);
-      }).join("");
-      const cleaned = filtered.replace(/[^\S\r\n]+/g, " ").replace(/[ \t]+(\r?\n)/g, "$1").trim();
+      const cleaned = content.replace(/[^\S\r\n]+/g, " ").replace(/[ \t]+(\r?\n)/g, "$1").trim();
       return cleaned;
     } catch (error) {
-      import_core.logger.error(`PdfService: Failed to clean up content - error: ${error}, contentLength: ${content.length}`);
+      import_core.logger.error(`PdfService: Failed to clean up content - error: ${error}`);
       return content;
     }
   }
@@ -202,6 +1739,5 @@ var pdfPlugin = {
   services: [PdfService],
   actions: []
 };
-var typescript_default = pdfPlugin;
 
-//# debugId=CE86293CD24CBEC264756E2164756E21
+//# debugId=11EC03194FE63DF364756E2164756E21