@sirdaspdf/core 0.1.0

package/dist/datasplit.js

@@ -0,0 +1,49 @@
+// Reparto en entrenamiento / validación / prueba.
+//
+// El error que casi todo el mundo comete: trocear los documentos primero y
+// repartir los trozos después. Dos trozos del mismo contrato acaban uno en
+// train y otro en test, el modelo ya vio la plantilla, y la métrica sale
+// preciosa y mentirosa. Aquí el reparto es SIEMPRE por documento: todos los
+// trozos de un documento caen en la misma partición.
+import { fnv1a } from "./text.js";
+const DEFAULT_RATIOS = { train: 0.8, validation: 0.1, test: 0.1 };
+/**
+ * Reparte registros agrupándolos por documento de origen.
+ *
+ * `docOf` dice a qué documento pertenece cada registro. El reparto se decide
+ * hasheando el nombre del documento junto con la semilla, así que es estable:
+ * volver a ejecutarlo con los mismos archivos da exactamente el mismo reparto,
+ * y añadir un documento nuevo no mueve a los demás de partición.
+ */
+export function splitByDocument(records, docOf, options = {}) {
+    const ratios = options.ratios ?? DEFAULT_RATIOS;
+    const seed = options.seed ?? "sirdas";
+    const total = ratios.train + ratios.validation + ratios.test;
+    if (total <= 0)
+        throw new Error("las proporciones deben sumar más de cero");
+    const trainEnd = ratios.train / total;
+    const valEnd = (ratios.train + ratios.validation) / total;
+    const bucketOf = new Map();
+    const decide = (doc) => {
+        const cached = bucketOf.get(doc);
+        if (cached)
+            return cached;
+        // El hash en [0,1): reparto determinista y sin estado compartido. El
+        // separador evita que "ab"+"c" y "a"+"bc" colisionen.
+        const r = fnv1a(`${seed}␟${doc}`) / 0x100000000;
+        const bucket = r < trainEnd ? "train" : r < valEnd ? "validation" : "test";
+        bucketOf.set(doc, bucket);
+        return bucket;
+    };
+    const out = {
+        train: [],
+        validation: [],
+        test: [],
+        documents: { train: 0, validation: 0, test: 0 },
+    };
+    for (const r of records)
+        out[decide(docOf(r))].push(r);
+    for (const bucket of bucketOf.values())
+        out.documents[bucket]++;
+    return out;
+}

package/dist/dedupe.d.ts

@@ -0,0 +1,62 @@
+export interface DedupeOptions {
+    /** Palabras por shingle. Más alto = más estricto. */
+    shingleSize?: number;
+    /** Tamaño de la firma MinHash. Más alto = mejor estimación, más lento. */
+    hashes?: number;
+    /**
+     * Bandas LSH. Debe dividir a `hashes`. Si se omite se deduce del umbral,
+     * que es lo que hay que hacer: el punto medio de la curva de LSH es
+     * (1/bandas)^(1/filas), y si no acompaña al umbral, bajarlo no sirve de nada
+     * porque los pares parecidos ni siquiera llegan a compararse.
+     */
+    bands?: number;
+    /** Jaccard mínimo para considerar que dos documentos son el mismo. */
+    threshold?: number;
+}
+export interface Duplicate {
+    /** Índice del documento que se descarta. */
+    index: number;
+    /** Índice del primero que apareció, y que se conserva. */
+    duplicateOf: number;
+    similarity: number;
+    exact: boolean;
+}
+export interface DedupeResult {
+    /** Índices que sobreviven, en su orden original. */
+    keep: number[];
+    duplicates: Duplicate[];
+    /** Cuántos eran idénticos una vez normalizados. */
+    exact: number;
+    /** Cuántos eran parecidos pero no idénticos. */
+    near: number;
+}
+/**
+ * Elige el bandeado de LSH para un umbral dado.
+ *
+ * Se toma el bandeado más barato (menos bandas, menos candidatos que verificar)
+ * que aun así proponga el 95 % de los pares que están justo en el umbral. El
+ * criterio es la recuperación y no el punto de cruce de la curva, porque el
+ * número de firmas solo admite divisores potencia de dos y ajustar por el cruce
+ * deja huecos: a umbral 0.9 el bandeado "elegante" recupera el 81 %, es decir,
+ * uno de cada cinco duplicados se pierde sin que nadie se entere. En un auditor
+ * de datasets un falso negativo silencioso es el peor resultado posible.
+ *
+ * El precio: con umbrales bajos (0.5 y menos) casi todos los pares acaban
+ * siendo candidatos y el coste se acerca al de comparar todo contra todo. Es
+ * inherente a pedir "parecido a medias", no un defecto de la implementación.
+ */
+export declare function bandsForThreshold(hashes: number, threshold: number, target?: number): number;
+/**
+ * Firma MinHash. Usa una familia de permutaciones (a·x + b mod p) con
+ * coeficientes derivados de un generador con semilla fija: el resultado es
+ * reproducible, que es requisito para poder auditar un dataset.
+ */
+export declare function minhash(shingles: Set<number>, hashes: number): Uint32Array;
+/** Fracción de posiciones iguales entre dos firmas: estima el Jaccard. */
+export declare function signatureSimilarity(a: Uint32Array, b: Uint32Array): number;
+/**
+ * Encuentra los duplicados de un corpus y devuelve qué conservar.
+ * Se conserva siempre la primera aparición, para que el resultado no dependa
+ * del orden en que el sistema de archivos devolvió los documentos.
+ */
+export declare function dedupe(texts: string[], options?: DedupeOptions): DedupeResult;

package/dist/dedupe.js

@@ -0,0 +1,159 @@
+// Deduplicación de un corpus por similitud, con MinHash + LSH.
+//
+// Por qué importa: un texto repetido en los datos de entrenamiento se aprende
+// de memoria en vez de generalizarse. Un corpus hecho de PDFs propios está
+// lleno de repeticiones que nadie puso a propósito — la misma plantilla de
+// contrato, el mismo pie de página, el mismo informe en dos versiones.
+//
+// Comparar todos los pares es O(n²) y se vuelve inviable enseguida. MinHash
+// resume cada documento en una firma corta, y LSH agrupa en el mismo cubo a los
+// que probablemente se parecen; solo esos pares se comparan de verdad, y la
+// comparación final es Jaccard exacto sobre los shingles, no la estimación de
+// la firma, para no dar por duplicado algo que no lo es.
+import { fnv1a, ngramHashes, jaccard } from "./text.js";
+const DEFAULTS = { shingleSize: 5, hashes: 128, threshold: 0.8 };
+/** Probabilidad de que LSH proponga como candidato un par con similitud `j`. */
+function lshRecall(bands, rows, j) {
+    return 1 - Math.pow(1 - Math.pow(j, rows), bands);
+}
+/**
+ * Elige el bandeado de LSH para un umbral dado.
+ *
+ * Se toma el bandeado más barato (menos bandas, menos candidatos que verificar)
+ * que aun así proponga el 95 % de los pares que están justo en el umbral. El
+ * criterio es la recuperación y no el punto de cruce de la curva, porque el
+ * número de firmas solo admite divisores potencia de dos y ajustar por el cruce
+ * deja huecos: a umbral 0.9 el bandeado "elegante" recupera el 81 %, es decir,
+ * uno de cada cinco duplicados se pierde sin que nadie se entere. En un auditor
+ * de datasets un falso negativo silencioso es el peor resultado posible.
+ *
+ * El precio: con umbrales bajos (0.5 y menos) casi todos los pares acaban
+ * siendo candidatos y el coste se acerca al de comparar todo contra todo. Es
+ * inherente a pedir "parecido a medias", no un defecto de la implementación.
+ */
+export function bandsForThreshold(hashes, threshold, target = 0.95) {
+    const divisors = [];
+    for (let b = 1; b <= hashes; b++)
+        if (hashes % b === 0)
+            divisors.push(b);
+    for (const b of divisors) {
+        if (lshRecall(b, hashes / b, threshold) >= target)
+            return b;
+    }
+    // Ningún bandeado llega: el más sensible posible, una fila por banda.
+    return hashes;
+}
+/**
+ * Firma MinHash. Usa una familia de permutaciones (a·x + b mod p) con
+ * coeficientes derivados de un generador con semilla fija: el resultado es
+ * reproducible, que es requisito para poder auditar un dataset.
+ */
+export function minhash(shingles, hashes) {
+    const P = 4294967291; // primo justo por debajo de 2³²
+    const sig = new Uint32Array(hashes).fill(0xffffffff);
+    if (shingles.size === 0)
+        return sig;
+    // Generador congruencial con semilla fija: mismos coeficientes siempre.
+    let seed = 0x9e3779b9;
+    const next = () => {
+        seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0;
+        return seed;
+    };
+    for (let i = 0; i < hashes; i++) {
+        const a = (next() % (P - 1)) + 1;
+        const b = next() % P;
+        let min = 0xffffffff;
+        for (const x of shingles) {
+            // (a·x + b) mod p sin perder precisión: x < 2³², a < 2³², el producto
+            // cabría en 64 bits pero no en un double, así que se parte en dos.
+            const hi = Math.floor(x / 65536);
+            const lo = x % 65536;
+            const v = ((((a * hi) % P) * 65536 + a * lo + b) % P) >>> 0;
+            if (v < min)
+                min = v;
+        }
+        sig[i] = min;
+    }
+    return sig;
+}
+/** Fracción de posiciones iguales entre dos firmas: estima el Jaccard. */
+export function signatureSimilarity(a, b) {
+    if (a.length !== b.length || a.length === 0)
+        return 0;
+    let same = 0;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] === b[i])
+            same++;
+    return same / a.length;
+}
+/**
+ * Encuentra los duplicados de un corpus y devuelve qué conservar.
+ * Se conserva siempre la primera aparición, para que el resultado no dependa
+ * del orden en que el sistema de archivos devolvió los documentos.
+ */
+export function dedupe(texts, options = {}) {
+    const { shingleSize, hashes, threshold } = { ...DEFAULTS, ...options };
+    const bands = options.bands ?? bandsForThreshold(hashes, threshold);
+    if (hashes % bands !== 0) {
+        throw new Error(`bands (${bands}) debe dividir a hashes (${hashes})`);
+    }
+    const rows = hashes / bands;
+    const shingles = texts.map((t) => ngramHashes(t, shingleSize));
+    const sigs = shingles.map((s) => minhash(s, hashes));
+    // LSH: dos documentos son candidatos si comparten una banda entera.
+    const buckets = new Map();
+    for (let i = 0; i < texts.length; i++) {
+        for (let b = 0; b < bands; b++) {
+            const slice = sigs[i].slice(b * rows, (b + 1) * rows).join(",");
+            const key = `${b}:${fnv1a(slice)}`;
+            const list = buckets.get(key);
+            if (list)
+                list.push(i);
+            else
+                buckets.set(key, [i]);
+        }
+    }
+    const candidates = new Map();
+    for (const list of buckets.values()) {
+        if (list.length < 2)
+            continue;
+        for (let i = 0; i < list.length; i++) {
+            for (let j = i + 1; j < list.length; j++) {
+                const [lo, hi] = [list[i], list[j]];
+                const set = candidates.get(hi) ?? new Set();
+                set.add(lo);
+                candidates.set(hi, set);
+            }
+        }
+    }
+    const duplicates = [];
+    const dropped = new Set();
+    for (let i = 0; i < texts.length; i++) {
+        const others = candidates.get(i);
+        if (!others)
+            continue;
+        // Contra el original vivo más temprano: si el candidato ya se descartó,
+        // el duplicado debe apuntar al documento que sí se conserva.
+        let best = -1;
+        let bestSim = 0;
+        for (const j of [...others].sort((x, y) => x - y)) {
+            if (dropped.has(j))
+                continue;
+            const sim = jaccard(shingles[i], shingles[j]);
+            if (sim >= threshold && sim > bestSim) {
+                best = j;
+                bestSim = sim;
+            }
+        }
+        if (best >= 0) {
+            dropped.add(i);
+            duplicates.push({ index: i, duplicateOf: best, similarity: bestSim, exact: bestSim === 1 });
+        }
+    }
+    return {
+        keep: texts.map((_, i) => i).filter((i) => !dropped.has(i)),
+        duplicates,
+        exact: duplicates.filter((d) => d.exact).length,
+        near: duplicates.filter((d) => !d.exact).length,
+    };
+}

package/dist/diff.d.ts

@@ -0,0 +1,44 @@
+import type { PDFDocumentProxy } from "pdfjs-dist";
+export type ChangeType = "equal" | "added" | "removed";
+export interface DiffLine {
+    type: ChangeType;
+    text: string;
+}
+export interface DiffStats {
+    added: number;
+    removed: number;
+    equal: number;
+    /** 0 a 1: proporción de líneas que no cambiaron. */
+    similarity: number;
+}
+export interface DiffOptions {
+    /** Ignora diferencias de espacios y mayúsculas al comparar. */
+    ignoreCase?: boolean;
+    /**
+     * Tope de seguridad. La comparación exacta cuesta O(n×m); por encima de este
+     * producto se devuelve un resultado degradado en vez de colgar el navegador.
+     */
+    maxCells?: number;
+}
+/** Divide un texto en líneas comparables, descartando las vacías. */
+export declare function toLines(text: string): string[];
+/** Compara dos listas de líneas y devuelve la secuencia de cambios. */
+export declare function diffLines(a: string[], b: string[], options?: DiffOptions): DiffLine[];
+/**
+ * Líneas de un PDF tal y como se ven en la página.
+ *
+ * Para comparar NO sirve el Markdown: allí los renglones consecutivos se
+ * fusionan en párrafos, y entonces cualquier cambio pequeño marca el párrafo
+ * entero como distinto. Quien revisa dos versiones de un contrato quiere ver
+ * la línea que cambió.
+ */
+export declare function pdfLineTexts(pdf: PDFDocumentProxy, onProgress?: (r: number) => void): Promise<string[]>;
+/** Compara dos textos completos. */
+export declare function diffText(a: string, b: string, options?: DiffOptions): DiffLine[];
+export declare function diffStats(diff: DiffLine[]): DiffStats;
+/** Solo los cambios, con algo de contexto alrededor, como hace `git diff`. */
+export declare function diffChangesOnly(diff: DiffLine[], context?: number): DiffLine[];
+/** Diferencias en Markdown, con el signo delante de cada línea. */
+export declare function diffToMarkdown(diff: DiffLine[]): string;
+/** Tokens aproximados de las líneas cambiadas: útil para pasárselas a una IA. */
+export declare function changedTokens(diff: DiffLine[]): number;

package/dist/diff.js

@@ -0,0 +1,133 @@
+import { estimateTokens, extractLines } from "./markdown.js";
+const normalize = (s, ignoreCase) => {
+    const clean = s.replace(/\s+/g, " ").trim();
+    return ignoreCase ? clean.toLowerCase() : clean;
+};
+/** Divide un texto en líneas comparables, descartando las vacías. */
+export function toLines(text) {
+    return text
+        .split("\n")
+        .map((l) => l.trim())
+        .filter(Boolean);
+}
+/**
+ * Subsecuencia común más larga, sobre el tramo que de verdad difiere: antes
+ * recortamos el principio y el final idénticos, que en dos versiones de un
+ * mismo documento suelen ser casi todo.
+ */
+function lcsDiff(a, b, key) {
+    const n = a.length;
+    const m = b.length;
+    // Tabla de longitudes: table[i][j] = LCS de a[i..] y b[j..].
+    const table = Array.from({ length: n + 1 }, () => new Uint32Array(m + 1));
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            table[i][j] =
+                key(a[i]) === key(b[j])
+                    ? table[i + 1][j + 1] + 1
+                    : Math.max(table[i + 1][j], table[i][j + 1]);
+        }
+    }
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (key(a[i]) === key(b[j])) {
+            out.push({ type: "equal", text: b[j] });
+            i++;
+            j++;
+        }
+        else if (table[i + 1][j] >= table[i][j + 1]) {
+            out.push({ type: "removed", text: a[i++] });
+        }
+        else {
+            out.push({ type: "added", text: b[j++] });
+        }
+    }
+    while (i < n)
+        out.push({ type: "removed", text: a[i++] });
+    while (j < m)
+        out.push({ type: "added", text: b[j++] });
+    return out;
+}
+/** Compara dos listas de líneas y devuelve la secuencia de cambios. */
+export function diffLines(a, b, options = {}) {
+    const ignoreCase = options.ignoreCase ?? false;
+    const maxCells = options.maxCells ?? 4_000_000;
+    const key = (s) => normalize(s, ignoreCase);
+    // Prefijo y sufijo idénticos: se emiten tal cual y se sacan del cálculo.
+    let start = 0;
+    while (start < a.length && start < b.length && key(a[start]) === key(b[start]))
+        start++;
+    let endA = a.length;
+    let endB = b.length;
+    while (endA > start && endB > start && key(a[endA - 1]) === key(b[endB - 1])) {
+        endA--;
+        endB--;
+    }
+    const head = a.slice(0, start).map((text) => ({ type: "equal", text }));
+    const tail = a.slice(endA).map((text) => ({ type: "equal", text }));
+    const midA = a.slice(start, endA);
+    const midB = b.slice(start, endB);
+    if (!midA.length && !midB.length)
+        return [...head, ...tail];
+    let middle;
+    if (midA.length * midB.length > maxCells) {
+        // Documentos enormes y muy distintos: mejor un resultado honesto y rápido
+        // que bloquear la pestaña calculando la coincidencia perfecta.
+        middle = [
+            ...midA.map((text) => ({ type: "removed", text })),
+            ...midB.map((text) => ({ type: "added", text })),
+        ];
+    }
+    else {
+        middle = lcsDiff(midA, midB, key);
+    }
+    return [...head, ...middle, ...tail];
+}
+/**
+ * Líneas de un PDF tal y como se ven en la página.
+ *
+ * Para comparar NO sirve el Markdown: allí los renglones consecutivos se
+ * fusionan en párrafos, y entonces cualquier cambio pequeño marca el párrafo
+ * entero como distinto. Quien revisa dos versiones de un contrato quiere ver
+ * la línea que cambió.
+ */
+export async function pdfLineTexts(pdf, onProgress) {
+    return (await extractLines(pdf, onProgress)).map((l) => l.text);
+}
+/** Compara dos textos completos. */
+export function diffText(a, b, options = {}) {
+    return diffLines(toLines(a), toLines(b), options);
+}
+export function diffStats(diff) {
+    const added = diff.filter((d) => d.type === "added").length;
+    const removed = diff.filter((d) => d.type === "removed").length;
+    const equal = diff.filter((d) => d.type === "equal").length;
+    const total = added + removed + equal;
+    return { added, removed, equal, similarity: total ? equal / total : 1 };
+}
+/** Solo los cambios, con algo de contexto alrededor, como hace `git diff`. */
+export function diffChangesOnly(diff, context = 2) {
+    const keep = new Set();
+    diff.forEach((d, i) => {
+        if (d.type === "equal")
+            return;
+        for (let k = Math.max(0, i - context); k <= Math.min(diff.length - 1, i + context); k++)
+            keep.add(k);
+    });
+    return diff.filter((_, i) => keep.has(i));
+}
+/** Diferencias en Markdown, con el signo delante de cada línea. */
+export function diffToMarkdown(diff) {
+    return diff
+        .map((d) => (d.type === "added" ? `+ ${d.text}` : d.type === "removed" ? `- ${d.text}` : `  ${d.text}`))
+        .join("\n");
+}
+/** Tokens aproximados de las líneas cambiadas: útil para pasárselas a una IA. */
+export function changedTokens(diff) {
+    return estimateTokens(diff
+        .filter((d) => d.type !== "equal")
+        .map((d) => d.text)
+        .join("\n"));
+}

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+/** Causa de un fallo, para poder dar un mensaje accionable al usuario. */
+export type ErrorCode = "encrypted" | "corrupt" | "generic";
+/**
+ * Traduce el error de pdf-lib o PDF.js a una causa. pdf-lib lanza
+ * EncryptedPDFError y PDF.js PasswordException para documentos con contraseña.
+ */
+export declare function classifyError(e: unknown): ErrorCode;
+/** Error de una operación PDF, con la causa ya clasificada. */
+export declare class PdfError extends Error {
+    code: ErrorCode;
+    constructor(message: string, code: ErrorCode);
+}

package/dist/errors.js

@@ -0,0 +1,24 @@
+/**
+ * Traduce el error de pdf-lib o PDF.js a una causa. pdf-lib lanza
+ * EncryptedPDFError y PDF.js PasswordException para documentos con contraseña.
+ */
+export function classifyError(e) {
+    const name = e instanceof Error ? e.name : "";
+    const message = e instanceof Error ? e.message : String(e);
+    if (name === "PasswordException" || name === "EncryptedPDFError")
+        return "encrypted";
+    if (/encrypt|password|contrase/i.test(message))
+        return "encrypted";
+    if (/invalid pdf|no pdf header|corrupt|malformed|unexpected end/i.test(message))
+        return "corrupt";
+    return "generic";
+}
+/** Error de una operación PDF, con la causa ya clasificada. */
+export class PdfError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = "PdfError";
+        this.code = code;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./anonymize.js";
+export * from "./ranges.js";
+export * from "./errors.js";
+export * from "./merge.js";
+export * from "./split.js";
+export * from "./organize.js";
+export * from "./lossless.js";
+export * from "./markdown.js";
+export * from "./ocr.js";
+export * from "./chunk.js";
+export * from "./tables.js";
+export * from "./diff.js";
+export * from "./text.js";
+export * from "./dedupe.js";
+export * from "./contamination.js";
+export * from "./datasplit.js";
+export * from "./dataset.js";
+export * from "./verifiable.js";
+export * from "./paragraphs.js";

package/dist/index.js

@@ -0,0 +1,21 @@
+// @sirdaspdf/core — motor PDF compartido por la web, la CLI y el servidor MCP.
+// Solo depende de pdf-lib; la parte de PDF.js recibe el documento ya abierto.
+export * from "./anonymize.js";
+export * from "./ranges.js";
+export * from "./errors.js";
+export * from "./merge.js";
+export * from "./split.js";
+export * from "./organize.js";
+export * from "./lossless.js";
+export * from "./markdown.js";
+export * from "./ocr.js";
+export * from "./chunk.js";
+export * from "./tables.js";
+export * from "./diff.js";
+export * from "./text.js";
+export * from "./dedupe.js";
+export * from "./contamination.js";
+export * from "./datasplit.js";
+export * from "./dataset.js";
+export * from "./verifiable.js";
+export * from "./paragraphs.js";

package/dist/lossless.d.ts

@@ -0,0 +1,2 @@
+/** Compresión estructural sin pérdida. Nunca devuelve algo más pesado que el original. */
+export declare function compressLossless(buf: ArrayBuffer | Uint8Array): Promise<Uint8Array>;

package/dist/lossless.js

@@ -0,0 +1,10 @@
+import { PDFDocument } from "pdf-lib";
+/** Compresión estructural sin pérdida. Nunca devuelve algo más pesado que el original. */
+export async function compressLossless(buf) {
+    const doc = await PDFDocument.load(buf);
+    doc.setProducer("Sirdas");
+    doc.setCreator("Sirdas");
+    const out = await doc.save({ useObjectStreams: true, addDefaultPage: false });
+    const original = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
+    return out.byteLength < original.byteLength ? out : original;
+}

package/dist/markdown.d.ts

@@ -0,0 +1,21 @@
+import type { PDFDocumentProxy } from "pdfjs-dist";
+export interface Line {
+    text: string;
+    size: number;
+    y: number;
+    x: number;
+    page: number;
+    bold: boolean;
+    /** Posición vertical relativa: 0 = pie de página, 1 = parte superior. */
+    rel: 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;
+/** Documento PDF.js abierto → Markdown. */
+export declare function pdfToMarkdown(pdf: PDFDocumentProxy, onProgress?: Progress): Promise<string>;
+/** Estimación rápida de tokens (~4 caracteres por token). */
+export declare function estimateTokens(text: string): number;
+export {};