med-pdf-nmo 0.1.0

package/dist/predictor/scorers/direction.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Сопоставляет направление (рост/снижение) в вопросе и в локальном контексте
+ * найденного варианта; штрафует противоположную полярность.
+ */
+export declare function polarityAdjustment({ pages, topQuestionPages, mode, question, questionTokens, answer }: {
+    pages: any;
+    topQuestionPages: any;
+    mode: any;
+    question: any;
+    questionTokens: any;
+    answer: any;
+}): {
+    adjustment: number;
+    evidence: any;
+};
+/**
+ * Различает дневные и ночные подсказки для single-вопросов и штрафует
+ * вариант с противоположным временем суток рядом с фокусом вопроса.
+ */
+export declare function temporalCueAdjustment({ mode, pages, topQuestionPages, answer, focusTokens, questionTokens }: {
+    mode: any;
+    pages: any;
+    topQuestionPages: any;
+    answer: any;
+    focusTokens: any;
+    questionTokens: any;
+}): {
+    support: any;
+    adjustment: number;
+    evidence: any;
+} | {
+    support: any;
+    adjustment: number;
+    evidence: any;
+};
+/**
+ * Штрафует multi-вариант, у которого сильнейшее evidence содержит
+ * противоположную подсказку (верх/низ, рост/снижение, порядок дистальный/
+ * проксимальный) либо противоположный модификатор у того же целевого слова.
+ */
+export declare function contrastCueMismatchAdjustment({ mode, answer }: {
+    mode: any;
+    answer: any;
+}, evidence: any): {
+    adjustment: number;
+    evidence: {
+        answerId: any;
+        page: any;
+        text: any;
+        score: number;
+        kind: string;
+    };
+};
+/**
+ * Штрафует вариант, чье локальное evidence относится к исключенной подгруппе
+ * (`при X` рядом с фразой ответа), когда вопрос явно про `без X`.
+ */
+export declare function excludedConditionMismatchAdjustment({ mode, question, answer }: {
+    mode: any;
+    question: any;
+    answer: any;
+}, evidence: any): {
+    adjustment: number;
+    evidence: {
+        answerId: any;
+        page: any;
+        text: any;
+        score: number;
+        kind: string;
+    };
+};

package/dist/predictor/scorers/direction.js

@@ -0,0 +1,345 @@
+import { coverage, normalizeForSearch, tokenize, uniqueTokens } from "../../normalize.js";
+import { FOCUS_STOPWORDS } from "../constants.js";
+import { answerSearchPhrases, betterEvidence, cachedLineWindowSegments, containsNormalizedPhrase, evidenceSnippet, findPhraseOccurrences, nearestCueName, pageWindow, tokenHitCount, tokenizeNormalized, } from "../text-utils.js";
+import { latinAnswerTokens } from "./biomedical-symbols.js";
+const POLARITY_UP_CUES = ["повыш", "увелич", "возраста", "рост", "высок", "более", "выше"].map((item) => normalizeForSearch(item));
+const POLARITY_DOWN_CUES = ["сниж", "уменьш", "низк", "менее", "ниже"].map((item) => normalizeForSearch(item));
+function detectPolarity(text) {
+    const normalized = normalizeForSearch(text);
+    if (containsNormalizedPhrase(normalized, "менее высокий") || containsNormalizedPhrase(normalized, "менее высок") || containsNormalizedPhrase(normalized, "ниже")) {
+        return "down";
+    }
+    if (containsNormalizedPhrase(normalized, "более высокий") || containsNormalizedPhrase(normalized, "более высок") || containsNormalizedPhrase(normalized, "выше")) {
+        return "up";
+    }
+    const up = POLARITY_UP_CUES.some((cue) => normalized.includes(cue));
+    const down = POLARITY_DOWN_CUES.some((cue) => normalized.includes(cue));
+    if (up && !down)
+        return "up";
+    if (down && !up)
+        return "down";
+    return null;
+}
+function nearestPolarityBefore(pageNorm, hit) {
+    const before = pageNorm.slice(Math.max(0, hit - 140), hit);
+    let best = null;
+    for (const cue of POLARITY_UP_CUES) {
+        const index = before.lastIndexOf(cue);
+        if (index >= 0 && (!best || index > best.index))
+            best = { type: "up", index };
+    }
+    for (const cue of POLARITY_DOWN_CUES) {
+        const index = before.lastIndexOf(cue);
+        if (index >= 0 && (!best || index > best.index))
+            best = { type: "down", index };
+    }
+    return best?.type ?? null;
+}
+/**
+ * Сопоставляет направление (рост/снижение) в вопросе и в локальном контексте
+ * найденного варианта; штрафует противоположную полярность.
+ */
+export function polarityAdjustment({ pages, topQuestionPages, mode, question, questionTokens, answer }) {
+    const targetPolarity = detectPolarity(question) ?? detectPolarity(answer.text);
+    if (!targetPolarity)
+        return { adjustment: 0, evidence: null };
+    const phrases = [...new Set([...latinAnswerTokens(answer.text), ...answerSearchPhrases(answer.text)])].slice(0, 14);
+    let bestMatch = null;
+    let bestMismatch = null;
+    for (const page of pages) {
+        if (topQuestionPages?.size && !topQuestionPages.has(page.page))
+            continue;
+        const pageNorm = page.normalized;
+        for (const phrase of phrases) {
+            const normalizedPhrase = normalizeForSearch(phrase);
+            if (!normalizedPhrase || normalizedPhrase.length < 3)
+                continue;
+            const hits = findPhraseOccurrences(pageNorm, phrase, { textIsNormalized: true });
+            for (const hit of hits) {
+                const local = pageWindow(page, hit, 180);
+                const questionCoverage = coverage(questionTokens, tokenizeNormalized(local));
+                if (questionCoverage < 0.16)
+                    continue;
+                const found = nearestPolarityBefore(pageNorm, hit);
+                if (!found)
+                    continue;
+                const evidence = {
+                    answerId: answer.id,
+                    page: page.page,
+                    text: evidenceSnippet(page.text, phrase),
+                    score: (found === targetPolarity ? 4.8 : 4.2) + questionCoverage * 5.0,
+                    kind: found === targetPolarity ? "polarity_match" : "polarity_mismatch",
+                };
+                if (found === targetPolarity)
+                    bestMatch = betterEvidence(bestMatch, evidence);
+                else
+                    bestMismatch = betterEvidence(bestMismatch, evidence);
+            }
+        }
+    }
+    if (bestMatch && (!bestMismatch || bestMatch.score >= bestMismatch.score + 0.3))
+        return { adjustment: 2.4, evidence: bestMatch };
+    if (bestMismatch && (!bestMatch || bestMismatch.score > bestMatch.score + 0.3)) {
+        return { adjustment: mode === "single" ? -5.2 : -2.4, evidence: bestMismatch };
+    }
+    return { adjustment: 0, evidence: null };
+}
+function temporalCue(text) {
+    const normalized = normalizeForSearch(text);
+    if (containsNormalizedPhrase(normalized, "ноч"))
+        return "night";
+    if (containsNormalizedPhrase(normalized, "днем") || containsNormalizedPhrase(normalized, "днев"))
+        return "day";
+    return null;
+}
+function nearestTemporalCue(local) {
+    return nearestCueName(local, [
+        ["night", ["ноч"]],
+        ["day", ["днем", "днев"]],
+    ]);
+}
+/**
+ * Различает дневные и ночные подсказки для single-вопросов и штрафует
+ * вариант с противоположным временем суток рядом с фокусом вопроса.
+ */
+export function temporalCueAdjustment({ mode, pages, topQuestionPages, answer, focusTokens, questionTokens }) {
+    if (mode !== "single")
+        return { support: null, adjustment: 0, evidence: null };
+    const cue = temporalCue(answer.text);
+    if (!cue)
+        return { support: null, adjustment: 0, evidence: null };
+    const usefulFocus = focusTokens?.length ? focusTokens : questionTokens;
+    let bestMatch = null;
+    let bestMismatch = null;
+    for (const page of pages) {
+        const topPage = topQuestionPages?.has(page.page);
+        const adjacentTopPage = topQuestionPages?.has(page.page - 1) || topQuestionPages?.has(page.page + 1);
+        if (topQuestionPages?.size && !topPage && !adjacentTopPage)
+            continue;
+        for (const segment of cachedLineWindowSegments(page)) {
+            const focusCoverage = coverage(usefulFocus, segment.tokens);
+            if (focusCoverage < 0.12)
+                continue;
+            const found = nearestTemporalCue(segment.normalized);
+            if (!found)
+                continue;
+            const evidence = {
+                answerId: answer.id,
+                page: page.page,
+                text: segment.text,
+                score: 9.8 + Math.min(0.5, focusCoverage) * 5.0,
+                kind: found === cue ? "temporal_cue_match" : "temporal_cue_mismatch",
+            };
+            if (found === cue)
+                bestMatch = betterEvidence(bestMatch, evidence);
+            else
+                bestMismatch = betterEvidence(bestMismatch, evidence);
+        }
+    }
+    if (bestMatch && (!bestMismatch || bestMatch.score >= bestMismatch.score - 0.4))
+        return { support: bestMatch, adjustment: 0, evidence: null };
+    if (bestMismatch && (!bestMatch || bestMismatch.score > bestMatch.score + 0.4))
+        return { support: null, adjustment: -4.8, evidence: bestMismatch };
+    return { support: null, adjustment: 0, evidence: null };
+}
+const CONTRAST_CUE_GROUPS = [
+    {
+        answer: ["верхн"],
+        opposite: ["нижн", "базал"],
+    },
+    {
+        answer: ["нижн", "базал"],
+        opposite: ["верхн"],
+    },
+    {
+        answer: ["повыш", "увелич"],
+        opposite: ["пониж", "сниж", "уменьш"],
+    },
+    {
+        answer: ["пониж", "сниж", "уменьш"],
+        opposite: ["повыш", "увелич"],
+    },
+    {
+        answer: ["дистальнопроксим"],
+        opposite: ["проксимальнодист"],
+    },
+    {
+        answer: ["проксимальнодист"],
+        opposite: ["дистальнопроксим"],
+    },
+].map((group) => ({
+    answer: group.answer.map((item) => normalizeForSearch(item)),
+    opposite: group.opposite.map((item) => normalizeForSearch(item)),
+}));
+const MODIFIER_TARGET_CONTRAST_GROUPS = [
+    {
+        answer: "ранний ранняя раннее ранней",
+        opposite: "поздний поздняя позднее поздней",
+    },
+    {
+        answer: "поздний поздняя позднее поздней",
+        opposite: "ранний ранняя раннее ранней",
+    },
+].map((group) => ({
+    answer: new Set(tokenize(group.answer)),
+    opposite: new Set(tokenize(group.opposite)),
+}));
+function modifierTargetContrastMismatch(answerText, sourceText) {
+    const answerTokens = tokenize(answerText);
+    const sourceTokens = tokenize(sourceText);
+    for (const group of MODIFIER_TARGET_CONTRAST_GROUPS) {
+        if (!answerTokens.some((token) => group.answer.has(token)))
+            continue;
+        const targets = answerTokens.filter((token) => token.length >= 4 && !group.answer.has(token) && !group.opposite.has(token) && !FOCUS_STOPWORDS.has(token));
+        if (!targets.length)
+            continue;
+        for (let index = 0; index < sourceTokens.length; index += 1) {
+            if (!targets.includes(sourceTokens[index]))
+                continue;
+            for (let cursor = index - 1; cursor >= Math.max(0, index - 4); cursor -= 1) {
+                const token = sourceTokens[cursor];
+                if (group.opposite.has(token))
+                    return true;
+                if (group.answer.has(token))
+                    break;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Штрафует multi-вариант, у которого сильнейшее evidence содержит
+ * противоположную подсказку (верх/низ, рост/снижение, порядок дистальный/
+ * проксимальный) либо противоположный модификатор у того же целевого слова.
+ */
+export function contrastCueMismatchAdjustment({ mode, answer }, evidence) {
+    if (mode !== "multi" || !evidence?.length)
+        return { adjustment: 0, evidence: null };
+    const answerNorm = normalizeForSearch(answer.text);
+    const group = CONTRAST_CUE_GROUPS.find((item) => item.answer.some((cue) => answerNorm.includes(cue)));
+    for (const item of evidence.slice(0, 4)) {
+        if ((item.score ?? 0) < 5.5 || !item.text)
+            continue;
+        const sourceNorm = normalizeForSearch(item.text);
+        if (modifierTargetContrastMismatch(answer.text, item.text)) {
+            return {
+                adjustment: -6.4,
+                evidence: {
+                    answerId: answer.id,
+                    page: item.page,
+                    text: item.text,
+                    score: 6.4,
+                    kind: "modifier_target_mismatch",
+                },
+            };
+        }
+        if (!group)
+            continue;
+        const hasAnswerCue = group.answer.some((cue) => sourceNorm.includes(cue));
+        const hasOppositeCue = group.opposite.some((cue) => sourceNorm.includes(cue));
+        if (!hasAnswerCue && hasOppositeCue) {
+            return {
+                adjustment: -5.2,
+                evidence: {
+                    answerId: answer.id,
+                    page: item.page,
+                    text: item.text,
+                    score: 5.2,
+                    kind: "contrast_cue_mismatch",
+                },
+            };
+        }
+    }
+    return { adjustment: 0, evidence: null };
+}
+const EXCLUDED_CONDITION_START_STOP = [
+    "сниж",
+    "повыш",
+    "примен",
+    "лечен",
+    "назнач",
+    "пров",
+    "провед",
+    "проведение",
+    "использ",
+    "концентр",
+    "проб",
+].flatMap((item) => uniqueTokens(item));
+const CONDITION_POSITIVE_CUES = [
+    "при",
+    "на фоне",
+    "налич",
+    "имеющ",
+].map((item) => normalizeForSearch(item));
+/**
+ * Достает короткое условие из формулировок вида `без цирроза`, чтобы отличать
+ * рекомендации для исключенной подгруппы от рекомендаций для этой подгруппы.
+ */
+function excludedConditionTokens(question) {
+    const normalized = normalizeForSearch(question);
+    if (containsNormalizedPhrase(normalized, "без проведен") ||
+        containsNormalizedPhrase(normalized, "без применен") ||
+        containsNormalizedPhrase(normalized, "без назнач")) {
+        return [];
+    }
+    const tokens = tokenize(question);
+    const withoutCue = normalizeForSearch("без");
+    const out = [];
+    for (let index = 0; index < tokens.length - 1; index += 1) {
+        if (tokens[index] !== withoutCue)
+            continue;
+        const next = tokens.slice(index + 1, index + 4).filter((token) => token.length >= 4 && !FOCUS_STOPWORDS.has(token));
+        if (!next.length)
+            continue;
+        if (EXCLUDED_CONDITION_START_STOP.some((prefix) => next[0].startsWith(prefix) || prefix.startsWith(next[0])))
+            continue;
+        out.push(...next.slice(0, 2));
+        break;
+    }
+    return [...new Set(out)];
+}
+function evidenceHasExcludedConditionBeforeAnswer(answerText, evidenceText, conditionTokens) {
+    if (!conditionTokens.length || !evidenceText)
+        return false;
+    const normalized = normalizeForSearch(evidenceText);
+    const phrases = answerSearchPhrases(answerText)
+        .map((phrase) => normalizeForSearch(phrase))
+        .filter((phrase) => phrase.length >= 3);
+    for (const phrase of phrases) {
+        const hit = normalized.indexOf(phrase);
+        if (hit < 0)
+            continue;
+        const before = normalized.slice(Math.max(0, hit - 140), hit);
+        if (!CONDITION_POSITIVE_CUES.some((cue) => before.includes(cue)))
+            continue;
+        if (tokenHitCount(conditionTokens, tokenizeNormalized(before)) > 0)
+            return true;
+    }
+    return false;
+}
+/**
+ * Штрафует вариант, чье локальное evidence относится к исключенной подгруппе
+ * (`при X` рядом с фразой ответа), когда вопрос явно про `без X`.
+ */
+export function excludedConditionMismatchAdjustment({ mode, question, answer }, evidence) {
+    const conditionTokens = excludedConditionTokens(question);
+    if (!conditionTokens.length)
+        return { adjustment: 0, evidence: null };
+    for (const item of evidence.slice(0, 5)) {
+        if ((item.score ?? 0) < 6.5)
+            continue;
+        if (!evidenceHasExcludedConditionBeforeAnswer(answer.text, item.text, conditionTokens))
+            continue;
+        return {
+            adjustment: mode === "single" ? -12.4 : -4.2,
+            evidence: {
+                answerId: answer.id,
+                page: item.page,
+                text: item.text,
+                score: 8.4,
+                kind: "excluded_condition_mismatch",
+            },
+        };
+    }
+    return { adjustment: 0, evidence: null };
+}

package/dist/predictor/scorers/drug-dose.d.ts

@@ -0,0 +1,6 @@
+export declare function bestDrugDoseSupport({ mode, pages, question, answer }: {
+    mode: any;
+    pages: any;
+    question: any;
+    answer: any;
+}): any;

package/dist/predictor/scorers/drug-dose.js

@@ -0,0 +1,221 @@
+import { extractNumbers, normalizeForSearch, uniqueTokens } from "../../normalize.js";
+import { FOCUS_STOPWORDS } from "../constants.js";
+import { betterEvidence, containsNormalizedPhrase, expandNumberToken, rawTokens, softCoverage, tokenizeNormalized } from "../text-utils.js";
+const DOSE_DRUG_GENERIC = new Set([
+    "\u0441\u0443\u0442\u043e\u0447\u043d\u0430\u044f",
+    "\u0434\u043e\u0437\u0430",
+    "\u0434\u043e\u0437\u044b",
+    "\u0434\u043e\u0437\u0435",
+    "\u043f\u0440\u0438",
+    "\u043b\u0435\u0447\u0435\u043d\u0438\u0438",
+    "\u043b\u0435\u0447\u0435\u043d\u0438\u044f",
+    "\u043b\u0435\u0447\u0435\u043d\u0438\u0435",
+    "\u043b\u043e\u043a\u0430\u043b\u0438\u0437\u043e\u0432\u0430\u043d\u043d\u044b\u0445",
+    "\u043b\u043e\u043a\u0430\u043b\u0438\u0437\u043e\u0432\u0430\u043d\u043d\u044b\u0435",
+    "\u0444\u043e\u0440\u043c",
+    "\u0444\u043e\u0440\u043c\u044b",
+    "\u0438\u043d\u0444\u0435\u043a\u0446\u0438\u0438",
+    "\u0438\u043d\u0444\u0435\u043a\u0446\u0438\u044f",
+    "\u043c\u0435\u043d\u0438\u043d\u0433\u043e\u043a\u043e\u043a\u043a\u043e\u0432\u043e\u0439",
+    "\u043f\u0430\u0446\u0438\u0435\u043d\u0442\u0430\u043c",
+    "\u043f\u0430\u0446\u0438\u0435\u043d\u0442\u043e\u0432",
+    "\u043e\u043f\u044b\u0442\u043e\u043c",
+    "\u043f\u0440\u0435\u0434\u0448\u0435\u0441\u0442\u0432\u0443\u044e\u0449\u0435\u0439",
+    "\u0442\u0435\u0440\u0430\u043f\u0438\u0438",
+    "\u0434\u0430\u043d\u043d\u044b\u043c",
+    "\u043f\u0440\u0435\u043f\u0430\u0440\u0430\u0442\u043e\u043c",
+    "\u0441\u043e\u0441\u0442\u0430\u0432\u043b\u044f\u0435\u0442",
+    "\u0441\u0443\u0442\u043a\u0438",
+    "\u0441\u0443\u0442",
+].flatMap((item) => uniqueTokens(item)));
+const DOSE_ASSIGNMENT_CUES = [
+    "\u043d\u0430\u0437\u043d\u0430\u0447",
+    "\u0440\u0435\u043a\u043e\u043c\u0435\u043d\u0434",
+    "\u043f\u0440\u0438\u043c\u0435\u043d",
+    "\u043f\u043e\u043b\u0443\u0447",
+    "\u0432\u0432\u043e\u0434",
+    "\u0441\u043e\u0441\u0442\u0430\u0432\u043b",
+].map((item) => normalizeForSearch(item));
+function doseTokenStartsWithAny(token, cues) {
+    const normalized = normalizeForSearch(token);
+    return cues.some((cue) => normalized.startsWith(cue));
+}
+function doseContentTokens(text) {
+    return uniqueTokens(text).filter((token) => token.length >= 5 && !DOSE_DRUG_GENERIC.has(token) && !FOCUS_STOPWORDS.has(token) && !/^\d/u.test(token));
+}
+function questionDoseDrugTokens(question) {
+    const normalized = normalizeForSearch(question);
+    if (!containsNormalizedPhrase(normalized, "\u0434\u043e\u0437"))
+        return [];
+    const raw = rawTokens(question);
+    const doseIndex = raw.findIndex((token) => doseTokenStartsWithAny(token, [normalizeForSearch("\u0434\u043e\u0437")]));
+    const assignIndex = raw.findIndex((token, index) => index < (doseIndex < 0 ? raw.length : doseIndex) && doseTokenStartsWithAny(token, DOSE_ASSIGNMENT_CUES));
+    if (assignIndex > 0) {
+        const beforeAssign = raw.slice(Math.max(0, assignIndex - 9), assignIndex).join(" ");
+        const local = doseContentTokens(beforeAssign).slice(-3);
+        if (local.length)
+            return local;
+    }
+    const tokens = doseContentTokens(question);
+    return tokens.slice(0, 3);
+}
+function drugTokenIndex(normalized, drugTokens) {
+    let best = -1;
+    for (const token of drugTokens) {
+        const prefix = token.slice(0, Math.min(token.length, 9));
+        const index = normalized.indexOf(prefix);
+        if (index >= 0)
+            best = best < 0 ? index : Math.min(best, index);
+    }
+    return best;
+}
+function doseSlashNumbers(sourceText, drugTokens) {
+    const out = [];
+    const slashPattern = /(\d+(?:[.,]\d+)?)\s*\/\s*(\d+(?:[.,]\d+)?)\s*мг/giu;
+    for (const match of sourceText.matchAll(slashPattern)) {
+        const rawIndex = match.index ?? 0;
+        const beforeText = sourceText.slice(Math.max(0, rawIndex - 150), rawIndex);
+        const before = normalizeForSearch(beforeText);
+        if (softCoverage(drugTokens, tokenizeNormalized(before)) < 0.8)
+            continue;
+        const drugIndex = drugTokenIndex(before, drugTokens);
+        if (drugIndex < 0)
+            continue;
+        const plusAfter = before.indexOf("+", drugIndex);
+        const plusBefore = before.lastIndexOf("+", drugIndex);
+        const first = String(match[1]).replace(",", ".");
+        const second = String(match[2]).replace(",", ".");
+        if (plusAfter >= 0 && plusAfter <= before.length - 1) {
+            out.push(first);
+        }
+        else if (plusBefore >= 0) {
+            out.push(second);
+        }
+        else {
+            out.push(first, second);
+        }
+        break;
+    }
+    return out;
+}
+function doseNearDrugNumbers(sourceText, drugTokens) {
+    const normalized = normalizeForSearch(sourceText);
+    const drugIndex = drugTokenIndex(normalized, drugTokens);
+    if (drugIndex < 0)
+        return [];
+    const local = normalized.slice(drugIndex, Math.min(normalized.length, drugIndex + 95));
+    if (!containsNormalizedPhrase(local, "\u043c\u0433"))
+        return [];
+    if (/\d+(?:[.,]\d+)?\s*\/\s*\d+(?:[.,]\d+)?\s*mг/iu.test(local))
+        return [];
+    const firstNumber = local.match(/\d+(?:[.,]\d+)?/u);
+    if (!firstNumber || (firstNumber.index ?? 0) > 55)
+        return [];
+    if (local.slice(0, firstNumber.index ?? 0).includes("+"))
+        return [];
+    const beforeNumberTokens = tokenizeNormalized(local.slice(0, firstNumber.index ?? 0));
+    const genericBeforeDose = new Set(["taб", "taбл", "paз", "p", "д", "mг"]);
+    const hasOtherDrugMarker = beforeNumberTokens.some((token) => {
+        if (genericBeforeDose.has(token) || /^\d/.test(token))
+            return false;
+        if (drugTokens.some((drugToken) => drugToken.startsWith(token) || token.startsWith(drugToken.slice(0, Math.min(8, drugToken.length)))))
+            return false;
+        return token.length >= 3;
+    });
+    if (hasOtherDrugMarker)
+        return [];
+    return extractNumbers(local).slice(0, 2).map((number) => String(number).replace(",", "."));
+}
+function normalizeDoseNumber(value) {
+    return String(value ?? "").replace(",", ".").replace(/\.0$/u, "");
+}
+function answerDoseFact(answerText) {
+    const normalized = normalizeForSearch(answerText);
+    const doseRangeMatch = normalized.match(/(\d+(?:[.,]\d+)?)\s*-\s*(\d+(?:[.,]\d+)?)\s*[\u006d\u043c]\u0433/iu);
+    const doseMatch = normalized.match(/(\d+(?:[.,]\d+)?)\s*[\u006d\u043c]\u0433/iu);
+    const frequencyMatch = normalized.match(/(?:[\u0078\u0445]\s*|(?:\u0440\u0430\u0437|\u0440)\s*)(\d+(?:[.,]\d+)?)(?:\s*[\u0070\u0440]\s*\/\s*\u0434|\s*\u0440|\s*\u0440\u0430\u0437)?/iu);
+    return {
+        doseRange: doseRangeMatch?.[1] && doseRangeMatch?.[2] ? [normalizeDoseNumber(doseRangeMatch[1]), normalizeDoseNumber(doseRangeMatch[2])] : null,
+        dose: doseMatch?.[1] ? normalizeDoseNumber(doseMatch[1]) : null,
+        frequency: frequencyMatch?.[1] ? normalizeDoseNumber(frequencyMatch[1]) : null,
+    };
+}
+function sourceDoseFacts(sourceText, drugTokens) {
+    const normalized = normalizeForSearch(sourceText);
+    const drugIndex = drugTokenIndex(normalized, drugTokens);
+    if (drugIndex < 0)
+        return [];
+    const local = normalized.slice(drugIndex, Math.min(normalized.length, drugIndex + 125));
+    const facts = [];
+    const dosePattern = /(\d+(?:[.,]\d+)?)(?:\s*-\s*(\d+(?:[.,]\d+)?))?\s*[\u006d\u043c]\u0433(?:\s*[\u0078\u0445]\s*(\d+(?:[.,]\d+)?))?/giu;
+    for (const match of local.matchAll(dosePattern)) {
+        const index = match.index ?? 0;
+        if (index > 80)
+            continue;
+        facts.push({
+            dose: normalizeDoseNumber(match[2] ?? match[1]),
+            doseRange: match[2] ? [normalizeDoseNumber(match[1]), normalizeDoseNumber(match[2])] : null,
+            frequency: match[3] ? normalizeDoseNumber(match[3]) : null,
+        });
+        break;
+    }
+    for (const number of [...doseSlashNumbers(sourceText, drugTokens), ...doseNearDrugNumbers(sourceText, drugTokens)]) {
+        facts.push({ dose: normalizeDoseNumber(number), doseRange: null, frequency: null });
+    }
+    return facts;
+}
+function doseFactMatchesAnswer(fact, answerFact, answerNumbers, hasFrequencyFacts = false) {
+    if (answerFact.doseRange) {
+        if (!fact.doseRange)
+            return false;
+        if (fact.doseRange[0] !== answerFact.doseRange[0] || fact.doseRange[1] !== answerFact.doseRange[1])
+            return false;
+    }
+    if (answerFact.dose && fact.dose !== answerFact.dose)
+        return false;
+    if (!answerFact.dose && !answerNumbers.has(fact.dose))
+        return false;
+    if (answerFact.frequency && hasFrequencyFacts && !fact.frequency)
+        return false;
+    if (answerFact.frequency && fact.frequency && fact.frequency !== answerFact.frequency)
+        return false;
+    return true;
+}
+export function bestDrugDoseSupport({ mode, pages, question, answer }) {
+    if (mode !== "single")
+        return null;
+    const drugTokens = questionDoseDrugTokens(question);
+    if (!drugTokens.length)
+        return null;
+    const answerNumbers = new Set(extractNumbers(answer.text).flatMap(expandNumberToken).map((number) => String(number).replace(",", ".")));
+    if (!answerNumbers.size || !containsNormalizedPhrase(normalizeForSearch(answer.text), "\u043c\u0433"))
+        return null;
+    const answerFact = answerDoseFact(answer.text);
+    let best = null;
+    for (const page of pages) {
+        const lines = page.lines ?? [];
+        for (let index = 0; index < lines.length; index += 1) {
+            const text = lines.slice(index, Math.min(lines.length, index + 3)).join(" ");
+            const normalized = normalizeForSearch(text);
+            const sourceTokens = tokenizeNormalized(normalized);
+            if (softCoverage(drugTokens, sourceTokens) < 0.8)
+                continue;
+            const facts = sourceDoseFacts(text, drugTokens);
+            if (!facts.length)
+                continue;
+            const hasFrequencyFacts = facts.some((fact) => fact.frequency);
+            const hit = facts.some((fact) => doseFactMatchesAnswer(fact, answerFact, answerNumbers, hasFrequencyFacts));
+            if (!hit)
+                continue;
+            const score = 16.2 + Math.min(2, facts.length) * 0.7 + (answerFact.frequency && facts.some((fact) => fact.frequency === answerFact.frequency) ? 2.1 : 0);
+            best = betterEvidence(best, {
+                answerId: answer.id,
+                page: page.page,
+                text,
+                score,
+                kind: "drug_dose_segment",
+            });
+        }
+    }
+    return best;
+}

package/dist/predictor/scorers/exact-answer.d.ts

@@ -0,0 +1,10 @@
+export declare function bestExactAnswerSupport({ mode, pages, topQuestionPages, question, answer, questionTokens, answerTokens, focusTokens }: {
+    mode: any;
+    pages: any;
+    topQuestionPages: any;
+    question: any;
+    answer: any;
+    questionTokens: any;
+    answerTokens: any;
+    focusTokens: any;
+}): any;