@sirdaspdf/core 0.1.0 → 0.3.0

package/dist/formats.js

@@ -0,0 +1,521 @@
+// Más allá del PDF: Word, Excel, PowerPoint, OpenDocument, HTML, EPUB, CSV,
+// correos y texto a Markdown, con las mismas reglas que un PDF para que todo lo
+// de después (clasificar, extraer, anonimizar, trocear) funcione igual.
+// Los formatos de Office son ZIP con XML dentro: se leen con fflate, sin
+// LibreOffice ni servidor. Se lee el contenido, no se reproduce la maquetación.
+import { strFromU8, unzipSync } from "fflate";
+const EXT = {
+    pdf: "pdf", docx: "docx", docm: "docx", xlsx: "xlsx", xlsm: "xlsx", pptx: "pptx", odt: "odt", ods: "ods", odp: "odp",
+    epub: "epub", html: "html", htm: "html", xhtml: "html", csv: "csv", tsv: "tsv", md: "md", markdown: "md", txt: "txt",
+    text: "txt", log: "txt", json: "json", jsonl: "txt", eml: "eml", rtf: "rtf", xml: "txt",
+    png: "image", jpg: "image", jpeg: "image", webp: "image", gif: "image", bmp: "image", tif: "image", tiff: "image", heic: "image",
+};
+/** Por contenido primero (la extensión miente a menudo), por nombre después. */
+export function detectFormat(bytes, filename = "") {
+    const head = strFromU8(bytes.subarray(0, 8), true);
+    if (head.startsWith("%PDF"))
+        return "pdf";
+    if (bytes[0] === 0x89 && head.slice(1, 4) === "PNG")
+        return "image";
+    if (bytes[0] === 0xff && bytes[1] === 0xd8)
+        return "image";
+    if (head.startsWith("{\\rtf"))
+        return "rtf";
+    if (bytes[0] === 0x50 && bytes[1] === 0x4b) {
+        try {
+            const names = Object.keys(unzipSync(bytes, { filter: (f) => f.name === "mimetype" || f.name === "[Content_Types].xml" || /^(word|xl|ppt)\//.test(f.name) }));
+            if (names.some((n) => n.startsWith("word/")))
+                return "docx";
+            if (names.some((n) => n.startsWith("xl/")))
+                return "xlsx";
+            if (names.some((n) => n.startsWith("ppt/")))
+                return "pptx";
+            const mime = unzipSync(bytes, { filter: (f) => f.name === "mimetype" }).mimetype;
+            const m = mime ? strFromU8(mime) : "";
+            if (m.includes("opendocument.text"))
+                return "odt";
+            if (m.includes("opendocument.spreadsheet"))
+                return "ods";
+            if (m.includes("opendocument.presentation"))
+                return "odp";
+            if (m.includes("epub"))
+                return "epub";
+        }
+        catch {
+            /* ZIP dañado: se decide por extensión */
+        }
+    }
+    const ext = filename.toLowerCase().split(".").pop() ?? "";
+    return EXT[ext] ?? "unknown";
+}
+/* ---------- XML mínimo ---------- */
+const decodeEntities = (s) => s
+    .replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&nbsp;/g, " ")
+    .replace(/&#x([0-9a-f]+);/gi, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+    .replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(Number(d)))
+    .replace(/&amp;/g, "&");
+/** Texto de todas las etiquetas `tag` dentro de un fragmento XML, en orden. */
+const texts = (xml, tag) => [...xml.matchAll(new RegExp(`<${tag}(?:\\s[^>]*)?>([\\s\\S]*?)</${tag}>`, "g"))].map((m) => decodeEntities(m[1]));
+/** Atributo de una etiqueta, sin depender del orden en que el programa los escribió. */
+const attr = (tag, name) => {
+    const m = tag.match(new RegExp(`\\s${name.replace(":", "\\:")}="([^"]*)"`));
+    return m ? decodeEntities(m[1]) : undefined;
+};
+/** Nivel de título por tamaño de letra frente al cuerpo, como con un PDF. */
+function headingBySize(size, body, bold, text) {
+    if (!size || !body)
+        return 0;
+    const r = size / body;
+    const short = text.length < 90 && !/[.,;:]$/.test(text);
+    if (r >= 1.6 && short)
+        return 1;
+    if (r >= 1.3 && short)
+        return 2;
+    if (((r >= 1.12 && short) || (bold && text.length < 70 && short)) && !/^[-•]/.test(text))
+        return 3;
+    return 0;
+}
+const modeOf = (values) => {
+    const c = new Map();
+    for (const v of values)
+        if (v)
+            c.set(v, (c.get(v) ?? 0) + 1);
+    return [...c.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? 0;
+};
+const cellMd = (s) => s.replace(/\|/g, "\\|").replace(/\s*\n\s*/g, " ").trim();
+export function rowsToMarkdown(rows) {
+    const width = Math.max(0, ...rows.map((r) => r.length));
+    if (!width)
+        return "";
+    const pad = (r) => [...r, ...Array(width - r.length).fill("")].map(cellMd);
+    const [head, ...body] = rows;
+    return [`| ${pad(head).join(" | ")} |`, `| ${Array(width).fill("---").join(" | ")} |`, ...body.map((r) => `| ${pad(r).join(" | ")} |`)].join("\n");
+}
+/* ---------- Word (DOCX) ---------- */
+function docxToMarkdown(files) {
+    const xml = strFromU8(files["word/document.xml"] ?? new Uint8Array());
+    const styles = strFromU8(files["word/styles.xml"] ?? new Uint8Array());
+    // Nivel de título por estilo: «Heading1», «Ttulo1» (Word en español) o outlineLvl.
+    const headingOf = new Map();
+    for (const m of styles.matchAll(/<w:style\b[^>]*w:styleId="([^"]+)"[^>]*>([\s\S]*?)<\/w:style>/g)) {
+        const lvl = m[2].match(/<w:outlineLvl w:val="(\d)"/)?.[1] ?? m[1].match(/(?:heading|t[ií]?tulo|ttulo)\s*(\d)/i)?.[1];
+        if (lvl !== undefined)
+            headingOf.set(m[1], Math.min(6, Number(lvl) + (m[2].includes("outlineLvl") ? 1 : 0)));
+        else if (/^(title|t[ií]tulo)$/i.test(m[1]))
+            headingOf.set(m[1], 1);
+    }
+    const out = [];
+    const tables = [];
+    const body = xml.match(/<w:body>([\s\S]*)<\/w:body>/)?.[1] ?? xml;
+    const blocks = [...body.matchAll(/<w:tbl>[\s\S]*?<\/w:tbl>|<w:p[ >][\s\S]*?<\/w:p>|<w:p\/>/g)].map((m) => m[0]);
+    const sizeOf = (b) => Math.max(0, ...[...b.matchAll(/<w:sz w:val="(\d+)"/g)].map((m) => Number(m[1])));
+    // El cuerpo es el tamaño más frecuente, ponderado por cuánto texto lo usa.
+    const bodySize = modeOf(blocks.filter((b) => !b.startsWith("<w:tbl")).flatMap((b) => Array(Math.min(20, texts(b, "w:t").join("").length)).fill(sizeOf(b))));
+    for (const b of blocks) {
+        if (b.startsWith("<w:tbl")) {
+            const rows = [...b.matchAll(/<w:tr[ >][\s\S]*?<\/w:tr>/g)].map((r) => [...r[0].matchAll(/<w:tc>[\s\S]*?<\/w:tc>/g)].map((c) => texts(c[0], "w:t").join("")));
+            if (rows.length) {
+                tables.push({ title: `Tabla ${tables.length + 1}`, rows });
+                out.push(rowsToMarkdown(rows), "");
+            }
+            continue;
+        }
+        const text = b.replace(/<w:tab\/>/g, "<w:t>\t</w:t>").replace(/<w:br\/>/g, "<w:t>\n</w:t>");
+        let line = texts(text, "w:t").join("").replace(/[ \t]+/g, " ").trim();
+        if (!line)
+            continue;
+        const bullet = /^[•●▪◦‣∙·\-–*]\s*/.test(line) || /<w:numPr>/.test(b);
+        line = line.replace(/^[•●▪◦‣∙·–*]\s*/, "");
+        const style = b.match(/<w:pStyle w:val="([^"]+)"/)?.[1] ?? "";
+        const runs = [...b.matchAll(/<w:r>[\s\S]*?<\/w:r>/g)].map((r) => r[0]).filter((r) => texts(r, "w:t").join("").trim());
+        const bold = runs.length > 0 && runs.every((r) => /<w:b\/>|<w:b w:val="(?:1|true)"\/>/.test(r));
+        const level = headingOf.get(style) ?? (bullet ? 0 : headingBySize(sizeOf(b), bodySize, bold, line));
+        if (level)
+            out.push(`${"#".repeat(level)} ${line}`, "");
+        else if (bullet)
+            out.push(`- ${line}`);
+        else
+            out.push(line, "");
+    }
+    const markdown = out.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+    return { format: "docx", markdown, parts: [{ title: "Documento", markdown }], tables, warnings: [] };
+}
+/* ---------- Excel (XLSX) ---------- */
+function colIndex(ref) {
+    const letters = ref.match(/^[A-Z]+/)?.[0] ?? "A";
+    return [...letters].reduce((n, ch) => n * 26 + ch.charCodeAt(0) - 64, 0) - 1;
+}
+function xlsxToMarkdown(files) {
+    const read = (p) => (files[p] ? strFromU8(files[p]) : "");
+    const shared = [...read("xl/sharedStrings.xml").matchAll(/<si>([\s\S]*?)<\/si>/g)].map((m) => texts(m[1], "t").join(""));
+    const workbook = read("xl/workbook.xml");
+    const rels = read("xl/_rels/workbook.xml.rels");
+    const target = new Map([...rels.matchAll(/<Relationship\b[^>]*>/g)].map((m) => [attr(m[0], "Id") ?? "", (attr(m[0], "Target") ?? "").replace(/^\/?xl\//, "")]));
+    const sheets = [...workbook.matchAll(/<sheet\b[^>]*>/g)].map((m) => ({ name: attr(m[0], "name") ?? "Hoja", path: `xl/${target.get(attr(m[0], "r:id") ?? "") ?? ""}` }));
+    const parts = [];
+    const tables = [];
+    const warnings = [];
+    for (const sheet of sheets) {
+        const xml = read(sheet.path);
+        const rows = [];
+        for (const r of xml.matchAll(/<row\b[^>]*>([\s\S]*?)<\/row>|<row\b[^>]*\/>/g)) {
+            if (!r[1])
+                continue;
+            const row = [];
+            for (const c of r[1].matchAll(/<c\b([^>]*?)(?:\/>|>([\s\S]*?)<\/c>)/g)) {
+                const attrs = c[1];
+                const ref = attrs.match(/r="([A-Z]+)\d+"/)?.[1] ?? "";
+                const type = attrs.match(/t="([^"]+)"/)?.[1];
+                const inner = c[2] ?? "";
+                const v = inner.match(/<v>([\s\S]*?)<\/v>/)?.[1];
+                const value = type === "s" ? shared[Number(v)] ?? "" : type === "inlineStr" ? texts(inner, "t").join("") : decodeEntities(v ?? "");
+                row[ref ? colIndex(ref) : row.length] = value;
+            }
+            if (row.some((x) => x?.trim()))
+                rows.push(Array.from(row, (x) => x ?? ""));
+        }
+        if (!rows.length)
+            continue;
+        if (xml.includes("<f>"))
+            warnings.push(`«${sheet.name}» tiene fórmulas: se usa el último valor calculado que guardó Excel.`);
+        tables.push({ title: sheet.name, rows });
+        parts.push({ title: sheet.name, markdown: `## ${sheet.name}\n\n${rowsToMarkdown(rows)}` });
+    }
+    return { format: "xlsx", markdown: parts.map((p) => p.markdown).join("\n\n"), parts, tables, warnings };
+}
+/* ---------- PowerPoint (PPTX) ---------- */
+function pptxToMarkdown(files) {
+    const slides = Object.keys(files)
+        .filter((n) => /^ppt\/slides\/slide\d+\.xml$/.test(n))
+        .sort((a, b) => Number(a.match(/\d+/g).pop()) - Number(b.match(/\d+/g).pop()));
+    const parts = slides.map((name, i) => {
+        const xml = strFromU8(files[name]);
+        const paragraphs = [...xml.matchAll(/<a:p>([\s\S]*?)<\/a:p>/g)].map((m) => texts(m[1], "a:t").join("").trim()).filter(Boolean);
+        const notesName = `ppt/notesSlides/notesSlide${name.match(/\d+/g).pop()}.xml`;
+        const notes = files[notesName]
+            ? [...strFromU8(files[notesName]).matchAll(/<a:p>([\s\S]*?)<\/a:p>/g)].map((m) => texts(m[1], "a:t").join("").trim()).filter((t) => t && !/^\d+$/.test(t))
+            : [];
+        const [title, ...rest] = paragraphs;
+        const md = [`## Diapositiva ${i + 1}${title ? `: ${title}` : ""}`, "", ...rest.map((p) => `- ${p}`), ...(notes.length ? ["", `> Notas: ${notes.join(" ")}`] : [])].join("\n");
+        return { title: title ?? `Diapositiva ${i + 1}`, markdown: md };
+    });
+    return { format: "pptx", markdown: parts.map((p) => p.markdown).join("\n\n"), parts, tables: [], warnings: [] };
+}
+/* ---------- OpenDocument ---------- */
+function odfToMarkdown(files, format) {
+    const xml = strFromU8(files["content.xml"] ?? new Uint8Array());
+    const plain = (s) => decodeEntities(s.replace(/<text:(?:s|tab)\b[^>]*\/>/g, " ").replace(/<text:line-break\/>/g, "\n").replace(/<[^>]+>/g, "")).trim();
+    if (format === "ods") {
+        const tables = [];
+        for (const t of xml.matchAll(/<table:table\b[^>]*table:name="([^"]*)"[^>]*>([\s\S]*?)<\/table:table>/g)) {
+            const rows = [...t[2].matchAll(/<table:table-row\b[^>]*>([\s\S]*?)<\/table:table-row>/g)]
+                .map((r) => [...r[1].matchAll(/<table:table-cell\b([^>]*?)(?:\/>|>([\s\S]*?)<\/table:table-cell>)/g)].flatMap((c) => {
+                const repeat = Math.min(50, Number(c[1].match(/number-columns-repeated="(\d+)"/)?.[1] ?? 1));
+                return Array(repeat).fill(plain(c[2] ?? ""));
+            }))
+                .map((r) => { while (r.length && !r[r.length - 1])
+                r.pop(); return r; })
+                .filter((r) => r.length);
+            if (rows.length)
+                tables.push({ title: decodeEntities(t[1]), rows });
+        }
+        const parts = tables.map((t) => ({ title: t.title, markdown: `## ${t.title}\n\n${rowsToMarkdown(t.rows)}` }));
+        return { format, markdown: parts.map((p) => p.markdown).join("\n\n"), parts, tables, warnings: [] };
+    }
+    // Estilos automáticos: tamaño y negrita de cada estilo de párrafo y de texto.
+    const styleInfo = new Map();
+    for (const m of xml.matchAll(/<style:style\b([^>]*)>([\s\S]*?)<\/style:style>/g)) {
+        const size = Number(m[2].match(/fo:font-size="([\d.]+)pt"/)?.[1] ?? 0);
+        styleInfo.set(attr(m[0], "style:name") ?? "", { size, bold: /fo:font-weight="bold"/.test(m[2]) });
+    }
+    const body = xml.match(/<office:(?:text|presentation)>([\s\S]*)<\/office:(?:text|presentation)>/)?.[1] ?? xml;
+    const blocks = [...body.matchAll(/<table:table\b[\s\S]*?<\/table:table>|<text:list\b[\s\S]*?<\/text:list>|<text:(h|p)\b[^>]*>[\s\S]*?<\/text:\1>|<draw:page\b[^>]*>/g)].map((m) => m[0]);
+    const paraSize = (b) => styleInfo.get(attr(b.match(/^<[^>]+>/)[0], "text:style-name") ?? "")?.size ?? 0;
+    const bodySize = modeOf(blocks.filter((b) => b.startsWith("<text:p")).map(paraSize));
+    const out = [];
+    const tables = [];
+    let slide = 0;
+    for (const b of blocks) {
+        if (b.startsWith("<draw:page")) {
+            out.push(`## Diapositiva ${++slide}`, "");
+        }
+        else if (b.startsWith("<table:table")) {
+            const rows = [...b.matchAll(/<table:table-row\b[^>]*>([\s\S]*?)<\/table:table-row>/g)].map((r) => [...r[1].matchAll(/<table:table-cell\b[^>]*?(?:\/>|>([\s\S]*?)<\/table:table-cell>)/g)].map((c) => plain(c[1] ?? "")));
+            if (rows.length) {
+                tables.push({ title: attr(b.match(/^<[^>]+>/)[0], "table:name") ?? `Tabla ${tables.length + 1}`, rows });
+                out.push(rowsToMarkdown(rows), "");
+            }
+        }
+        else if (b.startsWith("<text:list")) {
+            for (const it of b.matchAll(/<text:list-item\b[^>]*>([\s\S]*?)<\/text:list-item>/g)) {
+                const t = plain(it[1]);
+                if (t)
+                    out.push(`- ${t}`);
+            }
+            out.push("");
+        }
+        else {
+            const text = plain(b);
+            if (!text)
+                continue;
+            const open = b.match(/^<[^>]+>/)[0];
+            const spans = [...b.matchAll(/<text:span\b[^>]*>/g)].map((m) => styleInfo.get(attr(m[0], "text:style-name") ?? ""));
+            const bold = styleInfo.get(attr(open, "text:style-name") ?? "")?.bold || (spans.length > 0 && spans.every((x) => x?.bold));
+            const level = b.startsWith("<text:h") ? Number(attr(open, "text:outline-level") ?? 2) : headingBySize(paraSize(b), bodySize, !!bold, text);
+            out.push(level ? `${"#".repeat(Math.min(6, level))} ${text}` : text, "");
+        }
+    }
+    const markdown = out.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+    return { format, markdown, parts: [{ title: "Documento", markdown }], tables, warnings: [] };
+}
+/* ---------- HTML / EPUB ---------- */
+export function htmlToMarkdown(html) {
+    const tables = [];
+    let s = html
+        .replace(/<(script|style|noscript|svg|head|nav|footer)\b[\s\S]*?<\/\1>/gi, "")
+        .replace(/<!--[\s\S]*?-->/g, "");
+    s = s.replace(/<table\b[\s\S]*?<\/table>/gi, (t) => {
+        const rows = [...t.matchAll(/<tr\b[\s\S]*?<\/tr>/gi)].map((r) => [...r[0].matchAll(/<t[hd]\b[^>]*>([\s\S]*?)<\/t[hd]>/gi)].map((c) => decodeEntities(c[1].replace(/<[^>]+>/g, " ")).replace(/\s+/g, " ").trim())).filter((r) => r.length);
+        if (!rows.length)
+            return "";
+        tables.push(rows);
+        return `\n\n${rowsToMarkdown(rows)}\n\n`;
+    });
+    s = s
+        .replace(/<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi, (_, n, t) => `\n\n${"#".repeat(Number(n))} ${t.replace(/<[^>]+>/g, "").trim()}\n\n`)
+        .replace(/<li\b[^>]*>/gi, "\n- ")
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<\/(p|div|section|article|ul|ol|blockquote|tr)>/gi, "\n\n")
+        .replace(/<(strong|b)\b[^>]*>([\s\S]*?)<\/\1>/gi, "**$2**")
+        .replace(/<a\b[^>]*href="(https?:[^"]+)"[^>]*>([\s\S]*?)<\/a>/gi, "[$2]($1)")
+        .replace(/<[^>]+>/g, "");
+    const markdown = decodeEntities(s)
+        .split("\n")
+        .map((l) => l.replace(/[ \t]+/g, " ").trim())
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+    return { markdown, tables };
+}
+function epubToMarkdown(files) {
+    const container = strFromU8(files["META-INF/container.xml"] ?? new Uint8Array());
+    const opfPath = container.match(/full-path="([^"]+)"/)?.[1] ?? Object.keys(files).find((n) => n.endsWith(".opf")) ?? "";
+    const opf = strFromU8(files[opfPath] ?? new Uint8Array());
+    const base = opfPath.includes("/") ? opfPath.slice(0, opfPath.lastIndexOf("/") + 1) : "";
+    const manifest = new Map([...opf.matchAll(/<item\b[^>]*id="([^"]+)"[^>]*href="([^"]+)"/g)].map((m) => [m[1], m[2]]));
+    const spine = [...opf.matchAll(/<itemref\b[^>]*idref="([^"]+)"/g)].map((m) => base + decodeURIComponent(manifest.get(m[1]) ?? ""));
+    const parts = spine
+        .filter((p) => files[p])
+        .map((p, i) => {
+        const { markdown } = htmlToMarkdown(strFromU8(files[p]));
+        return { title: markdown.match(/^#+\s+(.+)$/m)?.[1] ?? `Capítulo ${i + 1}`, markdown };
+    })
+        .filter((p) => p.markdown);
+    return { format: "epub", markdown: parts.map((p) => p.markdown).join("\n\n"), parts, tables: [], warnings: [] };
+}
+/* ---------- texto ---------- */
+/** CSV con comillas, separador autodetectado (coma, punto y coma o tabulador). */
+export function parseDelimited(text, delimiter) {
+    const first = text.split("\n", 1)[0];
+    const sep = delimiter ?? [";", "\t", ","].reduce((best, d) => (first.split(d).length > first.split(best).length ? d : best), ",");
+    const rows = [];
+    let row = [];
+    let cell = "";
+    let quoted = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (quoted) {
+            if (ch === '"' && text[i + 1] === '"') {
+                cell += '"';
+                i++;
+            }
+            else if (ch === '"')
+                quoted = false;
+            else
+                cell += ch;
+        }
+        else if (ch === '"')
+            quoted = true;
+        else if (ch === sep) {
+            row.push(cell);
+            cell = "";
+        }
+        else if (ch === "\n" || ch === "\r") {
+            if (ch === "\r" && text[i + 1] === "\n")
+                i++;
+            row.push(cell);
+            cell = "";
+            if (row.some((c) => c.trim()))
+                rows.push(row);
+            row = [];
+        }
+        else
+            cell += ch;
+    }
+    row.push(cell);
+    if (row.some((c) => c.trim()))
+        rows.push(row);
+    return rows;
+}
+function emlToMarkdown(raw) {
+    const [headerBlock, ...bodyParts] = raw.split(/\r?\n\r?\n/);
+    const header = (name) => headerBlock.match(new RegExp(`^${name}:\\s*(.+(?:\\r?\\n[ \\t].+)*)`, "im"))?.[1].replace(/\r?\n[ \t]+/g, " ").trim();
+    let body = bodyParts.join("\n\n");
+    const htmlPart = body.match(/Content-Type:\s*text\/html[\s\S]*?\r?\n\r?\n([\s\S]*?)(?:\r?\n--|$)/i)?.[1];
+    const textPart = body.match(/Content-Type:\s*text\/plain[\s\S]*?\r?\n\r?\n([\s\S]*?)(?:\r?\n--|$)/i)?.[1];
+    body = textPart ?? (htmlPart ? htmlToMarkdown(htmlPart).markdown : body);
+    // quoted-printable, lo más común en correos en español.
+    body = body.replace(/=\r?\n/g, "").replace(/(?:=[0-9A-F]{2})+/g, (m) => {
+        try {
+            return new TextDecoder().decode(new Uint8Array(m.match(/[0-9A-F]{2}/g).map((h) => parseInt(h, 16))));
+        }
+        catch {
+            return m;
+        }
+    });
+    const meta = [["De", header("From")], ["Para", header("To")], ["Fecha", header("Date")]].filter(([, v]) => v).map(([k, v]) => `${k}: ${v}`);
+    const markdown = [`# ${header("Subject") ?? "(sin asunto)"}`, "", ...meta, "", body.trim()].join("\n");
+    const warnings = /Content-Disposition:\s*attachment/i.test(raw) ? ["El correo trae adjuntos: se leyó solo el cuerpo."] : [];
+    return { format: "eml", markdown, parts: [{ title: header("Subject") ?? "Correo", markdown }], tables: [], warnings };
+}
+/** RTF por grupos: se saltan tablas de fuentes, colores, estilos e info, y se decodifica cp1252. */
+function rtfToText(rtf) {
+    const cp1252 = new TextDecoder("windows-1252");
+    const SKIP = new Set(["fonttbl", "colortbl", "stylesheet", "info", "pict", "header", "footer", "listtable", "listoverridetable", "generator", "expandedcolortbl", "themedata", "datastore", "xmlnstbl", "latentstyles"]);
+    let out = "";
+    const stack = [];
+    let skipping = false;
+    let i = 0;
+    while (i < rtf.length) {
+        const ch = rtf[i];
+        if (ch === "{") {
+            stack.push(skipping);
+            i++;
+            if (rtf.startsWith("\\*", i))
+                skipping = true;
+            continue;
+        }
+        if (ch === "}") {
+            skipping = stack.pop() ?? false;
+            i++;
+            continue;
+        }
+        if (ch === "\\") {
+            const next = rtf[i + 1];
+            if (next === "\\" || next === "{" || next === "}") {
+                if (!skipping)
+                    out += next;
+                i += 2;
+                continue;
+            }
+            // «\» al final de línea es un salto de párrafo en el RTF de macOS y de Word.
+            if (next === "\n" || next === "\r") {
+                if (!skipping)
+                    out += "\n";
+                i += 2;
+                continue;
+            }
+            if (next === "'") {
+                if (!skipping)
+                    out += cp1252.decode(new Uint8Array([parseInt(rtf.slice(i + 2, i + 4), 16)]));
+                i += 4;
+                continue;
+            }
+            const m = rtf.slice(i).match(/^\\([a-z]+)(-?\d+)? ?/i);
+            if (!m) {
+                i += 2;
+                continue;
+            }
+            const [whole, word, num] = m;
+            i += whole.length;
+            if (SKIP.has(word))
+                skipping = true;
+            if (skipping)
+                continue;
+            if (word === "par" || word === "line" || word === "sect" || word === "row")
+                out += "\n";
+            else if (word === "tab" || word === "cell")
+                out += "\t";
+            else if (word === "u" && num) {
+                out += String.fromCharCode(Number(num) < 0 ? Number(num) + 65536 : Number(num));
+                if (rtf[i] === "?")
+                    i++;
+            }
+            continue;
+        }
+        if (ch === "\r" || ch === "\n") {
+            i++;
+            continue;
+        }
+        if (!skipping)
+            out += ch;
+        i++;
+    }
+    return out
+        .split("\n")
+        .map((l) => l.replace(/[ \t]+/g, " ").trim())
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+/**
+ * Convierte cualquier formato soportado a Markdown. PDF e imágenes no pasan
+ * por aquí: necesitan PDF.js y OCR, y quien llama ya los tiene.
+ */
+export function convertToMarkdown(bytes, filename = "") {
+    const format = detectFormat(bytes, filename);
+    const empty = (warning) => ({ format, markdown: "", parts: [], tables: [], warnings: [warning] });
+    const text = () => new TextDecoder("utf-8").decode(bytes).replace(/^/, "");
+    switch (format) {
+        case "docx":
+        case "xlsx":
+        case "pptx":
+        case "odt":
+        case "ods":
+        case "odp":
+        case "epub": {
+            const files = unzipSync(bytes);
+            if (format === "docx")
+                return docxToMarkdown(files);
+            if (format === "xlsx")
+                return xlsxToMarkdown(files);
+            if (format === "pptx")
+                return pptxToMarkdown(files);
+            if (format === "epub")
+                return epubToMarkdown(files);
+            return odfToMarkdown(files, format);
+        }
+        case "html": {
+            const { markdown, tables } = htmlToMarkdown(text());
+            return { format, markdown, parts: [{ title: "Página", markdown }], tables: tables.map((rows, i) => ({ title: `Tabla ${i + 1}`, rows })), warnings: [] };
+        }
+        case "csv":
+        case "tsv": {
+            const rows = parseDelimited(text(), format === "tsv" ? "\t" : undefined);
+            const markdown = rowsToMarkdown(rows);
+            return { format, markdown, parts: [{ title: filename || "Tabla", markdown }], tables: [{ title: filename || "Tabla", rows }], warnings: [] };
+        }
+        case "json": {
+            const raw = text();
+            try {
+                return { format, markdown: "```json\n" + JSON.stringify(JSON.parse(raw), null, 2) + "\n```", parts: [], tables: [], warnings: [] };
+            }
+            catch {
+                return { format: "txt", markdown: raw, parts: [], tables: [], warnings: ["JSON inválido: se leyó como texto."] };
+            }
+        }
+        case "eml":
+            return emlToMarkdown(text());
+        case "rtf":
+            return { format, markdown: rtfToText(text()), parts: [], tables: [], warnings: [] };
+        case "md":
+        case "txt":
+            return { format, markdown: text(), parts: [], tables: [], warnings: [] };
+        case "pdf":
+            return empty("PDF: usa pdfToMarkdown (necesita PDF.js).");
+        case "image":
+            return empty("Imagen: necesita OCR.");
+        default:
+            return empty("Formato no reconocido.");
+    }
+}

package/dist/forms.d.ts

@@ -0,0 +1,19 @@
+export interface FormField {
+    name: string;
+    type: "text" | "checkbox" | "radio" | "dropdown" | "list" | "signature" | "other";
+    /** Texto, opción elegida o lista de opciones elegidas; `null` si está vacío. */
+    value: string | string[] | null;
+    checked?: boolean;
+    options?: string[];
+    /** Página base 1 del primer widget, si se puede resolver. */
+    page: number | null;
+}
+export declare function readFormFields(buf: ArrayBuffer | Uint8Array): Promise<FormField[]>;
+export interface TextCheckbox {
+    label: string;
+    checked: boolean;
+    /** La línea donde apareció, para citarla. */
+    line: string;
+}
+/** Casillas escritas como caracteres en el texto de cualquier documento. */
+export declare function findTextCheckboxes(text: string): TextCheckbox[];

package/dist/forms.js

@@ -0,0 +1,57 @@
+// Formularios: lo que LlamaParse vende como «checkboxes» y «forms», resuelto
+// sin modelo de visión en los dos casos en que se puede hacer bien:
+//  1. Formularios PDF rellenables (AcroForm): el valor está en el archivo.
+//  2. Casillas dibujadas como caracteres (☐ ☑ ☒ [x] ( )): están en el texto.
+// Una casilla marcada a mano sobre un escaneo NO entra aquí: eso sí necesita visión.
+import { PDFCheckBox, PDFDocument, PDFDropdown, PDFOptionList, PDFRadioGroup, PDFTextField } from "pdf-lib";
+export async function readFormFields(buf) {
+    const doc = await PDFDocument.load(buf, { updateMetadata: false });
+    const pages = doc.getPages();
+    const pageOf = (field) => {
+        const ref = field.acroField.getWidgets()[0]?.P();
+        const i = ref ? pages.findIndex((p) => p.ref === ref) : -1;
+        return i >= 0 ? i + 1 : null;
+    };
+    const out = [];
+    for (const f of doc.getForm().getFields()) {
+        const base = { name: f.getName(), page: pageOf(f) };
+        if (f instanceof PDFTextField)
+            out.push({ ...base, type: "text", value: f.getText() || null });
+        else if (f instanceof PDFCheckBox)
+            out.push({ ...base, type: "checkbox", value: f.isChecked() ? "on" : null, checked: f.isChecked() });
+        else if (f instanceof PDFRadioGroup)
+            out.push({ ...base, type: "radio", value: f.getSelected() ?? null, options: f.getOptions() });
+        else if (f instanceof PDFDropdown)
+            out.push({ ...base, type: "dropdown", value: f.getSelected()[0] ?? null, options: f.getOptions() });
+        else if (f instanceof PDFOptionList)
+            out.push({ ...base, type: "list", value: f.getSelected(), options: f.getOptions() });
+        else if (f.constructor.name.includes("Signature"))
+            out.push({ ...base, type: "signature", value: null });
+        else
+            out.push({ ...base, type: "other", value: null });
+    }
+    return out;
+}
+const MARK_ON = "☑☒✅✔✓■▣⊠";
+const MARK_OFF = "☐□▢";
+/** Una casilla y su etiqueta: «☒ Sí», «[x] Hipertensión», «( ) No». */
+const BOX = new RegExp(String.raw `(?:([${MARK_ON}${MARK_OFF}])|\[\s*([xX✓✔*]?)\s*\]|\(\s*([xX✓✔*•]?)\s*\))\s*([^${MARK_ON}${MARK_OFF}\[\(\n]{1,60}?)(?=\s{2,}|\s*[${MARK_ON}${MARK_OFF}\[\(]|$)`, "gmu");
+/** Casillas escritas como caracteres en el texto de cualquier documento. */
+export function findTextCheckboxes(text) {
+    const out = [];
+    for (const line of text.split("\n")) {
+        // Sin al menos una marca de casilla, «(ver anexo)» o «[1]» no son casillas.
+        if (!new RegExp(`[${MARK_ON}${MARK_OFF}]|\\[\\s*[xX✓✔*]?\\s*\\]\\s*\\p{L}|\\(\\s*[xX✓✔*•]?\\s*\\)\\s*\\p{L}`, "u").test(line))
+            continue;
+        for (const m of line.matchAll(BOX)) {
+            const label = (m[4] ?? "").trim().replace(/[:;,.]$/, "");
+            if (!label || !/\p{L}/u.test(label))
+                continue;
+            const glyph = m[1];
+            const inner = m[2] ?? m[3];
+            const checked = glyph ? MARK_ON.includes(glyph) : !!inner;
+            out.push({ label, checked, line: line.trim().slice(0, 160) });
+        }
+    }
+    return out;
+}

package/dist/index.d.ts

@@ -17,3 +17,12 @@ export * from "./datasplit.js";
 export * from "./dataset.js";
 export * from "./verifiable.js";
 export * from "./paragraphs.js";
+export * from "./agentchunks.js";
+export * from "./classify.js";
+export * from "./pages.js";
+export * from "./security.js";
+export * from "./extract.js";
+export * from "./locate.js";
+export * from "./forms.js";
+export * from "./segment.js";
+export * from "./formats.js";

package/dist/index.js

@@ -19,3 +19,12 @@ export * from "./datasplit.js";
 export * from "./dataset.js";
 export * from "./verifiable.js";
 export * from "./paragraphs.js";
+export * from "./agentchunks.js";
+export * from "./classify.js";
+export * from "./pages.js";
+export * from "./security.js";
+export * from "./extract.js";
+export * from "./locate.js";
+export * from "./forms.js";
+export * from "./segment.js";
+export * from "./formats.js";

package/dist/locate.d.ts

@@ -0,0 +1,13 @@
+import type { Line } from "./markdown.js";
+export interface Location {
+    page: number;
+    /** Caja 0–1, origen arriba a la izquierda: [x0, y0, x1, y1]. */
+    bbox: [number, number, number, number];
+    /** Líneas que abarca la cita (una cita puede cruzar un salto de línea). */
+    lines: number;
+}
+/**
+ * Ubica `text` entre las líneas extraídas. Tolera diferencias de espacios,
+ * tildes y puntuación, y citas que ocupan hasta tres líneas seguidas.
+ */
+export declare function locateText(lines: Line[], text: string, page?: number | null): Location | null;