@nodetool-ai/base-nodes 0.7.0-rc.23 → 0.8.2

package/dist/nodes/lib-pdf.js

@@ -1,871 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-/**
- * PDF processing nodes using @llamaindex/liteparse.
- *
- * Provides text extraction, markdown conversion, table detection,
- * layout analysis, metadata reading, screenshots, text search,
- * and OCR extraction from PDF documents.
- */
-import { BaseNode, prop } from "@nodetool-ai/node-sdk";
-function asBytes(data) {
-    if (!data)
-        return new Uint8Array();
-    if (data instanceof Uint8Array)
-        return data;
-    return Uint8Array.from(Buffer.from(data, "base64"));
-}
-async function resolvePdfBuffer(pdf, context) {
-    if (pdf.data) {
-        return Buffer.from(asBytes(pdf.data));
-    }
-    else if (pdf.uri) {
-        const uri = pdf.uri.startsWith("file://") ? pdf.uri.slice(7) : pdf.uri;
-        if (context?.storage) {
-            const stored = await context.storage.retrieve(pdf.uri);
-            if (stored !== null)
-                return Buffer.from(stored);
-        }
-        const { promises: fs } = await import("node:fs");
-        return fs.readFile(uri);
-    }
-    throw new Error("No PDF data or URI provided");
-}
-async function parsePdf(pdf, context) {
-    const { LiteParse } = await import("@llamaindex/liteparse");
-    const pdfBuffer = await resolvePdfBuffer(pdf, context);
-    const parser = new LiteParse({ ocrEnabled: false });
-    return parser.parse(pdfBuffer, true);
-}
-function resolvePageRange(startPage, endPage, totalPages) {
-    const start = Math.max(0, startPage);
-    const end = endPage === -1 ? totalPages - 1 : Math.min(endPage, totalPages - 1);
-    return [start, end];
-}
-/** Standard page-range props shared by most nodes. */
-const PDF_INPUT = {
-    type: "document",
-    default: {
-        type: "document",
-        uri: "",
-        asset_id: null,
-        data: null,
-        metadata: null
-    },
-    title: "PDF",
-    description: "The PDF document to process"
-};
-// ---------------------------------------------------------------------------
-// PageCount
-// ---------------------------------------------------------------------------
-export class PdfPageCountNode extends BaseNode {
-    static nodeType = "lib.pdf.PageCount";
-    static title = "PDF Page Count";
-    static description = "Get the total number of pages in a PDF document.\n    pdf, pages, count, length";
-    static metadataOutputTypes = { output: "int" };
-    async process(context) {
-        const result = await parsePdf((this.pdf ?? {}), context);
-        return { output: result.pages.length };
-    }
-}
-__decorate([
-    prop(PDF_INPUT)
-], PdfPageCountNode.prototype, "pdf", void 0);
-// ---------------------------------------------------------------------------
-// ExtractText
-// ---------------------------------------------------------------------------
-export class PdfExtractTextNode extends BaseNode {
-    static nodeType = "lib.pdf.ExtractText";
-    static title = "PDF Extract Text";
-    static description = "Extract plain text from a PDF, preserving line breaks based on layout position.\n    pdf, text, extract, read, content";
-    static metadataOutputTypes = { output: "str" };
-    static exposeAsTool = true;
-    async process(context) {
-        const result = await parsePdf((this.pdf ?? {}), context);
-        const [start, end] = resolvePageRange(Number(this.start_page ?? 0), Number(this.end_page ?? -1), result.pages.length);
-        const parts = [];
-        for (let i = start; i <= end; i++) {
-            const page = result.pages[i];
-            if (page)
-                parts.push(page.text);
-        }
-        return { output: parts.join("\n\n").trim() };
-    }
-}
-__decorate([
-    prop(PDF_INPUT)
-], PdfExtractTextNode.prototype, "pdf", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Start Page",
-        description: "First page (0-based)"
-    })
-], PdfExtractTextNode.prototype, "start_page", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: -1,
-        title: "End Page",
-        description: "Last page (-1 for all)"
-    })
-], PdfExtractTextNode.prototype, "end_page", void 0);
-// ---------------------------------------------------------------------------
-// ExtractMarkdown
-// ---------------------------------------------------------------------------
-export class PdfExtractMarkdownNode extends BaseNode {
-    static nodeType = "lib.pdf.ExtractMarkdown";
-    static title = "PDF to Markdown";
-    static description = "Convert PDF to Markdown, inferring headings from font size.\n    pdf, markdown, convert, headings, structure";
-    static metadataOutputTypes = { output: "str" };
-    static exposeAsTool = true;
-    async process(context) {
-        const result = await parsePdf((this.pdf ?? {}), context);
-        const [start, end] = resolvePageRange(Number(this.start_page ?? 0), Number(this.end_page ?? -1), result.pages.length);
-        const bulletRe = /^[•‣◦⁃∙\-*]\s*/;
-        const numberedRe = /^(\d+)[.)]\s*/;
-        const mdParts = [];
-        for (let i = start; i <= end; i++) {
-            const page = result.pages[i];
-            if (!page)
-                continue;
-            const items = page.textItems
-                .filter((it) => it.str.trim())
-                .sort((a, b) => a.y - b.y || a.x - b.x);
-            if (items.length === 0)
-                continue;
-            // Compute average font size for heading thresholds
-            const sizes = items.map((it) => it.fontSize ?? it.height ?? 12);
-            const avgSize = sizes.reduce((a, b) => a + b, 0) / sizes.length;
-            // Detect left margin for indent detection
-            const leftMargin = Math.min(...items.map((it) => it.x));
-            const indentThreshold = 15;
-            const lineMap = new Map();
-            const yTol = 3;
-            for (const item of items) {
-                const ky = Math.round(item.y / yTol) * yTol;
-                const existing = lineMap.get(ky);
-                const size = item.fontSize ?? item.height ?? 12;
-                const isBold = /bold/i.test(item.fontName ?? "");
-                if (existing) {
-                    existing.text += item.str;
-                    existing.maxSize = Math.max(existing.maxSize, size);
-                    if (isBold)
-                        existing.isBold = true;
-                }
-                else {
-                    lineMap.set(ky, {
-                        text: item.str,
-                        maxSize: size,
-                        isBold,
-                        x: item.x,
-                        y: item.y
-                    });
-                }
-            }
-            const lineEntries = Array.from(lineMap.entries())
-                .sort((a, b) => a[0] - b[0])
-                .map(([, ld]) => ld);
-            // Detect table-like rows: groups with consistent multi-column layout
-            const tableYTol = 3;
-            const rowMap = new Map();
-            for (const item of items) {
-                const ky = Math.round(item.y / tableYTol) * tableYTol;
-                if (!rowMap.has(ky))
-                    rowMap.set(ky, []);
-                rowMap.get(ky).push({ x: item.x, str: item.str.trim() });
-            }
-            const rowEntries = Array.from(rowMap.entries())
-                .sort((a, b) => a[0] - b[0])
-                .map(([y, cells]) => ({ y, cells: cells.sort((a, b) => a.x - b.x) }));
-            const tableYRanges = [];
-            let runStart = 0;
-            while (runStart < rowEntries.length) {
-                const colCount = rowEntries[runStart].cells.length;
-                if (colCount < 2) {
-                    runStart++;
-                    continue;
-                }
-                let runEnd = runStart + 1;
-                while (runEnd < rowEntries.length &&
-                    rowEntries[runEnd].cells.length === colCount) {
-                    runEnd++;
-                }
-                if (runEnd - runStart >= 2) {
-                    tableYRanges.push({
-                        startY: rowEntries[runStart].y,
-                        endY: rowEntries[runEnd - 1].y,
-                        rows: rowEntries.slice(runStart, runEnd).map((r) => r.cells.map((c) => c.str))
-                    });
-                }
-                runStart = runEnd;
-            }
-            const isInTable = (y) => {
-                const ry = Math.round(y / tableYTol) * tableYTol;
-                for (const range of tableYRanges) {
-                    if (ry >= range.startY - tableYTol && ry <= range.endY + tableYTol)
-                        return range;
-                }
-                return null;
-            };
-            const emittedTables = new Set();
-            const lines = [];
-            for (let li = 0; li < lineEntries.length; li++) {
-                const ld = lineEntries[li];
-                const text = ld.text.trim();
-                if (!text)
-                    continue;
-                // Paragraph break detection (large Y gap between lines)
-                if (li > 0) {
-                    const prev = lineEntries[li - 1];
-                    const gap = ld.y - prev.y;
-                    if (gap > avgSize * 1.8)
-                        lines.push("");
-                }
-                const table = isInTable(ld.y);
-                if (table && !emittedTables.has(table)) {
-                    emittedTables.add(table);
-                    const header = table.rows[0];
-                    lines.push("| " + header.join(" | ") + " |");
-                    lines.push("| " + header.map(() => "---").join(" | ") + " |");
-                    for (let ri = 1; ri < table.rows.length; ri++) {
-                        lines.push("| " + table.rows[ri].join(" | ") + " |");
-                    }
-                    lines.push("");
-                    continue;
-                }
-                if (table)
-                    continue;
-                const bulletMatch = text.match(bulletRe);
-                const numberedMatch = text.match(numberedRe);
-                if (bulletMatch) {
-                    lines.push(`- ${text.replace(bulletRe, "")}`);
-                }
-                else if (numberedMatch) {
-                    lines.push(`${numberedMatch[1]}. ${text.replace(numberedRe, "")}`);
-                }
-                else if (ld.maxSize > avgSize * 1.5) {
-                    lines.push(`# ${text}`);
-                }
-                else if (ld.maxSize > avgSize * 1.2) {
-                    lines.push(`## ${text}`);
-                }
-                else if (ld.isBold && ld.maxSize >= avgSize) {
-                    lines.push(`### ${text}`);
-                }
-                else {
-                    const isIndented = ld.x - leftMargin > indentThreshold;
-                    void isIndented;
-                    lines.push(text);
-                }
-            }
-            mdParts.push(lines.join("\n"));
-        }
-        return { output: mdParts.join("\n\n---\n\n") };
-    }
-}
-__decorate([
-    prop(PDF_INPUT)
-], PdfExtractMarkdownNode.prototype, "pdf", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Start Page",
-        description: "First page (0-based)"
-    })
-], PdfExtractMarkdownNode.prototype, "start_page", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: -1,
-        title: "End Page",
-        description: "Last page (-1 for all)"
-    })
-], PdfExtractMarkdownNode.prototype, "end_page", void 0);
-// ---------------------------------------------------------------------------
-// ExtractTables
-// ---------------------------------------------------------------------------
-export class PdfExtractTablesNode extends BaseNode {
-    static nodeType = "lib.pdf.ExtractTables";
-    static title = "PDF Extract Tables";
-    static description = "Detect and extract tables from a PDF by analysing text layout.\n    pdf, tables, extract, data, rows, columns";
-    static metadataOutputTypes = { output: "list[dict]" };
-    static exposeAsTool = true;
-    async process(context) {
-        const result = await parsePdf((this.pdf ?? {}), context);
-        const [start, end] = resolvePageRange(Number(this.start_page ?? 0), Number(this.end_page ?? -1), result.pages.length);
-        const yTolerance = Number(this.y_tolerance ?? 3);
-        const tables = [];
-        for (let pageIdx = start; pageIdx <= end; pageIdx++) {
-            const page = result.pages[pageIdx];
-            if (!page)
-                continue;
-            const items = [];
-            for (const item of page.textItems) {
-                if (!item.str.trim())
-                    continue;
-                items.push({
-                    x: item.x,
-                    y: Math.round(item.y / yTolerance) * yTolerance,
-                    w: item.width,
-                    str: item.str.trim()
-                });
-            }
-            const rowMap = new Map();
-            for (const it of items) {
-                if (!rowMap.has(it.y))
-                    rowMap.set(it.y, []);
-                rowMap.get(it.y).push({ x: it.x, w: it.w, str: it.str });
-            }
-            const sortedRowEntries = Array.from(rowMap.entries())
-                .sort((a, b) => a[0] - b[0])
-                .map(([, cells]) => cells.sort((a, b) => a.x - b.x));
-            if (sortedRowEntries.length < 2)
-                continue;
-            const freq = new Map();
-            for (const r of sortedRowEntries) {
-                freq.set(r.length, (freq.get(r.length) ?? 0) + 1);
-            }
-            let mostCommonCount = 0;
-            let maxFreq = 0;
-            for (const [cols, count] of freq) {
-                if (cols >= 2 && count > maxFreq) {
-                    mostCommonCount = cols;
-                    maxFreq = count;
-                }
-            }
-            if (mostCommonCount < 2 || maxFreq < 2)
-                continue;
-            const candidateRows = sortedRowEntries.filter((r) => r.length === mostCommonCount);
-            const colXPositions = Array.from({ length: mostCommonCount }, () => []);
-            for (const row of candidateRows) {
-                for (let ci = 0; ci < row.length; ci++) {
-                    colXPositions[ci].push(row[ci].x);
-                }
-            }
-            const colCenters = colXPositions.map((xs) => {
-                const sorted = xs.slice().sort((a, b) => a - b);
-                return sorted[Math.floor(sorted.length / 2)];
-            });
-            const maxSpread = 15;
-            let aligned = true;
-            for (const xs of colXPositions) {
-                if (Math.max(...xs) - Math.min(...xs) > maxSpread) {
-                    aligned = false;
-                    break;
-                }
-            }
-            if (!aligned)
-                continue;
-            const colBoundaries = [];
-            for (let ci = 0; ci < mostCommonCount - 1; ci++) {
-                colBoundaries.push((colCenters[ci] + colCenters[ci + 1]) / 2);
-            }
-            const assignColumn = (x) => {
-                for (let bi = 0; bi < colBoundaries.length; bi++) {
-                    if (x < colBoundaries[bi])
-                        return bi;
-                }
-                return colBoundaries.length;
-            };
-            const tableRows = [];
-            for (const row of candidateRows) {
-                const cells = Array.from({ length: mostCommonCount }, () => "");
-                for (const cell of row) {
-                    const ci = assignColumn(cell.x);
-                    cells[ci] = cells[ci] ? `${cells[ci]} ${cell.str}` : cell.str;
-                }
-                tableRows.push(cells);
-            }
-            if (tableRows.length < 2)
-                continue;
-            tables.push({
-                page: pageIdx,
-                header: tableRows[0],
-                rows: tableRows.slice(1),
-                columns: mostCommonCount,
-                total_rows: tableRows.length
-            });
-        }
-        return { output: tables };
-    }
-}
-__decorate([
-    prop(PDF_INPUT)
-], PdfExtractTablesNode.prototype, "pdf", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Start Page",
-        description: "First page (0-based)"
-    })
-], PdfExtractTablesNode.prototype, "start_page", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: -1,
-        title: "End Page",
-        description: "Last page (-1 for all)"
-    })
-], PdfExtractTablesNode.prototype, "end_page", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 3,
-        title: "Y Tolerance",
-        description: "Pixel tolerance for grouping text into rows",
-        min: 1,
-        max: 20
-    })
-], PdfExtractTablesNode.prototype, "y_tolerance", void 0);
-// ---------------------------------------------------------------------------
-// ExtractTextBlocks
-// ---------------------------------------------------------------------------
-export class PdfExtractTextBlocksNode extends BaseNode {
-    static nodeType = "lib.pdf.ExtractTextBlocks";
-    static title = "PDF Extract Text Blocks";
-    static description = "Extract text blocks with bounding boxes, useful for layout analysis.\n    pdf, text, blocks, layout, bbox, position";
-    static metadataOutputTypes = { output: "list[dict]" };
-    static exposeAsTool = true;
-    async process(context) {
-        const result = await parsePdf((this.pdf ?? {}), context);
-        const [start, end] = resolvePageRange(Number(this.start_page ?? 0), Number(this.end_page ?? -1), result.pages.length);
-        const blocks = [];
-        for (let i = start; i <= end; i++) {
-            const page = result.pages[i];
-            if (!page)
-                continue;
-            const items = page.textItems.sort((a, b) => a.y - b.y || a.x - b.x);
-            let block = null;
-            let lastY = null;
-            const flushBlock = () => {
-                if (block?.text.trim()) {
-                    blocks.push({
-                        page: i,
-                        text: block.text.trim(),
-                        bbox: {
-                            x0: block.x0,
-                            y0: block.y0,
-                            x1: block.x1,
-                            y1: block.y1
-                        }
-                    });
-                }
-                block = null;
-            };
-            for (const item of items) {
-                const h = item.height ?? 12;
-                if (lastY !== null && Math.abs(item.y - lastY) > h * 1.5)
-                    flushBlock();
-                if (!block) {
-                    block = {
-                        text: "",
-                        x0: item.x,
-                        y0: item.y,
-                        x1: item.x + item.width,
-                        y1: item.y + h
-                    };
-                }
-                block.text += item.str;
-                block.x0 = Math.min(block.x0, item.x);
-                block.y0 = Math.min(block.y0, item.y);
-                block.x1 = Math.max(block.x1, item.x + item.width);
-                block.y1 = Math.max(block.y1, item.y + h);
-                lastY = item.y;
-            }
-            flushBlock();
-        }
-        return { output: blocks };
-    }
-}
-__decorate([
-    prop(PDF_INPUT)
-], PdfExtractTextBlocksNode.prototype, "pdf", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Start Page",
-        description: "First page (0-based)"
-    })
-], PdfExtractTextBlocksNode.prototype, "start_page", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: -1,
-        title: "End Page",
-        description: "Last page (-1 for all)"
-    })
-], PdfExtractTextBlocksNode.prototype, "end_page", void 0);
-// ---------------------------------------------------------------------------
-// ExtractStyledText
-// ---------------------------------------------------------------------------
-export class PdfExtractStyledTextNode extends BaseNode {
-    static nodeType = "lib.pdf.ExtractStyledText";
-    static title = "PDF Extract Styled Text";
-    static description = "Extract text spans with font name, size, bounding box, and color (always null; liteparse does not expose per-span color).\n    pdf, text, style, font, size, formatting, color";
-    static metadataOutputTypes = { output: "list[dict]" };
-    static exposeAsTool = true;
-    async process(context) {
-        const result = await parsePdf((this.pdf ?? {}), context);
-        const [start, end] = resolvePageRange(Number(this.start_page ?? 0), Number(this.end_page ?? -1), result.pages.length);
-        const spans = [];
-        for (let i = start; i <= end; i++) {
-            const page = result.pages[i];
-            if (!page)
-                continue;
-            for (const item of page.textItems) {
-                if (!item.str.trim())
-                    continue;
-                const h = item.height ?? 12;
-                spans.push({
-                    page: i,
-                    text: item.str,
-                    font: item.fontName ?? "unknown",
-                    size: item.fontSize ?? h,
-                    color: null,
-                    bbox: {
-                        x0: item.x,
-                        y0: item.y,
-                        x1: item.x + item.width,
-                        y1: item.y + h
-                    }
-                });
-            }
-        }
-        return { output: spans };
-    }
-}
-__decorate([
-    prop(PDF_INPUT)
-], PdfExtractStyledTextNode.prototype, "pdf", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Start Page",
-        description: "First page (0-based)"
-    })
-], PdfExtractStyledTextNode.prototype, "start_page", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: -1,
-        title: "End Page",
-        description: "Last page (-1 for all)"
-    })
-], PdfExtractStyledTextNode.prototype, "end_page", void 0);
-// ---------------------------------------------------------------------------
-// PageMetadata
-// ---------------------------------------------------------------------------
-export class PdfPageMetadataNode extends BaseNode {
-    static nodeType = "lib.pdf.PageMetadata";
-    static title = "PDF Page Metadata";
-    static description = "Get dimensions and bounding box for each page.\n    pdf, metadata, pages, size, dimensions";
-    static metadataOutputTypes = { output: "list[dict]" };
-    async process(context) {
-        const result = await parsePdf((this.pdf ?? {}), context);
-        const [start, end] = resolvePageRange(Number(this.start_page ?? 0), Number(this.end_page ?? -1), result.pages.length);
-        const metadata = [];
-        for (let i = start; i <= end; i++) {
-            const page = result.pages[i];
-            if (!page)
-                continue;
-            let x0 = Infinity;
-            let y0 = Infinity;
-            let x1 = -Infinity;
-            let y1 = -Infinity;
-            for (const item of page.textItems) {
-                if (!item.str.trim())
-                    continue;
-                const h = item.height ?? 12;
-                x0 = Math.min(x0, item.x);
-                y0 = Math.min(y0, item.y);
-                x1 = Math.max(x1, item.x + item.width);
-                y1 = Math.max(y1, item.y + h);
-            }
-            const hasContent = x0 !== Infinity;
-            metadata.push({
-                page: i,
-                width: page.width,
-                height: page.height,
-                bbox: hasContent ? { x0, y0, x1, y1 } : null
-            });
-        }
-        return { output: metadata };
-    }
-}
-__decorate([
-    prop(PDF_INPUT)
-], PdfPageMetadataNode.prototype, "pdf", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Start Page",
-        description: "First page (0-based)"
-    })
-], PdfPageMetadataNode.prototype, "start_page", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: -1,
-        title: "End Page",
-        description: "Last page (-1 for all)"
-    })
-], PdfPageMetadataNode.prototype, "end_page", void 0);
-// ---------------------------------------------------------------------------
-// Screenshot
-// ---------------------------------------------------------------------------
-export class PdfScreenshotNode extends BaseNode {
-    static nodeType = "lib.pdf.Screenshot";
-    static title = "PDF Page Screenshot";
-    static description = "Render PDF pages as PNG images.\n    pdf, screenshot, render, image, pages, png";
-    static metadataOutputTypes = { output: "list[image]" };
-    async process(context) {
-        // Bypass liteparse's parser.screenshot(): it loads the same buffer into
-        // pdf.js *and* PDFium, but pdf.js detaches the underlying ArrayBuffer
-        // during its load, leaving PDFium with a detached buffer (→ "File not in
-        // PDF format or corrupted"). Render directly via PDFium + sharp.
-        const [{ PDFiumLibrary }, sharpModule] = await Promise.all([
-            import("@hyzyla/pdfium"),
-            import("sharp")
-        ]);
-        const sharp = sharpModule.default;
-        const pdfBuffer = await resolvePdfBuffer((this.pdf ?? {}), context);
-        const dpi = Number(this.dpi ?? 150);
-        const scale = dpi / 72;
-        const lib = await PDFiumLibrary.init();
-        const images = [];
-        let doc = null;
-        try {
-            doc = await lib.loadDocument(Buffer.from(pdfBuffer));
-            const totalPages = doc.getPageCount();
-            const [start, end] = resolvePageRange(Number(this.start_page ?? 0), Number(this.end_page ?? -1), totalPages);
-            for (let i = start; i <= end; i++) {
-                const page = doc.getPage(i);
-                const image = await page.render({
-                    scale,
-                    render: async (options) => sharp(options.data, {
-                        raw: {
-                            width: options.width,
-                            height: options.height,
-                            channels: 4
-                        }
-                    })
-                        .png({ compressionLevel: 6 })
-                        .withMetadata({ density: dpi })
-                        .toBuffer()
-                });
-                images.push({
-                    type: "image",
-                    data: Buffer.from(image.data).toString("base64")
-                });
-            }
-        }
-        finally {
-            if (doc)
-                doc.destroy();
-            lib.destroy();
-        }
-        return { output: images };
-    }
-}
-__decorate([
-    prop(PDF_INPUT)
-], PdfScreenshotNode.prototype, "pdf", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Start Page",
-        description: "First page to render (0-based)"
-    })
-], PdfScreenshotNode.prototype, "start_page", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: -1,
-        title: "End Page",
-        description: "Last page to render (-1 for all)"
-    })
-], PdfScreenshotNode.prototype, "end_page", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 150,
-        title: "DPI",
-        description: "Rendering resolution in dots per inch",
-        min: 72,
-        max: 600
-    })
-], PdfScreenshotNode.prototype, "dpi", void 0);
-// ---------------------------------------------------------------------------
-// SearchText
-// ---------------------------------------------------------------------------
-export class PdfSearchTextNode extends BaseNode {
-    static nodeType = "lib.pdf.SearchText";
-    static title = "PDF Search Text";
-    static description = "Search a PDF for a phrase and return each match with its page number and bounding box.\n    pdf, search, find, phrase, text, location, bbox";
-    static metadataOutputTypes = { output: "list[dict]" };
-    static exposeAsTool = true;
-    async process(context) {
-        const { searchItems } = await import("@llamaindex/liteparse");
-        const result = await parsePdf((this.pdf ?? {}), context);
-        const [start, end] = resolvePageRange(Number(this.start_page ?? 0), Number(this.end_page ?? -1), result.pages.length);
-        const phrase = String(this.phrase ?? "");
-        const caseSensitive = Boolean(this.case_sensitive ?? false);
-        const matches = [];
-        for (let i = start; i <= end; i++) {
-            const page = result.pages[i];
-            if (!page)
-                continue;
-            // Convert TextItem (str) to JsonTextItem (text) shape for searchItems
-            const jsonItems = page.textItems.map((it) => ({
-                text: it.str,
-                x: it.x,
-                y: it.y,
-                width: it.width,
-                height: it.height,
-                fontName: it.fontName,
-                fontSize: it.fontSize,
-                confidence: it.confidence
-            }));
-            const found = searchItems(jsonItems, { phrase, caseSensitive });
-            for (const m of found) {
-                matches.push({
-                    page: i,
-                    text: m.text,
-                    x: m.x,
-                    y: m.y,
-                    width: m.width,
-                    height: m.height,
-                    fontName: m.fontName ?? null,
-                    fontSize: m.fontSize ?? null
-                });
-            }
-        }
-        return { output: matches };
-    }
-}
-__decorate([
-    prop(PDF_INPUT)
-], PdfSearchTextNode.prototype, "pdf", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Phrase",
-        description: "Text phrase to search for"
-    })
-], PdfSearchTextNode.prototype, "phrase", void 0);
-__decorate([
-    prop({
-        type: "bool",
-        default: false,
-        title: "Case Sensitive",
-        description: "Whether the search is case-sensitive"
-    })
-], PdfSearchTextNode.prototype, "case_sensitive", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Start Page",
-        description: "First page to search (0-based)"
-    })
-], PdfSearchTextNode.prototype, "start_page", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: -1,
-        title: "End Page",
-        description: "Last page to search (-1 for all)"
-    })
-], PdfSearchTextNode.prototype, "end_page", void 0);
-// ---------------------------------------------------------------------------
-// ExtractOcr
-// ---------------------------------------------------------------------------
-export class PdfExtractOcrNode extends BaseNode {
-    static nodeType = "lib.pdf.ExtractOcr";
-    static title = "PDF Extract Text (OCR)";
-    static description = "Extract text from a PDF using OCR, suitable for scanned documents and image-based PDFs.\n    pdf, ocr, scan, text, extract, image-based";
-    static metadataOutputTypes = { output: "str" };
-    static exposeAsTool = true;
-    async process(context) {
-        const { LiteParse } = await import("@llamaindex/liteparse");
-        const pdfBuffer = await resolvePdfBuffer((this.pdf ?? {}), context);
-        const ocrLanguage = String(this.ocr_language ?? "en");
-        const dpi = Number(this.dpi ?? 150);
-        const parser = new LiteParse({ ocrEnabled: true, ocrLanguage, dpi });
-        const result = await parser.parse(pdfBuffer, true);
-        const [start, end] = resolvePageRange(Number(this.start_page ?? 0), Number(this.end_page ?? -1), result.pages.length);
-        const parts = [];
-        for (let i = start; i <= end; i++) {
-            const page = result.pages[i];
-            if (page)
-                parts.push(page.text);
-        }
-        return { output: parts.join("\n\n").trim() };
-    }
-}
-__decorate([
-    prop(PDF_INPUT)
-], PdfExtractOcrNode.prototype, "pdf", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Start Page",
-        description: "First page (0-based)"
-    })
-], PdfExtractOcrNode.prototype, "start_page", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: -1,
-        title: "End Page",
-        description: "Last page (-1 for all)"
-    })
-], PdfExtractOcrNode.prototype, "end_page", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "en",
-        title: "OCR Language",
-        description: "ISO 639-1 language code for OCR (e.g. en, fr, de, es)"
-    })
-], PdfExtractOcrNode.prototype, "ocr_language", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 150,
-        title: "DPI",
-        description: "Rendering DPI for OCR — higher values improve accuracy on small text",
-        min: 72,
-        max: 600
-    })
-], PdfExtractOcrNode.prototype, "dpi", void 0);
-// ---------------------------------------------------------------------------
-// Export
-// ---------------------------------------------------------------------------
-export const LIB_PDF_NODES = [
-    PdfPageCountNode,
-    PdfExtractTextNode,
-    PdfExtractMarkdownNode,
-    PdfExtractTablesNode,
-    PdfExtractTextBlocksNode,
-    PdfExtractStyledTextNode,
-    PdfPageMetadataNode,
-    PdfScreenshotNode,
-    PdfSearchTextNode,
-    PdfExtractOcrNode
-];
-//# sourceMappingURL=lib-pdf.js.map