@sirdaspdf/core 0.1.0

package/dist/markdown.js

@@ -0,0 +1,177 @@
+const BULLET = /^\s*([•●▪◦‣∙·\-–*])\s+/;
+const NUMBERED = /^\s*(\d{1,3}|[a-zA-Z])[.)]\s+/;
+/** Líneas tipo formulario: "Paciente: …", "Fecha de ingreso: …". */
+const KEY_VALUE = /^([^:]{2,40}):\s+\S/;
+function isKeyValue(text) {
+    const m = text.match(KEY_VALUE);
+    return !!m && m[1].trim().split(/\s+/).length <= 7 && text.length < 160;
+}
+function mode(values) {
+    const counts = new Map();
+    for (const v of values)
+        counts.set(v, (counts.get(v) ?? 0) + 1);
+    let best = values[0] ?? 10;
+    let max = 0;
+    for (const [k, c] of counts)
+        if (c > max)
+            [best, max] = [k, c];
+    return best;
+}
+/** Extrae las líneas de texto con tamaño y posición de un documento abierto. */
+export async function extractLines(pdf, onProgress) {
+    const lines = [];
+    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 styles = content.styles;
+        const rows = new Map();
+        for (const it of content.items) {
+            if (!("str" in it) || !it.str)
+                continue;
+            const t = it.transform;
+            const size = Math.round(Math.hypot(t[2], t[3]) * 2) / 2 || Math.round(it.height);
+            const y = Math.round(t[5] / 2) * 2;
+            const font = `${it.fontName} ${styles[it.fontName]?.fontFamily ?? ""}`;
+            const bold = /bold|black|heavy|semibold/i.test(font);
+            const row = rows.get(y) ?? [];
+            row.push({ x: t[4], str: it.str, w: it.width, size, bold });
+            rows.set(y, row);
+        }
+        const ys = [...rows.keys()].sort((a, b) => b - a);
+        for (const y of ys) {
+            const row = rows.get(y).sort((a, b) => a.x - b.x);
+            let text = "";
+            let prevEnd = -Infinity;
+            for (const r of row) {
+                const gap = r.x - prevEnd;
+                if (text && gap > r.size * 0.15 && !text.endsWith(" ") && !r.str.startsWith(" "))
+                    text += " ";
+                text += r.str;
+                prevEnd = r.x + r.w;
+            }
+            text = text.replace(/\s+/g, " ").trim();
+            if (!text)
+                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 });
+        }
+        page.cleanup();
+        onProgress?.(p / pdf.numPages);
+    }
+    return removeRepeated(lines, pdf.numPages);
+}
+/** Quita encabezados/pies repetidos y números de página sueltos. */
+function removeRepeated(lines, pages) {
+    const norm = (s) => s.toLowerCase().replace(/\d+/g, "#");
+    const freq = new Map();
+    for (const l of lines) {
+        const k = norm(l.text);
+        if (k.length > 80)
+            continue;
+        const set = freq.get(k) ?? new Set();
+        set.add(l.page);
+        freq.set(k, set);
+    }
+    return lines.filter((l) => {
+        if (/^(p[aá]g(ina)?\.?\s*)?\d{1,4}(\s*(de|of|\/)\s*\d{1,4})?$/i.test(l.text))
+            return false;
+        const margin = l.rel < 0.1 || l.rel > 0.92;
+        if (pages >= 3 && margin) {
+            const s = freq.get(norm(l.text));
+            if (s && s.size >= Math.max(3, pages * 0.6))
+                return false;
+        }
+        return true;
+    });
+}
+/** Convierte líneas ya extraídas en Markdown (encabezados, listas, párrafos, campos). */
+export function linesToMarkdown(lines) {
+    if (!lines.length)
+        return "";
+    const body = mode(lines.map((l) => l.size));
+    const out = [];
+    let para = "";
+    let prev = null;
+    let inKv = false;
+    const flush = () => {
+        if (para)
+            out.push(para.trim(), "");
+        para = "";
+    };
+    const closeKv = () => {
+        if (inKv)
+            out.push("");
+        inKv = false;
+    };
+    for (const l of lines) {
+        const ratio = l.size / body;
+        const short = l.text.length < 90 && !/[.,;:]$/.test(l.text);
+        let heading = 0;
+        if (ratio >= 1.6)
+            heading = 1;
+        else if (ratio >= 1.3)
+            heading = 2;
+        else if ((ratio >= 1.12 || (l.bold && l.text.length < 70)) && short)
+            heading = 3;
+        if (!heading && isKeyValue(l.text)) {
+            flush();
+            out.push(`${l.text}  `);
+            inKv = true;
+            prev = l;
+            continue;
+        }
+        closeKv();
+        if (heading) {
+            flush();
+            out.push(`${"#".repeat(heading)} ${l.text}`, "");
+            prev = l;
+            continue;
+        }
+        if (BULLET.test(l.text)) {
+            flush();
+            out.push(`- ${l.text.replace(BULLET, "")}`);
+            prev = l;
+            continue;
+        }
+        if (NUMBERED.test(l.text) && l.text.length < 300) {
+            flush();
+            const m = l.text.match(NUMBERED);
+            out.push(`${/\d/.test(m[1]) ? m[1] : "-"}. ${l.text.replace(NUMBERED, "")}`.replace(/^-\. /, "- "));
+            prev = l;
+            continue;
+        }
+        const newBlock = !prev ||
+            prev.page !== l.page ||
+            Math.abs(prev.y - l.y) > l.size * 1.9 ||
+            Math.abs(prev.size - l.size) > 0.6;
+        const continuesList = out.length && /^(- |\d+\. )/.test(out[out.length - 1]) && !newBlock && !para;
+        if (continuesList) {
+            out[out.length - 1] += ` ${l.text}`;
+        }
+        else {
+            if (newBlock)
+                flush();
+            if (para.endsWith("-") && /^[a-záéíóúñ]/.test(l.text))
+                para = para.slice(0, -1) + l.text;
+            else
+                para += (para ? " " : "") + l.text;
+        }
+        prev = l;
+    }
+    flush();
+    closeKv();
+    return out
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+/** Documento PDF.js abierto → Markdown. */
+export async function pdfToMarkdown(pdf, onProgress) {
+    return linesToMarkdown(await extractLines(pdf, onProgress));
+}
+/** Estimación rápida de tokens (~4 caracteres por token). */
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}

package/dist/merge.d.ts

@@ -0,0 +1 @@
+export declare function mergePdfs(buffers: ArrayBuffer[]): Promise<Uint8Array>;

package/dist/merge.js

@@ -0,0 +1,10 @@
+import { PDFDocument } from "pdf-lib";
+export async function mergePdfs(buffers) {
+    const out = await PDFDocument.create();
+    for (const buf of buffers) {
+        const src = await PDFDocument.load(buf, { ignoreEncryption: false });
+        const pages = await out.copyPages(src, src.getPageIndices());
+        pages.forEach((p) => out.addPage(p));
+    }
+    return out.save({ useObjectStreams: true });
+}

package/dist/ocr.d.ts

@@ -0,0 +1,24 @@
+import type { Line } from "./markdown.js";
+/** Caja de una línea reconocida, en píxeles de la imagen (origen arriba-izquierda). */
+export interface OcrBox {
+    text: string;
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+export interface OcrPageInput {
+    /** Número de página, base 1. */
+    page: number;
+    /** Alto de la imagen rasterizada, en píxeles. */
+    heightPx: number;
+    /** Escala usada al rasterizar (1 = 72 dpi). Convierte píxeles a puntos PDF. */
+    scale: number;
+    boxes: OcrBox[];
+}
+/** Convierte las cajas de una página OCR en líneas del pipeline de Markdown. */
+export declare function ocrPageToLines({ page, heightPx, scale, boxes }: OcrPageInput): Line[];
+/** Une varias páginas OCR en una sola lista de líneas, en orden de lectura. */
+export declare function ocrPagesToLines(pages: OcrPageInput[]): Line[];
+/** ¿El texto extraído es tan pobre que conviene ofrecer OCR? */
+export declare function looksScanned(text: string, pageCount: number): boolean;

package/dist/ocr.js

@@ -0,0 +1,46 @@
+/**
+ * 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.
+ */
+const BUCKET = 2;
+const bucket = (n) => Math.max(BUCKET, Math.round(n / BUCKET) * BUCKET);
+/** 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;
+    const lines = [];
+    for (const b of boxes) {
+        const text = b.text.replace(/\s+/g, " ").trim();
+        if (!text)
+            continue;
+        // 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;
+        lines.push({
+            text,
+            size: bucket((b.y1 - b.y0) / scale),
+            y,
+            x: b.x0 / scale,
+            page,
+            // El OCR no distingue negritas de forma fiable: lo dejamos en falso y
+            // que el tamaño decida los encabezados.
+            bold: false,
+            rel: heightPt > 0 ? y / heightPt : 0,
+        });
+    }
+    return lines.sort((a, b) => b.y - a.y);
+}
+/** Une varias páginas OCR en una sola lista de líneas, en orden de lectura. */
+export function ocrPagesToLines(pages) {
+    return pages
+        .slice()
+        .sort((a, b) => a.page - b.page)
+        .flatMap(ocrPageToLines);
+}
+/** ¿El texto extraído es tan pobre que conviene ofrecer OCR? */
+export function looksScanned(text, pageCount) {
+    const clean = text.replace(/\s+/g, "");
+    // Menos de 40 caracteres útiles por página es, casi siempre, un escaneo.
+    return clean.length < Math.max(40, pageCount * 40);
+}

package/dist/organize.d.ts

@@ -0,0 +1,5 @@
+export interface PageEdit {
+    index: number;
+    rotation: number;
+}
+export declare function organizePdf(buf: ArrayBuffer, edits: PageEdit[]): Promise<Uint8Array>;

package/dist/organize.js

@@ -0,0 +1,13 @@
+import { PDFDocument, degrees } from "pdf-lib";
+export async function organizePdf(buf, edits) {
+    const src = await PDFDocument.load(buf);
+    const out = await PDFDocument.create();
+    const pages = await out.copyPages(src, edits.map((e) => e.index));
+    pages.forEach((p, i) => {
+        const extra = edits[i].rotation % 360;
+        if (extra)
+            p.setRotation(degrees((p.getRotation().angle + extra) % 360));
+        out.addPage(p);
+    });
+    return out.save({ useObjectStreams: true });
+}

package/dist/paragraphs.d.ts

@@ -0,0 +1,68 @@
+export interface ParagraphOptions {
+    /**
+     * Palabras mínimas para considerar un párrafo. Por debajo son títulos,
+     * números de página y firmas sueltas, que se repiten por naturaleza y
+     * quitarlos rompería la estructura del documento.
+     */
+    minWords?: number;
+    /** Apariciones a partir de las cuales se marca como repetido. */
+    minRepeats?: number;
+    /**
+     * Marcar solo lo que se repite en documentos distintos. Un párrafo repetido
+     * dentro de un mismo documento suele ser legítimo (una lista, un estribillo);
+     * el que sale en cinco archivos distintos es plantilla.
+     */
+    acrossDocumentsOnly?: boolean;
+}
+export interface RepeatedParagraph {
+    /** El texto tal y como apareció la primera vez. */
+    text: string;
+    /** Veces que aparece en todo el corpus. */
+    occurrences: number;
+    /** En cuántos documentos distintos. */
+    documents: number;
+    /** Nombres de esos documentos, hasta diez. */
+    examples: string[];
+    words: number;
+}
+export interface ParagraphReport {
+    repeated: RepeatedParagraph[];
+    /** Párrafos totales del corpus. */
+    total: number;
+    /** Párrafos que son una repetición (sin contar la primera aparición). */
+    redundant: number;
+    /** Fracción del texto, en palabras, que ocupan esas repeticiones. */
+    redundantWordRatio: number;
+}
+/**
+ * Normalización de CCNet: minúsculas, dígitos a cero, sin acentos y sin
+ * puntuación.
+ *
+ * Los dígitos van a cero para que «Factura 1042» y «Factura 1043» cuenten como
+ * el mismo párrafo de plantilla, que es justo lo que son. Es agresivo, y por
+ * eso el umbral de palabras mínimas existe: sobre textos cortos borraría
+ * distinciones reales.
+ */
+export declare function normalizeParagraph(text: string): string;
+/** Parte un documento en párrafos por línea en blanco. */
+export declare function splitParagraphs(markdown: string): string[];
+export interface ParagraphDocument {
+    name: string;
+    markdown: string;
+}
+/**
+ * Encuentra los párrafos repetidos en un corpus. No modifica nada: devuelve el
+ * informe para que quien lo lea decida.
+ */
+export declare function findRepeatedParagraphs(docs: ParagraphDocument[], options?: ParagraphOptions): ParagraphReport;
+/**
+ * Aplica el informe: devuelve los documentos sin las repeticiones, conservando
+ * siempre la primera aparición de cada párrafo.
+ *
+ * Es un paso aparte y explícito. El informe se puede leer y decidir; esto ya
+ * descarta contenido.
+ */
+export declare function stripRepeatedParagraphs(docs: ParagraphDocument[], options?: ParagraphOptions): {
+    documents: ParagraphDocument[];
+    removed: number;
+};

package/dist/paragraphs.js

@@ -0,0 +1,138 @@
+// Deduplicación exacta de párrafo, al estilo de CCNet.
+//
+// CCNet (arXiv:1911.00359) midió que los párrafos duplicados eran el 70 % del
+// texto de su corpus. En documentos de oficina el patrón es aún más nítido:
+// el encabezado con el membrete, el pie con «este documento es confidencial»,
+// la cláusula de tratamiento de datos que va idéntica en cada contrato. Eso se
+// aprende de memoria y no aporta nada.
+//
+// Su receta, que seguimos: normalizar el párrafo (minúsculas, dígitos a cero,
+// sin puntuación ni acentos), hashear, y quedarse con la primera aparición.
+// Cambiamos una cosa a propósito: CCNet usa los primeros 64 bits de SHA-1 y
+// aquí se usan dos FNV-1a de 32 bits con semillas distintas. Es síncrono, sin
+// dependencias y funciona igual en el navegador y en Node; la probabilidad de
+// colisión a esta escala es la misma en la práctica.
+//
+// Y una diferencia de diseño, no de algoritmo: esto **informa** antes de
+// borrar. Quitar contenido del corpus de alguien sin que lo vea es la clase de
+// cosa que este producto no hace.
+import { fnv1a } from "./text.js";
+const DEFAULTS = { minWords: 5, minRepeats: 2, acrossDocumentsOnly: true };
+/**
+ * Normalización de CCNet: minúsculas, dígitos a cero, sin acentos y sin
+ * puntuación.
+ *
+ * Los dígitos van a cero para que «Factura 1042» y «Factura 1043» cuenten como
+ * el mismo párrafo de plantilla, que es justo lo que son. Es agresivo, y por
+ * eso el umbral de palabras mínimas existe: sobre textos cortos borraría
+ * distinciones reales.
+ */
+export function normalizeParagraph(text) {
+    return text
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[̀-ͯ]/g, "")
+        .replace(/\d/g, "0")
+        .replace(/[^\p{L}\p{N}\s]/gu, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+/** Hash de 64 bits como dos mitades de 32, en hexadecimal. */
+function hash64(s) {
+    const a = fnv1a(s);
+    const b = fnv1a(`␟${s}`);
+    return a.toString(16).padStart(8, "0") + b.toString(16).padStart(8, "0");
+}
+/** Parte un documento en párrafos por línea en blanco. */
+export function splitParagraphs(markdown) {
+    return markdown
+        .split(/\n\s*\n/)
+        .map((p) => p.trim())
+        .filter((p) => p !== "");
+}
+const wordCount = (s) => (s === "" ? 0 : s.split(" ").length);
+/**
+ * Encuentra los párrafos repetidos en un corpus. No modifica nada: devuelve el
+ * informe para que quien lo lea decida.
+ */
+export function findRepeatedParagraphs(docs, options = {}) {
+    const { minWords, minRepeats, acrossDocumentsOnly } = { ...DEFAULTS, ...options };
+    const seen = new Map();
+    let total = 0;
+    let totalWords = 0;
+    for (const doc of docs) {
+        for (const raw of splitParagraphs(doc.markdown)) {
+            const normalized = normalizeParagraph(raw);
+            const words = wordCount(normalized);
+            total++;
+            totalWords += words;
+            if (words < minWords)
+                continue;
+            const key = hash64(normalized);
+            const entry = seen.get(key);
+            if (entry) {
+                entry.occurrences++;
+                entry.docs.add(doc.name);
+            }
+            else {
+                seen.set(key, { text: raw, occurrences: 1, docs: new Set([doc.name]), words });
+            }
+        }
+    }
+    const repeated = [];
+    let redundant = 0;
+    let redundantWords = 0;
+    for (const entry of seen.values()) {
+        if (entry.occurrences < minRepeats)
+            continue;
+        if (acrossDocumentsOnly && entry.docs.size < 2)
+            continue;
+        // La primera aparición se conserva: solo las siguientes son redundantes.
+        const extra = entry.occurrences - 1;
+        redundant += extra;
+        redundantWords += extra * entry.words;
+        repeated.push({
+            text: entry.text,
+            occurrences: entry.occurrences,
+            documents: entry.docs.size,
+            examples: [...entry.docs].slice(0, 10),
+            words: entry.words,
+        });
+    }
+    repeated.sort((a, b) => b.occurrences * b.words - a.occurrences * a.words);
+    return {
+        repeated,
+        total,
+        redundant,
+        redundantWordRatio: totalWords === 0 ? 0 : redundantWords / totalWords,
+    };
+}
+/**
+ * Aplica el informe: devuelve los documentos sin las repeticiones, conservando
+ * siempre la primera aparición de cada párrafo.
+ *
+ * Es un paso aparte y explícito. El informe se puede leer y decidir; esto ya
+ * descarta contenido.
+ */
+export function stripRepeatedParagraphs(docs, options = {}) {
+    const report = findRepeatedParagraphs(docs, options);
+    const targets = new Set(report.repeated.map((r) => hash64(normalizeParagraph(r.text))));
+    const kept = new Set();
+    let removed = 0;
+    const documents = docs.map((doc) => {
+        const out = [];
+        for (const raw of splitParagraphs(doc.markdown)) {
+            const key = hash64(normalizeParagraph(raw));
+            if (targets.has(key)) {
+                if (kept.has(key)) {
+                    removed++;
+                    continue;
+                }
+                kept.add(key);
+            }
+            out.push(raw);
+        }
+        return { name: doc.name, markdown: out.join("\n\n") };
+    });
+    return { documents, removed };
+}

package/dist/ranges.d.ts

@@ -0,0 +1,2 @@
+/** "1-3, 5, 8-10" -> grupos de índices base 0. Vacío = cada página por separado. */
+export declare function parseRanges(input: string, pageCount: number): number[][];

package/dist/ranges.js

@@ -0,0 +1,23 @@
+// Utilidad pura (sin dependencias pesadas) para interpretar rangos de páginas.
+// Vive aparte de split.ts para no arrastrar pdf-lib al bundle de la página.
+/** "1-3, 5, 8-10" -> grupos de índices base 0. Vacío = cada página por separado. */
+export function parseRanges(input, pageCount) {
+    const clean = input.trim();
+    if (!clean)
+        return Array.from({ length: pageCount }, (_, i) => [i]);
+    const groups = [];
+    for (const part of clean.split(/[,;]+/)) {
+        const p = part.trim();
+        if (!p)
+            continue;
+        const m = p.match(/^(\d+)\s*(?:-\s*(\d+|fin|end))?$/i);
+        if (!m)
+            throw new Error(`Rango inválido: ${p}`);
+        const start = Number(m[1]);
+        const end = m[2] ? (/^\d+$/.test(m[2]) ? Number(m[2]) : pageCount) : start;
+        if (start < 1 || end > pageCount || start > end)
+            throw new Error(`Rango fuera del documento: ${p}`);
+        groups.push(Array.from({ length: end - start + 1 }, (_, i) => start - 1 + i));
+    }
+    return groups;
+}

package/dist/split.d.ts

@@ -0,0 +1,3 @@
+export { parseRanges } from "./ranges.js";
+export declare function splitPdf(buf: ArrayBuffer, groups: number[][]): Promise<Uint8Array[]>;
+export declare function pageCount(buf: ArrayBuffer): Promise<number>;

package/dist/split.js

@@ -0,0 +1,17 @@
+import { PDFDocument } from "pdf-lib";
+export { parseRanges } from "./ranges.js";
+export async function splitPdf(buf, groups) {
+    const src = await PDFDocument.load(buf);
+    const results = [];
+    for (const g of groups) {
+        const out = await PDFDocument.create();
+        const pages = await out.copyPages(src, g);
+        pages.forEach((p) => out.addPage(p));
+        results.push(await out.save({ useObjectStreams: true }));
+    }
+    return results;
+}
+export async function pageCount(buf) {
+    const src = await PDFDocument.load(buf);
+    return src.getPageCount();
+}

package/dist/tables.d.ts

@@ -0,0 +1,44 @@
+import type { PDFDocumentProxy } from "pdfjs-dist";
+/** Un trozo de texto con su posición en la página, en puntos PDF. */
+export interface Cell {
+    text: string;
+    x0: number;
+    x1: number;
+    y: number;
+    page: number;
+}
+export interface Table {
+    page: number;
+    rows: string[][];
+    /** Número de columnas detectadas. */
+    columns: number;
+}
+export interface DetectOptions {
+    /** Filas mínimas para considerarlo una tabla (incluye el encabezado). */
+    minRows?: number;
+    /** Columnas mínimas. */
+    minCols?: number;
+    /** Separación vertical máxima entre filas de la misma tabla, en puntos. */
+    maxRowGap?: number;
+    /** Un corte vale si está en blanco en al menos esta fracción de filas. */
+    minSeparatorSupport?: number;
+}
+type Progress = (ratio: number) => void;
+/** Extrae cada trozo de texto con sus coordenadas, sin fusionar filas. */
+export declare function extractCells(pdf: PDFDocumentProxy, onProgress?: Progress): Promise<Cell[]>;
+/** Encuentra las tablas de un documento a partir de sus trozos de texto. */
+export declare function detectTables(cells: Cell[], options?: DetectOptions): Table[];
+/** Documento abierto → tablas detectadas. */
+export declare function pdfToTables(pdf: PDFDocumentProxy, options?: DetectOptions, onProgress?: Progress): Promise<Table[]>;
+export interface CsvOptions {
+    delimiter?: string;
+    /**
+     * Antepone la marca de orden de bytes. Excel en Windows la necesita para
+     * abrir UTF-8 con tildes correctamente.
+     */
+    bom?: boolean;
+}
+export declare function tableToCsv(table: Table, { delimiter, bom }?: CsvOptions): string;
+/** Tabla en Markdown, usando la primera fila como encabezado. */
+export declare function tableToMarkdown(table: Table): string;
+export {};