med-pdf-nmo 0.1.0

package/dist/bm25.js

@@ -0,0 +1,86 @@
+import { tokenize } from "./normalize.js";
+/**
+ * Небольшая реализация BM25 для локального поиска по чанкам PDF.
+ */
+export class BM25Index {
+    documents;
+    k1;
+    b;
+    docFreq;
+    termFreqs;
+    lengths;
+    avgdl;
+    /**
+     * Создает индекс для уже токенизированных документов.
+     *
+     * @param documents Документы с необязательными массивами `tokens`.
+     * @param options Параметры настройки BM25.
+     */
+    constructor(documents, { k1 = 1.35, b = 0.72 } = {}) {
+        this.documents = documents;
+        this.k1 = k1;
+        this.b = b;
+        this.docFreq = new Map();
+        this.termFreqs = [];
+        this.lengths = [];
+        let totalLength = 0;
+        for (const document of documents) {
+            const frequencies = new Map();
+            for (const token of document.tokens ?? []) {
+                frequencies.set(token, (frequencies.get(token) ?? 0) + 1);
+            }
+            this.termFreqs.push(frequencies);
+            this.lengths.push(document.tokens?.length ?? 0);
+            totalLength += document.tokens?.length ?? 0;
+            for (const token of frequencies.keys()) {
+                this.docFreq.set(token, (this.docFreq.get(token) ?? 0) + 1);
+            }
+        }
+        this.avgdl = documents.length ? totalLength / documents.length : 0;
+    }
+    /**
+     * Считает inverse document frequency для одного нормализованного токена.
+     */
+    idf(token) {
+        const n = this.documents.length;
+        const df = this.docFreq.get(token) ?? 0;
+        return Math.log(1 + (n - df + 0.5) / (df + 0.5));
+    }
+    /**
+     * Считает score токенизированного запроса для одного документа в индексе.
+     */
+    scoreTokens(queryTokens, docIndex) {
+        const frequencies = this.termFreqs[docIndex];
+        if (!frequencies)
+            return 0;
+        const dl = this.lengths[docIndex] || 1;
+        let score = 0;
+        for (const token of queryTokens) {
+            const tf = frequencies.get(token) ?? 0;
+            if (!tf)
+                continue;
+            const idf = this.idf(token);
+            const denom = tf + this.k1 * (1 - this.b + this.b * (dl / (this.avgdl || 1)));
+            score += idf * ((tf * (this.k1 + 1)) / denom);
+        }
+        return score;
+    }
+    /**
+     * Ищет по индексу сырой текст или заранее токенизированный запрос.
+     *
+     * @returns Лучшие совпадающие чанки с положительным BM25 score.
+     */
+    search(query, { limit = 10 } = {}) {
+        const queryTokens = Array.isArray(query) ? query : tokenize(query);
+        if (!queryTokens.length)
+            return [];
+        const scores = [];
+        for (let i = 0; i < this.documents.length; i += 1) {
+            const score = this.scoreTokens(queryTokens, i);
+            if (score > 0)
+                scores.push({ chunk: this.documents[i], score });
+        }
+        scores.sort((a, b) => b.score - a.score);
+        return scores.slice(0, limit);
+    }
+}

package/dist/browser-shims/buffer.d.ts

@@ -0,0 +1,30 @@
+declare function from(input: string | ArrayBuffer | ArrayBufferView | ArrayLike<number>, encoding?: string): Uint8Array<ArrayBuffer | SharedArrayBuffer>;
+/**
+ * Минимальный browser-compatible `Buffer`, достаточный для `Buffer.from(...)` в пользовательском коде.
+ *
+ * Это не полный polyfill Node.js Buffer. Для runtime predictor достаточно `Uint8Array`, поэтому shim
+ * намеренно покрывает только безопасное преобразование строк, ArrayBuffer и array-like данных в bytes.
+ */
+export declare const Buffer: {
+    /**
+     * Создает byte buffer из строки, ArrayBuffer, TypedArray или массива чисел.
+     *
+     * @param input Данные, которые нужно представить как `Uint8Array`.
+     * @param encoding Поддерживается только `utf8`/`utf-8` для строк.
+     * @returns Uint8Array-совместимый объект с именем `Buffer`.
+     */
+    from: typeof from;
+};
+declare const _default: {
+    Buffer: {
+        /**
+         * Создает byte buffer из строки, ArrayBuffer, TypedArray или массива чисел.
+         *
+         * @param input Данные, которые нужно представить как `Uint8Array`.
+         * @param encoding Поддерживается только `utf8`/`utf-8` для строк.
+         * @returns Uint8Array-совместимый объект с именем `Buffer`.
+         */
+        from: typeof from;
+    };
+};
+export default _default;

package/dist/browser-shims/buffer.js

@@ -0,0 +1,31 @@
+function from(input, encoding = "utf8") {
+    if (typeof input === "string") {
+        if (encoding && !/^utf-?8$/iu.test(encoding)) {
+            throw new Error(`Browser Buffer shim supports only utf8 strings, got "${encoding}".`);
+        }
+        return new Uint8Array(new TextEncoder().encode(input));
+    }
+    if (input instanceof ArrayBuffer)
+        return new Uint8Array(input.slice(0));
+    if (ArrayBuffer.isView(input)) {
+        return new Uint8Array(input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength));
+    }
+    return new Uint8Array(Array.from(input));
+}
+/**
+ * Минимальный browser-compatible `Buffer`, достаточный для `Buffer.from(...)` в пользовательском коде.
+ *
+ * Это не полный polyfill Node.js Buffer. Для runtime predictor достаточно `Uint8Array`, поэтому shim
+ * намеренно покрывает только безопасное преобразование строк, ArrayBuffer и array-like данных в bytes.
+ */
+export const Buffer = {
+    /**
+     * Создает byte buffer из строки, ArrayBuffer, TypedArray или массива чисел.
+     *
+     * @param input Данные, которые нужно представить как `Uint8Array`.
+     * @param encoding Поддерживается только `utf8`/`utf-8` для строк.
+     * @returns Uint8Array-совместимый объект с именем `Buffer`.
+     */
+    from,
+};
+export default { Buffer };

package/dist/browser-shims/crypto.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Browser shim для небольшого подмножества `node:crypto`.
+ *
+ * Predictor использует Web Crypto через browser/PDF.js окружение. Этот файл нужен как alias target
+ * для bundler-ов, которые встречают `crypto` или `node:crypto` в optional browser dependency branches.
+ */
+export declare const webcrypto: Crypto;
+/**
+ * Заполняет TypedArray криптографически случайными байтами через Web Crypto.
+ *
+ * @param array TypedArray, который нужно заполнить.
+ * @returns Тот же TypedArray после заполнения.
+ */
+export declare function getRandomValues<T extends ArrayBufferView>(array: T): T;
+/**
+ * Возвращает UUID через Web Crypto, либо генерирует RFC4122 v4 fallback из случайных байтов.
+ *
+ * @returns UUID string.
+ */
+export declare function randomUUID(): string;
+/**
+ * Заглушка для Node-only hashing API.
+ *
+ * @throws Всегда, потому что `createHash` не имеет совместимого синхронного browser API.
+ */
+export declare function createHash(): void;
+declare const _default: {
+    webcrypto: Crypto;
+    getRandomValues: typeof getRandomValues;
+    randomUUID: typeof randomUUID;
+    createHash: typeof createHash;
+};
+export default _default;

package/dist/browser-shims/crypto.js

@@ -0,0 +1,45 @@
+/**
+ * Browser shim для небольшого подмножества `node:crypto`.
+ *
+ * Predictor использует Web Crypto через browser/PDF.js окружение. Этот файл нужен как alias target
+ * для bundler-ов, которые встречают `crypto` или `node:crypto` в optional browser dependency branches.
+ */
+export const webcrypto = globalThis.crypto;
+/**
+ * Заполняет TypedArray криптографически случайными байтами через Web Crypto.
+ *
+ * @param array TypedArray, который нужно заполнить.
+ * @returns Тот же TypedArray после заполнения.
+ */
+export function getRandomValues(array) {
+    if (!globalThis.crypto?.getRandomValues) {
+        throw new Error("Web Crypto getRandomValues() is not available in this browser.");
+    }
+    globalThis.crypto.getRandomValues(array);
+    return array;
+}
+/**
+ * Возвращает UUID через Web Crypto, либо генерирует RFC4122 v4 fallback из случайных байтов.
+ *
+ * @returns UUID string.
+ */
+export function randomUUID() {
+    if (globalThis.crypto?.randomUUID)
+        return globalThis.crypto.randomUUID();
+    const bytes = getRandomValues(new Uint8Array(16));
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = [...bytes].map((byte) => byte.toString(16).padStart(2, "0"));
+    return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex
+        .slice(8, 10)
+        .join("")}-${hex.slice(10, 16).join("")}`;
+}
+/**
+ * Заглушка для Node-only hashing API.
+ *
+ * @throws Всегда, потому что `createHash` не имеет совместимого синхронного browser API.
+ */
+export function createHash() {
+    throw new Error("node:crypto createHash() is not available in the browser shim.");
+}
+export default { webcrypto, getRandomValues, randomUUID, createHash };

package/dist/browser-shims/fs-promises.d.ts

@@ -0,0 +1,13 @@
+export declare function readFile(): Promise<never>;
+export declare function writeFile(): Promise<never>;
+export declare function mkdir(): Promise<never>;
+export declare function rm(): Promise<never>;
+export declare function stat(): Promise<never>;
+declare const _default: {
+    readFile: typeof readFile;
+    writeFile: typeof writeFile;
+    mkdir: typeof mkdir;
+    rm: typeof rm;
+    stat: typeof stat;
+};
+export default _default;

package/dist/browser-shims/fs-promises.js

@@ -0,0 +1,25 @@
+/**
+ * Browser shim для `node:fs/promises`.
+ *
+ * Файловая система недоступна в браузере. Экспортируемые функции существуют только как alias target,
+ * чтобы optional Node branches в зависимостях не ломали сборку приложения.
+ */
+function unavailable(name) {
+    throw new Error(`node:fs/promises ${name}() is not available in the browser.`);
+}
+export async function readFile() {
+    return unavailable("readFile");
+}
+export async function writeFile() {
+    return unavailable("writeFile");
+}
+export async function mkdir() {
+    return unavailable("mkdir");
+}
+export async function rm() {
+    return unavailable("rm");
+}
+export async function stat() {
+    return unavailable("stat");
+}
+export default { readFile, writeFile, mkdir, rm, stat };

package/dist/browser-shims/fs.d.ts

@@ -0,0 +1,14 @@
+import * as promises from "./fs-promises.js";
+export { promises };
+export declare function readFileSync(): never;
+export declare function writeFileSync(): never;
+export declare function existsSync(): false;
+export declare function statSync(): never;
+declare const _default: {
+    promises: typeof promises;
+    readFileSync: typeof readFileSync;
+    writeFileSync: typeof writeFileSync;
+    existsSync: typeof existsSync;
+    statSync: typeof statSync;
+};
+export default _default;

package/dist/browser-shims/fs.js

@@ -0,0 +1,24 @@
+import * as promises from "./fs-promises.js";
+/**
+ * Browser shim для `node:fs`.
+ *
+ * Runtime predictor принимает PDF как bytes/File/Blob/URL и не требует доступа к файловой системе.
+ * Эти exports нужны для bundler alias-ов, когда optional Node branches попадают в dependency graph.
+ */
+function unavailable(name) {
+    throw new Error(`node:fs ${name}() is not available in the browser.`);
+}
+export { promises };
+export function readFileSync() {
+    return unavailable("readFileSync");
+}
+export function writeFileSync() {
+    return unavailable("writeFileSync");
+}
+export function existsSync() {
+    return false;
+}
+export function statSync() {
+    return unavailable("statSync");
+}
+export default { promises, readFileSync, writeFileSync, existsSync, statSync };

package/dist/browser-shims/globals.d.ts

@@ -0,0 +1,9 @@
+import { Buffer } from "./buffer.js";
+import processShim from "./process.js";
+/**
+ * Устанавливает минимальные browser globals, которые часто ожидают Node-oriented dependency branches.
+ *
+ * Функция не делает браузер Node-средой: `process` остается обычным object, без Node toStringTag.
+ */
+export declare function installBrowserNodeGlobals(): void;
+export { Buffer, processShim as process };

package/dist/browser-shims/globals.js

@@ -0,0 +1,23 @@
+import { Buffer } from "./buffer.js";
+import processShim from "./process.js";
+/**
+ * Устанавливает минимальные browser globals, которые часто ожидают Node-oriented dependency branches.
+ *
+ * Функция не делает браузер Node-средой: `process` остается обычным object, без Node toStringTag.
+ */
+export function installBrowserNodeGlobals() {
+    const target = globalThis;
+    if (!target.process) {
+        target.process = processShim;
+    }
+    else {
+        target.process.env ??= {};
+        target.process.versions ??= {};
+        target.process.browser ??= true;
+        target.process.getBuiltinModule ??= processShim.getBuiltinModule;
+    }
+    if (!target.Buffer)
+        target.Buffer = Buffer;
+}
+installBrowserNodeGlobals();
+export { Buffer, processShim as process };

package/dist/browser-shims/path.d.ts

@@ -0,0 +1,57 @@
+export declare const sep = "/";
+export declare const delimiter = ":";
+/**
+ * Склеивает части пути через `/`.
+ */
+export declare function join(...parts: string[]): string;
+/**
+ * Нормализует `.` и `..` в POSIX-like пути.
+ */
+export declare function normalize(value: string): string;
+/**
+ * Возвращает последнюю часть пути.
+ */
+export declare function basename(value: string, ext?: string): string;
+/**
+ * Возвращает путь без последней части.
+ */
+export declare function dirname(value: string): string;
+/**
+ * Возвращает расширение файла, включая точку.
+ */
+export declare function extname(value: string): string;
+/**
+ * Делает путь абсолютным относительно корня `/`.
+ */
+export declare function resolve(...parts: string[]): string;
+export declare const posix: {
+    sep: string;
+    delimiter: string;
+    join: typeof join;
+    normalize: typeof normalize;
+    basename: typeof basename;
+    dirname: typeof dirname;
+    extname: typeof extname;
+    resolve: typeof resolve;
+};
+declare const _default: {
+    sep: string;
+    delimiter: string;
+    join: typeof join;
+    normalize: typeof normalize;
+    basename: typeof basename;
+    dirname: typeof dirname;
+    extname: typeof extname;
+    resolve: typeof resolve;
+    posix: {
+        sep: string;
+        delimiter: string;
+        join: typeof join;
+        normalize: typeof normalize;
+        basename: typeof basename;
+        dirname: typeof dirname;
+        extname: typeof extname;
+        resolve: typeof resolve;
+    };
+};
+export default _default;

package/dist/browser-shims/path.js

@@ -0,0 +1,65 @@
+/**
+ * Небольшой POSIX-like browser shim для `node:path`.
+ *
+ * Покрывает частые операции, которые bundler/dependency code может вызвать для URL-like путей.
+ */
+function cleanParts(parts) {
+    const out = [];
+    for (const part of parts) {
+        if (!part || part === ".")
+            continue;
+        if (part === "..")
+            out.pop();
+        else
+            out.push(part);
+    }
+    return out;
+}
+export const sep = "/";
+export const delimiter = ":";
+/**
+ * Склеивает части пути через `/`.
+ */
+export function join(...parts) {
+    return normalize(parts.filter(Boolean).join("/"));
+}
+/**
+ * Нормализует `.` и `..` в POSIX-like пути.
+ */
+export function normalize(value) {
+    const absolute = value.startsWith("/");
+    const suffix = value.endsWith("/") ? "/" : "";
+    const body = cleanParts(value.split("/")).join("/");
+    return `${absolute ? "/" : ""}${body || (absolute ? "" : ".")}${body ? suffix : ""}`;
+}
+/**
+ * Возвращает последнюю часть пути.
+ */
+export function basename(value, ext = "") {
+    const base = value.split("/").filter(Boolean).pop() ?? "";
+    return ext && base.endsWith(ext) ? base.slice(0, -ext.length) : base;
+}
+/**
+ * Возвращает путь без последней части.
+ */
+export function dirname(value) {
+    const parts = value.split("/").filter(Boolean);
+    parts.pop();
+    return value.startsWith("/") ? `/${parts.join("/")}` : parts.join("/") || ".";
+}
+/**
+ * Возвращает расширение файла, включая точку.
+ */
+export function extname(value) {
+    const base = basename(value);
+    const index = base.lastIndexOf(".");
+    return index > 0 ? base.slice(index) : "";
+}
+/**
+ * Делает путь абсолютным относительно корня `/`.
+ */
+export function resolve(...parts) {
+    return normalize(`/${join(...parts)}`);
+}
+export const posix = { sep, delimiter, join, normalize, basename, dirname, extname, resolve };
+export default { sep, delimiter, join, normalize, basename, dirname, extname, resolve, posix };

package/dist/browser-shims/process.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Минимальный browser shim для `process`.
+ *
+ * Важно: объект не маскируется под настоящий Node.js process, чтобы PDF.js не считал браузер Node-средой.
+ */
+export declare const env: Record<string, string | undefined>;
+export declare const versions: Record<string, string | undefined>;
+export declare const browser = true;
+/**
+ * Возвращает browser shim для редких вызовов `process.getBuiltinModule(...)`.
+ *
+ * @param name Имя Node built-in модуля.
+ * @returns Объект shim-а для известных модулей или пустой объект.
+ */
+export declare function getBuiltinModule(name: string): {};
+declare const _default: {
+    env: Record<string, string>;
+    versions: Record<string, string>;
+    browser: boolean;
+    getBuiltinModule: typeof getBuiltinModule;
+};
+export default _default;

package/dist/browser-shims/process.js

@@ -0,0 +1,27 @@
+/**
+ * Минимальный browser shim для `process`.
+ *
+ * Важно: объект не маскируется под настоящий Node.js process, чтобы PDF.js не считал браузер Node-средой.
+ */
+export const env = {};
+export const versions = {};
+export const browser = true;
+/**
+ * Возвращает browser shim для редких вызовов `process.getBuiltinModule(...)`.
+ *
+ * @param name Имя Node built-in модуля.
+ * @returns Объект shim-а для известных модулей или пустой объект.
+ */
+export function getBuiltinModule(name) {
+    const normalized = name.replace(/^node:/u, "");
+    if (normalized === "fs")
+        return {};
+    if (normalized === "fs/promises")
+        return {};
+    if (normalized === "path" || normalized === "url" || normalized === "module" || normalized === "stream")
+        return {};
+    if (normalized === "crypto")
+        return globalThis.crypto ?? {};
+    return {};
+}
+export default { env, versions, browser, getBuiltinModule };

package/dist/browser.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Точка входа для браузерной сборки.
+ *
+ * Скрипт сборки превращает этот файл в:
+ * - `dist/med-pdf-nmo.browser.js` с глобальным объектом `MedPdfNmo`
+ * - `dist/med-pdf-nmo.browser.mjs` как браузерный ESM-бандл
+ */
+import "./browser-shims/globals.js";
+export { answerQuestion, predict, clearPredictorCache, setPdfJsLib } from "./index.js";

package/dist/browser.js

@@ -0,0 +1,12 @@
+/**
+ * Точка входа для браузерной сборки.
+ *
+ * Скрипт сборки превращает этот файл в:
+ * - `dist/med-pdf-nmo.browser.js` с глобальным объектом `MedPdfNmo`
+ * - `dist/med-pdf-nmo.browser.mjs` как браузерный ESM-бандл
+ */
+import "./browser-shims/globals.js";
+import * as pdfjsLib from "pdfjs-dist/legacy/build/pdf.mjs";
+import { setPdfJsLib } from "./pdf.js";
+setPdfJsLib(pdfjsLib);
+export { answerQuestion, predict, clearPredictorCache, setPdfJsLib } from "./index.js";

package/dist/chunk.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Создает поисковые чанки из извлеченного текста PDF.
+ *
+ * Predictor комбинирует окна предложений, отдельные строки, пары строк и
+ * контексты списков/заголовков, чтобы scorers могли находить и обычный текст,
+ * и характерные для рекомендаций таблицы/списки.
+ *
+ * @param pdfText Результат `extractPdfText`.
+ * @param options Настройки размера чанка и перекрытия предложений.
+ * @returns Поисковые чанки с нормализованным текстом и токенами.
+ */
+export declare function buildChunks(pdfText: any, { targetTokens, overlapSentences }?: {
+    targetTokens?: number;
+    overlapSentences?: number;
+}): any[];

package/dist/chunk.js

@@ -0,0 +1,76 @@
+import { normalizeForSearch, tokenize } from "./normalize.js";
+function splitSentences(text) {
+    const normalized = String(text ?? "")
+        .replace(/\r/g, "")
+        .replace(/([.!?;])\s+(?=[А-ЯA-Z0-9])/g, "$1\n")
+        .replace(/\n{3,}/g, "\n\n");
+    return normalized
+        .split(/\n+|(?<=[.!?;])\s+/u)
+        .map((part) => part.trim())
+        .filter((part) => part.length >= 8);
+}
+function tokenCount(text) {
+    return tokenize(text, { keepStopwords: true, stem: false }).length;
+}
+/**
+ * Создает поисковые чанки из извлеченного текста PDF.
+ *
+ * Predictor комбинирует окна предложений, отдельные строки, пары строк и
+ * контексты списков/заголовков, чтобы scorers могли находить и обычный текст,
+ * и характерные для рекомендаций таблицы/списки.
+ *
+ * @param pdfText Результат `extractPdfText`.
+ * @param options Настройки размера чанка и перекрытия предложений.
+ * @returns Поисковые чанки с нормализованным текстом и токенами.
+ */
+export function buildChunks(pdfText, { targetTokens = 95, overlapSentences = 2 } = {}) {
+    const chunks = [];
+    for (const page of pdfText.pages) {
+        const sentences = splitSentences(page.text);
+        let current = [];
+        let currentTokens = 0;
+        for (const sentence of sentences) {
+            const sentenceTokens = Math.max(1, tokenCount(sentence));
+            if (current.length && currentTokens + sentenceTokens > targetTokens) {
+                chunks.push(makeChunk(page.page, current.join(" ")));
+                current = current.slice(-overlapSentences);
+                currentTokens = tokenCount(current.join(" "));
+            }
+            current.push(sentence);
+            currentTokens += sentenceTokens;
+        }
+        if (current.length) {
+            chunks.push(makeChunk(page.page, current.join(" ")));
+        }
+        const lines = page.text
+            .split(/\n+/)
+            .map((line) => line.trim())
+            .filter((line) => line.length >= 12);
+        for (let i = 0; i < lines.length; i += 1) {
+            const line = lines[i];
+            chunks.push(makeChunk(page.page, line, "line"));
+            if (i + 1 < lines.length) {
+                chunks.push(makeChunk(page.page, `${line} ${lines[i + 1]}`, "line_pair"));
+            }
+            const listLike = /^(\d+(?:\.\d+)*[.)]?|[-*•]|[a-zа-я]\))\s+/iu.test(line);
+            const headingLike = line.length < 120 && !/[.!?]$/.test(line);
+            if (listLike || headingLike) {
+                const context = lines.slice(Math.max(0, i - 2), Math.min(lines.length, i + 5)).join(" ");
+                chunks.push(makeChunk(page.page, context, listLike ? "list" : "heading"));
+            }
+        }
+    }
+    return chunks
+        .filter((chunk) => chunk.tokens.length)
+        .map((chunk, index) => ({ ...chunk, id: index }));
+}
+function makeChunk(page, text, kind = "body") {
+    return {
+        page,
+        kind,
+        text: String(text ?? "").replace(/\s+/g, " ").trim(),
+        normalized: normalizeForSearch(text),
+        tokens: tokenize(text),
+        rawTokens: tokenize(text, { keepStopwords: true, stem: false }),
+    };
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};