@bendyline/squisq-formats 1.2.3 → 1.3.1

package/dist/pdf/import.js

@@ -1,796 +0,0 @@
-/**
- * PDF Import
- *
- * Parses a PDF file and converts its content into a squisq
- * MarkdownDocument (or Doc) using heuristic detection of headings,
- * lists, code blocks, tables, blockquotes, and hyperlinks.
- *
- * Uses pdfjs-dist (Mozilla pdf.js) for text extraction — a battle-tested,
- * browser-compatible PDF parser. Since PDFs encode positioned glyphs
- * rather than semantic structure, all structure detection is inherently
- * heuristic and works best on simply-formatted documents.
- *
- * @example
- * ```ts
- * import { pdfToMarkdownDoc } from '@bendyline/squisq-formats/pdf';
- *
- * const response = await fetch('document.pdf');
- * const data = await response.arrayBuffer();
- * const doc = await pdfToMarkdownDoc(data);
- * ```
- */
-import { markdownToDoc } from '@bendyline/squisq/doc';
-import { MemoryContentContainer } from '@bendyline/squisq/storage';
-import { DEFAULT_FONT_SIZE, IMPORT_HEADING_MIN_SIZE, IMPORT_HEADING_SIZE_RANGES, IMPORT_PARAGRAPH_GAP, IMPORT_BULLET_CHARS, IMPORT_ORDERED_PREFIX, IMPORT_COLUMN_TOLERANCE, IMPORT_TABLE_MIN_ROWS, IMPORT_URL_PATTERN, } from './styles.js';
-/**
- * Convert a PDF file to a MarkdownDocument.
- *
- * Structure detection is heuristic — results are best-effort.
- *
- * @param data - The raw PDF file as ArrayBuffer, Uint8Array, or Blob
- * @param options - Import options
- * @returns A MarkdownDocument representing the detected content
- */
-export async function pdfToMarkdownDoc(data, options = {}) {
-    const bytes = data instanceof Blob
-        ? new Uint8Array(await data.arrayBuffer())
-        : data instanceof ArrayBuffer
-            ? new Uint8Array(data)
-            : data;
-    const textLines = await extractTextLines(bytes);
-    if (textLines.length === 0) {
-        return { type: 'document', children: [] };
-    }
-    const bodySize = options.bodyFontSize ?? detectBodyFontSize(textLines);
-    const blocks = classifyLines(textLines, bodySize, options);
-    return { type: 'document', children: blocks };
-}
-/**
- * Convert a PDF file to a squisq Doc.
- *
- * Convenience wrapper: PDF → MarkdownDocument → Doc.
- */
-export async function pdfToDoc(data, options = {}) {
-    const markdownDoc = await pdfToMarkdownDoc(data, options);
-    return markdownToDoc(markdownDoc);
-}
-/**
- * Convert a PDF file to a ContentContainer with markdown + extracted images.
- *
- * The container will contain:
- * - The primary markdown document (index.md)
- * - Any embedded images under images/ (e.g., images/image1.png)
- *
- * Image extraction uses pdfjs-dist's operator list API and requires a browser
- * environment (canvas is used to encode pixel data to PNG).
- *
- * @param data - The raw PDF file as ArrayBuffer, Uint8Array, or Blob
- * @param options - Import options
- * @returns A ContentContainer with the document and its media
- */
-export async function pdfToContainer(data, options = {}) {
-    const bytes = data instanceof Blob
-        ? new Uint8Array(await data.arrayBuffer())
-        : data instanceof ArrayBuffer
-            ? new Uint8Array(data)
-            : data;
-    const textLines = await extractTextLines(bytes);
-    const images = await extractImages(bytes);
-    const bodySize = options.bodyFontSize ?? detectBodyFontSize(textLines);
-    // If we have images, insert image references into the block list
-    let blocks = classifyLines(textLines, bodySize, options);
-    if (images.length > 0) {
-        blocks = insertImageBlocks(blocks, images);
-    }
-    const markdownDoc = { type: 'document', children: blocks };
-    const { stringifyMarkdown } = await import('@bendyline/squisq/markdown');
-    const markdown = stringifyMarkdown(markdownDoc);
-    const container = new MemoryContentContainer();
-    await container.writeDocument(markdown);
-    for (const img of images) {
-        await container.writeFile(img.path, new Uint8Array(img.data), 'image/png');
-    }
-    return container;
-}
-/**
- * Extract embedded images from a PDF using pdfjs-dist operator list API.
- * Requires browser canvas for PNG encoding.
- */
-async function extractImages(data) {
-    // Canvas is required for PNG encoding — skip in non-browser environments
-    if (typeof document === 'undefined')
-        return [];
-    let pdfjsLib;
-    try {
-        pdfjsLib = (await import('pdfjs-dist/legacy/build/pdf.mjs'));
-    }
-    catch {
-        pdfjsLib = (await import('pdfjs-dist'));
-    }
-    await applyWorkerConfig(pdfjsLib);
-    const OPS_paintImageXObject = pdfjsLib.OPS?.paintImageXObject ?? 85;
-    const loadingTask = pdfjsLib.getDocument({
-        data,
-        isEvalSupported: false,
-        useSystemFonts: true,
-    });
-    const pdf = await loadingTask.promise;
-    const images = [];
-    let counter = 0;
-    for (let pageNum = 1; pageNum <= pdf.numPages; pageNum++) {
-        const page = (await pdf.getPage(pageNum));
-        if (!page.getOperatorList)
-            continue;
-        const opList = await page.getOperatorList();
-        const seen = new Set();
-        for (let i = 0; i < opList.fnArray.length; i++) {
-            if (opList.fnArray[i] !== OPS_paintImageXObject)
-                continue;
-            const imgName = opList.argsArray[i]?.[0];
-            if (!imgName || typeof imgName !== 'string' || seen.has(imgName))
-                continue;
-            seen.add(imgName);
-            try {
-                const imgData = page.objs?.get(imgName);
-                if (!imgData?.data || !imgData.width || !imgData.height)
-                    continue;
-                const pngData = imageDataToPng(imgData);
-                if (!pngData)
-                    continue;
-                counter++;
-                images.push({
-                    path: `images/image${counter}.png`,
-                    data: pngData,
-                    page: pageNum - 1,
-                    y: 0,
-                });
-            }
-            catch {
-                // Skip images that fail to extract
-            }
-        }
-    }
-    return images;
-}
-/** Encode pdfjs image data to PNG using a canvas element. */
-function imageDataToPng(img) {
-    try {
-        const canvas = document.createElement('canvas');
-        canvas.width = img.width;
-        canvas.height = img.height;
-        const ctx = canvas.getContext('2d');
-        if (!ctx)
-            return null;
-        // pdfjs kind=1 is GRAYSCALE, kind=2 is RGB, kind=3 is RGBA
-        let imageData;
-        if (img.kind === 3 || img.data.length === img.width * img.height * 4) {
-            // RGBA — use directly
-            imageData = new ImageData(new Uint8ClampedArray(img.data), img.width, img.height);
-        }
-        else if (img.kind === 2 || img.data.length === img.width * img.height * 3) {
-            // RGB — expand to RGBA
-            const rgba = new Uint8ClampedArray(img.width * img.height * 4);
-            for (let j = 0, k = 0; j < img.data.length; j += 3, k += 4) {
-                rgba[k] = img.data[j];
-                rgba[k + 1] = img.data[j + 1];
-                rgba[k + 2] = img.data[j + 2];
-                rgba[k + 3] = 255;
-            }
-            imageData = new ImageData(rgba, img.width, img.height);
-        }
-        else if (img.kind === 1 || img.data.length === img.width * img.height) {
-            // Grayscale — expand to RGBA
-            const rgba = new Uint8ClampedArray(img.width * img.height * 4);
-            for (let j = 0, k = 0; j < img.data.length; j++, k += 4) {
-                rgba[k] = img.data[j];
-                rgba[k + 1] = img.data[j];
-                rgba[k + 2] = img.data[j];
-                rgba[k + 3] = 255;
-            }
-            imageData = new ImageData(rgba, img.width, img.height);
-        }
-        else {
-            return null;
-        }
-        ctx.putImageData(imageData, 0, 0);
-        // Convert canvas to PNG ArrayBuffer
-        const dataUrl = canvas.toDataURL('image/png');
-        const base64 = dataUrl.split(',')[1];
-        const binaryStr = atob(base64);
-        const bytes = new Uint8Array(binaryStr.length);
-        for (let i = 0; i < binaryStr.length; i++) {
-            bytes[i] = binaryStr.charCodeAt(i);
-        }
-        return bytes.buffer;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Insert image reference blocks between text blocks.
- * Places each image after the last text block on the same page (or at the end).
- */
-function insertImageBlocks(blocks, images) {
-    if (images.length === 0)
-        return blocks;
-    // Simple strategy: append all images at the end as paragraphs
-    const result = [...blocks];
-    for (const img of images) {
-        const imgNode = {
-            type: 'image',
-            url: img.path,
-            alt: `Image ${img.path.replace('images/image', '').replace('.png', '')}`,
-        };
-        const para = {
-            type: 'paragraph',
-            children: [imgNode],
-        };
-        result.push(para);
-    }
-    return result;
-}
-// ============================================
-// PDF Text Extraction (pdfjs-dist)
-// ============================================
-/**
- * Configure the pdfjs-dist PDF worker source URL.
- *
- * pdfjs-dist requires a worker for PDF parsing. In the **browser**, bundlers
- * (Vite, webpack) typically handle this automatically, or you can point to a
- * CDN-hosted worker script. In **Node.js / SSR / test** environments, call
- * this with a `file://` URL to the worker module **before** any import call.
- *
- * @example
- * ```ts
- * // Browser — CDN
- * configurePdfWorker('https://cdn.jsdelivr.net/npm/pdfjs-dist@4/legacy/build/pdf.worker.min.mjs');
- *
- * // Node / vitest — file URL
- * import { pathToFileURL } from 'url';
- * configurePdfWorker(pathToFileURL(require.resolve('pdfjs-dist/legacy/build/pdf.worker.mjs')).href);
- * ```
- */
-export function configurePdfWorker(workerSrc) {
-    _workerSrc = workerSrc;
-}
-/** Module-level storage for the worker source URL. */
-let _workerSrc;
-async function applyWorkerConfig(pdfjsLib) {
-    if (!pdfjsLib.GlobalWorkerOptions)
-        return;
-    if (pdfjsLib.GlobalWorkerOptions.workerSrc)
-        return;
-    if (_workerSrc) {
-        pdfjsLib.GlobalWorkerOptions.workerSrc = _workerSrc;
-    }
-    // If no workerSrc is set, pdfjs-dist's legacy build will attempt its
-    // built-in fake-worker fallback. In browsers this usually works; in
-    // Node.js the caller must have called configurePdfWorker() first.
-}
-async function extractTextLines(data) {
-    // Dynamic import — the legacy build bundles a fake-worker fallback
-    // that avoids a real Web Worker in environments that don't support it.
-    let pdfjsLib;
-    try {
-        pdfjsLib = (await import('pdfjs-dist/legacy/build/pdf.mjs'));
-    }
-    catch {
-        pdfjsLib = (await import('pdfjs-dist'));
-    }
-    await applyWorkerConfig(pdfjsLib);
-    const loadingTask = pdfjsLib.getDocument({
-        data,
-        isEvalSupported: false,
-        useSystemFonts: true,
-    });
-    const pdf = await loadingTask.promise;
-    const allLines = [];
-    for (let pageNum = 1; pageNum <= pdf.numPages; pageNum++) {
-        const page = await pdf.getPage(pageNum);
-        const content = await page.getTextContent();
-        // Build a fontName → fontFamily lookup from pdfjs styles
-        const styleMap = content.styles || {};
-        // Group text items into lines by y-coordinate
-        const items = [];
-        for (const item of content.items) {
-            if (!item.str || item.str.trim().length === 0)
-                continue;
-            const transform = item.transform || [1, 0, 0, 1, 0, 0];
-            const x = transform[4];
-            const y = transform[5];
-            const height = Math.abs(transform[3]) || item.height || 12;
-            const width = item.width || 0;
-            const fontName = item.fontName || '';
-            const fontFamily = styleMap[fontName]?.fontFamily || '';
-            items.push({ str: item.str, x, y, width, height, fontName, fontFamily });
-        }
-        // Group into lines (items within 2pt of same y are same line)
-        const lineMap = new Map();
-        for (const item of items) {
-            const roundedY = Math.round(item.y * 2) / 2;
-            let foundKey;
-            for (const key of lineMap.keys()) {
-                if (Math.abs(key - roundedY) < 2) {
-                    foundKey = key;
-                    break;
-                }
-            }
-            if (foundKey !== undefined) {
-                lineMap.get(foundKey).push(item);
-            }
-            else {
-                lineMap.set(roundedY, [item]);
-            }
-        }
-        // Sort lines top-to-bottom (highest y first), items left-to-right
-        const sortedKeys = [...lineMap.keys()].sort((a, b) => b - a);
-        for (const key of sortedKeys) {
-            const lineItems = lineMap.get(key).sort((a, b) => a.x - b.x);
-            const fontSizes = lineItems.map((i) => i.height);
-            const fontSize = mode(fontSizes) || 12;
-            const fontFamilies = lineItems.map((i) => i.fontFamily);
-            const fontFamily = modeStr(fontFamilies) || '';
-            const fontNames = lineItems.map((i) => i.fontName);
-            const fontName = modeStr(fontNames) || '';
-            const minX = Math.min(...lineItems.map((i) => i.x));
-            const text = lineItems.map((i) => i.str).join(' ');
-            allLines.push({
-                items: lineItems,
-                y: key,
-                page: pageNum - 1,
-                fontSize,
-                fontFamily,
-                fontName,
-                minX,
-                text,
-            });
-        }
-    }
-    return allLines;
-}
-// ============================================
-// Font Size Detection
-// ============================================
-function detectBodyFontSize(lines) {
-    const sizes = lines.map((l) => Math.round(l.fontSize * 2) / 2);
-    return mode(sizes) || DEFAULT_FONT_SIZE;
-}
-function mode(arr) {
-    const freq = new Map();
-    for (const v of arr)
-        freq.set(v, (freq.get(v) || 0) + 1);
-    let maxCount = 0;
-    let maxVal = 0;
-    for (const [v, c] of freq) {
-        if (c > maxCount) {
-            maxCount = c;
-            maxVal = v;
-        }
-    }
-    return maxVal;
-}
-function modeStr(arr) {
-    const freq = new Map();
-    for (const v of arr)
-        freq.set(v, (freq.get(v) || 0) + 1);
-    let maxCount = 0;
-    let maxVal = '';
-    for (const [v, c] of freq) {
-        if (c > maxCount) {
-            maxCount = c;
-            maxVal = v;
-        }
-    }
-    return maxVal;
-}
-// ============================================
-// Line Classification → MarkdownBlockNode[]
-// ============================================
-function classifyLines(lines, bodySize, options) {
-    const blocks = [];
-    const detectTables = options.detectTables !== false;
-    const detectCodeBlocks = options.detectCodeBlocks !== false;
-    const detectBlockquotes = options.detectBlockquotes !== false;
-    const _detectLinks = options.detectLinks !== false;
-    // Determine typical left margin (most common minX)
-    const leftMargins = lines.map((l) => Math.round(l.minX));
-    const typicalLeftMargin = mode(leftMargins) || 72;
-    let i = 0;
-    while (i < lines.length) {
-        const line = lines[i];
-        // --- Heading detection ---
-        if (line.fontSize >= IMPORT_HEADING_MIN_SIZE && line.fontSize > bodySize + 1) {
-            const depth = sizeToHeadingDepth(line.fontSize);
-            blocks.push({
-                type: 'heading',
-                depth,
-                children: buildInlineNodes(line, options),
-            });
-            i++;
-            continue;
-        }
-        // --- Code block detection (monospace font runs) ---
-        if (detectCodeBlocks && isMonospaceLine(line)) {
-            const codeLines = [];
-            while (i < lines.length && isMonospaceLine(lines[i])) {
-                codeLines.push(lines[i].text);
-                i++;
-            }
-            blocks.push({
-                type: 'code',
-                value: codeLines.join('\n'),
-            });
-            continue;
-        }
-        // --- Table detection (column-aligned consecutive lines) ---
-        if (detectTables && i + 1 < lines.length) {
-            const tableLines = tryDetectTable(lines, i, typicalLeftMargin);
-            if (tableLines > 0) {
-                const table = buildTable(lines.slice(i, i + tableLines), options);
-                if (table) {
-                    blocks.push(table);
-                    i += tableLines;
-                    continue;
-                }
-            }
-        }
-        // --- List detection ---
-        const bulletMatch = tryMatchBullet(line.text);
-        const orderedMatch = line.text.match(IMPORT_ORDERED_PREFIX);
-        if (bulletMatch || orderedMatch) {
-            const listResult = consumeList(lines, i, typicalLeftMargin, bodySize, options);
-            blocks.push(listResult.list);
-            i = listResult.nextIndex;
-            continue;
-        }
-        // --- Blockquote detection (indented text) ---
-        if (detectBlockquotes && line.minX > typicalLeftMargin + 20) {
-            const quoteLines = [];
-            while (i < lines.length &&
-                lines[i].minX > typicalLeftMargin + 20 &&
-                !isMonospaceLine(lines[i]) &&
-                lines[i].fontSize <= bodySize + 1) {
-                quoteLines.push(lines[i]);
-                i++;
-            }
-            const quoteBlocks = quoteLines.map((ql) => ({
-                type: 'paragraph',
-                children: buildInlineNodes(ql, options),
-            }));
-            blocks.push({
-                type: 'blockquote',
-                children: quoteBlocks,
-            });
-            continue;
-        }
-        // --- Regular paragraph ---
-        // Merge consecutive body-sized lines on the same page with small y-gaps
-        const paraLines = [line];
-        i++;
-        while (i < lines.length) {
-            const next = lines[i];
-            // Same page, same-ish font size, close y (within line-height gap), not bullet/heading
-            if (next.page === line.page &&
-                Math.abs(next.fontSize - bodySize) <= 1 &&
-                !isMonospaceLine(next) &&
-                next.minX <= typicalLeftMargin + 15 &&
-                !tryMatchBullet(next.text) &&
-                !next.text.match(IMPORT_ORDERED_PREFIX)) {
-                // Check y-gap: lines are sorted top-to-bottom so y decreases
-                const yGap = paraLines[paraLines.length - 1].y - next.y;
-                const lineHeight = bodySize * 1.6;
-                if (yGap > 0 && yGap < lineHeight + IMPORT_PARAGRAPH_GAP) {
-                    paraLines.push(next);
-                    i++;
-                }
-                else {
-                    break;
-                }
-            }
-            else {
-                break;
-            }
-        }
-        // Build paragraph from merged lines
-        const allInlines = [];
-        for (let j = 0; j < paraLines.length; j++) {
-            if (j > 0) {
-                allInlines.push({ type: 'text', value: ' ' });
-            }
-            allInlines.push(...buildInlineNodes(paraLines[j], options));
-        }
-        if (allInlines.length > 0) {
-            blocks.push({
-                type: 'paragraph',
-                children: mergeAdjacentText(allInlines),
-            });
-        }
-    }
-    return blocks;
-}
-// ============================================
-// Heading Depth Mapping
-// ============================================
-function sizeToHeadingDepth(fontSize) {
-    for (const range of IMPORT_HEADING_SIZE_RANGES) {
-        if (fontSize >= range.min)
-            return range.depth;
-    }
-    return 6;
-}
-// ============================================
-// Font Heuristics
-// ============================================
-/**
- * Check if a line is predominantly monospace.
- * Uses the resolved fontFamily from pdfjs styles first,
- * falls back to fontName pattern matching for embedded fonts.
- */
-function isMonospaceLine(line) {
-    return isMonospaceFamily(line.fontFamily) || isMonospaceName(line.fontName);
-}
-/**
- * Check if a text item is monospace.
- */
-function isMonospaceItem(item) {
-    return isMonospaceFamily(item.fontFamily) || isMonospaceName(item.fontName);
-}
-function isMonospaceFamily(fontFamily) {
-    const lower = fontFamily.toLowerCase();
-    return lower === 'monospace' || lower.includes('monospace');
-}
-function isMonospaceName(fontName) {
-    const lower = fontName.toLowerCase();
-    return (lower.includes('courier') ||
-        lower.includes('mono') ||
-        lower.includes('consolas') ||
-        lower.includes('menlo') ||
-        lower.includes('inconsolata') ||
-        lower.includes('firacode') ||
-        lower.includes('source code') ||
-        lower.includes('dejavu sans mono'));
-}
-function isBoldFont(fontName) {
-    const lower = fontName.toLowerCase();
-    return lower.includes('bold') || lower.includes('black') || lower.includes('heavy');
-}
-function isItalicFont(fontName) {
-    const lower = fontName.toLowerCase();
-    return lower.includes('italic') || lower.includes('oblique') || lower.includes('slanted');
-}
-// ============================================
-// Inline Node Construction
-// ============================================
-function buildInlineNodes(line, options) {
-    const nodes = [];
-    const detectLinksOpt = options.detectLinks !== false;
-    for (const item of line.items) {
-        const text = item.str;
-        if (!text || text.trim().length === 0)
-            continue;
-        const bold = isBoldFont(item.fontName);
-        const italic = isItalicFont(item.fontName);
-        const mono = isMonospaceItem(item);
-        let inlineNodes;
-        if (mono) {
-            inlineNodes = [{ type: 'inlineCode', value: text }];
-        }
-        else if (detectLinksOpt) {
-            inlineNodes = splitTextWithLinks(text);
-        }
-        else {
-            inlineNodes = [{ type: 'text', value: text }];
-        }
-        // Wrap in formatting
-        for (const node of inlineNodes) {
-            let wrapped = node;
-            if (italic) {
-                wrapped = { type: 'emphasis', children: [wrapped] };
-            }
-            if (bold) {
-                wrapped = { type: 'strong', children: [wrapped] };
-            }
-            nodes.push(wrapped);
-        }
-    }
-    return nodes;
-}
-/**
- * Split a text string into text nodes and link nodes wherever
- * URL patterns are found.
- */
-function splitTextWithLinks(text) {
-    const nodes = [];
-    let lastIndex = 0;
-    // Reset regex state
-    IMPORT_URL_PATTERN.lastIndex = 0;
-    let match;
-    while ((match = IMPORT_URL_PATTERN.exec(text)) !== null) {
-        // Text before URL
-        if (match.index > lastIndex) {
-            nodes.push({ type: 'text', value: text.slice(lastIndex, match.index) });
-        }
-        // URL as link
-        const url = match[0];
-        nodes.push({
-            type: 'link',
-            url,
-            children: [{ type: 'text', value: url }],
-        });
-        lastIndex = match.index + url.length;
-    }
-    // Remaining text
-    if (lastIndex < text.length) {
-        nodes.push({ type: 'text', value: text.slice(lastIndex) });
-    }
-    return nodes.length > 0 ? nodes : [{ type: 'text', value: text }];
-}
-// ============================================
-// List Detection
-// ============================================
-function tryMatchBullet(text) {
-    if (text.length === 0)
-        return false;
-    return IMPORT_BULLET_CHARS.has(text[0]) || IMPORT_BULLET_CHARS.has(text.trimStart()[0]);
-}
-function stripBullet(text) {
-    const trimmed = text.trimStart();
-    if (IMPORT_BULLET_CHARS.has(trimmed[0])) {
-        return trimmed.slice(1).trimStart();
-    }
-    return text;
-}
-function stripOrderedPrefix(text) {
-    return text.replace(IMPORT_ORDERED_PREFIX, '');
-}
-function consumeList(lines, startIdx, _typicalLeftMargin, _bodySize, _options) {
-    const firstLine = lines[startIdx];
-    const isOrdered = !!firstLine.text.match(IMPORT_ORDERED_PREFIX);
-    const items = [];
-    let i = startIdx;
-    while (i < lines.length) {
-        const line = lines[i];
-        const isBullet = tryMatchBullet(line.text);
-        const isOrd = !!line.text.match(IMPORT_ORDERED_PREFIX);
-        if (!isBullet && !isOrd)
-            break;
-        // All items in one list should be same type
-        if (isOrdered && !isOrd)
-            break;
-        if (!isOrdered && !isBullet)
-            break;
-        const cleanText = isOrdered ? stripOrderedPrefix(line.text) : stripBullet(line.text);
-        const para = {
-            type: 'paragraph',
-            children: splitTextWithLinks(cleanText),
-        };
-        items.push({
-            type: 'listItem',
-            children: [para],
-        });
-        i++;
-    }
-    return {
-        list: {
-            type: 'list',
-            ordered: isOrdered,
-            children: items,
-        },
-        nextIndex: i,
-    };
-}
-// ============================================
-// Table Detection
-// ============================================
-/**
- * Look ahead from index `start` and return the number of consecutive
- * lines that form an aligned table, or 0 if no table detected.
- */
-function tryDetectTable(lines, start, _typicalLeftMargin) {
-    // A table needs multiple items per line (columns) on consecutive lines
-    // with roughly the same x-alignment pattern.
-    const firstLine = lines[start];
-    if (firstLine.items.length < 2)
-        return 0;
-    const cols = getColumnPositions(firstLine);
-    if (cols.length < 2)
-        return 0;
-    let count = 1;
-    for (let i = start + 1; i < lines.length; i++) {
-        const line = lines[i];
-        if (line.items.length < 2)
-            break;
-        // Check if this line's columns align with the first line's
-        const lineCols = getColumnPositions(line);
-        if (lineCols.length !== cols.length)
-            break;
-        let aligned = true;
-        for (let c = 0; c < cols.length; c++) {
-            if (Math.abs(lineCols[c] - cols[c]) > IMPORT_COLUMN_TOLERANCE) {
-                aligned = false;
-                break;
-            }
-        }
-        if (!aligned)
-            break;
-        count++;
-    }
-    return count >= IMPORT_TABLE_MIN_ROWS ? count : 0;
-}
-function getColumnPositions(line) {
-    // Cluster item x-positions
-    const positions = [];
-    for (const item of line.items) {
-        const x = Math.round(item.x);
-        // Check if this x is close to an existing column
-        let found = false;
-        for (const p of positions) {
-            if (Math.abs(p - x) < IMPORT_COLUMN_TOLERANCE) {
-                found = true;
-                break;
-            }
-        }
-        if (!found)
-            positions.push(x);
-    }
-    return positions.sort((a, b) => a - b);
-}
-function buildTable(lines, _options) {
-    if (lines.length === 0)
-        return null;
-    // Use the first line's column positions as anchors
-    const cols = getColumnPositions(lines[0]);
-    if (cols.length < 2)
-        return null;
-    const rows = [];
-    for (let ri = 0; ri < lines.length; ri++) {
-        const line = lines[ri];
-        const cells = [];
-        for (let ci = 0; ci < cols.length; ci++) {
-            const colLeft = cols[ci] - IMPORT_COLUMN_TOLERANCE;
-            const colRight = ci + 1 < cols.length ? cols[ci + 1] - IMPORT_COLUMN_TOLERANCE : Infinity;
-            // Collect items in this column
-            const cellItems = line.items.filter((item) => item.x >= colLeft && item.x < colRight);
-            const text = cellItems
-                .map((i) => i.str)
-                .join(' ')
-                .trim();
-            cells.push({
-                type: 'tableCell',
-                isHeader: ri === 0,
-                children: text.length > 0 ? [{ type: 'text', value: text }] : [],
-            });
-        }
-        rows.push({
-            type: 'tableRow',
-            children: cells,
-        });
-    }
-    return {
-        type: 'table',
-        children: rows,
-    };
-}
-// ============================================
-// Text Merging
-// ============================================
-/**
- * Merge adjacent text nodes to reduce fragmentation.
- */
-function mergeAdjacentText(nodes) {
-    if (nodes.length <= 1)
-        return nodes;
-    const result = [];
-    for (const node of nodes) {
-        const prev = result[result.length - 1];
-        if (prev && prev.type === 'text' && node.type === 'text') {
-            prev.value += node.value;
-        }
-        else {
-            result.push(node);
-        }
-    }
-    return result;
-}
-//# sourceMappingURL=import.js.map