@sirdaspdf/core 0.2.0 → 0.3.1

package/README.md

@@ -1,6 +1,6 @@
 # @sirdaspdf/core
 
-The engine behind [Sırdaş](https://sirdas.app): PDF operations, PDF→Markdown for
+The engine behind [Sırdaş](https://www.sirdaspdf.com): PDF operations, PDF→Markdown for
 LLMs, local anonymization of personal data, and the pieces needed to turn
 documents into a training set. Runs in the browser and in Node, with the same
 code path.
@@ -52,5 +52,5 @@ import { dedupe } from "@sirdaspdf/core/dedupe";
 Anonymization detection is rule-based and can miss unusual formats. Review
 before sharing a sensitive document.
 
-Full documentation: https://sirdas.app/docs/agents/core.md ·
+Full documentation: https://www.sirdaspdf.com/docs/agents/core.md ·
 Source: https://github.com/Brayan15p/SIRDAS-APP-PDF · MIT

package/dist/dataset.d.ts

@@ -2,7 +2,18 @@
  * Formatos de salida. Los nombres de campo son los que consumen los
  * entrenadores; cambiarlos rompe la carga del dataset, así que no se tocan.
  */
-export type DatasetFormat = "text" | "chat" | "prompt-completion";
+export type DatasetFormat = "text" | "chat" | "prompt-completion"
+/** Stanford Alpaca: instruction / input / output. Lo usan Axolotl, LLaMA-Factory y Unsloth. */
+ | "alpaca"
+/** ShareGPT: conversations con from human / gpt. */
+ | "sharegpt"
+/** Documentos de LangChain: page_content + metadata. */
+ | "langchain"
+/** TextNode de LlamaIndex: id_ + text + metadata. */
+ | "llamaindex"
+/** Para una base vectorial: id estable + text + metadata plana. */
+ | "embeddings";
+export declare const DATASET_FORMATS: DatasetFormat[];
 export interface SourceDocument {
     /** Nombre del archivo: es la clave del reparto y de la trazabilidad. */
     name: string;
@@ -54,6 +65,19 @@ export declare function buildRecords(docs: SourceDocument[], options?: BuildOpti
  * campos que no conocen, así que dejarla puesta sale gratis y permite rastrear
  * de qué página salió cada ejemplo cuando el modelo diga algo raro.
  */
+/**
+ * Tarjeta de dataset para Hugging Face (README.md con metadatos YAML). Un
+ * dataset sin tarjeta no dice de dónde salió ni qué se le quitó, y eso es justo
+ * lo que un equipo de ML necesita para confiar en él.
+ */
+export declare function datasetCard(stats: DatasetStats, opts: {
+    name?: string;
+    format: DatasetFormat;
+    language?: string;
+    splits?: string[];
+    anonymized: boolean;
+    deduplicated?: boolean;
+}): string;
 export declare function toJsonl(records: DatasetRecord[], withMeta?: boolean): string;
 export interface DatasetStats {
     records: number;

package/dist/dataset.js

@@ -5,9 +5,11 @@
 // Eso exigiría mandar tus documentos a una API, que es exactamente lo que este
 // producto existe para evitar. Aquí todo sale del documento por reglas, y cada
 // registro dice de dónde salió.
+import { contentId } from "./agentchunks.js";
 import { chunkMarkdown } from "./chunk.js";
 import { anonymize as redactPii } from "./anonymize.js";
 import { estimateTokens } from "./markdown.js";
+export const DATASET_FORMATS = ["text", "chat", "prompt-completion", "alpaca", "sharegpt", "langchain", "llamaindex", "embeddings"];
 const DEFAULT_TEMPLATE = "Resume el contenido de «{heading}» del documento {document}.";
 /** Un trozo sin encabezado no puede pedir «resume la sección “archivo.pdf”». */
 const DEFAULT_TEMPLATE_NO_HEADING = "Resume el contenido del documento {document}.";
@@ -46,13 +48,30 @@ export function buildRecords(docs, options = {}) {
             const hasHeading = (chunk.heading ?? "").trim() !== "";
             const tpl = options.template ?? (hasHeading ? DEFAULT_TEMPLATE : DEFAULT_TEMPLATE_NO_HEADING);
             const instruction = fillTemplate(tpl, { heading: chunk.heading ?? "", document: doc.name });
-            records.push({ data: shape(format, text, instruction, system), meta });
+            records.push({ data: shape(format, text, instruction, system, meta), meta });
         });
     }
     return records;
 }
-function shape(format, text, instruction, system) {
+function shape(format, text, instruction, system, meta) {
+    const metadata = meta ? { source: meta.document, chunk: meta.chunk, heading: meta.heading, tokens: meta.tokens } : {};
     switch (format) {
+        case "alpaca":
+            return { instruction, input: "", output: text, ...(system ? { system } : {}) };
+        case "sharegpt":
+            return {
+                conversations: [
+                    ...(system ? [{ from: "system", value: system }] : []),
+                    { from: "human", value: instruction },
+                    { from: "gpt", value: text },
+                ],
+            };
+        case "langchain":
+            return { page_content: text, metadata, type: "Document" };
+        case "llamaindex":
+            return { id_: contentId(text), text, metadata, class_name: "TextNode" };
+        case "embeddings":
+            return { id: contentId(text), text, metadata };
         case "text":
             return { text };
         case "prompt-completion":
@@ -75,6 +94,53 @@ function shape(format, text, instruction, system) {
  * campos que no conocen, así que dejarla puesta sale gratis y permite rastrear
  * de qué página salió cada ejemplo cuando el modelo diga algo raro.
  */
+/**
+ * Tarjeta de dataset para Hugging Face (README.md con metadatos YAML). Un
+ * dataset sin tarjeta no dice de dónde salió ni qué se le quitó, y eso es justo
+ * lo que un equipo de ML necesita para confiar en él.
+ */
+export function datasetCard(stats, opts) {
+    const size = stats.records < 1000 ? "n<1K" : stats.records < 10000 ? "1K<n<10K" : stats.records < 100000 ? "10K<n<100K" : "100K<n<1M";
+    const splits = opts.splits ?? ["train"];
+    return [
+        "---",
+        `language: [${opts.language ?? "es"}]`,
+        `size_categories: [${size}]`,
+        "tags: [sirdas, pdf, local-processing]",
+        "configs:",
+        "  - config_name: default",
+        "    data_files:",
+        ...splits.map((sp) => `      - split: ${sp}
+        path: ${sp}.jsonl`),
+        "---",
+        "",
+        `# ${opts.name ?? "Dataset"}`,
+        "",
+        "Generado con [Sırdaş](https://www.sirdaspdf.com) en la máquina de quien lo creó: los documentos originales no se subieron a ningún servicio.",
+        "",
+        "| | |",
+        "|---|---|",
+        `| Formato | \`${opts.format}\` |`,
+        `| Registros | ${stats.records} |`,
+        `| Documentos de origen | ${stats.documents} |`,
+        `| Tokens (estimados) | ${stats.tokens} (mediana ${stats.medianTokens}, máx. ${stats.maxTokens}) |`,
+        `| Anonimizado | ${opts.anonymized ? `sí: ${stats.redacted} datos personales sustituidos en ${stats.recordsWithPii} registros` : "no"} |`,
+        `| Deduplicado | ${opts.deduplicated ? "sí (MinHash)" : "no"} |`,
+        `| Particiones | ${splits.join(", ")}${splits.length > 1 ? " — repartidas por documento, nunca por trozo, para que no se filtren a evaluación" : ""} |`,
+        "",
+        "## Uso",
+        "",
+        "```python",
+        "from datasets import load_dataset",
+        'ds = load_dataset("json", data_files={' + splits.map((sp) => `"${sp}": "${sp}.jsonl"`).join(", ") + "})",
+        "```",
+        "",
+        "## Límites",
+        "",
+        "La anonimización es por reglas (identificaciones, NIT, correos, teléfonos, direcciones, nombres con etiqueta) y puede dejar pasar formatos poco comunes. Revisa una muestra antes de publicar.",
+        "",
+    ].join("\n");
+}
 export function toJsonl(records, withMeta = true) {
     return records
         .map((r) => JSON.stringify(withMeta ? { ...r.data, sirdas: r.meta } : r.data))

package/dist/formats.d.ts

@@ -0,0 +1,30 @@
+export type SourceFormat = "pdf" | "docx" | "xlsx" | "pptx" | "odt" | "ods" | "odp" | "epub" | "html" | "csv" | "tsv" | "md" | "txt" | "json" | "eml" | "rtf" | "image" | "unknown";
+export interface ConvertedDocument {
+    format: SourceFormat;
+    markdown: string;
+    /** Hojas, diapositivas o capítulos: la unidad natural de cada formato. */
+    parts: {
+        title: string;
+        markdown: string;
+    }[];
+    /** Tablas ya estructuradas (Excel, CSV, tablas de Word y HTML). */
+    tables: {
+        title: string;
+        rows: string[][];
+    }[];
+    warnings: string[];
+}
+/** Por contenido primero (la extensión miente a menudo), por nombre después. */
+export declare function detectFormat(bytes: Uint8Array, filename?: string): SourceFormat;
+export declare function rowsToMarkdown(rows: string[][]): string;
+export declare function htmlToMarkdown(html: string): {
+    markdown: string;
+    tables: string[][][];
+};
+/** CSV con comillas, separador autodetectado (coma, punto y coma o tabulador). */
+export declare function parseDelimited(text: string, delimiter?: string): string[][];
+/**
+ * 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 declare function convertToMarkdown(bytes: Uint8Array, filename?: string): ConvertedDocument;

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

@@ -22,3 +22,7 @@ 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

@@ -24,3 +24,7 @@ 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;

package/dist/locate.js

@@ -0,0 +1,35 @@
+const norm = (s) => s.toLowerCase().normalize("NFD").replace(/\p{Diacritic}/gu, "").replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+/**
+ * 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 function locateText(lines, text, page) {
+    const needle = norm(text);
+    if (needle.length < 3)
+        return null;
+    const pool = lines.map((l, i) => ({ l, i })).filter(({ l }) => l.bbox && (!page || l.page === page));
+    for (let span = 1; span <= 3; span++) {
+        for (let k = 0; k + span <= pool.length; k++) {
+            const group = pool.slice(k, k + span);
+            if (group.some((g) => g.l.page !== group[0].l.page))
+                continue;
+            if (span > 1 && group.some((g, j) => j > 0 && g.i !== group[j - 1].i + 1))
+                continue;
+            const hay = norm(group.map((g) => g.l.text).join(" "));
+            if (!hay.includes(needle))
+                continue;
+            const boxes = group.map((g) => g.l.bbox);
+            return {
+                page: group[0].l.page,
+                bbox: [
+                    Math.min(...boxes.map((b) => b[0])),
+                    Math.min(...boxes.map((b) => b[1])),
+                    Math.max(...boxes.map((b) => b[2])),
+                    Math.max(...boxes.map((b) => b[3])),
+                ],
+                lines: span,
+            };
+        }
+    }
+    return null;
+}

package/dist/markdown.d.ts

@@ -8,6 +8,12 @@ export interface Line {
     bold: boolean;
     /** Posición vertical relativa: 0 = pie de página, 1 = parte superior. */
     rel: number;
+    /**
+     * Caja de la línea normalizada 0–1 con origen arriba a la izquierda
+     * [x0, y0, x1, y1]: lo que necesita un visor para resaltar una cita sin
+     * saber nada de coordenadas PDF. Ausente en líneas que no vienen de un PDF.
+     */
+    bbox?: [number, number, number, number];
 }
 type Progress = (ratio: number) => void;
 /** Extrae las líneas de texto con tamaño y posición de un documento abierto. */

package/dist/markdown.js

@@ -23,7 +23,9 @@ export async function extractLines(pdf, onProgress) {
     for (let p = 1; p <= pdf.numPages; p++) {
         const page = await pdf.getPage(p);
         const content = await page.getTextContent();
-        const pageHeight = page.getViewport({ scale: 1 }).height || 792;
+        const viewport = page.getViewport({ scale: 1 });
+        const pageHeight = viewport.height || 792;
+        const pageWidth = viewport.width || 612;
         const styles = content.styles;
         const rows = new Map();
         for (const it of content.items) {
@@ -55,7 +57,17 @@ export async function extractLines(pdf, onProgress) {
                 continue;
             const size = Math.max(...row.map((r) => r.size));
             const bold = row.filter((r) => r.bold).reduce((s, r) => s + r.str.length, 0) > text.length * 0.6;
-            lines.push({ text, size, y, x: row[0].x, page: p, bold, rel: y / pageHeight });
+            const x0 = row[0].x;
+            const x1 = Math.max(...row.map((r) => r.x + r.w));
+            const r4 = (n) => Math.round(Math.min(1, Math.max(0, n)) * 10000) / 10000;
+            // y es la línea base: la caja sube un cuerpo de letra y baja lo que ocupan los descendentes.
+            const bbox = [
+                r4(x0 / pageWidth),
+                r4(1 - (y + size * 0.9) / pageHeight),
+                r4(x1 / pageWidth),
+                r4(1 - (y - size * 0.25) / pageHeight),
+            ];
+            lines.push({ text, size, y, x: x0, page: p, bold, rel: y / pageHeight, bbox });
         }
         page.cleanup();
         onProgress?.(p / pdf.numPages);

package/dist/segment.d.ts

@@ -0,0 +1,10 @@
+import { type DocType } from "./classify.js";
+export interface Segment {
+    /** Páginas base 1, inclusivas. */
+    from: number;
+    to: number;
+    type: DocType;
+    /** Por qué empieza aquí un documento nuevo (vacío en el primero). */
+    reasons: string[];
+}
+export declare function segmentPages(pages: string[]): Segment[];

package/dist/segment.js

@@ -0,0 +1,46 @@
+// Separar un PDF que en realidad son varios documentos pegados: el lote que
+// sale del escáner de la recepción, un expediente con factura + historia +
+// autorización. Sin modelo: se buscan los cortes que una persona vería.
+import { classifyDocument } from "./classify.js";
+/** «Página 1 de 5», «Pág. 1/3», «Page 1 of 2», «1 de 4» al pie. */
+const FIRST_PAGE = /\b(?:p[aá]g(?:ina)?\.?|page)\s*1\s*(?:de|of|\/)\s*\d+\b/i;
+const OTHER_PAGE = /\b(?:p[aá]g(?:ina)?\.?|page)\s*([2-9]|\d{2,})\s*(?:de|of|\/)\s*\d+\b/i;
+/** Encabezados con los que suele abrir un documento. */
+const OPENING = /^(?:#+\s*)?(factura(?:\s+electr[oó]nica)?(?:\s+de\s+venta)?|historia\s+cl[ií]nica|epicrisis|certificado|certifica(?:ci[oó]n)?|contrato\s+de|registro\s+[uú]nico\s+tributario|extracto|autorizaci[oó]n|orden\s+m[eé]dica|f[oó]rmula\s+m[eé]dica|acta\s+de|poder\s+especial|constancia|cuenta\s+de\s+cobro|resultados?\s+de\s+laboratorio)\b/im;
+export function segmentPages(pages) {
+    if (!pages.length)
+        return [];
+    const kinds = pages.map((t) => classifyDocument(t));
+    const segments = [];
+    let current = { from: 1, to: 1, type: kinds[0].type, reasons: [] };
+    for (let i = 1; i < pages.length; i++) {
+        const text = pages[i];
+        const head = text.split("\n").slice(0, 8).join("\n");
+        const reasons = [];
+        const prevType = current.type;
+        const k = kinds[i];
+        if (FIRST_PAGE.test(text))
+            reasons.push("numeración reinicia en «página 1»");
+        if (OPENING.test(head))
+            reasons.push(`abre con «${head.match(OPENING)[1]}»`);
+        // Un cambio de tipo solo cuenta con señales fuertes en ambos lados: una
+        // página de anexos sin palabras clave no debe partir un contrato.
+        if (k.type !== "desconocido" && prevType !== "desconocido" && k.type !== prevType && k.confidence >= 0.6) {
+            reasons.push(`cambia de ${prevType} a ${k.type}`);
+        }
+        // «Página 3 de 5» contradice un corte: sigue el mismo documento.
+        const continues = OTHER_PAGE.test(text) && !FIRST_PAGE.test(text);
+        const cut = !continues && (reasons.length >= 2 || reasons.some((r) => r.startsWith("numeración")));
+        if (cut) {
+            segments.push(current);
+            current = { from: i + 1, to: i + 1, type: k.type, reasons };
+        }
+        else {
+            current.to = i + 1;
+            if (current.type === "desconocido" && k.type !== "desconocido")
+                current.type = k.type;
+        }
+    }
+    segments.push(current);
+    return segments;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sirdaspdf/core",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Sırdaş core: PDF operations, PDF→Markdown for AI and local PII anonymization. Runs in the browser and in Node; files never leave the machine.",
   "keywords": [
     "pdf",
@@ -14,7 +14,7 @@
     "fine-tuning",
     "deduplication"
   ],
-  "homepage": "https://sirdas.app",
+  "homepage": "https://www.sirdaspdf.com",
   "bugs": {
     "url": "https://github.com/Brayan15p/SIRDAS-APP-PDF/issues"
   },
@@ -55,6 +55,7 @@
     "prepublishOnly": "npm run test"
   },
   "dependencies": {
+    "fflate": "0.8.3",
     "pdf-lib": "1.17.1"
   },
   "peerDependencies": {