@sirdaspdf/core 0.1.0 → 0.3.0

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,14 +8,28 @@ 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. */
 export declare function extractLines(pdf: PDFDocumentProxy, onProgress?: Progress): Promise<Line[]>;
 /** Convierte líneas ya extraídas en Markdown (encabezados, listas, párrafos, campos). */
-export declare function linesToMarkdown(lines: Line[]): string;
+export interface MarkdownOptions {
+    /**
+     * Inserta `<!-- page N -->` donde empieza cada página. Invisible al renderizar,
+     * pero permite que los trozos sepan de qué página salen y el agente cite.
+     */
+    pageMarkers?: boolean;
+}
+export declare const PAGE_MARKER: RegExp;
+export declare function linesToMarkdown(lines: Line[], opts?: MarkdownOptions): string;
 /** Documento PDF.js abierto → Markdown. */
-export declare function pdfToMarkdown(pdf: PDFDocumentProxy, onProgress?: Progress): Promise<string>;
+export declare function pdfToMarkdown(pdf: PDFDocumentProxy, onProgress?: Progress, opts?: MarkdownOptions): Promise<string>;
 /** Estimación rápida de tokens (~4 caracteres por token). */
 export declare function estimateTokens(text: string): number;
 export {};

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);
@@ -86,8 +98,8 @@ function removeRepeated(lines, pages) {
         return true;
     });
 }
-/** Convierte líneas ya extraídas en Markdown (encabezados, listas, párrafos, campos). */
-export function linesToMarkdown(lines) {
+export const PAGE_MARKER = /^<!-- page (\d+) -->$/;
+export function linesToMarkdown(lines, opts = {}) {
     if (!lines.length)
         return "";
     const body = mode(lines.map((l) => l.size));
@@ -105,7 +117,14 @@ export function linesToMarkdown(lines) {
             out.push("");
         inKv = false;
     };
+    let markedPage = -1;
     for (const l of lines) {
+        if (opts.pageMarkers && l.page !== markedPage) {
+            flush();
+            closeKv();
+            out.push(`<!-- page ${l.page} -->`, "");
+            markedPage = l.page;
+        }
         const ratio = l.size / body;
         const short = l.text.length < 90 && !/[.,;:]$/.test(l.text);
         let heading = 0;
@@ -168,8 +187,8 @@ export function linesToMarkdown(lines) {
         .trim();
 }
 /** Documento PDF.js abierto → Markdown. */
-export async function pdfToMarkdown(pdf, onProgress) {
-    return linesToMarkdown(await extractLines(pdf, onProgress));
+export async function pdfToMarkdown(pdf, onProgress, opts) {
+    return linesToMarkdown(await extractLines(pdf, onProgress), opts);
 }
 /** Estimación rápida de tokens (~4 caracteres por token). */
 export function estimateTokens(text) {

package/dist/ocr.js

@@ -1,14 +1,40 @@
 /**
  * El alto de una caja varía según tenga tildes o letras con cola ("Hola" vs
- * "Hpqy"), así que agrupamos tamaños parecidos en cubos. Sin esto, el cálculo
- * de "tamaño de cuerpo" del Markdown vería decenas de tamaños distintos y no
- * distinguiría un encabezado de un párrafo.
+ * "Hpqy"), así que agrupamos tamaños parecidos en cubos.
  */
 const BUCKET = 2;
 const bucket = (n) => Math.max(BUCKET, Math.round(n / BUCKET) * BUCKET);
+/**
+ * Cuánto más alta que el cuerpo tiene que ser una línea para considerarla
+ * encabezado.
+ *
+ * El alto de una caja de OCR NO es el tamaño de la letra: es la envolvente de
+ * lo que se dibujó. En una página con todo el cuerpo al mismo tamaño, medimos
+ * 9,1 pt en "Cedula de ciudadania" y 12,0 pt en "Correo: juan.perez@…", solo
+ * porque la segunda tiene jota y arroba. Con un umbral bajo, cada línea con
+ * una cola se convertía en un «###», el documento salía troceado en secciones
+ * falsas y los párrafos se perdían.
+ *
+ * 1,35 es deliberadamente conservador: un encabezado sutil (1,15× el cuerpo)
+ * es indistinguible del ruido y se deja como párrafo. Perder un encabezado
+ * discreto molesta; inventar veinte destruye la estructura.
+ */
+const HEADING_RATIO = 1.35;
+/** Mediana: resiste que una línea suelta salga enorme o diminuta. */
+function median(values) {
+    if (values.length === 0)
+        return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = sorted.length >> 1;
+    return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
 /** Convierte las cajas de una página OCR en líneas del pipeline de Markdown. */
 export function ocrPageToLines({ page, heightPx, scale, boxes }) {
     const heightPt = heightPx / scale;
+    // El tamaño del cuerpo de ESTA página, no un valor absoluto: un escaneo a
+    // 150 dpi y otro a 300 tienen que producir el mismo Markdown.
+    const usable = boxes.filter((b) => b.text.trim() !== "");
+    const bodyPt = median(usable.map((b) => (b.y1 - b.y0) / scale));
     const lines = [];
     for (const b of boxes) {
         const text = b.text.replace(/\s+/g, " ").trim();
@@ -17,9 +43,13 @@ export function ocrPageToLines({ page, heightPx, scale, boxes }) {
         // PDF mide la y desde abajo; el OCR desde arriba. Invertimos para que el
         // resto del pipeline (saltos de bloque, encabezados/pies) funcione igual.
         const y = (heightPx - b.y1) / scale;
+        // Todo lo que no sea claramente más alto que el cuerpo SE IGUALA al cuerpo.
+        // Si no, el ruido de las cajas decide los encabezados.
+        const raw = (b.y1 - b.y0) / scale;
+        const size = bodyPt > 0 && raw < bodyPt * HEADING_RATIO ? bucket(bodyPt) : bucket(raw);
         lines.push({
             text,
-            size: bucket((b.y1 - b.y0) / scale),
+            size,
             y,
             x: b.x0 / scale,
             page,

package/dist/pages.d.ts

@@ -0,0 +1,24 @@
+/** Quita las páginas indicadas (base 0). Negarse a vaciar el documento evita un PDF inválido. */
+export declare function deletePages(buf: ArrayBuffer, remove: number[]): Promise<Uint8Array>;
+/** Un PDF nuevo con solo esas páginas, en ese orden. */
+export declare function extractPages(buf: ArrayBuffer, indices: number[]): Promise<Uint8Array>;
+/** Gira páginas concretas (o todas si `indices` va vacío). */
+export declare function rotatePages(buf: ArrayBuffer, angle: 90 | 180 | 270, indices?: number[]): Promise<Uint8Array>;
+export type Corner = "bottom-center" | "bottom-right" | "bottom-left" | "top-center" | "top-right" | "top-left";
+export interface PageNumberOptions {
+    position?: Corner;
+    /** `{n}` es la página y `{total}` el total. */
+    format?: string;
+    startAt?: number;
+    fontSize?: number;
+    /** Saltar las N primeras páginas (portadas). */
+    skipFirst?: number;
+}
+export declare function addPageNumbers(buf: ArrayBuffer, opts?: PageNumberOptions): Promise<Uint8Array>;
+export interface WatermarkOptions {
+    opacity?: number;
+    fontSize?: number;
+    /** Diagonal por defecto, que es lo que se reconoce como marca de agua. */
+    angle?: number;
+}
+export declare function addWatermark(buf: ArrayBuffer, text: string, opts?: WatermarkOptions): Promise<Uint8Array>;

package/dist/pages.js

@@ -0,0 +1,92 @@
+// Operaciones de página que tienen todas las suites de la competencia: quitar,
+// extraer, girar, numerar y marca de agua. Todas con pdf-lib, en local.
+import { PDFDocument, StandardFonts, degrees, rgb } from "pdf-lib";
+async function copyOf(buf, indices) {
+    const src = await PDFDocument.load(buf);
+    const out = await PDFDocument.create();
+    for (const p of await out.copyPages(src, indices))
+        out.addPage(p);
+    return out.save({ useObjectStreams: true });
+}
+function assertIndices(indices, total) {
+    for (const i of indices) {
+        if (!Number.isInteger(i) || i < 0 || i >= total)
+            throw new Error(`Página fuera del documento: ${i + 1}`);
+    }
+}
+/** Quita las páginas indicadas (base 0). Negarse a vaciar el documento evita un PDF inválido. */
+export async function deletePages(buf, remove) {
+    const total = (await PDFDocument.load(buf)).getPageCount();
+    assertIndices(remove, total);
+    const drop = new Set(remove);
+    const keep = Array.from({ length: total }, (_, i) => i).filter((i) => !drop.has(i));
+    if (!keep.length)
+        throw new Error("No se pueden quitar todas las páginas: el PDF quedaría vacío.");
+    return copyOf(buf, keep);
+}
+/** Un PDF nuevo con solo esas páginas, en ese orden. */
+export async function extractPages(buf, indices) {
+    const total = (await PDFDocument.load(buf)).getPageCount();
+    assertIndices(indices, total);
+    if (!indices.length)
+        throw new Error("Indica al menos una página.");
+    return copyOf(buf, indices);
+}
+/** Gira páginas concretas (o todas si `indices` va vacío). */
+export async function rotatePages(buf, angle, indices = []) {
+    const doc = await PDFDocument.load(buf);
+    const pages = doc.getPages();
+    assertIndices(indices, pages.length);
+    const targets = indices.length ? indices : pages.map((_, i) => i);
+    for (const i of targets)
+        pages[i].setRotation(degrees((pages[i].getRotation().angle + angle) % 360));
+    return doc.save({ useObjectStreams: true });
+}
+/** Helvetica estándar solo codifica WinAnsi: mejor un error claro que un PDF corrupto. */
+function safeText(font, text) {
+    try {
+        font.encodeText(text);
+        return text;
+    }
+    catch {
+        throw new Error(`El texto «${text}» tiene caracteres que la fuente estándar del PDF no admite.`);
+    }
+}
+export async function addPageNumbers(buf, opts = {}) {
+    const { position = "bottom-center", format = "{n}", startAt = 1, fontSize = 10, skipFirst = 0 } = opts;
+    const doc = await PDFDocument.load(buf);
+    const font = await doc.embedFont(StandardFonts.Helvetica);
+    const pages = doc.getPages();
+    const numbered = pages.length - skipFirst;
+    pages.forEach((page, i) => {
+        if (i < skipFirst)
+            return;
+        const label = safeText(font, format.replace("{n}", String(i - skipFirst + startAt)).replace("{total}", String(numbered + startAt - 1)));
+        const { width, height } = page.getSize();
+        const w = font.widthOfTextAtSize(label, fontSize);
+        const margin = 28;
+        const x = position.endsWith("left") ? margin : position.endsWith("right") ? width - margin - w : (width - w) / 2;
+        const y = position.startsWith("top") ? height - margin : margin - fontSize / 2;
+        page.drawText(label, { x, y, size: fontSize, font, color: rgb(0.25, 0.25, 0.25) });
+    });
+    return doc.save({ useObjectStreams: true });
+}
+export async function addWatermark(buf, text, opts = {}) {
+    if (!text.trim())
+        throw new Error("La marca de agua necesita un texto.");
+    const { opacity = 0.15, angle = 45 } = opts;
+    const doc = await PDFDocument.load(buf);
+    const font = await doc.embedFont(StandardFonts.HelveticaBold);
+    const label = safeText(font, text.trim());
+    for (const page of doc.getPages()) {
+        const { width, height } = page.getSize();
+        const size = opts.fontSize ?? Math.min(96, (Math.hypot(width, height) * 0.7) / Math.max(label.length * 0.6, 1));
+        const w = font.widthOfTextAtSize(label, size);
+        const rad = (angle * Math.PI) / 180;
+        // Centrar el texto girado: se desplaza el origen media anchura sobre su propio eje.
+        const x = width / 2 - (Math.cos(rad) * w) / 2 + (Math.sin(rad) * size) / 3;
+        const y = height / 2 - (Math.sin(rad) * w) / 2 - (Math.cos(rad) * size) / 3;
+        page.drawText(label, { x, y, size, font, color: rgb(0.55, 0.1, 0.25), opacity, rotate: degrees(angle) });
+    }
+    return doc.save({ useObjectStreams: true });
+}

package/dist/security.d.ts

@@ -0,0 +1,40 @@
+/** Lo mínimo que usamos del módulo Emscripten de qpdf. */
+export interface QpdfModule {
+    FS: {
+        writeFile(path: string, data: Uint8Array): void;
+        readFile(path: string): Uint8Array;
+    };
+    callMain(args: string[]): number;
+}
+export type QpdfFactory = () => Promise<QpdfModule>;
+export type LockState = 
+/** Sin cifrado. */
+"none"
+/** Cifrado solo con contraseña de propietario: se abre, pero con permisos limitados (imprimir, copiar…). */
+ | "restricted"
+/** Hace falta contraseña para abrirlo. */
+ | "password";
+export declare class WrongPasswordError extends Error {
+    constructor();
+}
+export declare function lockState(factory: QpdfFactory, input: Uint8Array): Promise<LockState>;
+export interface ProtectOptions {
+    /** Contraseña para abrir. */
+    password: string;
+    /**
+     * Contraseña de propietario (para cambiar permisos). Si no se da, se genera
+     * una aleatoria: reutilizar la de apertura haría que cualquiera que abre el
+     * archivo pudiera también quitarle las restricciones.
+     */
+    ownerPassword?: string;
+    allowPrint?: boolean;
+    allowCopy?: boolean;
+    allowEdit?: boolean;
+}
+/** Cifra con AES-256, el estándar que abren Acrobat, Chrome, Preview y cualquier lector actual. */
+export declare function protectPdf(factory: QpdfFactory, input: Uint8Array, opts: ProtectOptions): Promise<Uint8Array>;
+/**
+ * Quita el cifrado. Sin contraseña funciona con los PDF «restringidos» (se
+ * abren pero no dejan copiar o imprimir), que son la mayoría de los casos.
+ */
+export declare function unlockPdf(factory: QpdfFactory, input: Uint8Array, password?: string): Promise<Uint8Array>;

package/dist/security.js

@@ -0,0 +1,100 @@
+// Poner y quitar contraseñas con qpdf compilado a WebAssembly. core no depende
+// de qpdf: quien llama inyecta el módulo, porque en el navegador el .wasm se
+// sirve desde nuestro propio origen y en Node se lee del disco. Así core sigue
+// cargando sin 1,3 MB que la mayoría de herramientas no necesita.
+import { PDFDocument } from "pdf-lib";
+export class WrongPasswordError extends Error {
+    constructor() {
+        super("Contraseña incorrecta.");
+        this.name = "WrongPasswordError";
+    }
+}
+const IN = "/in.pdf";
+const OUT = "/out.pdf";
+/** qpdf termina con `exit()`: Emscripten lo lanza como excepción con `status`. */
+function exitCode(q, args) {
+    try {
+        return q.callMain(args);
+    }
+    catch (e) {
+        const status = e.status;
+        if (typeof status === "number")
+            return status;
+        throw e;
+    }
+}
+async function run(factory, input, args) {
+    // Un módulo por operación: callMain deja estado global y reutilizarlo falla
+    // de forma intermitente en la segunda llamada.
+    const q = await factory();
+    q.FS.writeFile(IN, input);
+    const code = exitCode(q, args);
+    let output = null;
+    try {
+        output = q.FS.readFile(OUT);
+    }
+    catch {
+        output = null;
+    }
+    return { code, output };
+}
+export async function lockState(factory, input) {
+    // Esta build de qpdf sale con 2 tanto si el PDF no está cifrado como si pide
+    // una contraseña que no tiene, así que pdf-lib decide si hay cifrado y qpdf
+    // solo desempata: --requires-password da 3 cuando se abre sin contraseña.
+    try {
+        await PDFDocument.load(input, { updateMetadata: false });
+        return "none";
+    }
+    catch (e) {
+        // Por nombre y no con instanceof: en Node pueden convivir la copia CJS y la ESM de pdf-lib.
+        if (e.name !== "EncryptedPDFError" && !/is encrypted/.test(e.message))
+            throw e;
+    }
+    const { code } = await run(factory, input, ["--requires-password", IN]);
+    return code === 3 ? "restricted" : "password";
+}
+function randomSecret() {
+    const bytes = new Uint8Array(24);
+    globalThis.crypto.getRandomValues(bytes);
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+/** Cifra con AES-256, el estándar que abren Acrobat, Chrome, Preview y cualquier lector actual. */
+export async function protectPdf(factory, input, opts) {
+    if (!opts.password)
+        throw new Error("La contraseña no puede estar vacía.");
+    const { allowPrint = true, allowCopy = true, allowEdit = true } = opts;
+    const { code, output } = await run(factory, input, [
+        // Forma con nombre: una contraseña que empiece por «--» no se confunde con una opción.
+        "--encrypt",
+        `--user-password=${opts.password}`,
+        `--owner-password=${opts.ownerPassword || randomSecret()}`,
+        "--bits=256",
+        `--print=${allowPrint ? "full" : "none"}`,
+        `--extract=${allowCopy ? "y" : "n"}`,
+        `--modify=${allowEdit ? "all" : "none"}`,
+        "--",
+        IN,
+        OUT,
+    ]);
+    // 3 = terminó con avisos (PDF algo irregular) pero la salida es válida.
+    if ((code !== 0 && code !== 3) || !output) {
+        const state = await lockState(factory, input).catch(() => "none");
+        if (state !== "none")
+            throw new Error("Este PDF ya tiene contraseña. Quítala primero y vuelve a protegerlo.");
+        throw new Error("No se pudo cifrar el PDF.");
+    }
+    return output;
+}
+/**
+ * Quita el cifrado. Sin contraseña funciona con los PDF «restringidos» (se
+ * abren pero no dejan copiar o imprimir), que son la mayoría de los casos.
+ */
+export async function unlockPdf(factory, input, password = "") {
+    const { code, output } = await run(factory, input, [`--password=${password}`, "--decrypt", IN, OUT]);
+    if ((code === 0 || code === 3) && output)
+        return output;
+    if ((await lockState(factory, input)) === "password")
+        throw new WrongPasswordError();
+    throw new Error("No se pudo quitar la contraseña del PDF.");
+}

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.1.0",
+  "version": "0.3.0",
   "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",
@@ -55,6 +55,7 @@
     "prepublishOnly": "npm run test"
   },
   "dependencies": {
+    "fflate": "0.8.3",
     "pdf-lib": "1.17.1"
   },
   "peerDependencies": {
@@ -66,6 +67,7 @@
     }
   },
   "devDependencies": {
+    "@neslinesli93/qpdf-wasm": "0.3.0",
     "pdfjs-dist": "4.10.38",
     "typescript": "5.9.2"
   }