@openhealth/oht-custom-parser-lib 0.2.81 → 0.3.1

package/dist/util-ts/extractionUtils.js

@@ -0,0 +1,666 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRange = parseRange;
+exports.handleBiomarkerId = handleBiomarkerId;
+exports.ohtReportExtractUnit = ohtReportExtractUnit;
+exports.ohtReportExtractReferenceAnnotation = ohtReportExtractReferenceAnnotation;
+exports.ohtReportExtractReferenceRanges = ohtReportExtractReferenceRanges;
+exports.ohtReportExtractValueFromGreaterLowerThan = ohtReportExtractValueFromGreaterLowerThan;
+exports.ohtReportParseExamValue = ohtReportParseExamValue;
+exports.ohtReportCheckValueForPlausibleValues = ohtReportCheckValueForPlausibleValues;
+const oht_types_1 = require("../types/oht.types");
+const moment_1 = __importDefault(require("moment"));
+const pinoLogger_1 = __importDefault(require("../util-ts/pinoLogger"));
+const dataUtils_1 = require("./dataUtils");
+/**
+ * Logger instance for the application
+ */
+const logger = (0, pinoLogger_1.default)();
+/**
+ * Default range parsing function that extracts range information from exam data
+ * @param exam - The OHT exam object containing range information
+ * @param labToOhtMapper - The lab to OHT mapper configuration
+ * @returns Range extraction response with parsed range bounds
+ */
+function parseRange(exam, patientInfo) {
+    // Define document date with priority:
+    // 1. collectionDate
+    // 2. effectiveDate
+    // 3. examCollectionDate
+    // 4. examEffectiveDate
+    // 5. documentDate
+    const documentDate = exam.collectionDate ||
+        exam.effectiveDate ||
+        exam.examCollectionDate ||
+        exam.examEffectiveDate ||
+        exam.documentDate;
+    const age = patientInfo.birthdate ? (0, moment_1.default)(documentDate).diff((0, moment_1.default)(patientInfo.birthdate), 'years', false) : null;
+    const sex = patientInfo.sex;
+    // If patient age is not available, return early
+    if (age === null) {
+        return { from: null, to: null, isRangeParsedCorrectly: false };
+    }
+    // if noSourceRanges is true, return early and set isRangeParsedCorrectly to true
+    if (exam.range.some(range => range.noSourceRanges)) {
+        return { from: null, to: null, isRangeParsedCorrectly: true };
+    }
+    /**
+     * Checks if a range age string matches the patient's age
+     * Supports formats: ">70", "30-50", "19+", "<10", "adult"
+     */
+    const doesAgeMatch = (rangeAge, patientAge) => {
+        if (!rangeAge || rangeAge.trim() === '') {
+            return false; // No age info - will be handled separately
+        }
+        const ageStr = rangeAge.trim().toLowerCase();
+        // "adult" matches all adults (18+)
+        if (ageStr === 'adult') {
+            return patientAge >= 18;
+        }
+        // Range format: "30-50"
+        const rangeMatch = ageStr.match(/^(\d+)-(\d+)$/);
+        if (rangeMatch) {
+            const lowerAge = parseInt(rangeMatch[1]);
+            const upperAge = parseInt(rangeMatch[2]);
+            return patientAge >= lowerAge && patientAge <= upperAge;
+        }
+        // Greater than format: ">70" or "70+"
+        const greaterThanMatch = ageStr.match(/^>?(\d+)\+?$/);
+        if (greaterThanMatch) {
+            const minAge = parseInt(greaterThanMatch[1]);
+            return patientAge >= minAge;
+        }
+        // Less than format: "<10"
+        const lessThanMatch = ageStr.match(/^<(\d+)$/);
+        if (lessThanMatch) {
+            const maxAge = parseInt(lessThanMatch[1]);
+            return patientAge < maxAge;
+        }
+        return false;
+    };
+    /**
+     * Checks if a range sex matches the patient's sex
+     * "ADULT" matches any patient sex (MALE or FEMALE)
+     */
+    const doesSexMatch = (rangeSex, patientSex) => {
+        if (!rangeSex || rangeSex.trim() === '') {
+            return false; // No sex info - will be handled separately
+        }
+        const rangeSexUpper = rangeSex.trim().toUpperCase();
+        const patientSexUpper = patientSex.trim().toUpperCase();
+        // "ADULT" matches any patient sex (MALE or FEMALE)
+        if (rangeSexUpper === 'ADULT') {
+            return patientSexUpper === 'MALE' || patientSexUpper === 'FEMALE';
+        }
+        return rangeSexUpper === patientSexUpper;
+    };
+    /**
+     * Checks if range text mentions opposite sex (fallback when range.sex is not available)
+     * Returns false if both sexes are mentioned (range applies to everyone)
+     */
+    const mentionsOppositeSex = (rangeText, patientSex) => {
+        const lower = rangeText.toLowerCase();
+        // Check if both sexes are mentioned - if so, range applies to everyone
+        const hasMasculine = lower.includes("homens") || lower.includes("masculino");
+        const hasFeminine = lower.includes("mulheres") || lower.includes("feminino");
+        if (hasMasculine && hasFeminine) {
+            return false; // Both sexes mentioned, so it's not opposite sex only
+        }
+        if (patientSex === "MALE") {
+            return hasFeminine;
+        }
+        else if (patientSex === "FEMALE") {
+            return hasMasculine;
+        }
+        return false;
+    };
+    /**
+     * Calculates precision score (0-100) for a range
+     * Higher score = more precise/appropriate range
+     */
+    const calculatePrecisionScore = (range, patientAge, patientSex) => {
+        let score = 50; // Base score for ranges without info
+        const hasAgeInfo = !!range.age && range.age.trim() !== '';
+        const hasSexInfo = !!range.sex && range.sex.trim() !== '';
+        // Penalize ranges without age/sex info
+        if (!hasAgeInfo && !hasSexInfo) {
+            score = 30; // Lower score for generic ranges
+        }
+        // Age matching bonuses
+        if (hasAgeInfo) {
+            if (doesAgeMatch(range.age, patientAge)) {
+                score += 30; // Exact age match
+            }
+            else {
+                score += 10; // Has age info but doesn't match (still better than no info)
+            }
+            // Additional specificity bonus for age ranges
+            if (range.age) {
+                const ageRangeMatch = range.age.match(/^(\d+)-(\d+)$/);
+                if (ageRangeMatch) {
+                    const lowerAge = parseInt(ageRangeMatch[1]);
+                    const upperAge = parseInt(ageRangeMatch[2]);
+                    const rangeSize = upperAge - lowerAge;
+                    // Smaller range = higher specificity (max 15 points)
+                    const specificityBonus = Math.max(0, 15 - Math.floor(rangeSize / 5));
+                    score += specificityBonus;
+                }
+            }
+        }
+        // Sex matching bonuses
+        if (hasSexInfo) {
+            if (doesSexMatch(range.sex, patientSex)) {
+                score += 20; // Exact sex match
+            }
+            else {
+                score += 5; // Has sex info but doesn't match (still better than no info)
+            }
+        }
+        // Cap at 100
+        return Math.min(100, score);
+    };
+    // Helper function to try parsing range from text
+    const tryParseFromText = (text) => {
+        // Helper function to attempt extraction from a given text string
+        const attemptExtraction = (textToSearch) => {
+            // Try standard range pattern (e.g., "70-100", "70 a 100", "70.5-100.2", "70,5 a 100,2", "de 2,0 até 4,1")
+            // Exclude ranges followed by "ano" or "anos" (e.g., "70 a 100 anos")
+            const rangeRegex = /(?:de\s+)?(\d+(?:[.,]\d+)?)\s*(?:[-]|à|a|A|À|até)\s*(\d+(?:[.,]\d+)?)(?!\s*(?:ano|anos|Ano|Anos)\b)/u;
+            const rangeMatch = rangeRegex.exec(textToSearch);
+            if (rangeMatch) {
+                try {
+                    const value1 = parsePtNumber(rangeMatch[1]);
+                    const value2 = parsePtNumber(rangeMatch[2]);
+                    if (!isNaN(value1) && !isNaN(value2) && value2 >= value1) {
+                        return { from: value1, to: value2, isRangeParsedCorrectly: true };
+                    }
+                }
+                catch (error) {
+                    // Continue to next pattern if parsing fails
+                }
+            }
+            // Try "até X" pattern (works even when "até" is not at the start of the string)
+            // This handles cases like "Valor de Referência: até 40,0 µg/dL"
+            const atePattern = /at[eé]\s+([\d\.,]+)/i;
+            const ateMatch = atePattern.exec(textToSearch);
+            if (ateMatch) {
+                try {
+                    const value = parsePtNumber(ateMatch[1]);
+                    if (!isNaN(value)) {
+                        return { from: null, to: value, isRangeParsedCorrectly: true };
+                    }
+                }
+                catch (error) {
+                    // Continue to next pattern if parsing fails
+                }
+            }
+            // Try "less than" patterns
+            const lessThanPatterns = getLessThanPatternsLocal();
+            for (const pattern of lessThanPatterns) {
+                try {
+                    const match = pattern.exec(textToSearch.toLowerCase());
+                    if (match) {
+                        const value = parsePtNumber(match[1]);
+                        if (!isNaN(value)) {
+                            return { from: null, to: value, isRangeParsedCorrectly: true };
+                        }
+                    }
+                }
+                catch (error) {
+                    // Continue to next pattern if parsing fails
+                }
+            }
+            // Try "greater than" patterns
+            const greaterThanPatterns = getGreaterThanPatternsLocal();
+            for (const pattern of greaterThanPatterns) {
+                try {
+                    const match = pattern.exec(textToSearch.toLowerCase());
+                    if (match) {
+                        const value = parsePtNumber(match[1]);
+                        if (!isNaN(value)) {
+                            return { from: value, to: null, isRangeParsedCorrectly: true };
+                        }
+                    }
+                }
+                catch (error) {
+                    // Continue to next pattern if parsing fails
+                }
+            }
+            // Try to extract ignoring unit (e.g 41,68 U/mL a 95,06 U/mL)
+            const ignoringUnitRegex = /(\d+(?:[.,]\d+)?)\s*[^0-9]*?\s*[AaÀà-]\s*(\d+(?:[.,]\d+)?)/;
+            const ignoringUnitMatch = ignoringUnitRegex.exec(textToSearch.toLowerCase());
+            if (ignoringUnitMatch) {
+                try {
+                    const value1 = parsePtNumber(ignoringUnitMatch[1] || '');
+                    const value2 = parsePtNumber(ignoringUnitMatch[2] || '');
+                    if (!isNaN(value1) && !isNaN(value2) && value2 >= value1) {
+                        return { from: value1, to: value2, isRangeParsedCorrectly: true };
+                    }
+                }
+                catch (error) {
+                    // Continue to next attempt if parsing fails
+                }
+            }
+            return null;
+        };
+        // If text contains ":", try extraction from both parts
+        // First try part after ":", then try part before ":"
+        if (text.includes(':')) {
+            const parts = text.split(':');
+            const beforeColon = parts[0].trim();
+            const afterColon = parts.slice(1).join(':').trim();
+            // Try extraction from part after ":" first
+            if (afterColon) {
+                const result = attemptExtraction(afterColon);
+                if (result && result.isRangeParsedCorrectly) {
+                    return result;
+                }
+            }
+            // If no result from after ":", try part before ":"
+            if (beforeColon) {
+                const result = attemptExtraction(beforeColon);
+                if (result && result.isRangeParsedCorrectly) {
+                    return result;
+                }
+            }
+        }
+        // If no ":" or extraction from both parts failed, try full text
+        const result = attemptExtraction(text);
+        if (result) {
+            return result;
+        }
+        return { from: null, to: null, isRangeParsedCorrectly: false };
+    };
+    // Filter 1: Exclude ranges with opposite sex
+    // Use range.sex when available, otherwise check text
+    const sexFiltered = exam.range.filter(range => {
+        // If range has explicit sex info, use it
+        if (range.sex && range.sex.trim() !== '') {
+            return doesSexMatch(range.sex, sex);
+        }
+        // If no explicit sex info, check if text mentions opposite sex
+        // Only exclude if explicitly mentions opposite sex
+        if (sex && (sex === "MALE" || sex === "FEMALE")) {
+            return !mentionsOppositeSex(range.text, sex);
+        }
+        // If patient sex is unknown, keep all ranges
+        return true;
+    });
+    // Filter 2: Exclude ranges with age that doesn't match patient
+    // Prioritize ranges with age info that matches
+    const ageFiltered = sexFiltered.filter(range => {
+        // If range has explicit age info, check if it matches
+        if (range.age && range.age.trim() !== '') {
+            return doesAgeMatch(range.age, age);
+        }
+        // If no age info, keep it (will be scored lower)
+        return true;
+    });
+    // If we have ranges with age info that matches, use only those
+    // Otherwise, use all remaining ranges (including those without age info)
+    const rangesWithAgeInfo = ageFiltered.filter(r => r.age && r.age.trim() !== '');
+    let rangesToProcess = rangesWithAgeInfo.length > 0 ? rangesWithAgeInfo : ageFiltered;
+    // Sort ranges by precision score (highest first)
+    rangesToProcess = rangesToProcess.sort((a, b) => {
+        const scoreA = calculatePrecisionScore(a, age, sex);
+        const scoreB = calculatePrecisionScore(b, age, sex);
+        return scoreB - scoreA; // Higher score first
+    });
+    // Try to extract from filtered ranges (check all ranges in order)
+    if (rangesToProcess.length > 0) {
+        for (const range of rangesToProcess) {
+            // Special case: if from, to, and text are all "0", return directly
+            const fromTrimmed = (range.from != null && typeof range.from === 'string' ? range.from.trim() : (range.from != null ? String(range.from) : ''));
+            const toTrimmed = (range.to != null && typeof range.to === 'string' ? range.to.trim() : (range.to != null ? String(range.to) : ''));
+            const textTrimmed = (range.text != null && typeof range.text === 'string' ? range.text.trim() : (range.text != null ? String(range.text) : ''));
+            if (fromTrimmed === '0' && toTrimmed === '0' && textTrimmed === '0') {
+                return { from: 0, to: 0, isRangeParsedCorrectly: true };
+            }
+            const result = tryParseFromText(range.text);
+            if (result.isRangeParsedCorrectly)
+                return result;
+        }
+    }
+    // If no range is parsed correctly, return null values
+    return { from: null, to: null, isRangeParsedCorrectly: false };
+}
+/**
+* Parses numbers with Portuguese-Brazilian thousand/decimal separators
+* Examples handled:
+* - "1.000" -> 1000
+* - "1.234,56" -> 1234.56
+* - "41,68" -> 41.68
+* - "0.016" -> 0.016 (decimal format, not thousand separator)
+* - "0.078" -> 0.078 (decimal format, not thousand separator)
+* - falls back to replacing comma with dot otherwise
+* @param raw - The raw string to parse
+* @returns The parsed number or NaN if parsing fails
+*/
+function parsePtNumber(raw) {
+    if (raw == null)
+        return NaN;
+    const s = String(raw).trim();
+    if (s === '')
+        return NaN;
+    // Special case: values starting with "0." followed by 3+ digits are decimals (English format)
+    // This prevents "0.016" from being treated as thousand separator format
+    const decimalZeroPattern = /^0\.\d{3,}$/;
+    if (decimalZeroPattern.test(s)) {
+        return parseFloat(s);
+    }
+    const ptPattern = /^\d{1,3}(?:\.\d{3})*(?:,\d+)?$/;
+    const thousandOnlyPattern = /^\d{1,3}(?:\.\d{3})+$/;
+    let normalized;
+    if (ptPattern.test(s) || thousandOnlyPattern.test(s)) {
+        normalized = s.replace(/\./g, '').replace(',', '.');
+    }
+    else {
+        normalized = s.replaceAll(',', '.');
+    }
+    // Count original decimal places
+    const decimalMatch = normalized.match(/\.(\d+)$/);
+    if (decimalMatch) {
+        const decimalPlaces = decimalMatch[1].length;
+        return parseFloat(parseFloat(normalized).toFixed(decimalPlaces));
+    }
+    return parseFloat(normalized);
+}
+/**
+* Gets an array of regular expressions for matching "less than" patterns in various languages
+* @returns Array of RegExp objects for "less than" pattern matching
+*/
+function getLessThanPatternsLocal() {
+    const patterns = [
+        /<=\s*([\d\.,]+)/, // Universal: "<="
+        /at[eé]\s*([\d\.,]+)/, // Portuguese: "até"
+        /inferior\s+a\s+([\d\.,]+)/, // Portuguese: "inferior a"
+        /<\s?([\d\.,]+)/, // Universal: "<"
+        /menor\s+que\s+([\d\.,]+)/, // Portuguese: "menor que"
+        /menos\s+que\s+([\d\.,]+)/, // Portuguese: "menos que"
+        /less\s+than\s+([\d\.,]+)/i, // English: "less than"
+        /below\s+([\d\.,]+)/i, // English: "below"
+        /under\s+([\d\.,]+)/i, // English: "under"
+        /menor\s+ou\s+igual\s+a\s+([\d\.,]+)/, // Portuguese: "menor ou igual a"
+        /inferior\s+ou\s+igual\s+(?:a\s+)?([\d\.,]+)/, // Portuguese: "inferior ou igual a"
+        /less\s+than\s+or\s+equal\s+to\s+([\d\.,]+)/i, // English: "less than or equal to"
+    ];
+    return patterns;
+}
+/**
+ * Gets an array of regular expressions for matching "greater than" patterns in various languages
+ * @returns Array of RegExp objects for "greater than" pattern matching
+ */
+function getGreaterThanPatternsLocal() {
+    const patterns = [
+        />=\s*([\d\.,]+)/, // Universal: ">="
+        /superior\s+a\s+([\d\.,]+)/, // Spanish: "superior a"
+        />\s?([\d\.,]+)/, // Universal: ">"
+        /maior\s+que\s+([\d\.,]+)/, // Portuguese: "maior que"
+        /mais\s+que\s+([\d\.,]+)/, // Portuguese: "mais que"
+        /greater\s+than\s+([\d\.,]+)/i, // English: "greater than"
+        /above\s+([\d\.,]+)/i, // English: "above"
+        /over\s+([\d\.,]+)/i, // English: "over"
+        /acima\s+de\s+([\d\.,]+)/, // Portuguese: "acima de"
+        /maior\s+ou\s+igual\s+(?:a\s+)?([\d\.,]+)/, // Portuguese: "maior ou igual a"
+        /greater\s+than\s+or\s+equal\s+to\s+([\d\.,]+)/i, // English: "greater than or equal to"
+    ];
+    return patterns;
+}
+/**
+* Converts backend biomarker id to know if it should be mapped or unmapped
+* @param backendMapping - The backend mapping configuration
+* @param labKey - The lab key identifier
+* @returns The final ohtBmId and annotationConfig
+*/
+function handleBiomarkerId(backendMapping, labKey) {
+    // Handle unmapped biomarkers:
+    // 1. ohtBmId: -1 means already unmapped in backend
+    // 2. keepAsUnmapped: true means override to unmapped (ohtBmId becomes -1)
+    const isAlreadyUnmapped = backendMapping.ohtBmId === -1;
+    const shouldBeUnmapped = backendMapping.keepAsUnmapped === true;
+    const finalOhtBmId = shouldBeUnmapped ? -1 : backendMapping.ohtBmId;
+    if (isAlreadyUnmapped) {
+        logger.info(`Processing backend unmapped biomarker: ${labKey} (ohtBmId: -1)`);
+    }
+    else if (shouldBeUnmapped) {
+        logger.info(`Overriding biomarker to unmapped: ${labKey} (ohtBmId: ${backendMapping.ohtBmId} -> -1)`);
+    }
+    return {
+        ohtBmId: finalOhtBmId,
+        annotationConfig: {
+            enabled: backendMapping.annotationConfig?.enabled ?? false,
+            labKeys: backendMapping.annotationConfig?.labKeys ?? [],
+        },
+    };
+}
+/**
+ * Extracts unit from ohtExam (OhtExam object)
+ * @param ohtExam - OhtExam object (not a JSON string)
+ * @param ohtBiomarker - Biomarker information
+ * @param synonymUnits - Synonym units for unit resolution
+ * @param partnerId - Partner ID for synonym resolution
+ */
+function ohtReportExtractUnit(ohtExam, ohtBiomarker, synonymUnits = null, partnerId) {
+    if (!(0, dataUtils_1.isBiomarkerValueNumerical)(ohtBiomarker)) {
+        return { unit: "None", isUnitParsedCorrectly: true, originalUnit: "", isArbitraryUnit: false, unknownUnit: '' };
+    }
+    const isArbitraryUnit = ohtBiomarker.acf.standardUnitArbUnitLogic === 'default';
+    let originalUnit = '';
+    // Use unit directly from ohtExam
+    const unit = ohtExam?.unit ?? '';
+    let unitLowerCase = unit?.toLowerCase();
+    unitLowerCase = unitLowerCase?.replaceAll(/ /g, '') ?? '';
+    const standardUnit = ohtBiomarker.acf.standardUnit;
+    const allBmOhtUnits = [
+        standardUnit?.toLowerCase(),
+        ...ohtBiomarker.acf?.alternativeUnits
+            ?.map((bmAlternative) => bmAlternative.name.toLowerCase()) ?? []
+    ];
+    // If the biomarker uses an arbitrary unit, return standard unit and set the original unit as the unit extracted from the data
+    if (isArbitraryUnit) {
+        originalUnit = unit;
+        return { unit: standardUnit, isUnitParsedCorrectly: true, originalUnit: originalUnit, isArbitraryUnit: isArbitraryUnit, unknownUnit: '' };
+    }
+    // First test if the biomarker has the unit explicit in the 'unity' field
+    const allUnitContainsJsonUnit = allBmOhtUnits.includes(unitLowerCase);
+    if (unitLowerCase?.length > 0 && allUnitContainsJsonUnit) {
+        // Find the original case version from standardUnit or alternativeUnits
+        let matchedUnit = standardUnit?.toLowerCase().replaceAll(/ /g, '') === unitLowerCase
+            ? standardUnit?.replaceAll(/ /g, '')
+            : ohtBiomarker.acf?.alternativeUnits?.find((bmAlternative) => bmAlternative.name.toLowerCase().replaceAll(/ /g, '') === unitLowerCase)?.name?.replaceAll(/ /g, '');
+        // Fallback to original unit if no match found (shouldn't happen, but safety check)
+        matchedUnit = matchedUnit || unit?.replaceAll(/ /g, '');
+        return {
+            unit: matchedUnit,
+            isUnitParsedCorrectly: true,
+            originalUnit: originalUnit,
+            isArbitraryUnit: isArbitraryUnit,
+            unknownUnit: ''
+        };
+    }
+    // Check if there are any Synonym configured
+    if (unitLowerCase?.length > 0) {
+        let resolvedUnit = null;
+        if (synonymUnits && synonymUnits.length > 0) {
+            const resolved = (0, dataUtils_1.resolveUnitFromSynonyms)(unitLowerCase, ohtBiomarker.id, partnerId, synonymUnits);
+            if (resolved.found && resolved.targetUnit) {
+                resolvedUnit = resolved.targetUnit;
+            }
+        }
+        if (resolvedUnit) {
+            const allUnitContainsJsonUnitSynonyms = allBmOhtUnits.includes(resolvedUnit.toLowerCase());
+            if (allUnitContainsJsonUnitSynonyms) {
+                return { unit: resolvedUnit, isUnitParsedCorrectly: true, originalUnit: originalUnit, isArbitraryUnit: isArbitraryUnit, unknownUnit: '' };
+            }
+        }
+    }
+    // if the unit didnt match any of the cases, add the unit to an unknownUnit list
+    return { unit: '', isUnitParsedCorrectly: false, originalUnit: '', isArbitraryUnit: false, unknownUnit: unit };
+}
+/**
+ * Extracts reference annotation from ohtExam (OhtExam object)
+ * @param annotationConfig - Annotation configuration for appended biomarkers
+ * @param ohtExam - OhtExam object (not a JSON string)
+ * @param patientInfo - Patient information
+ * @param documentDate - Document date
+ * @param exams - Array of exams for appended mappings
+ * @param filename - Current filename being processed (for error reporting)
+ */
+function ohtReportExtractReferenceAnnotation(annotationConfig, ohtExam, patientInfo, documentDate, exams, filename) {
+    let annotation = '';
+    // if it is an appended mapping, add the extracted values to annotation
+    if (annotationConfig?.enabled && annotationConfig.labKeys) {
+        const appendedResult = (0, dataUtils_1.processAppendedMappings)(exams, annotationConfig.labKeys, filename, {
+            maxLength: annotationConfig.maxLength,
+            fallbackValue: annotationConfig.fallbackValue,
+            separator: annotationConfig.separator,
+        });
+        if (appendedResult.text?.length) {
+            annotation += appendedResult.text;
+        }
+    }
+    // Use annotation directly from ohtExam
+    const extractedReference = ohtExam?.annotation ?? '';
+    if (extractedReference?.length) {
+        annotation += annotation ? `\n${extractedReference}` : extractedReference;
+    }
+    return annotation || undefined;
+}
+/**
+ * Extracts reference ranges from ohtExam (OhtExam object)
+ * Always uses parseRange function from extractionUtils for range extraction
+ */
+function ohtReportExtractReferenceRanges(ohtExam, patientInfo) {
+    const nullRangeNotParsedCorrectly = { from: null, to: null, isRangeParsedCorrectly: false };
+    // Always use parseRange function from extractionUtils
+    const rangeExtractionResult = parseRange(ohtExam, patientInfo);
+    if (rangeExtractionResult.isRangeParsedCorrectly) {
+        return rangeExtractionResult;
+    }
+    return nullRangeNotParsedCorrectly;
+}
+function ohtReportExtractValueFromGreaterLowerThan(value) {
+    // Checks first if any greater than pattern is present
+    const greaterThanPatterns = getGreaterThanPatternsLocal(); // TODO: CAN USE THE SAME PATTERNS AS PARSE RANGE FUNCTION?
+    const lowerThanPatterns = getLessThanPatternsLocal();
+    value = value.toLowerCase();
+    for (const pattern of greaterThanPatterns) {
+        const match = pattern.exec(value);
+        if (match) {
+            const value = parseFloat(match?.[1].replaceAll(',', '.'));
+            const valueComparator = oht_types_1.MeasurementValueComparator.GREATER_THAN;
+            return {
+                extractedValue: value,
+                extractedValueComparator: valueComparator,
+                valueParsedCorrectly: !Number.isNaN(value)
+            };
+        }
+    }
+    // Checks if any lower than pattern is present
+    for (const pattern of lowerThanPatterns) {
+        const match = pattern.exec(value);
+        if (match) {
+            const value = parseFloat(match?.[1].replaceAll(',', '.'));
+            const valueComparator = oht_types_1.MeasurementValueComparator.LESS_THAN;
+            return {
+                extractedValue: value,
+                extractedValueComparator: valueComparator,
+                valueParsedCorrectly: !Number.isNaN(value)
+            };
+        }
+    }
+    // If no pattern is found, return the value as is and the comparator as EQUAL and isValueParsedCorrectly as false
+    return { extractedValue: null, extractedValueComparator: null, valueParsedCorrectly: false };
+}
+/**
+ * Parses exam value from ohtExam (OhtExam object)
+ * Now uses value directly from ohtExam
+ */
+function ohtReportParseExamValue(ohtExam, ohtBiomarker) {
+    // Use value directly from ohtExam
+    let value = ohtExam?.value ?? '';
+    // Normalize to string for parseFloat
+    if (value != null) {
+        value = String(value);
+    }
+    else {
+        value = '';
+    }
+    // If is parse float nan, the value is alphanumerical
+    const valueType = (0, dataUtils_1.isBiomarkerValueNumerical)(ohtBiomarker)
+        ? oht_types_1.BiomarkerValueType.NUMERICAL
+        : oht_types_1.BiomarkerValueType.ALPHANUMERICAL;
+    let alphanumericalValue = Number.isNaN(parseFloat(value))
+        ? value
+        : null;
+    if (valueType === oht_types_1.BiomarkerValueType.ALPHANUMERICAL
+        && !Number.isNaN(parseFloat(value))) {
+        // convert numberValue to string
+        alphanumericalValue = value.toString();
+    }
+    if (valueType === oht_types_1.BiomarkerValueType.NUMERICAL
+        && Number.isNaN(parseFloat(value))) {
+        // convert numberValue to string
+        const { extractedValue, extractedValueComparator, valueParsedCorrectly } = ohtReportExtractValueFromGreaterLowerThan(value);
+        return {
+            valueType,
+            alphanumericalValue,
+            numberValue: extractedValue,
+            valueComparator: extractedValueComparator ?? oht_types_1.MeasurementValueComparator.EQUAL,
+            isValueParsedCorrectly: valueParsedCorrectly
+        };
+    }
+    if (valueType === 'NUMERICAL') {
+        return {
+            valueType,
+            alphanumericalValue,
+            numberValue: parseFloat(value),
+            valueComparator: oht_types_1.MeasurementValueComparator.EQUAL,
+            isValueParsedCorrectly: !Number.isNaN(parseFloat(value))
+        };
+    }
+    if (valueType === 'ALPHANUMERICAL') {
+        return {
+            valueType,
+            alphanumericalValue,
+            numberValue: parseFloat(value),
+            valueComparator: oht_types_1.MeasurementValueComparator.EQUAL,
+            isValueParsedCorrectly: Boolean(alphanumericalValue)
+        };
+    }
+    return {
+        valueType,
+        alphanumericalValue,
+        numberValue: null,
+        valueComparator: oht_types_1.MeasurementValueComparator.EQUAL,
+        isValueParsedCorrectly: false
+    };
+}
+function ohtReportCheckValueForPlausibleValues(ohtBmId, labKey, ohtBiomarker, unit, value, isUnitParsedCorrectly, filename) {
+    if (!(0, dataUtils_1.isBiomarkerValueNumerical)(ohtBiomarker) && isUnitParsedCorrectly) {
+        return true;
+    }
+    const standardUnit = ohtBiomarker.acf.standardUnit;
+    const plausibleLowerValue = ohtBiomarker.acf.plausibilityRangeCheck;
+    const plausibleUpperValue = ohtBiomarker.acf.plausibilityRangeCheckHigh;
+    const biomarkerStdValueDecimals = ohtBiomarker.acf?.displayDecimals ?? 2;
+    if (unit !== standardUnit) {
+        const alternativeUnit = (Array.isArray(ohtBiomarker.acf?.alternativeUnits)
+            ? ohtBiomarker.acf?.alternativeUnits
+            : [])?.find((altUnit) => altUnit.name === unit);
+        if (alternativeUnit) {
+            const conversionFactor = alternativeUnit.conversionFactor;
+            value = +(value * conversionFactor).toFixed(biomarkerStdValueDecimals);
+        }
+    }
+    const isPlausibleValue = value >= plausibleLowerValue && value <= plausibleUpperValue;
+    // Log if the value is not plausible
+    if (!isPlausibleValue) {
+        logger.warn({ ohtBmId, labKey, value, standardUnit, plausibleLowerValue, plausibleUpperValue, filename }, `Value "${value} ${standardUnit}" not plausible "${plausibleLowerValue} to ${plausibleUpperValue}" for "${ohtBmId}" | "${labKey}", filename: ${filename}`);
+    }
+    return isPlausibleValue;
+}
+//# sourceMappingURL=extractionUtils.js.map