@sirdaspdf/core 0.1.0 → 0.2.0

package/dist/agentchunks.d.ts

@@ -0,0 +1,18 @@
+export interface AgentChunk {
+    /** Hash del contenido: el mismo texto da el mismo id en cualquier máquina. */
+    id: string;
+    index: number;
+    /** Primera y última página de las que sale el texto (base 1), o null si el Markdown no traía marcas. */
+    pages: [number, number] | null;
+    /** Ruta de encabezados, del más general al más concreto. */
+    section: string[];
+    text: string;
+    tokens: number;
+}
+/** Dos semillas: 64 bits de identificador bastan para no chocar en un corpus. */
+export declare function contentId(text: string): string;
+/**
+ * Parte Markdown (idealmente generado con `pageMarkers: true`) en trozos con
+ * procedencia. Las marcas de página se usan y se retiran del texto final.
+ */
+export declare function chunkForAgents(markdown: string, maxTokens?: number): AgentChunk[];

package/dist/agentchunks.js

@@ -0,0 +1,85 @@
+// Trozos para agentes: lo mismo que chunkMarkdown, más lo que un agente
+// necesita para citar y deduplicar sin volver a leer el PDF: de qué páginas
+// sale cada trozo, en qué sección cae y un identificador estable.
+import { chunkMarkdown } from "./chunk.js";
+import { estimateTokens, PAGE_MARKER } from "./markdown.js";
+const HEADING = /^(#{1,6})\s+(.+)$/;
+/** FNV-1a de 32 bits. Sin node:crypto, para que core siga cargando en el navegador. */
+function fnv1a(text, seed) {
+    let h = seed >>> 0;
+    for (let i = 0; i < text.length; i++) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return h.toString(16).padStart(8, "0");
+}
+/** Dos semillas: 64 bits de identificador bastan para no chocar en un corpus. */
+export function contentId(text) {
+    return `fnv1a:${fnv1a(text, 0x811c9dc5)}${fnv1a(text, 0x050c5d1f)}`;
+}
+/** Ruta completa de cada encabezado, en el orden en que aparece. */
+function headingPaths(markdown) {
+    const paths = new Map();
+    const stack = [];
+    for (const line of markdown.split("\n")) {
+        const m = line.match(HEADING);
+        if (!m)
+            continue;
+        const level = m[1].length;
+        while (stack.length && stack[stack.length - 1].level >= level)
+            stack.pop();
+        stack.push({ level, text: m[2].trim() });
+        if (!paths.has(m[2].trim()))
+            paths.set(m[2].trim(), stack.map((s) => s.text));
+    }
+    return paths;
+}
+const stripMarkers = (text) => text
+    .split("\n")
+    .filter((l) => !PAGE_MARKER.test(l.trim()))
+    .join("\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+/**
+ * Parte Markdown (idealmente generado con `pageMarkers: true`) en trozos con
+ * procedencia. Las marcas de página se usan y se retiran del texto final.
+ */
+export function chunkForAgents(markdown, maxTokens = 2000) {
+    const hasMarkers = markdown.split("\n").some((l) => PAGE_MARKER.test(l.trim()));
+    const paths = headingPaths(markdown);
+    // El texto va en orden, así que la página vigente al empezar un trozo es la
+    // última marca vista en los trozos anteriores.
+    let current = 1;
+    const out = [];
+    for (const c of chunkMarkdown(markdown, maxTokens)) {
+        const lines = c.text.split("\n");
+        let first = null;
+        let last = current;
+        for (const line of lines) {
+            const m = line.trim().match(PAGE_MARKER);
+            if (m) {
+                current = Number(m[1]);
+                continue;
+            }
+            // Una marca al final del trozo pertenece al siguiente: solo cuenta la
+            // página si hay texto real después de ella.
+            if (line.trim() && !HEADING.test(line)) {
+                if (first === null)
+                    first = current;
+                last = current;
+            }
+        }
+        const text = stripMarkers(c.text);
+        if (!text)
+            continue;
+        out.push({
+            id: contentId(text),
+            index: out.length + 1,
+            pages: hasMarkers ? [first ?? current, Math.max(first ?? current, last)] : null,
+            section: c.heading ? (paths.get(c.heading) ?? [c.heading]) : [],
+            text,
+            tokens: estimateTokens(text),
+        });
+    }
+    return out;
+}

package/dist/anonymize.js

@@ -3,20 +3,52 @@ const MONTHS = "enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|set
 // se filtra. Cubrimos las partículas españolas ("de", "del", "de la/las/los")
 // y hasta siete palabras, que es lo que llega a tener un nombre compuesto
 // colombiano con dos apellidos.
-const PARTICLE = "(?:de\\s+(?:la|las|los)\\s+|del\\s+|de\\s+)?";
-const NAME = `[A-ZÁÉÍÓÚÑ][a-záéíóúñü]+(?:\\s+${PARTICLE}[A-ZÁÉÍÓÚÑ][a-záéíóúñü]+){1,6}`;
-const NAME_UPPER = "[A-ZÁÉÍÓÚÑ]{2,}(?:\\s+[A-ZÁÉÍÓÚÑ]{2,}){1,6}";
+// Los espacios dentro de un nombre son de la MISMA línea. Con \s+ el patrón
+// cruzaba el salto y «Paciente: Juan Carlos Perez Gomez» seguido de «Cedula de
+// ciudadania…» capturaba «…Perez Gomez Cedula» como un solo nombre, dejando la
+// palabra suelta sustituida en medio de la frase siguiente. Un párrafo ya llega
+// con sus líneas unidas, así que no se pierde ningún nombre real por esto.
+const SP = "[ \\t]+";
+const PARTICLE = `(?:de${SP}(?:la|las|los)${SP}|del${SP}|de${SP})?`;
+const NAME = `[A-ZÁÉÍÓÚÑ][a-záéíóúñü]+(?:${SP}${PARTICLE}[A-ZÁÉÍÓÚÑ][a-záéíóúñü]+){1,6}`;
+const NAME_UPPER = `[A-ZÁÉÍÓÚÑ]{2,}(?:${SP}[A-ZÁÉÍÓÚÑ]{2,}){1,6}`;
 /** Vuelve insensible a mayúsculas solo las etiquetas (el nombre sí distingue mayúsculas). */
 const ci = (src) => src.replace(/[a-záéíóúñ]/g, (ch) => `[${ch}${ch.toUpperCase()}]`);
 const NAME_LABELS = "nombres?(?:\\s+completo)?|paciente|usuario|afiliado|señora?|sr\\.|sra\\.|don|doña|comprador(?:a)?|vendedor(?:a)?|otorgante|compareciente|demandante|demandado|arrendador(?:a)?|arrendatario|apoderad[oa]|titular|firmado por|name|patient|client|signed by";
+/** Algoritmo de Luhn: todas las tarjetas lo cumplen; la mayoría de números al azar, no. */
+function luhn(value) {
+    const d = value.replace(/\D/g, "");
+    if (d.length < 13 || d.length > 19)
+        return false;
+    let sum = 0;
+    for (let i = 0; i < d.length; i++) {
+        let n = Number(d[d.length - 1 - i]);
+        if (i % 2)
+            n = n * 2 > 9 ? n * 2 - 9 : n * 2;
+        sum += n;
+    }
+    return sum % 10 === 0;
+}
+/** Números largos de documentos comerciales que no son tarjetas aunque pasen Luhn (1 de cada 10 lo hace por azar). */
+const NOT_A_CARD = /(resoluci[oó]n|cufe|cude|autorizaci[oó]n|radicado|factura|consecutivo|orden|pedido|gu[ií]a|referencia|c[oó]digo|matr[ií]cula|expediente)[^\n]{0,30}$/i;
 const RULES = [
     { type: "EMAIL", re: /[\w.+-]+@[\w-]+(?:\.[\w-]+)+/g },
-    { type: "HISTORIA_CLINICA", re: /\b(?:historia\s+cl[ií]nica|h\.?\s?c\.?|n[uú]mero\s+de\s+historia)\s*(?:n[oº°.]*|#|:)?\s*([A-Z0-9-]{4,})/gi, group: 1 },
+    // El separador NO puede cruzar una línea en blanco, y el número tiene que
+    // llevar al menos un dígito. Sin las dos condiciones, un título «Historia
+    // clínica» seguido de «Paciente: Fulano» capturaba la palabra «Paciente»
+    // como si fuera el número de historia, la sustituía en todo el documento y
+    // con eso rompía el patrón «Paciente: nombre»: el nombre quedaba a la vista.
+    {
+        type: "HISTORIA_CLINICA",
+        re: /\b(?:historia\s+cl[ií]nica|h\.?\s?c\.?|n[uú]mero\s+de\s+historia)[ \t]*(?:n[oº°.]*|#|:)?[ \t]*((?=[A-Z0-9-]*\d)[A-Z0-9-]{4,})/gi,
+        group: 1,
+    },
     { type: "NIT", re: /\b(?:NIT\.?\s*:?\s*)?\d{3}\.?\d{3}\.?\d{3}\s?-\s?\d\b/g },
-    { type: "TARJETA", re: /\b(?:\d{4}[ -]?){3}\d{1,4}\b/g },
+    { type: "TARJETA", re: /\b(?:\d{4}[ -]?){3}\d{1,4}\b/g, accept: (v, before) => luhn(v) && !NOT_A_CARD.test(before) },
     {
         type: "DOCUMENTO",
-        re: /\b(?:C\.?\s?C\.?|c[eé]dula(?:\s+de\s+ciudadan[ií]a)?|T\.?\s?I\.?|C\.?\s?E\.?|NUIP|pasaporte|DNI|RUT|CURP|RFC|ID)\s*(?:n[oº°.]*|#|:)?\s*([A-Z]{0,4}\d[\d.\s-]{4,14}\d)/gi,
+        // Mismo motivo que arriba: la etiqueta y el número van en la misma línea.
+        re: /\b(?:C\.?\s?C\.?|c[eé]dula(?:\s+de\s+ciudadan[ií]a)?|T\.?\s?I\.?|C\.?\s?E\.?|NUIP|pasaporte|DNI|RUT|CURP|RFC|ID)[ \t]*(?:n[oº°.]*|#|:)?[ \t]*([A-Z]{0,4}\d[\d.\s-]{4,14}\d)/gi,
         group: 1,
     },
     { type: "DOCUMENTO", re: /(?<![$€£\d.,]\s?)\b\d{1,3}(?:\.\d{3}){2,3}\b(?!\s*(?:pesos|cop|usd|millones|m²|m2))/gi },
@@ -36,7 +68,14 @@ const RULES = [
         type: "DIRECCION",
         re: /\b(?:calle|cll?|carrera|cra|kr|kra|avenida|av|transversal|tv|diagonal|dg|autopista|street|st|avenue|ave)\.?\s*\d+[a-z]?(?:\s*bis)?(?:\s*(?:sur|norte|este))?\s*(?:#|n[oº°.]*|no\.?)\s*\d+[a-z]?\s*-\s*\d+(?:\s*(?:sur|norte|este))?(?:[,\s]+(?:apto|apartamento|oficina|of|int|interior|casa|torre)\.?\s*[\w-]+)*/gi,
     },
-    { type: "NOMBRE", re: new RegExp(`(?:${ci(NAME_LABELS)})\\s*[:\\-]?\\s*(${NAME_UPPER}|${NAME})(?![a-záéíóúñ])`, "g"), group: 1 },
+    // Se admite un único salto de línea entre la etiqueta y el nombre («Paciente:»
+    // al final de una línea y el nombre en la siguiente), pero no una línea en
+    // blanco: eso ya es otro párrafo y capturarlo produce falsos positivos.
+    {
+        type: "NOMBRE",
+        re: new RegExp(`(?:${ci(NAME_LABELS)})[ \\t]*[:\\-]?[ \\t]*(?:\\r?\\n[ \\t]*)?(${NAME_UPPER}|${NAME})(?![a-záéíóúñ])`, "g"),
+        group: 1,
+    },
 ];
 export function anonymize(text) {
     const map = new Map();
@@ -61,6 +100,15 @@ export function anonymize(text) {
             const target = rule.group ? args[rule.group] : full;
             if (!target || target.startsWith("["))
                 return full;
+            if (rule.accept) {
+                // Firma de replace: (coincidencia, ...grupos, offset, cadena[, grupos con nombre]).
+                const named = typeof args[args.length - 1] === "object";
+                const offset = args[args.length - (named ? 3 : 2)];
+                const source = args[args.length - (named ? 2 : 1)];
+                const before = source.slice(source.lastIndexOf("\n", offset) + 1, offset);
+                if (!rule.accept(target, before))
+                    return full;
+            }
             if (rule.type === "NOMBRE" && /\[/.test(target))
                 return full;
             const label = labelFor(rule.type, target);

package/dist/classify.d.ts

@@ -0,0 +1,12 @@
+export type DocType = "factura" | "contrato" | "historia_clinica" | "cedula" | "rut" | "extracto_bancario" | "certificado" | "hoja_de_vida" | "desconocido";
+export interface Classification {
+    type: DocType;
+    /** 0–1. Proporción de señales del ganador frente al total; no es una probabilidad calibrada. */
+    confidence: number;
+    /** Señales encontradas, para que un humano pueda comprobar por qué. */
+    signals: string[];
+    /** Segundo candidato, útil cuando la confianza es baja. */
+    runnerUp: DocType | null;
+}
+/** Clasifica por el texto (basta con las primeras páginas). */
+export declare function classifyDocument(text: string): Classification;

package/dist/classify.js

@@ -0,0 +1,89 @@
+// Tipo de documento por reglas, sin modelo: un agente decide qué hacer con un
+// PDF (qué campos buscar, si anonimizar) antes de leerlo entero, y el contenido
+// nunca sale de la máquina para averiguarlo.
+const RULES = {
+    factura: [
+        [/factura\s+(electr[oó]nica\s+)?de\s+venta/i, 4],
+        [/\bcufe\b/i, 4],
+        [/\binvoice\b/i, 3],
+        [/\biva\b/i, 1],
+        [/subtotal/i, 2],
+        [/total\s+a\s+pagar/i, 2],
+        [/resoluci[oó]n\s+dian/i, 3],
+    ],
+    contrato: [
+        [/\bcontrato\s+de\b/i, 4],
+        [/cl[aá]usula\s+(primera|segunda|tercera|\d+)/i, 3],
+        [/\bel\s+contratante\b|\bel\s+contratista\b/i, 3],
+        [/\bpartes\b.*\bacuerdan\b/is, 2],
+        [/\bagreement\b|\bwhereas\b/i, 3],
+        [/en\s+constancia\s+se\s+firma/i, 2],
+    ],
+    historia_clinica: [
+        [/historia\s+cl[ií]nica/i, 4],
+        [/\bepicrisis\b/i, 4],
+        [/motivo\s+de\s+consulta/i, 3],
+        [/\bdiagn[oó]stico\b/i, 2],
+        [/\bcie-?10\b/i, 3],
+        [/signos\s+vitales|tensi[oó]n\s+arterial/i, 2],
+    ],
+    cedula: [
+        [/c[eé]dula\s+de\s+ciudadan[ií]a/i, 4],
+        [/registradur[ií]a\s+nacional/i, 4],
+        [/fecha\s+y\s+lugar\s+de\s+nacimiento/i, 2],
+        [/\bgrupo\s+sangu[ií]neo\b|\bG\.?S\.?\s*RH\b/i, 2],
+    ],
+    rut: [
+        [/registro\s+[uú]nico\s+tributario/i, 5],
+        [/formulario\s+del\s+registro/i, 2],
+        [/responsabilidades,?\s+calidades/i, 3],
+        [/direcci[oó]n\s+seccional/i, 2],
+    ],
+    extracto_bancario: [
+        [/extracto/i, 3],
+        [/saldo\s+(anterior|final|disponible)/i, 3],
+        [/movimientos/i, 2],
+        [/\bbank\s+statement\b/i, 4],
+        [/n[uú]mero\s+de\s+cuenta/i, 1],
+    ],
+    certificado: [
+        [/\bcertifica(do)?\b/i, 2],
+        [/hace\s+constar/i, 3],
+        [/certificado\s+de\s+(existencia|tradici[oó]n|ingresos|retenci[oó]n)/i, 4],
+    ],
+    hoja_de_vida: [
+        [/hoja\s+de\s+vida|curr[ií]culum/i, 4],
+        [/experiencia\s+(laboral|profesional)/i, 3],
+        [/formaci[oó]n\s+acad[eé]mica|educaci[oó]n/i, 2],
+        [/referencias\s+(personales|laborales)/i, 2],
+    ],
+};
+/** Clasifica por el texto (basta con las primeras páginas). */
+export function classifyDocument(text) {
+    const sample = text.slice(0, 20000);
+    const scores = [];
+    for (const [type, rules] of Object.entries(RULES)) {
+        let score = 0;
+        const signals = [];
+        for (const [re, weight] of rules) {
+            const m = sample.match(re);
+            if (m) {
+                score += weight;
+                signals.push(m[0].replace(/\s+/g, " ").trim().slice(0, 40));
+            }
+        }
+        scores.push({ type, score, signals });
+    }
+    scores.sort((a, b) => b.score - a.score);
+    const [best, second] = scores;
+    const total = scores.reduce((n, s) => n + s.score, 0);
+    // Por debajo de 3 puntos es una palabra suelta, no un documento de ese tipo.
+    if (best.score < 3)
+        return { type: "desconocido", confidence: 0, signals: [], runnerUp: best.score ? best.type : null };
+    return {
+        type: best.type,
+        confidence: Math.round((best.score / total) * 100) / 100,
+        signals: best.signals,
+        runnerUp: second.score ? second.type : null,
+    };
+}

package/dist/extract.d.ts

@@ -0,0 +1,16 @@
+import type { DocType } from "./classify.js";
+export interface ExtractedField {
+    /** Nombre estable en snake_case, pensado para JSON y hojas de cálculo. */
+    name: string;
+    value: string;
+    /** Página (base 1) donde apareció, si el Markdown traía marcas de página. */
+    page: number | null;
+    /** El fragmento que casó la regla: la cita para que una persona lo verifique. */
+    evidence: string;
+    /** Dato de una persona: se sustituye si se pide anonimizar. */
+    personal: boolean;
+}
+/** Tipos para los que hay reglas: el resto devuelve lista vacía, no un error. */
+export declare const EXTRACTABLE_TYPES: DocType[];
+/** Extrae los campos de un tipo. Mejor con Markdown generado con `pageMarkers: true`, para citar la página. */
+export declare function extractFields(markdown: string, type: DocType): ExtractedField[];

package/dist/extract.js

@@ -0,0 +1,103 @@
+import { PAGE_MARKER } from "./markdown.js";
+const money = (v) => v.replace(/[\s$]/g, "");
+const digits = (v) => v.replace(/[^\dkK-]/g, "");
+const AMOUNT = String.raw `\$?\s*([\d]{1,3}(?:[.,\s]\d{3})*(?:[.,]\d{1,2})?)`;
+const DATE = String.raw `(\d{1,2}[/-]\d{1,2}[/-]\d{2,4}|\d{4}-\d{2}-\d{2}|\d{1,2}\s+de\s+[a-záéíóú]+\s+de\s+\d{4})`;
+const NIT = String.raw `(\d{3}\.?\d{3}\.?\d{3}\s*-?\s*\d)`;
+const RULES = {
+    factura: [
+        { name: "numero_factura", re: /factura[^\n]{0,40}?(?:n[oº°.]*|número|numero)\s*[:.]?\s*([A-Z]{0,6}-?\d{1,12})/i },
+        { name: "cufe", re: /\bcufe\s*[:.]?\s*([0-9a-f]{8,128})/i },
+        { name: "nit_emisor", re: new RegExp(String.raw `nit[^\n\d]{0,20}` + NIT, "i"), clean: digits },
+        { name: "fecha_emision", re: new RegExp(String.raw `fecha(?:\s+de)?\s*(?:emisi[oó]n|expedici[oó]n|factura)?\s*[:.]?\s*` + DATE, "i") },
+        { name: "fecha_vencimiento", re: new RegExp(String.raw `vencimiento\s*[:.]?\s*` + DATE, "i") },
+        { name: "subtotal", re: new RegExp(String.raw `subtotal\s*[:.]?\s*` + AMOUNT, "i"), clean: money },
+        { name: "iva", re: new RegExp(String.raw `\biva\b(?:\s*\d{1,2}\s*%)?\s*[:.]?\s*` + AMOUNT, "i"), clean: money },
+        // «Subtotal» también contiene «total»: se exige que no vaya pegado a otra palabra.
+        { name: "total", re: new RegExp(String.raw `(?<![a-záéíóú])total\s*(?:a\s+pagar|factura|general)?\s*[:.]?\s*` + AMOUNT, "i"), clean: money },
+        { name: "resolucion_dian", re: /resoluci[oó]n(?:\s+dian)?\s*(?:n[oº°.]*)?\s*[:.]?\s*(\d{8,20})/i },
+    ],
+    rut: [
+        { name: "nit", re: new RegExp(String.raw `(?:n[uú]mero\s+de\s+identificaci[oó]n\s+tributaria|\bnit\b)[^\n\d]{0,30}` + NIT, "i"), clean: digits },
+        { name: "razon_social", re: /raz[oó]n\s+social\s*[:.]?\s*([^\n]{3,80})/i },
+        { name: "direccion_seccional", re: /direcci[oó]n\s+seccional\s*[:.]?\s*([^\n]{3,60})/i },
+        { name: "actividad_principal", re: /actividad\s+principal\s*[:.]?\s*(\d{4})/i },
+    ],
+    cedula: [
+        { name: "numero_documento", re: /(?:n[uú]mero|c\.?\s?c\.?|c[eé]dula(?:\s+de\s+ciudadan[ií]a)?)\s*[:.]?\s*(\d{1,3}(?:\.\d{3}){1,3}|\d{6,10})\b/i, personal: true, clean: digits },
+        { name: "fecha_nacimiento", re: new RegExp(String.raw `fecha\s+de\s+nacimiento\s*[:.]?\s*` + DATE, "i"), personal: true },
+        { name: "fecha_expedicion", re: new RegExp(String.raw `fecha\s+(?:y\s+lugar\s+)?de\s+expedici[oó]n\s*[:.]?\s*` + DATE, "i") },
+    ],
+    historia_clinica: [
+        { name: "paciente", re: /[Pp]aciente\s*[:.]?\s*([A-ZÁÉÍÓÚÑ][a-záéíóúñ]+(?:[ \t]+[A-ZÁÉÍÓÚÑ][a-záéíóúñ]+){1,4})/, personal: true },
+        { name: "documento_paciente", re: /(?:c\.?\s?c\.?|documento|identificaci[oó]n)\s*[:.]?\s*(\d{1,3}(?:\.\d{3}){1,3}|\d{6,10})\b/i, personal: true, clean: digits },
+        { name: "fecha_atencion", re: new RegExp(String.raw `fecha(?:\s+de)?\s*(?:atenci[oó]n|ingreso|consulta)?\s*[:.]?\s*` + DATE, "i") },
+        { name: "motivo_consulta", re: /motivo\s+de\s+consulta\s*[:.]?\s*([^\n]{3,160})/i },
+        { name: "diagnostico_cie10", re: /\b([A-TV-Z]\d{2}(?:\.?\d{1,2})?)\b(?=[^\n]{0,80}(?:diagn|cie|principal|relacionado)|\s*[-–:]\s*[A-ZÁÉÍÓÚ])/g, all: true },
+    ],
+    extracto_bancario: [
+        { name: "numero_cuenta", re: /(?:n[uú]mero\s+de\s+)?cuenta\s*(?:n[oº°.]*)?\s*[:.]?\s*([*\dX]{4,}[\d-]*)/i, personal: true },
+        { name: "periodo", re: new RegExp(String.raw `(?:periodo|per[ií]odo)\s*[:.]?\s*` + DATE + String.raw `(?:\s*(?:al|a|-)\s*)` + DATE, "i") },
+        { name: "saldo_anterior", re: new RegExp(String.raw `saldo\s+anterior\s*[:.]?\s*` + AMOUNT, "i"), clean: money },
+        { name: "saldo_final", re: new RegExp(String.raw `saldo\s+(?:final|actual|disponible|total)\s*[:.]?\s*` + AMOUNT, "i"), clean: money },
+    ],
+    contrato: [
+        { name: "tipo_contrato", re: /contrato\s+de\s+([a-záéíóúñ ]{4,60}?)(?:\s+(?:entre|n[oº°.]|celebrado|suscrito)|[\n.,])/i },
+        { name: "valor", re: new RegExp(String.raw `valor(?:\s+(?:total|del\s+contrato))?\s*[:.]?\s*(?:de\s+)?` + AMOUNT, "i"), clean: money },
+        { name: "plazo", re: /(?:plazo|duraci[oó]n|t[eé]rmino)(?:\s+de\s+ejecuci[oó]n)?\s*[:.]?\s*(?:de\s+)?(\d{1,3}\s*\(?[a-z ]*\)?\s*(?:d[ií]as|meses|años))/i },
+        { name: "fecha_firma", re: new RegExp(String.raw `(?:firma|suscribe|a\s+los)[^\n]{0,40}?` + DATE, "i") },
+    ],
+    certificado: [
+        { name: "entidad", re: /^([A-ZÁÉÍÓÚÑ][A-ZÁÉÍÓÚÑ .&]{5,80})$/m },
+        { name: "fecha_expedicion", re: new RegExp(String.raw `(?:expedid[oa]|fecha)[^\n]{0,30}?` + DATE, "i") },
+    ],
+};
+/** Página de una posición: la última marca `<!-- page N -->` antes de ella. */
+function pageAt(markdown, index) {
+    let page = null;
+    const re = new RegExp(PAGE_MARKER.source.replace("^", "").replace("$", ""), "g");
+    for (const m of markdown.matchAll(re)) {
+        if ((m.index ?? 0) > index)
+            break;
+        page = Number(m[1]);
+    }
+    return page;
+}
+function evidenceAround(text, index, length) {
+    const start = text.lastIndexOf("\n", index) + 1;
+    const endNl = text.indexOf("\n", index + length);
+    return text
+        .slice(start, endNl === -1 ? undefined : endNl)
+        .trim()
+        .slice(0, 160);
+}
+/** Tipos para los que hay reglas: el resto devuelve lista vacía, no un error. */
+export const EXTRACTABLE_TYPES = Object.keys(RULES);
+/** Extrae los campos de un tipo. Mejor con Markdown generado con `pageMarkers: true`, para citar la página. */
+export function extractFields(markdown, type) {
+    const rules = RULES[type] ?? [];
+    const out = [];
+    for (const rule of rules) {
+        const re = rule.all ? new RegExp(rule.re.source, rule.re.flags.includes("g") ? rule.re.flags : rule.re.flags + "g") : rule.re;
+        const matches = rule.all ? [...markdown.matchAll(re)] : [markdown.match(re)].filter((m) => !!m);
+        const seen = new Set();
+        for (const m of matches) {
+            const raw = (m[1] ?? "").trim();
+            if (!raw)
+                continue;
+            const value = rule.clean ? rule.clean(raw) : raw.replace(/\s+/g, " ");
+            if (seen.has(value))
+                continue;
+            seen.add(value);
+            const index = m.index ?? 0;
+            out.push({
+                name: rule.name,
+                value,
+                page: pageAt(markdown, index),
+                evidence: evidenceAround(markdown, index, m[0].length),
+                personal: !!rule.personal,
+            });
+        }
+    }
+    return out;
+}

package/dist/index.d.ts

@@ -17,3 +17,8 @@ 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";

package/dist/index.js

@@ -19,3 +19,8 @@ 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";

package/dist/markdown.d.ts

@@ -13,9 +13,17 @@ 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

@@ -86,8 +86,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 +105,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 +175,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sirdaspdf/core",
-  "version": "0.1.0",
+  "version": "0.2.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",
@@ -66,6 +66,7 @@
     }
   },
   "devDependencies": {
+    "@neslinesli93/qpdf-wasm": "0.3.0",
     "pdfjs-dist": "4.10.38",
     "typescript": "5.9.2"
   }